triggerExpression::PathReader Class Reference

#include <TriggerExpressionPathReader.h>

Inheritance diagram for triggerExpression::PathReader:

Public Member Functions
void	dump (std::ostream &out, bool const ignoreMasks=false) const override
void	init (const Data &data) override
void	mask (Evaluator const &eval) override
bool	operator() (const Data &data) const override
	PathReader (const std::string &pattern)
std::vector< std::string >	patterns () 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	~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 TriggerExpressionPathReader.h.

Constructor & Destructor Documentation

PathReader()

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

inline

Definition at line 10 of file TriggerExpressionPathReader.h.

References topSingleLeptonDQM_PU_cfi::pattern.

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

Member Function Documentation

dump()

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

overridevirtual

Implements triggerExpression::Evaluator.

Definition at line 25 of file TriggerExpressionPathReader.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_Path_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::PathReader::init ( const Data &  data )

overridevirtual

Reimplemented from triggerExpression::Evaluator.

Definition at line 46 of file TriggerExpressionPathReader.cc.

References cms::cuda::assert(), data, edm::is_glob(), m_initialised, m_pattern, m_triggers, m_triggersAfterMasking, oniaPATMuonsWithTrigger_cff::matches, mps_check::msg, AlCaHLTBitMon_ParallelJobs::p, and edm::regexMatch().

                                        {
    // clear the previous configuration
    m_triggers.clear();

    // check if the pattern has is a glob expression, or a single trigger name
    if (not edm::is_glob(m_pattern)) {
      // no wildcard expression
      auto index = data.triggerIndex(m_pattern);
      if (index >= 0)
        m_triggers.push_back(std::make_pair(m_pattern, index));
      else {
        std::stringstream msg;
        msg << "requested HLT path \"" << m_pattern << "\" does not exist - known paths are:";
        if (data.triggerNames().empty())
          msg << " (none)";
        else
          for (auto const& p : data.triggerNames())
            msg << "\n\t" << p;
        if (data.shouldThrow())
          throw cms::Exception("Configuration") << msg.str();
        else
          edm::LogWarning("Configuration") << msg.str();
      }
    } else {
      // expand wildcards in the pattern
      const std::vector<std::vector<std::string>::const_iterator>& matches =
          edm::regexMatch(data.triggerNames(), m_pattern);
      if (matches.empty()) {
        // m_pattern does not match any trigger paths
        std::stringstream msg;
        msg << "requested pattern \"" << m_pattern << "\" does not match any HLT paths - known paths are:";
        if (data.triggerNames().empty())
          msg << " (none)";
        else
          for (auto const& p : data.triggerNames())
            msg << "\n\t" << p;
        if (data.shouldThrow())
          throw cms::Exception("Configuration") << msg.str();
        else
          edm::LogWarning("Configuration") << msg.str();
      } else {
        // store indices corresponding to the matching triggers
        for (auto const& match : matches) {
          auto index = data.triggerIndex(*match);
          assert(index >= 0);
          m_triggers.push_back(std::make_pair(*match, index));
        }
      }
    }

    m_triggersAfterMasking = m_triggers;
    m_initialised = true;
  }

mask()

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

overridevirtual

Reimplemented from triggerExpression::Evaluator.

Definition at line 100 of file TriggerExpressionPathReader.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") << "\tPathReader[\"" << *this << "\"]::mask(arg = \"" << eval << "\")"
                                       << " failed: arg.triggers() is empty";
      return;
    }

    // patterns() is always empty for a L1uGTReader, and not empty for PathReader;
    // here, L1uGTReader evaluators are skipped as they shouldn't be used to mask a PathReader
    if (eval.patterns().empty()) {
      edm::LogWarning("InvalidArgumentForMasking")
          << "\tPathReader[\"" << *this << "\"]::mask(arg = \"" << eval << "\")"
          << " failed: arg.patterns() is empty (arg is not a PathReader)";
      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::PathReader::operator() ( const Data &  data ) const

overridevirtual

Implements triggerExpression::Evaluator.

Definition at line 12 of file TriggerExpressionPathReader.cc.

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

                                                    {
    if (not data.hasHLT() && not data.usePathStatus())
      return false;

    auto const& triggers = masksEnabled() ? m_triggersAfterMasking : m_triggers;

    for (auto const& trigger : triggers)
      if (data.passHLT(trigger.second))
        return true;

    return false;
  }

patterns()

std::vector<std::string> triggerExpression::PathReader::patterns ( ) const

inlineoverridevirtual

Reimplemented from triggerExpression::Evaluator.

Definition at line 17 of file TriggerExpressionPathReader.h.

References m_pattern.

{ return {m_pattern}; }

triggers()

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

inlineoverridevirtual

Reimplemented from triggerExpression::Evaluator.

Definition at line 23 of file TriggerExpressionPathReader.h.

References m_triggers.

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

{ return m_triggers; }

triggersAfterMasking()

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

inline

Definition at line 24 of file TriggerExpressionPathReader.h.

References m_triggersAfterMasking.

{ return m_triggersAfterMasking; }

Member Data Documentation

m_initialised

bool triggerExpression::PathReader::m_initialised

private

Definition at line 30 of file TriggerExpressionPathReader.h.

Referenced by dump(), and init().

m_pattern

std::string triggerExpression::PathReader::m_pattern

private

Definition at line 27 of file TriggerExpressionPathReader.h.

Referenced by init(), and patterns().

m_triggers

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

private

Definition at line 28 of file TriggerExpressionPathReader.h.

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

m_triggersAfterMasking

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

private

Definition at line 29 of file TriggerExpressionPathReader.h.

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