art::EventSelector Class Reference

#include "EventSelector.h"

Classes
struct	BitInfo

Public Types
using	Strings = std::vector< std::string >

Public Member Functions
	EventSelector (Strings const &pathspecs, Strings const &names)
	EventSelector (Strings const &pathspecs)
	EventSelector (fhicl::ParameterSet const &pset, Strings const &triggernames)
bool	wantAll () const
bool	acceptEvent (TriggerResults const &)
std::shared_ptr< TriggerResults >	maskTriggerResults (TriggerResults const &inputResults)

Private Types
using	Bits = std::vector< BitInfo >

Private Member Functions
void	init (Strings const &paths, Strings const &triggernames)
bool	acceptOneBit (Bits const &b, HLTGlobalStatus const &tr, hlt::HLTState const &s=hlt::Ready) const
bool	acceptAllBits (Bits const &b, HLTGlobalStatus const &tr) const
bool	containsExceptions (HLTGlobalStatus const &tr) const
bool	selectionDecision (HLTGlobalStatus const &tr) const

Static Private Member Functions
static std::vector< Strings::const_iterator >	matching_triggers (Strings const &trigs, std::string const &s)
static bool	identical (std::vector< bool > const &a, std::vector< bool > const &b)
static bool	identical (EventSelector const &a, EventSelector const &b, unsigned int N)
static std::vector< bool >	expandDecisionList (Bits const &b, bool PassOrFail, unsigned int n)
static bool	overlapping (std::vector< bool > const &a, std::vector< bool > const &b)
static bool	subset (std::vector< bool > const &a, std::vector< bool > const &b)
static std::vector< bool >	combine (std::vector< bool > const &a, std::vector< bool > const &b)

Private Attributes
bool	accept_all_ {false}
Bits	absolute_acceptors_ {}
Bits	conditional_acceptors_ {}
Bits	exception_acceptors_ {}
std::vector< Bits >	all_must_fail_ {}
std::vector< Bits >	all_must_fail_noex_ {}
bool	results_from_current_process_ {true}
bool	psetID_initialized_ {false}
fhicl::ParameterSetID	psetID_ {}
Strings	paths_ {}
int	nTriggerNames_ {0}
bool	notStarPresent_ {false}

Detailed Description

Definition at line 34 of file EventSelector.h.

Member Typedef Documentation

using art::EventSelector::Bits = std::vector<BitInfo>

private

Definition at line 65 of file EventSelector.h.

using art::EventSelector::Strings = std::vector<std::string>

Definition at line 36 of file EventSelector.h.

Constructor & Destructor Documentation

art::EventSelector::EventSelector	(	Strings const &	pathspecs,
		Strings const &	names
	)

Definition at line 19 of file EventSelector.cc.

  {
    init(pathspecs, names);
  }

art::EventSelector::EventSelector ( Strings const &  pathspecs )

explicit

Definition at line 24 of file EventSelector.cc.

    : results_from_current_process_(false), paths_(pathspecs)
  {}

art::EventSelector::EventSelector	(	fhicl::ParameterSet const &	pset,
		Strings const &	triggernames
	)

Definition at line 28 of file EventSelector.cc.

References fhicl::ParameterSet::get(), and init().

  {
    auto paths = config.get<Strings>("SelectEvents", {});
    init(paths, triggernames);
  }

Member Function Documentation

bool art::EventSelector::acceptAllBits ( Bits const &  b, HLTGlobalStatus const &  tr  ) const

private

Definition at line 314 of file EventSelector.cc.

References art::hlt::Fail, art::hlt::Pass, and art::HLTGlobalStatus::state().

Referenced by selectionDecision().

  {
    for (auto const& b : bits) {
      hlt::HLTState const bstate = b.accept_state_ ? hlt::Pass : hlt::Fail;
      if (tr[b.pos_].state() != bstate)
        return false;
    }
    return true;
  } // acceptAllBits

bool art::EventSelector::acceptEvent

