Filter module using a response an existing trigger path response. More...

Inheritance diagram for FilterOnArtPathOutcome:

Classes
struct	Config

struct	TriggerSpec

Public Types
using	Parameters = art::SharedFilter::Table< Config >

Public Member Functions
	FilterOnArtPathOutcome (Parameters const &params, const art::ProcessingFrame &)
	Constructor. No surprise here. More...

virtual bool	filter (art::Event &event, const art::ProcessingFrame &) override

Private Member Functions
art::TriggerResults const &	readTriggerResults (art::Event const &event, art::InputTag const &tag) const
	Reads the needed trigger data product, and throws if not found. More...

art::HLTPathStatus const &	findPath (art::TriggerResults const &results, std::string const &name) const

std::vector< std::string >	pathNames (art::TriggerResults const &results) const

bool	responseFromPath (art::HLTPathStatus const &path) const
	Translates a path status into the response from this filter. More...

Static Private Member Functions
static TriggerSpec	parseTriggerSpec (std::string const &spec)
	Parses a trigger path specification. More...

Private Attributes
TriggerSpec const	fTriggerSpec
	Trigger configuration. More...

bool const	fResponseWhenNotRun
	What to do if path was not run at all. More...

bool const	fResponseOnError
	What to do if path ended with error. More...

Detailed Description

Filter module using a response an existing trigger path response.

This filter emits the same response as for a art path (not just a filter) that was run previously.

Input

Given a configured Path, this module reads from the event the data product named TriggerResults (art::TriggerResults type) from the process specified in that configuration parameter.

Configuration parameters

Path (string, mandatory): the trigger path specification in the form process:path name.

Definition at line 55 of file FilterOnArtPathOutcome_module.cc.

Member Typedef Documentation

using FilterOnArtPathOutcome::Parameters = art::SharedFilter::Table<Config>

Definition at line 82 of file FilterOnArtPathOutcome_module.cc.

Constructor & Destructor Documentation

FilterOnArtPathOutcome::FilterOnArtPathOutcome	(	Parameters const &	params,
		const art::ProcessingFrame &
	)

Constructor. No surprise here.

Definition at line 129 of file FilterOnArtPathOutcome_module.cc.

   : art::SharedFilter{ params }
   , fTriggerSpec       { parseTriggerSpec(params().Path()) }
   , fResponseWhenNotRun{ params().ResponseWhenNotRun() }
   , fResponseOnError   { params().ResponseOnError() }
 {
   
   async<art::InEvent>();
   
 } // FilterOnArtPathOutcome::FilterOnArtPathOutcome()

Member Function Documentation

bool FilterOnArtPathOutcome::filter	(	art::Event &	event,
		const art::ProcessingFrame &
	)

overridevirtual

Definition at line 143 of file FilterOnArtPathOutcome_module.cc.

 {
   
   art::TriggerResults const& trgResults
     = readTriggerResults(event, fTriggerSpec.tag);
   
   art::HLTPathStatus const& path = findPath(trgResults, fTriggerSpec.path);
   
   return responseFromPath(path);
   
 } // FilterOnArtPathOutcome::filter()

art::HLTPathStatus const & FilterOnArtPathOutcome::findPath	(	art::TriggerResults const &	results,
		std::string const &	name
	)		const

private

Returns the status of the path with the required name.

Exceptions

cet::exception if not found

Definition at line 198 of file FilterOnArtPathOutcome_module.cc.

 {
   std::vector<std::string> const names = pathNames(results);
   
   //
   // find the proper one...
   //
   
   auto iPathName = names.end();
   do { // quick-exit block
     
     // try verbatim first:
     iPathName = std::find(names.begin(), names.end(), name);
     if (iPathName != names.end()) break;
     
     // art has the custom of prepending an index to the name ("<index>:<name>");
     // let's try to ignore it
     iPathName = std::find_if(names.begin(), names.end(), 
       [name](std::string const& s)
         {
           std::size_t const iSep = s.find(':');
           return ((iSep == std::string::npos)? s: s.substr(iSep+1)) == name;
         }
       );
   
   } while (false);
   
   if (iPathName == names.end()) {
     cet::exception e{ "FilterOnArtPathOutcome" };
     e << "The trigger path '" << fTriggerSpec.tag.process()
       << "' does not include '" << name << "'! The " << names.size()
       << " available paths are:";
     for (std::string const& pathName: names)
       e << "\n - '" << pathName << "'";
     throw e << "\n";
   }
   
   // in principle we could also extract the index from the name; we don't.
   std::size_t const pathIndex = std::distance(names.begin(), iPathName);
   
   return results.at(pathIndex);
   
 } // FilterOnArtPathOutcome::findPath()

