This class takes a vector of HLT paths and returns a weight based on their HLT and L1 prescales. The weight is equal to the lowest combined (L1*HLT) prescale of the selected paths. More...

#include "CommonTools/TriggerUtils/interface/PrescaleWeightProvider.h"

Public Member Functions
void	initRun (const edm::Run &run, const edm::EventSetup &setup)

int	prescaleWeight (const edm::Event &event, const edm::EventSetup &setup)

template<typename T >
	PrescaleWeightProvider (const edm::ParameterSet &config, edm::ConsumesCollector &&iC, T &module)

template<typename T >
	PrescaleWeightProvider (const edm::ParameterSet &config, edm::ConsumesCollector &iC, T &module)

	~PrescaleWeightProvider ()

Private Member Functions
void	parseL1Seeds (const std::string &l1Seeds)

	PrescaleWeightProvider (const edm::ParameterSet &config, edm::ConsumesCollector &iC)

Private Attributes
bool	configured_

std::vector< std::string >	hltPaths_

std::unique_ptr< HLTPrescaleProvider >	hltPrescaleProvider_

bool	init_

edm::InputTag	l1GtTriggerMenuLiteTag_

edm::EDGetTokenT< L1GtTriggerMenuLite >	l1GtTriggerMenuLiteToken_

std::vector< std::string >	l1SeedPaths_

edm::Handle< L1GtTriggerMenuLite >	triggerMenuLite_

edm::InputTag	triggerResultsTag_

edm::EDGetTokenT< edm::TriggerResults >	triggerResultsToken_

unsigned	verbosity_

Detailed Description

This class takes a vector of HLT paths and returns a weight based on their HLT and L1 prescales. The weight is equal to the lowest combined (L1*HLT) prescale of the selected paths.

Author: Aram Avetisyan

Definition at line 47 of file PrescaleWeightProvider.h.

Constructor & Destructor Documentation

◆ PrescaleWeightProvider() [1/3]

template<typename T >

PrescaleWeightProvider::PrescaleWeightProvider	(	const edm::ParameterSet &	config,
		edm::ConsumesCollector &&	iC,
		T &	module
	)

Definition at line 85 of file PrescaleWeightProvider.h.

86 : PrescaleWeightProvider(config, iC, module) {}

◆ PrescaleWeightProvider() [2/3]

template<typename T >

PrescaleWeightProvider::PrescaleWeightProvider	(	const edm::ParameterSet &	config,
		edm::ConsumesCollector &	iC,
		T &	module
	)

Definition at line 89 of file PrescaleWeightProvider.h.

     : PrescaleWeightProvider(config, iC) {
   hltPrescaleProvider_.reset(new HLTPrescaleProvider(config, iC, module));
 }

References hltPrescaleProvider_.

◆ ~PrescaleWeightProvider()

PrescaleWeightProvider::~PrescaleWeightProvider ( )

inline

Definition at line 71 of file PrescaleWeightProvider.h.

71 {}

◆ PrescaleWeightProvider() [3/3]

PrescaleWeightProvider::PrescaleWeightProvider	(	const edm::ParameterSet &	config,
		edm::ConsumesCollector &	iC
	)

private

Definition at line 18 of file PrescaleWeightProvider.cc.

     : init_(false),
       verbosity_(0),
       triggerResultsTag_("TriggerResults::HLT"),
       triggerResultsToken_(iC.mayConsume<edm::TriggerResults>(triggerResultsTag_)),
       l1GtTriggerMenuLiteTag_("l1GtTriggerMenuLite"),
       l1GtTriggerMenuLiteToken_(iC.mayConsume<L1GtTriggerMenuLite, edm::InRun>(l1GtTriggerMenuLiteTag_)) {
   hltPaths_.clear();
   if (config.exists("prescaleWeightVerbosityLevel"))
     verbosity_ = config.getParameter<unsigned>("prescaleWeightVerbosityLevel");
   if (config.exists("prescaleWeightTriggerResults"))
     triggerResultsTag_ = config.getParameter<edm::InputTag>("prescaleWeightTriggerResults");
   if (config.exists("prescaleWeightL1GtTriggerMenuLite"))
     l1GtTriggerMenuLiteTag_ = config.getParameter<edm::InputTag>("prescaleWeightL1GtTriggerMenuLite");
   if (config.exists("prescaleWeightHltPaths"))
     hltPaths_ = config.getParameter<std::vector<std::string> >("prescaleWeightHltPaths");
  
   configured_ = true;
   if (triggerResultsTag_.process().empty()) {
     configured_ = false;
     if (verbosity_ > 0)
       edm::LogWarning("PrescaleWeightProvider") << "Process name not configured via TriggerResults InputTag";
   } else if (triggerResultsTag_.label().empty()) {
     configured_ = false;
     if (verbosity_ > 0)
       edm::LogWarning("PrescaleWeightProvider") << "TriggerResults label not configured";
   } else if (l1GtTriggerMenuLiteTag_.label().empty()) {
     configured_ = false;
     if (verbosity_ > 0)
       edm::LogWarning("PrescaleWeightProvider") << "L1GtTriggerMenuLite label not configured";
   } else if (hltPaths_.empty()) {
     configured_ = false;
     if (verbosity_ > 0)
       edm::LogError("PrescaleWeightProvider") << "HLT paths of interest not configured";
   }
   if (configured_) {
     triggerResultsToken_ = iC.mayConsume<edm::TriggerResults>(triggerResultsTag_);
     l1GtTriggerMenuLiteToken_ = iC.mayConsume<L1GtTriggerMenuLite, edm::InRun>(l1GtTriggerMenuLiteTag_);
   }
 }