(

TriggerResults const &

tr

)

Definition at line 204 of file EventSelector.cc.

References accept_all_, init(), art::TriggerResults::parameterSetID(), paths_, psetID_, psetID_initialized_, results_from_current_process_, selectionDecision(), and art::errors::Unknown.

Referenced by art::detail::ProcessAndEventSelector::match().

  {
    if (accept_all_)
      return true;

    // For the current process we already initialized in the constructor,
    // The trigger names will not change so we can skip initialization.
    if (!results_from_current_process_) {

      // For previous processes we need to get the trigger names that
      // correspond to the bits in TriggerResults from the ParameterSet
      // set registry, which is stored once per file.  The ParameterSetID
      // stored in TriggerResults is the key used to find the info in the
      // registry.  We optimize using the fact the ID is unique. If the ID
      // has not changed since the last time we initialized with new
      // triggernames, then the names have not changed and we can skip this
      // initialization.
      if (!(psetID_initialized_ && psetID_ == tr.parameterSetID())) {

        Strings triggernames;
        if (ServiceHandle<TriggerNamesService const> {}->getTrigPaths(
              tr, triggernames)) {
          init(paths_, triggernames);
          psetID_ = tr.parameterSetID();
          psetID_initialized_ = true;
        }
        // This should never happen
        else {
          throw art::Exception(errors::Unknown)
            << "EventSelector::acceptEvent cannot find the trigger names for\n"
               "a process for which the configuration has requested that the\n"
               "OutputModule use TriggerResults to select events from.  This "
               "should\n"
               "be impossible, please send information to reproduce this "
               "problem to\n"
               "the art developers at artists@fnal.gov.\n";
        }
      }
    }

    // Now make the decision, based on the supplied TriggerResults tr,
    // which of course can be treated as an HLTGlobalStatus by inheritance

    return selectionDecision(tr);

  } // acceptEvent(TriggerResults const& tr)

bool art::EventSelector::acceptOneBit ( Bits const &  b, HLTGlobalStatus const &  tr, hlt::HLTState const &  s = hlt::Ready  ) const

private

Definition at line 296 of file EventSelector.cc.

References art::hlt::Exception, art::hlt::Fail, art::hlt::Pass, and art::HLTGlobalStatus::state().

Referenced by selectionDecision().

  {
    bool lookForException = (s == hlt::Exception);
    for (auto const& b : bits) {
      hlt::HLTState const bstate = lookForException ?
                                     hlt::Exception :
                                     b.accept_state_ ? hlt::Pass : hlt::Fail;
      if (tr[b.pos_].state() == bstate)
        return true;
    }
    return false;
  } // acceptOneBit

vector< bool > art::EventSelector::combine ( std::vector< bool > const &  a, std::vector< bool > const &  b  )

staticprivate

Definition at line 586 of file EventSelector.cc.

References x.

  {
    assert(a.size() == b.size());
    vector<bool> x(a.size());
    for (unsigned int i = 0; i != a.size(); ++i) {
      x[i] = a[i] || b[i];
    } // a really sharp compiler will optimize the hell out of this,
      // exploiting word-size OR operations.
    return x;
  } // combine

bool art::EventSelector::containsExceptions ( HLTGlobalStatus const &  tr ) const

private

Definition at line 419 of file EventSelector.cc.

References e, art::hlt::Exception, and art::HLTGlobalStatus::size().

Referenced by selectionDecision().

  {
    unsigned int e = tr.size();
    for (unsigned int i = 0; i < e; ++i) {
      if (tr[i].state() == hlt::Exception)
        return true;
    }
    return false;
  }

vector< bool > art::EventSelector::expandDecisionList ( Bits const &  b, bool  PassOrFail, unsigned int  n  )

staticprivate

Definition at line 515 of file EventSelector.cc.

References x.