auto FilterOnArtPathOutcome::parseTriggerSpec ( std::string const & spec )

staticprivate

Parses a trigger path specification.

Definition at line 294 of file FilterOnArtPathOutcome_module.cc.

 {
   std::string processName, pathName;
   auto const iSep = spec.find(':');
   if (iSep == std::string::npos) {
     pathName = spec;
   }
   else {
     processName = spec.substr(0, iSep);
     pathName = spec.substr(iSep + 1);
   }
   
   return { art::InputTag{ "TriggerResults", "", processName }, pathName };
   
 } // FilterOnArtPathOutcome::parseTriggerSpec()

std::vector< std::string > FilterOnArtPathOutcome::pathNames ( art::TriggerResults const & results ) const

private

Returns the list of path names stored in results.

Exceptions

art::Exception (code: art::errors::Unknown) on logic errors

Definition at line 245 of file FilterOnArtPathOutcome_module.cc.

 {
   //
   // list of paths for this event;
   // copied from art/Framework/Core/EventSelector.cc of art 3.9.3, `dataFor()`:
   //
   fhicl::ParameterSet pset;
   if (!fhicl::ParameterSetRegistry::get(results.parameterSetID(), pset)) {
     // "This should never happen";
     // just in case, I leave the message and blame to art
     throw art::Exception(art::errors::Unknown)
       << "FilterOnArtPathOutcome::findPath 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 names = pset.get<std::vector<std::string>>("trigger_paths", {});
   if (names.size() != results.size()) {
     throw art::Exception(art::errors::Unknown)
       << "FilterOnArtPathOutcome::findPath: path names vector and\n"
       << "TriggerResults are different sizes (" << names.size()
       << " vs. " << results.size() << ").  This should be impossible,\n"
       << "please send information to reproduce this problem to\n"
       << "the art developers.\n";
   }
   
   return names;
   
 } // FilterOnArtPathOutcome::pathNames()

art::TriggerResults const & FilterOnArtPathOutcome::readTriggerResults	(	art::Event const &	event,
		art::InputTag const &	tag
	)		const

private

Reads the needed trigger data product, and throws if not found.

Definition at line 158 of file FilterOnArtPathOutcome_module.cc.

 {
 
   try {
     return event.getProduct<art::TriggerResults>(tag);
   }
   catch (art::Exception const& e) {
     if (e.categoryCode() != art::errors::ProductNotFound) throw;
     
     std::optional<std::vector<art::InputTag>> available;
     try {
       std::vector<art::Handle<art::TriggerResults>> const& triggerHandles
         = event.getMany<art::TriggerResults>();
       available.emplace();
       for (art::Handle<art::TriggerResults> const& handle: triggerHandles) {
         if (handle.isValid() && handle.provenance())
           available->push_back(handle.provenance()->inputTag());
       } // for
     }
     catch (...) {} // we tried to be nice, and failed.
     
     art::Exception msg { e.categoryCode(), "", e };
     msg << "Trigger data product '" << tag.encode() << "' not found.";
     if (available) {
       msg << "\n" << available->size() << " trigger products available";
       if (available->empty()) msg << ".";
       else {
         msg << ":";
         for (art::InputTag const& tag: *available)
           msg << "\n - '" << tag.encode() << "'";
       } // if ... else
     } // if available
     throw msg << "\n";
   }
   
 } // FilterOnArtPathOutcome::readTriggerResults()

bool FilterOnArtPathOutcome::responseFromPath ( art::HLTPathStatus const & path ) const

private

Translates a path status into the response from this filter.

Definition at line 279 of file FilterOnArtPathOutcome_module.cc.

 {
   
   if (!path.wasrun()) { // path was not run at all
     return fResponseWhenNotRun;
   }
   else if (path.error()) { // path terminated with an exception
     return fResponseOnError;
   }
   else return path.accept();
   
 } // FilterOnArtPathOutcome::responseFromPath()