HLTPrescaleProvider.h

Go to the documentation of this file.

#ifndef HLTcore_HLTPrescaleProvider_h
#define HLTcore_HLTPrescaleProvider_h
 
#include "HLTrigger/HLTcore/interface/FractionalPrescale.h"
#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtUtils.h"
#include "L1Trigger/L1TGlobal/interface/L1TGlobalUtil.h"
#include "DataFormats/L1TGlobal/interface/GlobalLogicParser.h"
#include "DataFormats/Common/interface/TriggerResults.h"
 
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace edm {
  class ConsumesCollector;
  class Event;
  class EventSetup;
  class ParameterSet;
  class Run;
}  // namespace edm
 
class HLTPrescaleProvider {
public:
  template <typename T>
  HLTPrescaleProvider(edm::ParameterSet const& pset, edm::ConsumesCollector&& iC, T& module);
 
  template <typename T>
  HLTPrescaleProvider(edm::ParameterSet const& pset, edm::ConsumesCollector& iC, T& module);
 
  bool init(const edm::Run& iRun, const edm::EventSetup& iSetup, const std::string& processName, bool& changed);
 
  HLTConfigProvider const& hltConfigProvider() const { return hltConfigProvider_; }
  L1GtUtils const& l1GtUtils() const;
  l1t::L1TGlobalUtil const& l1tGlobalUtil() const;
 
  int prescaleSet(const edm::Event& iEvent, const edm::EventSetup& iSetup);
  // negative == error
 
  template <typename T = unsigned int>
  T prescaleValue(const edm::Event& iEvent, const edm::EventSetup& iSetup, const std::string& trigger) {
    const int set(prescaleSet(iEvent, iSetup));
    //there is a template specialisation for unsigned in which returns +1 which
    //emulates old behaviour
    return set < 0 ? -1 : hltConfigProvider_.prescaleValue<T>(static_cast<unsigned int>(set), trigger);
  }
 
  template <typename TL1 = int, typename THLT = TL1>
  std::pair<TL1, THLT> prescaleValues(const edm::Event& iEvent,
                                      const edm::EventSetup& iSetup,
                                      const std::string& trigger) {
    return {convertL1PS<TL1>(getL1PrescaleValue(iEvent, iSetup, trigger)),
            prescaleValue<THLT>(iEvent, iSetup, trigger)};
  }
  // any one negative => error in retrieving this (L1T or HLT) prescale
 
  // In case of a complex Boolean expression as L1 seed
  template <typename TL1 = int, typename THLT = TL1>
  std::pair<std::vector<std::pair<std::string, TL1> >, THLT> prescaleValuesInDetail(const edm::Event& iEvent,
                                                                                    const edm::EventSetup& iSetup,
                                                                                    const std::string& trigger) {
    std::pair<std::vector<std::pair<std::string, TL1> >, THLT> retval;
    for (auto& entry : getL1PrescaleValueInDetail(iEvent, iSetup, trigger)) {
      retval.first.emplace_back(std::move(entry.first), convertL1PS<TL1>(entry.second));
    }
    retval.second = prescaleValue<THLT>(iEvent, iSetup, trigger);
    return retval;
  }
  // Event rejected by HLTPrescaler on ith HLT path?
  bool rejectedByHLTPrescaler(const edm::TriggerResults& triggerResults, unsigned int i) const;
  static int l1PrescaleDenominator() { return kL1PrescaleDenominator_; }
 
private:
  void checkL1GtUtils() const;
  void checkL1TGlobalUtil() const;
  template <typename T>
  T convertL1PS(double val) const {
    return T(val);
  }
 
  double getL1PrescaleValue(const edm::Event& iEvent, const edm::EventSetup& iSetup, const std::string& trigger);
  std::vector<std::pair<std::string, double> > getL1PrescaleValueInDetail(const edm::Event& iEvent,
                                                                          const edm::EventSetup& iSetup,
                                                                          const std::string& trigger);
  static constexpr int kL1PrescaleDenominator_ = 100;
  HLTConfigProvider hltConfigProvider_;
  std::unique_ptr<L1GtUtils> l1GtUtils_;
  std::unique_ptr<l1t::L1TGlobalUtil> l1tGlobalUtil_;
  unsigned char count_[5] = {0, 0, 0, 0, 0};
  bool inited_ = false;
};
 
template <typename T>
HLTPrescaleProvider::HLTPrescaleProvider(edm::ParameterSet const& pset, edm::ConsumesCollector&& iC, T& module)
    : HLTPrescaleProvider(pset, iC, module) {}
 
template <typename T>
HLTPrescaleProvider::HLTPrescaleProvider(edm::ParameterSet const& pset, edm::ConsumesCollector& iC, T& module) {
  unsigned int stageL1Trigger = pset.getParameter<unsigned int>("stageL1Trigger");
  if (stageL1Trigger <= 1) {
    l1GtUtils_ = std::make_unique<L1GtUtils>(pset, iC, false, module, L1GtUtils::UseEventSetupIn::Run);
  } else {
    l1tGlobalUtil_ = std::make_unique<l1t::L1TGlobalUtil>(pset, iC, module, l1t::UseEventSetupIn::Run);
  }
}
 
template <>
FractionalPrescale HLTPrescaleProvider::convertL1PS<FractionalPrescale>(double val) const;
 
template <>
unsigned int HLTPrescaleProvider::prescaleValue<unsigned int>(const edm::Event& iEvent,
                                                              const edm::EventSetup& iSetup,
                                                              const std::string& trigger);
 
#endif