Referenced by identical(), and maskTriggerResults().

  {
    vector<bool> x(n, false);
    for (unsigned int i = 0; i != b.size(); ++i) {
      if (b[i].accept_state_ == PassOrFail)
        x[b[i].pos_] = true;
    }
    return x;
  } // expandDecisionList

bool art::EventSelector::identical ( std::vector< bool > const &  a, std::vector< bool > const &  b  )

staticprivate

Definition at line 432 of file EventSelector.cc.

References n.

Referenced by identical().

  {
    unsigned int n = a.size();
    if (n != b.size())
      return false;
    for (unsigned int i = 0; i != n; ++i) {
      if (a[i] != b[i])
        return false;
    }
    return true;
  }

bool art::EventSelector::identical ( EventSelector const &  a, EventSelector const &  b, unsigned int  N  )

staticprivate

Definition at line 445 of file EventSelector.cc.

References absolute_acceptors_, all_must_fail_, all_must_fail_noex_, conditional_acceptors_, exception_acceptors_, expandDecisionList(), and identical().

  {
    // create the expanded masks for the various decision lists in a and b
    if (!identical(expandDecisionList(a.absolute_acceptors_, true, N),
                   expandDecisionList(b.absolute_acceptors_, true, N)))
      return false;
    if (!identical(expandDecisionList(a.conditional_acceptors_, true, N),
                   expandDecisionList(b.conditional_acceptors_, true, N)))
      return false;
    if (!identical(expandDecisionList(a.absolute_acceptors_, false, N),
                   expandDecisionList(b.absolute_acceptors_, false, N)))
      return false;
    if (!identical(expandDecisionList(a.conditional_acceptors_, false, N),
                   expandDecisionList(b.conditional_acceptors_, false, N)))
      return false;
    if (!identical(expandDecisionList(a.exception_acceptors_, true, N),
                   expandDecisionList(b.exception_acceptors_, true, N)))
      return false;
    if (a.all_must_fail_.size() != b.all_must_fail_.size())
      return false;

    vector<vector<bool>> aMustFail;
    for (unsigned int m = 0; m != a.all_must_fail_.size(); ++m) {
      aMustFail.push_back(expandDecisionList(a.all_must_fail_[m], false, N));
    }
    vector<vector<bool>> aMustFailNoex;
    for (unsigned int m = 0; m != a.all_must_fail_noex_.size(); ++m) {
      aMustFailNoex.push_back(
        expandDecisionList(a.all_must_fail_noex_[m], false, N));
    }
    vector<vector<bool>> bMustFail;
    for (unsigned int m = 0; m != b.all_must_fail_.size(); ++m) {
      bMustFail.push_back(expandDecisionList(b.all_must_fail_[m], false, N));
    }
    vector<vector<bool>> bMustFailNoex;
    for (unsigned int m = 0; m != b.all_must_fail_noex_.size(); ++m) {
      bMustFailNoex.push_back(
        expandDecisionList(b.all_must_fail_noex_[m], false, N));
    }

    for (unsigned int m = 0; m != aMustFail.size(); ++m) {
      bool match = false;
      for (unsigned int k = 0; k != bMustFail.size(); ++k) {
        if (identical(aMustFail[m], bMustFail[k])) {
          match = true;
          break;
        }
      }
      if (!match)
        return false;
    }
    for (unsigned int m = 0; m != aMustFailNoex.size(); ++m) {
      bool match = false;
      for (unsigned int k = 0; k != bMustFailNoex.size(); ++k) {
        if (identical(aMustFailNoex[m], bMustFailNoex[k])) {
          match = true;
          break;
        }
      }
      if (!match)
        return false;
    }

    return true;

  } // identical (EventSelector, EventSelector, N);

void art::EventSelector::init ( Strings const &  paths, Strings const &  triggernames  )

private

Definition at line 36 of file EventSelector.cc.

References absolute_acceptors_, accept_all_, all_must_fail_, all_must_fail_noex_, conditional_acceptors_, art::errors::Configuration, exception_acceptors_, art::is_glob(), notStarPresent_, nTriggerNames_, and art::regexMatch().