References configured_, hltPaths_, edm::InRun, l1GtTriggerMenuLiteTag_, l1GtTriggerMenuLiteToken_, edm::InputTag::label(), edm::ConsumesCollector::mayConsume(), edm::InputTag::process(), triggerResultsTag_, triggerResultsToken_, and verbosity_.

Member Function Documentation

◆ initRun()

void PrescaleWeightProvider::initRun	(	const edm::Run &	run,
		const edm::EventSetup &	setup
	)

Definition at line 60 of file PrescaleWeightProvider.cc.

                                                                                   {
   init_ = true;
  
   if (!configured_) {
     init_ = false;
     if (verbosity_ > 0)
       edm::LogWarning("PrescaleWeightProvider") << "Run initialisation failed due to failing configuration";
     return;
   }
  
   HLTConfigProvider const& hltConfig = hltPrescaleProvider_->hltConfigProvider();
   bool hltChanged(false);
   if (!hltPrescaleProvider_->init(run, setup, triggerResultsTag_.process(), hltChanged)) {
     if (verbosity_ > 0)
       edm::LogError("PrescaleWeightProvider")
           << "HLT config initialization error with process name \"" << triggerResultsTag_.process() << "\"";
     init_ = false;
   } else if (hltConfig.size() <= 0) {
     if (verbosity_ > 0)
       edm::LogError("PrescaleWeightProvider") << "HLT config size error";
     init_ = false;
   } else if (hltChanged) {
     if (verbosity_ > 0)
       edm::LogInfo("PrescaleWeightProvider") << "HLT configuration changed";
   }
   if (!init_)
     return;
  
   run.getByToken(l1GtTriggerMenuLiteToken_, triggerMenuLite_);
   if (!triggerMenuLite_.isValid()) {
     if (verbosity_ > 0)
       edm::LogError("PrescaleWeightProvider")
           << "L1GtTriggerMenuLite with label \"" << l1GtTriggerMenuLiteTag_.label() << "\" not found";
     init_ = false;
   }
 }

References configured_, HltComparatorCreateWorkflow::hltConfig, hltPrescaleProvider_, init_, edm::HandleBase::isValid(), l1GtTriggerMenuLiteTag_, l1GtTriggerMenuLiteToken_, edm::InputTag::label(), edm::InputTag::process(), writedatasetfile::run, singleTopDQM_cfi::setup, triggerMenuLite_, triggerResultsTag_, and verbosity_.

◆ parseL1Seeds()

void PrescaleWeightProvider::parseL1Seeds ( const std::string & l1Seeds )

private

Definition at line 200 of file PrescaleWeightProvider.cc.

                                                                   {
   l1SeedPaths_.clear();
   std::stringstream ss(l1Seeds);
   std::string buf;
  
   while (ss.good() && !ss.eof()) {
     ss >> buf;
     if (buf[0] == '(' || buf[buf.size() - 1] == ')' || buf == "AND" || buf == "NOT") {
       l1SeedPaths_.clear();
       if (verbosity_ > 0)
         edm::LogWarning("PrescaleWeightProvider::parseL1Seeds") << "Only supported logical expression is OR";
       return;
     } else if (buf == "OR")
       continue;
     else
       l1SeedPaths_.push_back(buf);
   }
 }

