#include <TriggerExpressionL1uGTReader.h>

Inheritance diagram for triggerExpression::L1uGTReader:

Public Member Functions
void	dump (std::ostream &out, bool const ignoreMasks=false) const override

void	init (const Data &data) override

	L1uGTReader (const std::string &pattern)

void	mask (Evaluator const &eval) override

bool	operator() (const Data &data) const override

std::vector< std::pair< std::string, unsigned int > >	triggers () const override

std::vector< std::pair< std::string, unsigned int > >	triggersAfterMasking () const

Public Member Functions inherited from triggerExpression::Evaluator
virtual void	disableMasks ()

virtual void	enableMasks ()

	Evaluator ()=default

virtual bool	masksEnabled () const

virtual std::vector< std::string >	patterns () const

virtual	~Evaluator ()=default

Private Attributes
bool	m_initialised

std::string	m_pattern

std::vector< std::pair< std::string, unsigned int > >	m_triggers

std::vector< std::pair< std::string, unsigned int > >	m_triggersAfterMasking

Detailed Description

Definition at line 8 of file TriggerExpressionL1uGTReader.h.

Constructor & Destructor Documentation

◆ L1uGTReader()

triggerExpression::L1uGTReader::L1uGTReader ( const std::string & pattern )

inline

Definition at line 10 of file TriggerExpressionL1uGTReader.h.

References topSingleLeptonDQM_PU_cfi::pattern.

11 : m_pattern{pattern}, m_triggers{}, m_triggersAfterMasking{}, m_initialised{false} {}

topSingleLeptonDQM_PU_cfi.pattern

pattern

Definition: topSingleLeptonDQM_PU_cfi.py:39

triggerExpression::L1uGTReader::m_triggers

std::vector< std::pair< std::string, unsigned int > > m_triggers

Definition: TriggerExpressionL1uGTReader.h:26

triggerExpression::L1uGTReader::m_triggersAfterMasking

std::vector< std::pair< std::string, unsigned int > > m_triggersAfterMasking

Definition: TriggerExpressionL1uGTReader.h:27

triggerExpression::L1uGTReader::m_initialised

bool m_initialised

Definition: TriggerExpressionL1uGTReader.h:28

triggerExpression::L1uGTReader::m_pattern

std::string m_pattern

Definition: TriggerExpressionL1uGTReader.h:25

Member Function Documentation

◆ dump()

void triggerExpression::L1uGTReader::dump	(	std::ostream &	out,
		bool const	ignoreMasks = `false`
	)		const

overridevirtual

Implements triggerExpression::Evaluator.

Definition at line 30 of file TriggerExpressionL1uGTReader.cc.

References first, mps_fire::i, m_initialised, m_triggers, m_triggersAfterMasking, triggerExpression::Evaluator::masksEnabled(), or, MillePedeFileConverter_cfg::out, and triggers().

                                                                       {
     if (not m_initialised) {
       out << "Uninitialised_L1_Expression";
       return;
     }
 
     auto const& triggers = ignoreMasks or not masksEnabled() ? m_triggers : m_triggersAfterMasking;
 
     if (triggers.empty()) {
       out << "FALSE";
     } else if (triggers.size() == 1) {
       out << triggers[0].first;
     } else {
       out << "(" << triggers[0].first;
       for (unsigned int i = 1; i < triggers.size(); ++i)
         out << " OR " << triggers[i].first;
       out << ")";
     }
   }

◆ init()

void triggerExpression::L1uGTReader::init ( const Data & data )

overridevirtual

Reimplemented from triggerExpression::Evaluator.

Definition at line 50 of file TriggerExpressionL1uGTReader.cc.