Referenced by acceptEvent(), and EventSelector().

  {
    accept_all_ = false;
    absolute_acceptors_.clear(), conditional_acceptors_.clear(),
      exception_acceptors_.clear(), all_must_fail_.clear();
    all_must_fail_noex_.clear();
    nTriggerNames_ = triggernames.size();
    notStarPresent_ = false;

    if (paths.empty()) {
      accept_all_ = true;
      return;
    }

    // The following are for the purpose of establishing accept_all_ by
    // virtue of an inclusive set of paths:
    bool unrestricted_star = false;
    bool negated_star = false;
    bool exception_star = false;

    for (std::string const& pathSpecifier : paths) {

      string specifier{pathSpecifier};

      boost::erase_all(specifier, " \t"); // whitespace eliminated
      if (specifier == "*")
        unrestricted_star = true;
      if (specifier == "!*")
        negated_star = true;
      if (specifier == "exception@*")
        exception_star = true;

      // Remove "@noexception" from specifier
      bool noex_demanded{false};
      std::string const& noexLiteral{"&noexception"};
      auto const noexception_pos = specifier.find(noexLiteral);
      if (noexception_pos != string::npos) {
        if (noexception_pos + noexLiteral.length() < specifier.length()) {
          throw art::Exception(errors::Configuration)
            << "EventSelector::init, An OutputModule is using SelectEvents\n"
               "to request a trigger name that has extra characters after "
               "'&noexception'.\n"
            << "The improper trigger name is: " << pathSpecifier << "\n";
        }
        specifier.erase(noexception_pos);
        noex_demanded = true;
      }

      // Remove '!' and "exception@"
      bool negative_criterion{false};
      if (specifier[0] == '!') {
        negative_criterion = true;
        specifier.erase(0, 1);
      }
      bool exception_spec{false};
      std::string const& exLiteral{"exception@"};
      auto const pos = specifier.find(exLiteral);
      if (pos == 0) {
        exception_spec = true;
        specifier.erase(0, exLiteral.length());
      } else if (pos != std::string::npos) {
        throw art::Exception(errors::Configuration)
          << "EventSelector::init, An OutputModule is using SelectEvents\n"
             "to request a trigger name that has disallowed characters before "
             "'exception@'.\n"
          << "The improper trigger name is: " << pathSpecifier << "\n";
      }

      if (negative_criterion && exception_spec)
        throw art::Exception(errors::Configuration)
          << "EventSelector::init, An OutputModule is using SelectEvents\n"
             "to request a trigger name starting with !exception@.\n"
             "This is not supported.\n"
          << "The improper trigger name is: " << pathSpecifier << "\n";

      if (noex_demanded && exception_spec)
        throw art::Exception(errors::Configuration)
          << "EventSelector::init, An OutputModule is using SelectEvents\n"
             "to request a trigger name starting with exception@ "
             "and also demanding no &exceptions.\n"
          << "The improper trigger name is: " << pathSpecifier << "\n";

      // instead of "see if the name can be found in the full list of
      // paths" we want to find all paths that match this name.
      //
      // 'specifier' now corresponds to the real trigger-path name,
      // free of any decorations
      std::string const& realname{specifier};
      vector<Strings::const_iterator> matches =
        regexMatch(triggernames, realname);

      if (matches.empty()) {
        if (is_glob(realname)) {
          mf::LogWarning("Configuration")
            << "EventSelector::init, An OutputModule is using SelectEvents\n"
               "to request a wildcarded trigger name that does not match any "
               "trigger \n"
            << "The wildcarded trigger name is: " << realname
            << " (from trigger-path specification: " << pathSpecifier << ") \n";
        } else {
          throw art::Exception(errors::Configuration)
            << "EventSelector::init, An OutputModule is using SelectEvents\n"
               "to request a trigger name that does not exist\n"
            << "The unknown trigger name is: " << realname
            << " (from trigger-path specification: " << pathSpecifier << ") \n";
        }
      }

      auto makeBitInfoPass = [&triggernames](auto m) {
        return BitInfo(distance(triggernames.begin(), m), true);
      };

      auto makeBitInfoFail = [&triggernames](auto m) {
        return BitInfo(distance(triggernames.begin(), m), false);
      };

      if (!negative_criterion && !noex_demanded && !exception_spec) {
        cet::transform_all(
          matches, std::back_inserter(absolute_acceptors_), makeBitInfoPass);
      } else if (!negative_criterion && noex_demanded) {
        cet::transform_all(
          matches, std::back_inserter(conditional_acceptors_), makeBitInfoPass);
      } else if (exception_spec) {
        cet::transform_all(
          matches, std::back_inserter(exception_acceptors_), makeBitInfoPass);
      } else if (negative_criterion && !noex_demanded) {
        if (matches.empty()) {
          throw art::Exception(errors::Configuration)
            << "EventSelector::init, An OutputModule is using SelectEvents\n"
               "to request all fails on a set of trigger names that do not "
               "exist\n"
            << "The problematic name is: " << pathSpecifier << "\n";

        } else if (matches.size() == 1) {
          BitInfo bi(distance(triggernames.begin(), matches[0]), false);
          absolute_acceptors_.push_back(bi);
        } else {
          Bits mustfail;
          // We set this to false because that will demand bits are Fail.
          cet::transform_all(
            matches, std::back_inserter(mustfail), makeBitInfoFail);
          all_must_fail_.push_back(mustfail);
        }
      } else if (negative_criterion && noex_demanded) {
        if (matches.empty()) {
          throw art::Exception(errors::Configuration)
            << "EventSelector::init, An OutputModule is using SelectEvents\n"
               "to request all fails on a set of trigger names that do not "
               "exist\n"
            << "The problematic name is: " << pathSpecifier << "\n";
        } else if (matches.size() == 1) {
          BitInfo bi(distance(triggernames.begin(), matches[0]), false);
          conditional_acceptors_.push_back(bi);
        } else {
          Bits mustfail;
          cet::transform_all(
            matches, std::back_inserter(mustfail), makeBitInfoFail);
          all_must_fail_noex_.push_back(mustfail);
        }
      }
    } // for (std::string pathSpecifier : paths)

    if (unrestricted_star && negated_star && exception_star)
      accept_all_ = true;

  } // EventSelector::init

