recon::SequentialTrigger Class Reference

Class that provides a trigger skimming decision from multiple Triggers based on either AND or OR. More...

#include <SequentialTrigger.h>

Public Member Functions
	SequentialTrigger (const std::string &name, framework::Process &process)
	Class constructor.
virtual	~SequentialTrigger ()=default
	Class destructor.
void	configure (framework::config::Parameters &parameters) override
	Configure the processor using the given user specified parameters.
void	produce (framework::Event &event) override
	Run the doOR or doAND check and create a SequentialTrigger object to contain the pass boolean value.
Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.
virtual void	beforeNewRun (ldmx::RunHeader &header)
	Handle allowing producers to modify run headers before the run begins.
Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()
	Class destructor.
virtual void	onNewRun (const ldmx::RunHeader &runHeader)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.
virtual void	onFileOpen (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.
virtual void	onProcessStart ()
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.
virtual void	onProcessEnd ()
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.
template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.
TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.
void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module.
void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.
int	getLogFrequency () const
	Get the current logging frequency from the process.
int	getRunNumber () const
	Get the run number from the process.
std::string	getName () const
	Get the processor name.
void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Attributes
std::vector< std::string >	trigger_list_
	The name of the input collection of triggers.
std::vector< std::string >	trigger_passNames_
	pass name of the triggers
bool	doOR_
	options to enable OR or AND skimming
bool	doAND_
bool	doVAL_
	enables a output collection with the keep tag for the purposes of validation

Additional Inherited Members
Static Public Member Functions inherited from framework::EventProcessor
static void	declare (const std::string &classname, int classtype, EventProcessorMaker *)
	Internal function which is part of the PluginFactory machinery.
Static Public Attributes inherited from framework::Producer
static const int	CLASSTYPE {1}
	Constant used to track EventProcessor types by the PluginFactory.
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from framework::EventProcessor
HistogramHelper	histograms_
	Interface class for making and filling histograms.
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	theLog_
	The logger for this EventProcessor.

Detailed Description

Class that provides a trigger skimming decision from multiple Triggers based on either AND or OR.

• Note

  TriggerProcessor takes in a set of parameters to determine whether, upon an input collection of triggers, an OR or AND descision will be made. Each trigger layer is obtained after TriggerProcessor is run, and then running through the array the first pass returns true for doOR_ and the first fail false for doAND_. Once at worst all triggers are run through, we set the keep event flag to the resultant doOR or doAND result. If doVAL is set to true, we produce and output collection with this boolean value.

Definition at line 34 of file SequentialTrigger.h.

Constructor & Destructor Documentation

SequentialTrigger()

recon::SequentialTrigger::SequentialTrigger ( const std::string &  name, framework::Process &  process  )

inline

Class constructor.

Definition at line 39 of file SequentialTrigger.h.

      : framework::Producer(name, process) {}

Member Function Documentation

configure()

void recon::SequentialTrigger::configure ( framework::config::Parameters &  ps )

overridevirtual

Configure the processor using the given user specified parameters.

Instantiates the variables used in this processor.

Parameters

parameters

Set of parameters used to configure this processor.

We take trigger_list_ and trigger_passNames_ to obtain trigger collections, a doOR_ and doAND_ option to check if one of or all events pass, and doVAL_ to output a validation collection

Reimplemented from framework::EventProcessor.

Definition at line 14 of file SequentialTrigger.cxx.

                                                               {
  trigger_list_ = ps.getParameter<std::vector<std::string>>("trigger_list");
  trigger_passNames_ =
      ps.getParameter<std::vector<std::string>>("trigger_passNames");
  doAND_ = ps.getParameter<bool>("doAND");
  doOR_ = ps.getParameter<bool>("doOR");
  doVAL_ = ps.getParameter<bool>("doVAL");
  // Returns an error if some bad combination of doOR and doAND is enabled.
  if (doAND_ == doOR_) {
    EXCEPTION_RAISE("InvalidArg",
                    "Either tried to do both or neither of doAND and doOR. "
                    "Exactly one should be true.");
  }
  return;
}

References doOR_, doVAL_, framework::config::Parameters::getParameter(), trigger_list_, and trigger_passNames_.

produce()

void recon::SequentialTrigger::produce ( framework::Event &  event )

overridevirtual

Run the doOR or doAND check and create a SequentialTrigger object to contain the pass boolean value.

This producer takes in a list of triggers and runs an OR or AND skimmer depending on the config file.

Also sets the Storage Hint. param event The event to run skimmer on.

It will change the keep tag and produce nothing. This is unless the validation command is set to true, in which case it produces a boolean collection in an output file with the keeping flag.

Implements framework::Producer.

Definition at line 40 of file SequentialTrigger.cxx.

                                                     {
  bool hasPassed = not(doOR_) or (doAND_);
 
  for (int i = 0; i < trigger_list_.size(); i++) {
    // Returns an error is a trigger collection DNE
    try {
      auto trigResult{event.getObject<ldmx::TriggerResult>(
          trigger_list_[i], trigger_passNames_[i])};
 
      // Returns true should any trigger pass and doOR_ enabled, and returns
      // false if doAND_ and any fail
      if (trigResult.passed()) {
        if (doOR_) {
          hasPassed = true;
          break;
        }
      } else {
        if (doAND_) {
          hasPassed = false;
          break;
        }
      }
    } catch (...) {
      std::string errorMessage =
          "Attemping to use non-existing trigger collection " +
          trigger_list_[i] + "_" + trigger_passNames_[i] + " to skim! Exiting.";
      EXCEPTION_RAISE("InvalidArg", errorMessage.data());
      return;
    }
  }
 
  // Used to validate if code was working
  if (doVAL_) {
    event.add("validation", hasPassed);
  }
  // mark the event
  if (hasPassed)
    setStorageHint(framework::hint_shouldKeep);
  else
    setStorageHint(framework::hint_shouldDrop);
}

References doOR_, doVAL_, framework::hint_shouldDrop, framework::hint_shouldKeep, framework::EventProcessor::setStorageHint(), trigger_list_, and trigger_passNames_.

Member Data Documentation

doAND_

bool recon::SequentialTrigger::doAND_

private

Definition at line 71 of file SequentialTrigger.h.

doOR_

bool recon::SequentialTrigger::doOR_

private

options to enable OR or AND skimming

Definition at line 70 of file SequentialTrigger.h.

Referenced by configure(), and produce().

doVAL_

bool recon::SequentialTrigger::doVAL_

private

enables a output collection with the keep tag for the purposes of validation

Definition at line 77 of file SequentialTrigger.h.

Referenced by configure(), and produce().

trigger_list_

std::vector<std::string> recon::SequentialTrigger::trigger_list_

private

The name of the input collection of triggers.

Definition at line 64 of file SequentialTrigger.h.

Referenced by configure(), and produce().

trigger_passNames_

std::vector<std::string> recon::SequentialTrigger::trigger_passNames_

private

pass name of the triggers

Definition at line 67 of file SequentialTrigger.h.

Referenced by configure(), and produce().

---

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

• Recon/include/Recon/SequentialTrigger.h
• Recon/src/Recon/SequentialTrigger.cxx