References visDQMUpload::buf, l1SeedPaths_, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, and verbosity_.

Referenced by prescaleWeight().

◆ prescaleWeight()

int PrescaleWeightProvider::prescaleWeight	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

Definition at line 97 of file PrescaleWeightProvider.cc.

                                                                                             {
   if (!init_)
     return 1;
  
   // L1
   L1GtUtils const& l1GtUtils = hltPrescaleProvider_->l1GtUtils();
  
   // HLT
   HLTConfigProvider const& hltConfig = hltPrescaleProvider_->hltConfigProvider();
  
   edm::Handle<edm::TriggerResults> triggerResults;
   event.getByToken(triggerResultsToken_, triggerResults);
   if (!triggerResults.isValid()) {
     if (verbosity_ > 0)
       edm::LogError("PrescaleWeightProvider::prescaleWeight")
           << "TriggerResults product not found for InputTag \"" << triggerResultsTag_.encode() << "\"";
     return 1;
   }
  
   const int SENTINEL(-1);
   int weight(SENTINEL);
  
   for (unsigned ui = 0; ui < hltPaths_.size(); ui++) {
     const std::string hltPath(hltPaths_.at(ui));
     unsigned hltIndex(hltConfig.triggerIndex(hltPath));
     if (hltIndex == hltConfig.size()) {
       if (verbosity_ > 0)
         edm::LogError("PrescaleWeightProvider::prescaleWeight") << "HLT path \"" << hltPath << "\" does not exist";
       continue;
     }
     if (!triggerResults->accept(hltIndex))
       continue;
  
     const std::vector<std::pair<bool, std::string> >& level1Seeds = hltConfig.hltL1GTSeeds(hltPath);
     if (level1Seeds.size() != 1) {
       if (verbosity_ > 0)
         edm::LogError("PrescaleWeightProvider::prescaleWeight")
             << "HLT path \"" << hltPath << "\" provides too many L1 seeds";
       return 1;
     }
     parseL1Seeds(level1Seeds.at(0).second);
     if (l1SeedPaths_.empty()) {
       if (verbosity_ > 0)
         edm::LogWarning("PrescaleWeightProvider::prescaleWeight")
             << "Failed to parse L1 seeds for HLT path \"" << hltPath << "\"";
       continue;
     }
  
     int l1Prescale(SENTINEL);
     for (unsigned uj = 0; uj < l1SeedPaths_.size(); uj++) {
       int l1TempPrescale(SENTINEL);
       int errorCode(0);
       if (level1Seeds.at(0).first) {  // technical triggers
         unsigned techBit(atoi(l1SeedPaths_.at(uj).c_str()));
         const std::string techName(*(triggerMenuLite_->gtTechTrigName(techBit, errorCode)));
         if (errorCode != 0)
           continue;
         if (!l1GtUtils.decision(event, techName, errorCode))
           continue;
         if (errorCode != 0)
           continue;
         l1TempPrescale = l1GtUtils.prescaleFactor(event, techName, errorCode);
         if (errorCode != 0)
           continue;
       } else {  // algorithmic triggers
         if (!l1GtUtils.decision(event, l1SeedPaths_.at(uj), errorCode))
           continue;
         if (errorCode != 0)
           continue;
         l1TempPrescale = l1GtUtils.prescaleFactor(event, l1SeedPaths_.at(uj), errorCode);
         if (errorCode != 0)
           continue;
       }
       if (l1TempPrescale > 0) {
         if (l1Prescale == SENTINEL || l1Prescale > l1TempPrescale)
           l1Prescale = l1TempPrescale;
       }
     }
     if (l1Prescale == SENTINEL) {
       if (verbosity_ > 0)
         edm::LogError("PrescaleWeightProvider::prescaleWeight")
             << "Unable to find the L1 prescale for HLT path \"" << hltPath << "\"";
       continue;
     }
  
     int hltPrescale(hltPrescaleProvider_->prescaleValue(event, setup, hltPath));
  
     if (hltPrescale * l1Prescale > 0) {
       if (weight == SENTINEL || weight > hltPrescale * l1Prescale) {
         weight = hltPrescale * l1Prescale;
       }
     }
   }
  
   if (weight == SENTINEL) {
     if (verbosity_ > 0)
       edm::LogWarning("PrescaleWeightProvider::prescaleWeight")
           << "No valid weight for any requested HLT path, returning default weight of 1";
     return 1;
   }
   return weight;
 }