std::shared_ptr< TriggerResults > art::EventSelector::maskTriggerResults

(

TriggerResults const &

inputResults

)

Applies a trigger selection mask to a specified trigger result object. Within the trigger result object, each path status is left unchanged if it satisfies the trigger selection (path specs) or cleared if it does not satisfy the trigger selection. In this way, the resulting trigger result object contains only path status values that "pass" the selection criteria.

Parameters

inputResults

The raw trigger results object that will be masked.

Returns

a copy of the input trigger results object with only the path status results that match the trigger selection.

Exceptions

art::Exception

if the number of paths in the TriggerResults object does not match the specified full trigger list, or if the trigger selection is invalid in the context of the full trigger list.

Definition at line 342 of file EventSelector.cc.

References absolute_acceptors_, all_must_fail_, all_must_fail_noex_, conditional_acceptors_, art::errors::DataCorruption, art::hlt::Exception, exception_acceptors_, expandDecisionList(), f, art::hlt::Fail, nTriggerNames_, art::TriggerResults::parameterSetID(), art::hlt::Pass, s, art::HLTGlobalStatus::size(), and art::HLTGlobalStatus::state().

  {
    // fetch and validate the total number of paths
    unsigned int const N = nTriggerNames_;
    if (N != inputResults.size()) {
      throw art::Exception(errors::DataCorruption)
        << "EventSelector::maskTriggerResults, the TriggerResults\n"
        << "size (" << inputResults.size()
        << ") does not match the number of paths in the\n"
        << "full trigger list (" << N << ").\n";
    }

    // create a suitable global status object to work with, all in Ready state
    HLTGlobalStatus mask{N};

    // Deal with must_fail acceptors that would cause selection
    for (auto const& mf : all_must_fail_) {
      vector<bool> const f = expandDecisionList(mf, false, N);
      bool all_fail = true;
      for (unsigned int ipath = 0; ipath < N; ++ipath) {
        if ((f[ipath]) && (inputResults[ipath].state() != hlt::Fail)) {
          all_fail = false;
          break;
        }
      }
      if (all_fail) {
        for (unsigned int ipath = 0; ipath < N; ++ipath) {
          if (f[ipath]) {
            mask[ipath] = hlt::Fail;
          }
        }
      }
    }
    for (auto const& mf_noex : all_must_fail_noex_) {
      vector<bool> const f = expandDecisionList(mf_noex, false, N);
      bool all_fail = true;
      for (unsigned int ipath = 0; ipath < N; ++ipath) {
        if ((f[ipath]) && (inputResults[ipath].state() != hlt::Fail)) {
          all_fail = false;
          break;
        }
      }
      if (all_fail) {
        for (unsigned int ipath = 0; ipath < N; ++ipath) {
          if (f[ipath]) {
            mask[ipath] = hlt::Fail;
          }
        }
      }
    } // factoring opportunity - work done for fail_noex_ is same as for fail_

    // Deal with normal acceptors that would cause selection
    vector<bool> aPassAbs = expandDecisionList(absolute_acceptors_, true, N);
    vector<bool> aPassCon = expandDecisionList(conditional_acceptors_, true, N);
    vector<bool> aFailAbs = expandDecisionList(absolute_acceptors_, false, N);
    vector<bool> aFailCon =
      expandDecisionList(conditional_acceptors_, false, N);
    vector<bool> aExc = expandDecisionList(exception_acceptors_, true, N);

    for (unsigned int ipath = 0; ipath < N; ++ipath) {
      hlt::HLTState s = inputResults[ipath].state();
      if (((aPassAbs[ipath]) && (s == hlt::Pass)) ||
          ((aPassCon[ipath]) && (s == hlt::Pass)) ||
          ((aFailAbs[ipath]) && (s == hlt::Fail)) ||
          ((aFailCon[ipath]) && (s == hlt::Fail)) ||
          ((aExc[ipath]) && (s == hlt::Exception))) {
        mask[ipath] = s;
      }
    }

    // Based on the global status for the mask, create and return a
    // TriggerResults
    return std::make_shared<TriggerResults>(mask,
                                            inputResults.parameterSetID());
  } // maskTriggerResults

