triggerExpression::L1uGTReader Class Reference

#include <TriggerExpressionL1uGTReader.h>

Inheritance diagram for triggerExpression::L1uGTReader:

Public Member Functions
void	dump (std::ostream &out) const override
void	init (const Data &data) override
	L1uGTReader (const std::string &pattern)
bool	operator() (const Data &data) const override
Public Member Functions inherited from triggerExpression::Evaluator
	Evaluator ()=default
virtual std::vector< std::string >	patterns () const
virtual	~Evaluator ()=default

Private Attributes
std::string	m_pattern
std::vector< std::pair < std::string, unsigned int > >	m_triggers

Detailed Description

Definition at line 11 of file TriggerExpressionL1uGTReader.h.

Constructor & Destructor Documentation

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

inline

Definition at line 13 of file TriggerExpressionL1uGTReader.h.

: m_pattern(pattern), m_triggers() {}

Member Function Documentation

void triggerExpression::L1uGTReader::dump ( std::ostream &  out ) const

overridevirtual

Implements triggerExpression::Evaluator.

Definition at line 30 of file TriggerExpressionL1uGTReader.cc.

References first, mps_fire::i, and m_triggers.

                                              {
    if (m_triggers.empty()) {
      out << "FALSE";
    } else if (m_triggers.size() == 1) {
      out << m_triggers[0].first;
    } else {
      out << "(" << m_triggers[0].first;
      for (unsigned int i = 1; i < m_triggers.size(); ++i)
        out << " OR " << m_triggers[i].first;
      out << ")";
    }
  }

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

overridevirtual

Reimplemented from triggerExpression::Evaluator.

Definition at line 43 of file TriggerExpressionL1uGTReader.cc.

References mps_splice::entry, L1TUtmTriggerMenu::getAlgorithmMap(), edm::glob2reg(), triggerExpression::Data::hasL1T(), edm::is_glob(), triggerExpression::Data::l1tMenu(), m_pattern, m_triggers, match(), relval_steps::menu, and triggerExpression::Data::shouldThrow().

                                         {
    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";
      }
    }
  }

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

overridevirtual

Implements triggerExpression::Evaluator.

Definition at line 15 of file TriggerExpressionL1uGTReader.cc.

References triggerExpression::Data::hasL1T(), triggerExpression::Data::l1tResults(), and m_triggers.

                                                     {
    if (not data.hasL1T())
      return false;

    std::vector<bool> const& word = data.l1tResults();
    if (word.empty())
      return false;

    for (auto const& trigger : m_triggers)
      if (trigger.second < word.size() and word[trigger.second])
        return true;

    return false;
  }

Member Data Documentation

std::string triggerExpression::L1uGTReader::m_pattern

private

Definition at line 22 of file TriggerExpressionL1uGTReader.h.

Referenced by init().

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

private

Definition at line 23 of file TriggerExpressionL1uGTReader.h.

Referenced by dump(), init(), and operator()().