HLTcore/src/TriggerExpressionL1uGTReader.cc

0001 #include <iostream>
0002 #include <regex>
0003
0004 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0005 #include "FWCore/Utilities/interface/RegexMatch.h"
0006 #include "CondFormats/L1TObjects/interface/L1TUtmTriggerMenu.h"
0007 #include "HLTrigger/HLTcore/interface/TriggerExpressionData.h"
0008 #include "HLTrigger/HLTcore/interface/TriggerExpressionL1uGTReader.h"
0009
0010 namespace triggerExpression {
0011
0012   // define the result of the module from the L1 reults
0013   bool L1uGTReader::operator()(const Data& data) const {
0014     if (not data.hasL1T())
0015       return false;
0016
0017     std::vector<bool> const& word = data.l1tResults();
0018     if (word.empty())
0019       return false;
0020
0021     auto const& triggers = masksEnabled() ? m_triggersAfterMasking : m_triggers;
0022
0023     for (auto const& trigger : triggers)
0024       if (trigger.second < word.size() and word[trigger.second])
0025         return true;
0026
0027     return false;
0028   }
0029
0030   void L1uGTReader::dump(std::ostream& out, bool const ignoreMasks) const {
0031     if (not m_initialised) {
0032       out << "Uninitialised_L1_Expression";
0033       return;
0034     }
0035
0036     auto const& triggers = ignoreMasks or not masksEnabled() ? m_triggers : m_triggersAfterMasking;
0037
0038     if (triggers.empty()) {
0039       out << "FALSE";
0040     } else if (triggers.size() == 1) {
0041       out << triggers[0].first;
0042     } else {
0043       out << "(" << triggers[0].first;
0044       for (unsigned int i = 1; i < triggers.size(); ++i)
0045         out << " OR " << triggers[i].first;
0046       out << ")";
0047     }
0048   }
0049
0050   void L1uGTReader::init(const Data& data) {
0051     if (not data.hasL1T())
0052       return;
0053
0054     const L1TUtmTriggerMenu& menu = data.l1tMenu();
0055
0056     // clear the previous configuration
0057     m_triggers.clear();
0058
0059     // check if the pattern has is a glob expression, or a single trigger name
0060     auto const& triggerMap = menu.getAlgorithmMap();
0061     if (not edm::is_glob(m_pattern)) {
0062       // no wildcard expression
0063       auto entry = triggerMap.find(m_pattern);
0064       if (entry != triggerMap.end()) {
0065         // single L1 bit
0066         m_triggers.push_back(std::make_pair(m_pattern, entry->second.getIndex()));
0067       } else {
0068         // trigger not found in the current menu
0069         if (data.shouldThrow())
0070           throw cms::Exception("Configuration")
0071               << "requested L1 trigger \"" << m_pattern << "\" does not exist in the current L1 menu";
0072         else
0073           edm::LogWarning("Configuration")
0074               << "requested L1 trigger \"" << m_pattern << "\" does not exist in the current L1 menu";
0075       }
0076     } else {
0077       // expand wildcards in the pattern
0078       bool match = false;
0079       std::regex re(edm::glob2reg(m_pattern));
0080       for (auto const& entry : triggerMap)
0081         if (std::regex_match(entry.first, re)) {
0082           match = true;
0083           m_triggers.push_back(std::make_pair(entry.first, entry.second.getIndex()));
0084         }
0085
0086       if (not match) {
0087         // m_pattern does not match any L1 bits
0088         if (data.shouldThrow())
0089           throw cms::Exception("Configuration")
0090               << "requested pattern \"" << m_pattern << "\" does not match any L1 trigger in the current menu";
0091         else
0092           edm::LogWarning("Configuration")
0093               << "requested pattern \"" << m_pattern << "\" does not match any L1 trigger in the current menu";
0094       }
0095     }
0096
0097     m_triggersAfterMasking = m_triggers;
0098     m_initialised = true;
0099   }
0100
0101   void L1uGTReader::mask(Evaluator const& eval) {
0102     auto const& triggersToMask = eval.triggers();
0103
0104     if (triggersToMask.empty()) {
0105       edm::LogInfo("NoTriggersToMask") << "\tL1uGTReader[\"" << *this << "\"]::mask(arg = \"" << eval << "\")"
0106                                        << " failed: arg.triggers() is empty";
0107       return;
0108     }
0109
0110     // patterns() is always empty for a L1uGTReader, and not empty for PathReader;
0111     // here, PathReader evaluators are skipped as they shouldn't be used to mask a L1uGTReader
0112     if (not eval.patterns().empty()) {
0113       edm::LogWarning("InvalidArgumentForMasking")
0114           << "\tL1uGTReader[\"" << *this << "\"]::mask(arg = \"" << eval << "\")"
0115           << " failed: arg.patterns() is not empty (arg is not a L1uGTReader)";
0116       return;
0117     }
0118
0119     enableMasks();
0120
0121     // clang-format off
0122     m_triggersAfterMasking.erase(
0123       std::remove_if(
0124         m_triggersAfterMasking.begin(),
0125         m_triggersAfterMasking.end(),
0126         [&triggersToMask](auto const& foo) {
0127           return std::find(triggersToMask.begin(), triggersToMask.end(), foo) != triggersToMask.end();
0128         }
0129       ),
0130       m_triggersAfterMasking.end()
0131     );
0132     // clang-format on
0133   }
0134
0135 }  // namespace triggerExpression