static std::vector<Strings::const_iterator> art::EventSelector::matching_triggers ( Strings const &  trigs, std::string const &  s  )

staticprivate

bool art::EventSelector::overlapping ( std::vector< bool > const &  a, std::vector< bool > const &  b  )

staticprivate

Definition at line 529 of file EventSelector.cc.

  {
    if (a.size() != b.size())
      return false;
    for (unsigned int i = 0; i != a.size(); ++i) {
      if (a[i] && b[i])
        return true;
    }
    return false;
  } // overlapping

bool art::EventSelector::selectionDecision ( HLTGlobalStatus const &  tr ) const

private

Definition at line 252 of file EventSelector.cc.

References absolute_acceptors_, accept_all_, acceptAllBits(), acceptOneBit(), all_must_fail_, all_must_fail_noex_, conditional_acceptors_, containsExceptions(), art::hlt::Exception, exception_acceptors_, and f.

Referenced by acceptEvent().

  {
    if (accept_all_)
      return true;

    bool exceptionPresent = false;
    bool exceptionsLookedFor = false;

    if (acceptOneBit(absolute_acceptors_, tr))
      return true;
    if (acceptOneBit(conditional_acceptors_, tr)) {
      exceptionPresent = containsExceptions(tr);
      if (!exceptionPresent)
        return true;
      exceptionsLookedFor = true;
    }
    if (acceptOneBit(exception_acceptors_, tr, hlt::Exception))
      return true;

    for (auto const& f : all_must_fail_) {
      if (acceptAllBits(f, tr))
        return true;
    }

    for (auto const& fn : all_must_fail_noex_) {
      if (acceptAllBits(fn, tr)) {
        if (!exceptionsLookedFor) {
          exceptionPresent = containsExceptions(tr);
        }
        return !exceptionPresent;
      }
    }

    // If we have not accepted based on any of the acceptors, nor on any one of
    // the all_must_fail_ collections, then we reject this event.

    return false;

  } // selectionDecision()

