TriggerUtils/interface/PrescaleWeightProvider.h

0001 #ifndef CommonTools_TriggerUtils_PrescaleWeightProvider_h
0002 #define CommonTools_TriggerUtils_PrescaleWeightProvider_h
0003
0004 // -*- C++ -*-
0005 //
0006 // Package:    CommonTools/TriggerUtils
0007 // Class:      PrescaleWeightProvider
0008 //
0009 /*
0010   \class    PrescaleWeightProvider PrescaleWeightProvider.h "CommonTools/TriggerUtils/interface/PrescaleWeightProvider.h"
0011   \brief
0012
0013    This class takes a vector of HLT paths and returns a weight based on their
0014    HLT and L1 prescales. The weight is equal to the lowest combined (L1*HLT) prescale
0015    of the selected paths
0016
0017   \author   Aram Avetisyan
0018 */
0019
0020 #include <memory>
0021 #include <string>
0022 #include <vector>
0023 #include <type_traits>
0024
0025 #include "DataFormats/Common/interface/Handle.h"
0026
0027 #include "FWCore/Framework/interface/Run.h"
0028 #include "FWCore/Framework/interface/Event.h"
0029 #include "FWCore/Framework/interface/EventSetup.h"
0030 #include "FWCore/Framework/interface/ConsumesCollector.h"
0031 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0032 #include "FWCore/Utilities/interface/EDGetToken.h"
0033 #include "FWCore/Utilities/interface/InputTag.h"
0034
0035 #include "HLTrigger/HLTcore/interface/HLTPrescaleProvider.h"
0036
0037 class L1GtTriggerMenuLite;
0038
0039 namespace edm {
0040   class ConsumesCollector;
0041   class Event;
0042   class EventSetup;
0043   class ParameterSet;
0044   class Run;
0045   class TriggerResults;
0046 }  // namespace edm
0047
0048 class PrescaleWeightProvider {
0049   bool configured_;
0050   bool init_;
0051   std::unique_ptr<HLTPrescaleProvider> hltPrescaleProvider_;
0052   edm::Handle<L1GtTriggerMenuLite> triggerMenuLite_;
0053
0054   std::vector<std::string> l1SeedPaths_;
0055
0056   // configuration parameters
0057   unsigned verbosity_;               // optional (default: 0)
0058   edm::InputTag triggerResultsTag_;  // optional (default: "TriggerResults::HLT")
0059   edm::EDGetTokenT<edm::TriggerResults> triggerResultsToken_;
0060   edm::InputTag l1GtTriggerMenuLiteTag_;                            // optional (default: "l1GtTriggerMenuLite")
0061   edm::EDGetTokenT<L1GtTriggerMenuLite> l1GtTriggerMenuLiteToken_;  // optional (default: "l1GtTriggerMenuLite")
0062   std::vector<std::string> hltPaths_;
0063
0064 public:
0065   // The constructor must be called from the ED module's c'tor
0066   template <typename T>
0067   PrescaleWeightProvider(const edm::ParameterSet& config, edm::ConsumesCollector&& iC, T& module);
0068
0069   template <typename T>
0070   PrescaleWeightProvider(const edm::ParameterSet& config, edm::ConsumesCollector& iC, T& module);
0071
0072   ~PrescaleWeightProvider() {}
0073
0074   // to be called from the ED module's beginRun() method
0075   void initRun(const edm::Run& run, const edm::EventSetup& setup);
0076
0077   // to be called from the ED module's event loop method
0078   template <typename T = int>
0079   T prescaleWeight(const edm::Event& event, const edm::EventSetup& setup);
0080
0081 private:
0082   PrescaleWeightProvider(const edm::ParameterSet& config, edm::ConsumesCollector& iC);
0083
0084   void parseL1Seeds(const std::string& l1Seeds);
0085 };
0086
0087 template <typename T>
0088 PrescaleWeightProvider::PrescaleWeightProvider(const edm::ParameterSet& config, edm::ConsumesCollector&& iC, T& module)
0089     : PrescaleWeightProvider(config, iC, module) {}
0090
0091 template <typename T>
0092 PrescaleWeightProvider::PrescaleWeightProvider(const edm::ParameterSet& config, edm::ConsumesCollector& iC, T& module)
0093     : PrescaleWeightProvider(config, iC) {
0094   hltPrescaleProvider_ = std::make_unique<HLTPrescaleProvider>(config, iC, module);
0095 }
0096
0097 template <typename T>
0098 T PrescaleWeightProvider::prescaleWeight(const edm::Event& event, const edm::EventSetup& setup) {
0099   static_assert(std::is_same_v<T, double> or std::is_same_v<T, FractionalPrescale>,
0100                 "\n\tPlease use prescaleWeight<double> or prescaleWeight<FractionalPrescale>"
0101                 "\n\t(other types for HLT prescales are not supported anymore by PrescaleWeightProvider");
0102   if (!init_)
0103     return 1;
0104
0105   // L1
0106   L1GtUtils const& l1GtUtils = hltPrescaleProvider_->l1GtUtils();
0107
0108   // HLT
0109   HLTConfigProvider const& hltConfig = hltPrescaleProvider_->hltConfigProvider();
0110
0111   edm::Handle<edm::TriggerResults> triggerResults;
0112   event.getByToken(triggerResultsToken_, triggerResults);
0113   if (!triggerResults.isValid()) {
0114     if (verbosity_ > 0)
0115       edm::LogError("PrescaleWeightProvider::prescaleWeight")
0116           << "TriggerResults product not found for InputTag \"" << triggerResultsTag_.encode() << "\"";
0117     return 1;
0118   }
0119
0120   const int SENTINEL(-1);
0121   int weight(SENTINEL);
0122
0123   for (unsigned ui = 0; ui < hltPaths_.size(); ui++) {
0124     const std::string hltPath(hltPaths_.at(ui));
0125     unsigned hltIndex(hltConfig.triggerIndex(hltPath));
0126     if (hltIndex == hltConfig.size()) {
0127       if (verbosity_ > 0)
0128         edm::LogError("PrescaleWeightProvider::prescaleWeight") << "HLT path \"" << hltPath << "\" does not exist";
0129       continue;
0130     }
0131     if (!triggerResults->accept(hltIndex))
0132       continue;
0133
0134     const std::vector<std::pair<bool, std::string> >& level1Seeds = hltConfig.hltL1GTSeeds(hltPath);
0135     if (level1Seeds.size() != 1) {
0136       if (verbosity_ > 0)
0137         edm::LogError("PrescaleWeightProvider::prescaleWeight")
0138             << "HLT path \"" << hltPath << "\" provides too many L1 seeds";
0139       return 1;
0140     }
0141     parseL1Seeds(level1Seeds.at(0).second);
0142     if (l1SeedPaths_.empty()) {
0143       if (verbosity_ > 0)
0144         edm::LogWarning("PrescaleWeightProvider::prescaleWeight")
0145             << "Failed to parse L1 seeds for HLT path \"" << hltPath << "\"";
0146       continue;
0147     }
0148
0149     int l1Prescale(SENTINEL);
0150     for (unsigned uj = 0; uj < l1SeedPaths_.size(); uj++) {
0151       int l1TempPrescale(SENTINEL);
0152       int errorCode(0);
0153       if (level1Seeds.at(0).first) {  // technical triggers
0154         unsigned techBit(atoi(l1SeedPaths_.at(uj).c_str()));
0155         const std::string techName(*(triggerMenuLite_->gtTechTrigName(techBit, errorCode)));
0156         if (errorCode != 0)
0157           continue;
0158         if (!l1GtUtils.decision(event, techName, errorCode))
0159           continue;
0160         if (errorCode != 0)
0161           continue;
0162         l1TempPrescale = l1GtUtils.prescaleFactor(event, techName, errorCode);
0163         if (errorCode != 0)
0164           continue;
0165       } else {  // algorithmic triggers
0166         if (!l1GtUtils.decision(event, l1SeedPaths_.at(uj), errorCode))
0167           continue;
0168         if (errorCode != 0)
0169           continue;
0170         l1TempPrescale = l1GtUtils.prescaleFactor(event, l1SeedPaths_.at(uj), errorCode);
0171         if (errorCode != 0)
0172           continue;
0173       }
0174       if (l1TempPrescale > 0) {
0175         if (l1Prescale == SENTINEL || l1Prescale > l1TempPrescale)
0176           l1Prescale = l1TempPrescale;
0177       }
0178     }
0179     if (l1Prescale == SENTINEL) {
0180       if (verbosity_ > 0)
0181         edm::LogError("PrescaleWeightProvider::prescaleWeight")
0182             << "Unable to find the L1 prescale for HLT path \"" << hltPath << "\"";
0183       continue;
0184     }
0185
0186     auto const prescale = l1Prescale * hltPrescaleProvider_->prescaleValue<T>(event, setup, hltPath);
0187
0188     if (prescale > 0) {
0189       if (weight == SENTINEL || weight > prescale) {
0190         weight = prescale;
0191       }
0192     }
0193   }
0194
0195   if (weight == SENTINEL) {
0196     if (verbosity_ > 0)
0197       edm::LogWarning("PrescaleWeightProvider::prescaleWeight")
0198           << "No valid weight for any requested HLT path, returning default weight of 1";
0199     return 1;
0200   }
0201
0202   return weight;
0203 }
0204
0205 #endif  // CommonTools_TriggerUtils_PrescaleWeightProvider_h