art::EventSelector Class Reference

#include <EventSelector.h>

Classes
struct	BitInfo
struct	ScheduleData

Public Member Functions
	EventSelector (std::vector< std::string > const &pathspecs)
bool	acceptEvent (ScheduleID id, TriggerResults const &tr) const

Private Member Functions
ScheduleData	data_for (TriggerResults const &tr) const
bool	selectionDecision (ScheduleData const &data, HLTGlobalStatus const &) const

Private Attributes
std::vector< std::string > const	path_specs_
bool const	accept_all_
PerScheduleContainer< ScheduleData >	acceptors_

Detailed Description

Definition at line 14 of file EventSelector.h.

Constructor & Destructor Documentation

art::EventSelector::EventSelector ( std::vector< std::string > const &  pathspecs )

explicit

Definition at line 148 of file EventSelector.cc.

    : path_specs_{pathspecs}, accept_all_{accept_all(path_specs_)}
  {
    acceptors_.expand_to_num_schedules();
  }

Member Function Documentation

bool art::EventSelector::acceptEvent	(	ScheduleID	id,
		TriggerResults const &	tr
	)		const

Definition at line 309 of file EventSelector.cc.

  {
    if (accept_all_) {
      return true;
    }

    auto& data = acceptors_.at(id);
    if (data.psetID != tr.parameterSetID()) {
      data = data_for(tr);
    }
    return selectionDecision(data, tr);
  }

EventSelector::ScheduleData art::EventSelector::data_for ( TriggerResults const &  tr ) const

private

Definition at line 156 of file EventSelector.cc.

  {
    fhicl::ParameterSet pset;
    if (!fhicl::ParameterSetRegistry::get(tr.parameterSetID(), pset)) {
      // This should never happen
      throw 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";
    }
    auto const trigger_path_specs =
      pset.get<vector<string>>("trigger_paths", {});
    if (trigger_path_specs.size() != tr.size()) {
      throw Exception(errors::Unknown)
        << "EventSelector::acceptEvent: Trigger names vector and\n"
        << "TriggerResults are different sizes.  This should be impossible,\n"
        << "please send information to reproduce this problem to\n"
        << "the art developers.\n";
    }

    std::vector<BitInfo> absolute_acceptors;
    std::vector<BitInfo> conditional_acceptors;
    std::vector<BitInfo> exception_acceptors;
    std::vector<std::vector<BitInfo>> all_must_fail;
    std::vector<std::vector<BitInfo>> all_must_fail_noex;

    for (string const& pathSpecifier : path_specs_) {
      string specifier{pathSpecifier};

      bool const noex_demanded = remove_noexception(pathSpecifier, specifier);
      bool const negative_criterion = remove_negation(specifier);
      bool const exception_spec = remove_exception(pathSpecifier, specifier);

      if (negative_criterion && exception_spec) {
        throw Exception(errors::Configuration)
          << "EventSelector::init, A module 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 Exception(errors::Configuration)
          << "EventSelector::init, A module is using SelectEvents\n"
          << "to request a trigger name starting with exception@ "
          << "and also demanding &noexception.\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.
      string const& realname{specifier};
      auto const matches = regexMatch(trigger_path_specs, realname);
      if (matches.empty()) {
        if (is_glob(realname)) {
          mf::LogWarning("Configuration")
            << "EventSelector::init, A module 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 Exception(errors::Configuration)
            << "EventSelector::init, A module 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 = [&trigger_path_specs](auto m) {
        return BitInfo{path_position(trigger_path_specs, m), true};
      };
      auto makeBitInfoFail = [&trigger_path_specs](auto m) {
        return BitInfo{path_position(trigger_path_specs, m), false};
      };

      if (!negative_criterion && !noex_demanded && !exception_spec) {
        cet::transform_all(
          matches, back_inserter(absolute_acceptors), makeBitInfoPass);
        continue;
      }

      if (!negative_criterion && noex_demanded) {
        cet::transform_all(
          matches, back_inserter(conditional_acceptors), makeBitInfoPass);
        continue;
      }

      if (exception_spec) {
        cet::transform_all(
          matches, back_inserter(exception_acceptors), makeBitInfoPass);
        continue;
      }

      if (negative_criterion && !noex_demanded) {
        if (matches.empty()) {
          throw Exception(errors::Configuration)
            << "EventSelector::init, A module 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";
        }

        if (matches.size() == 1) {
          BitInfo bi{path_position(trigger_path_specs, matches[0]), false};
          absolute_acceptors.push_back(bi);
        } else {
          // We set this to false because that will demand bits are Fail.
          auto must_fail = matches | ranges::views::transform(makeBitInfoFail) |
                           ranges::to_vector;
          all_must_fail.push_back(move(must_fail));
        }
        continue;
      }

      if (negative_criterion && noex_demanded) {
        if (matches.empty()) {
          throw Exception(errors::Configuration)
            << "EventSelector::init, A module 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";
        }

        if (matches.size() == 1) {
          BitInfo bi{path_position(trigger_path_specs, matches[0]), false};
          conditional_acceptors.push_back(bi);
        } else {
          auto must_fail = matches | ranges::views::transform(makeBitInfoFail) |
                           ranges::to_vector;
          all_must_fail_noex.push_back(move(must_fail));
        }
      }
    }
    return ScheduleData{tr.parameterSetID(),
                        absolute_acceptors,
                        conditional_acceptors,
                        exception_acceptors,
                        all_must_fail,
                        all_must_fail_noex};
  }

bool art::EventSelector::selectionDecision ( ScheduleData const &  data, HLTGlobalStatus const &  tr  ) const

private

Definition at line 324 of file EventSelector.cc.

  {
    if (accept_all_) {
      return true;
    }

    if (any_bit(data.absolute_acceptors, tr)) {
      return true;
    }

    bool exceptionPresent = false;
    bool exceptionsLookedFor = false;
    if (any_bit(data.conditional_acceptors, tr)) {
      exceptionPresent = tr.error();
      if (!exceptionPresent) {
        return true;
      }
      exceptionsLookedFor = true;
    }

    if (any_bit(data.exception_acceptors, tr, hlt::Exception)) {
      return true;
    }

    for (auto const& f : data.all_must_fail) {
      if (all_bits(f, tr)) {
        return true;
      }
    }

    for (auto const& fn : data.all_must_fail_noex) {
      if (all_bits(fn, tr)) {
        if (!exceptionsLookedFor) {
          exceptionPresent = tr.error();
        }
        return !exceptionPresent;
      }
    }
    return false;
  }

Member Data Documentation

bool const art::EventSelector::accept_all_

private

Definition at line 27 of file EventSelector.h.

PerScheduleContainer<ScheduleData> art::EventSelector::acceptors_

mutableprivate

Definition at line 36 of file EventSelector.h.

std::vector<std::string> const art::EventSelector::path_specs_

private

Definition at line 26 of file EventSelector.h.

---

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

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