References data, mps_splice::entry, edm::glob2reg(), edm::is_glob(), m_initialised, m_pattern, m_triggers, m_triggersAfterMasking, and optionsL1T::menu.

                                          {
     if (not data.hasL1T())
       return;
 
     const L1TUtmTriggerMenu& menu = data.l1tMenu();
 
     // clear the previous configuration
     m_triggers.clear();
 
     // check if the pattern has is a glob expression, or a single trigger name
     auto const& triggerMap = menu.getAlgorithmMap();
     if (not edm::is_glob(m_pattern)) {
       // no wildcard expression
       auto entry = triggerMap.find(m_pattern);
       if (entry != triggerMap.end()) {
         // single L1 bit
         m_triggers.push_back(std::make_pair(m_pattern, entry->second.getIndex()));
       } else {
         // trigger not found in the current menu
         if (data.shouldThrow())
           throw cms::Exception("Configuration")
               << "requested L1 trigger \"" << m_pattern << "\" does not exist in the current L1 menu";
         else
           edm::LogWarning("Configuration")
               << "requested L1 trigger \"" << m_pattern << "\" does not exist in the current L1 menu";
       }
     } else {
       // expand wildcards in the pattern
       bool match = false;
       std::regex re(edm::glob2reg(m_pattern));
       for (auto const& entry : triggerMap)
         if (std::regex_match(entry.first, re)) {
           match = true;
           m_triggers.push_back(std::make_pair(entry.first, entry.second.getIndex()));
         }
 
       if (not match) {
         // m_pattern does not match any L1 bits
         if (data.shouldThrow())
           throw cms::Exception("Configuration")
               << "requested pattern \"" << m_pattern << "\" does not match any L1 trigger in the current menu";
         else
           edm::LogWarning("Configuration")
               << "requested pattern \"" << m_pattern << "\" does not match any L1 trigger in the current menu";
       }
     }
 
     m_triggersAfterMasking = m_triggers;
     m_initialised = true;
   }

◆ mask()

void triggerExpression::L1uGTReader::mask ( Evaluator const & eval )

overridevirtual

Reimplemented from triggerExpression::Evaluator.

Definition at line 101 of file TriggerExpressionL1uGTReader.cc.

References triggerExpression::Evaluator::enableMasks(), spr::find(), m_triggersAfterMasking, triggerExpression::Evaluator::patterns(), and triggerExpression::Evaluator::triggers().

                                               {
     auto const& triggersToMask = eval.triggers();
 
     if (triggersToMask.empty()) {
       edm::LogInfo("NoTriggersToMask") << "\tL1uGTReader[\"" << *this << "\"]::mask(arg = \"" << eval << "\")"
                                        << " failed: arg.triggers() is empty";
       return;
     }
 
     // patterns() is always empty for a L1uGTReader, and not empty for PathReader;
     // here, PathReader evaluators are skipped as they shouldn't be used to mask a L1uGTReader
     if (not eval.patterns().empty()) {
       edm::LogWarning("InvalidArgumentForMasking")
           << "\tL1uGTReader[\"" << *this << "\"]::mask(arg = \"" << eval << "\")"
           << " failed: arg.patterns() is not empty (arg is not a L1uGTReader)";
       return;
     }
 
     enableMasks();
 
     // clang-format off
     m_triggersAfterMasking.erase(
       std::remove_if(
         m_triggersAfterMasking.begin(),
         m_triggersAfterMasking.end(),
         [&triggersToMask](auto const& foo) {
           return std::find(triggersToMask.begin(), triggersToMask.end(), foo) != triggersToMask.end();
         }
       ),
       m_triggersAfterMasking.end()
     );
     // clang-format on
   }

◆ operator()()

bool triggerExpression::L1uGTReader::operator() ( const Data & data ) const

overridevirtual

Implements triggerExpression::Evaluator.

Definition at line 13 of file TriggerExpressionL1uGTReader.cc.

References data, m_triggers, m_triggersAfterMasking, triggerExpression::Evaluator::masksEnabled(), and triggers().

                                                      {
     if (not data.hasL1T())
       return false;
 
     std::vector<bool> const& word = data.l1tResults();
     if (word.empty())
       return false;
 
     auto const& triggers = masksEnabled() ? m_triggersAfterMasking : m_triggers;
 
     for (auto const& trigger : triggers)
       if (trigger.second < word.size() and word[trigger.second])
         return true;
 
     return false;
   }