bool art::EventSelector::subset ( std::vector< bool > const &  a, std::vector< bool > const &  b  )

staticprivate

Definition at line 543 of file EventSelector.cc.

  {
    if (a.size() != b.size())
      return false;
    // First test whether a is a non-empty subset of b
    bool aPresent = false;
    bool aSubset = true;
    for (unsigned int i = 0; i != a.size(); ++i) {
      if (a[i]) {
        aPresent = true;
        if (!b[i]) {
          aSubset = false;
          break;
        }
      }
    }
    if (!aPresent)
      return false;
    if (aSubset)
      return true;

    // Now test whether b is a non-empty subset of a
    bool bPresent = false;
    bool bSubset = true;
    for (unsigned int i = 0; i != b.size(); ++i) {
      if (b[i]) {
        bPresent = true;
        if (!a[i]) {
          bSubset = false;
          break;
        }
      }
    }
    if (!bPresent)
      return false;
    if (bSubset)
      return true;

    return false;
  } // subset

bool art::EventSelector::wantAll ( ) const

inline

Definition at line 45 of file EventSelector.h.

    {
      return accept_all_;
    }

Member Data Documentation

Bits art::EventSelector::absolute_acceptors_ {}

private

Definition at line 68 of file EventSelector.h.

Referenced by identical(), init(), maskTriggerResults(), and selectionDecision().

bool art::EventSelector::accept_all_ {false}

private

Definition at line 67 of file EventSelector.h.

Referenced by acceptEvent(), init(), and selectionDecision().

std::vector<Bits> art::EventSelector::all_must_fail_ {}

private

Definition at line 71 of file EventSelector.h.

Referenced by identical(), init(), maskTriggerResults(), and selectionDecision().

std::vector<Bits> art::EventSelector::all_must_fail_noex_ {}

private

Definition at line 72 of file EventSelector.h.

Referenced by identical(), init(), maskTriggerResults(), and selectionDecision().

Bits art::EventSelector::conditional_acceptors_ {}

private

Definition at line 69 of file EventSelector.h.

Referenced by identical(), init(), maskTriggerResults(), and selectionDecision().

Bits art::EventSelector::exception_acceptors_ {}

private

Definition at line 70 of file EventSelector.h.

Referenced by identical(), init(), maskTriggerResults(), and selectionDecision().

bool art::EventSelector::notStarPresent_ {false}

private

Definition at line 81 of file EventSelector.h.

Referenced by init().

int art::EventSelector::nTriggerNames_ {0}

private

Definition at line 80 of file EventSelector.h.

Referenced by init(), and maskTriggerResults().

Strings art::EventSelector::paths_ {}

private

Definition at line 78 of file EventSelector.h.

Referenced by acceptEvent().

fhicl::ParameterSetID art::EventSelector::psetID_ {}

private

Definition at line 76 of file EventSelector.h.

Referenced by acceptEvent().

bool art::EventSelector::psetID_initialized_ {false}

private

Definition at line 75 of file EventSelector.h.

Referenced by acceptEvent().

bool art::EventSelector::results_from_current_process_ {true}

private

Definition at line 74 of file EventSelector.h.

Referenced by acceptEvent().

---

The documentation for this class was generated from the following files:

• art/Framework/Core/EventSelector.h
• art/Framework/Core/EventSelector.cc