PrescaleWeightProvider Class Reference

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.

    : 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.

References submitPVResolutionJobs::config, hltPrescaleProvider_, and callgraph::module.

    : PrescaleWeightProvider(config, iC) {
  hltPrescaleProvider_ = std::make_unique<HLTPrescaleProvider>(config, iC, module);
}

~PrescaleWeightProvider()

PrescaleWeightProvider::~PrescaleWeightProvider ( )

inline

Definition at line 71 of file PrescaleWeightProvider.h.

{}

PrescaleWeightProvider() [3/3]

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

private

Definition at line 18 of file PrescaleWeightProvider.cc.

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

    : 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_);
  }
}

Member Function Documentation

initRun()

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

Definition at line 60 of file PrescaleWeightProvider.cc.

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_.

                                                                                  {
  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;
  }
}

parseL1Seeds()

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

private

Definition at line 200 of file PrescaleWeightProvider.cc.

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

Referenced by prescaleWeight().

                                                                  {
  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);
  }
}

prescaleWeight()

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

Definition at line 97 of file PrescaleWeightProvider.cc.

References L1GtUtils::decision(), edm::InputTag::encode(), L1GtTriggerMenuLite::gtTechTrigName(), HltComparatorCreateWorkflow::hltConfig, TriggerAnalyzer::hltPath, hltPaths_, hltPrescaleProvider_, init_, l1SeedPaths_, parseL1Seeds(), L1GtUtils::prescaleFactor(), singleTopDQM_cfi::setup, AlCaHLTBitMon_QueryRunRegistry::string, triggerMenuLite_, triggerResults, triggerResultsTag_, triggerResultsToken_, interactiveExample::ui, verbosity_, and mps_merge::weight.

                                                                                            {
  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;
}

Member Data Documentation

configured_

bool PrescaleWeightProvider::configured_

private

Definition at line 48 of file PrescaleWeightProvider.h.

Referenced by initRun(), and PrescaleWeightProvider().

hltPaths_

std::vector<std::string> PrescaleWeightProvider::hltPaths_

private

Definition at line 61 of file PrescaleWeightProvider.h.

Referenced by prescaleWeight(), and PrescaleWeightProvider().

hltPrescaleProvider_

std::unique_ptr<HLTPrescaleProvider> PrescaleWeightProvider::hltPrescaleProvider_

private

Definition at line 50 of file PrescaleWeightProvider.h.

Referenced by initRun(), prescaleWeight(), and PrescaleWeightProvider().

init_

bool PrescaleWeightProvider::init_

private

Definition at line 49 of file PrescaleWeightProvider.h.

Referenced by initRun(), and prescaleWeight().

l1GtTriggerMenuLiteTag_

edm::InputTag PrescaleWeightProvider::l1GtTriggerMenuLiteTag_

private

Definition at line 59 of file PrescaleWeightProvider.h.

Referenced by initRun(), and PrescaleWeightProvider().

l1GtTriggerMenuLiteToken_

edm::EDGetTokenT<L1GtTriggerMenuLite> PrescaleWeightProvider::l1GtTriggerMenuLiteToken_

private

Definition at line 60 of file PrescaleWeightProvider.h.

Referenced by initRun(), and PrescaleWeightProvider().

l1SeedPaths_

std::vector<std::string> PrescaleWeightProvider::l1SeedPaths_

private

Definition at line 53 of file PrescaleWeightProvider.h.

Referenced by parseL1Seeds(), and prescaleWeight().

triggerMenuLite_

edm::Handle<L1GtTriggerMenuLite> PrescaleWeightProvider::triggerMenuLite_

private

Definition at line 51 of file PrescaleWeightProvider.h.

Referenced by initRun(), and prescaleWeight().

triggerResultsTag_

edm::InputTag PrescaleWeightProvider::triggerResultsTag_

private

Definition at line 57 of file PrescaleWeightProvider.h.

Referenced by initRun(), prescaleWeight(), and PrescaleWeightProvider().

triggerResultsToken_

edm::EDGetTokenT<edm::TriggerResults> PrescaleWeightProvider::triggerResultsToken_

private

Definition at line 58 of file PrescaleWeightProvider.h.

Referenced by prescaleWeight(), and PrescaleWeightProvider().

verbosity_

unsigned PrescaleWeightProvider::verbosity_

private

Definition at line 56 of file PrescaleWeightProvider.h.

Referenced by initRun(), parseL1Seeds(), prescaleWeight(), and PrescaleWeightProvider().