HLTPrescaleProvider Class Reference

#include <HLTPrescaleProvider.h>

Public Member Functions
HLTConfigProvider const &	hltConfigProvider () const
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)
L1GtUtils const &	l1GtUtils () const
l1t::L1TGlobalUtil const &	l1tGlobalUtil () const
int	prescaleSet (const edm::Event &iEvent, const edm::EventSetup &iSetup)
template<typename T = unsigned int>
T	prescaleValue (const edm::Event &iEvent, const edm::EventSetup &iSetup, const std::string &trigger)
	combining the two methods above More...
template<>
unsigned int	prescaleValue (const edm::Event &iEvent, const edm::EventSetup &iSetup, const std::string &trigger)
template<>
unsigned int	prescaleValue (const edm::Event &iEvent, const edm::EventSetup &iSetup, const std::string &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)
	Combined L1T (pair.first) and HLT (pair.second) prescales per HLT path. More...
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)
bool	rejectedByHLTPrescaler (const edm::TriggerResults &triggerResults, unsigned int i) const

Static Public Member Functions
static int	l1PrescaleDenominator ()

Private Member Functions
void	checkL1GtUtils () const
void	checkL1TGlobalUtil () const
template<typename T >
T	convertL1PS (double val) const
template<>
FractionalPrescale	convertL1PS (double val) const
template<>
FractionalPrescale	convertL1PS (double val) const
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)

Private Attributes
unsigned char	count_ [5] = {0, 0, 0, 0, 0}
HLTConfigProvider	hltConfigProvider_
bool	inited_ = false
std::unique_ptr< L1GtUtils >	l1GtUtils_
std::unique_ptr< l1t::L1TGlobalUtil >	l1tGlobalUtil_

Static Private Attributes
static constexpr int	kL1PrescaleDenominator_ = 100

Detailed Description

This class provides access routines to get hold of the HLT Configuration

Author

Martin Grunewald

Originally the functions in here were in HLTConfigProvider. The functions that use L1GtUtils and get products from the Event were moved into this class in 2015 when the consumes function calls were added. W. David Dagenhart

See header file for documentation

Author

Martin Grunewald

Definition at line 38 of file HLTPrescaleProvider.h.

Constructor & Destructor Documentation

HLTPrescaleProvider() [1/2]

template<typename T >

HLTPrescaleProvider::HLTPrescaleProvider	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &&	iC,
		T &	module
	)

Definition at line 117 of file HLTPrescaleProvider.h.

    : HLTPrescaleProvider(pset, iC, module) {}

HLTPrescaleProvider() [2/2]

template<typename T >

HLTPrescaleProvider::HLTPrescaleProvider	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &	iC,
		T &	module
	)

Definition at line 121 of file HLTPrescaleProvider.h.

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

References l1GtUtils_, l1tGlobalUtil_, callgraph::module, muonDTDigis_cfi::pset, l1t::Run, L1GtUtils::Run, and PDWG_DiPhoton_SD_cff::stageL1Trigger.

Member Function Documentation

checkL1GtUtils()

void HLTPrescaleProvider::checkL1GtUtils ( ) const

private

Definition at line 344 of file HLTPrescaleProvider.cc.

                                               {
  if (!l1GtUtils_) {
    throw cms::Exception("Configuration") << "HLTPrescaleProvider::checkL1GtUtils(),\n"
                                             "Attempt to use L1GtUtils object when none was constructed.\n"
                                             "Possibly the proper era is not configured or\n"
                                             "the module configuration does not use the era properly\n"
                                             "or input is from mixed eras";
  }
}

References Exception, and l1GtUtils_.

Referenced by getL1PrescaleValue(), getL1PrescaleValueInDetail(), init(), l1GtUtils(), and prescaleSet().

checkL1TGlobalUtil()

void HLTPrescaleProvider::checkL1TGlobalUtil ( ) const

private

Definition at line 354 of file HLTPrescaleProvider.cc.

                                                   {
  if (!l1tGlobalUtil_) {
    throw cms::Exception("Configuration") << "HLTPrescaleProvider:::checkL1TGlobalUtil(),\n"
                                             "Attempt to use L1TGlobalUtil object when none was constructed.\n"
                                             "Possibly the proper era is not configured or\n"
                                             "the module configuration does not use the era properly\n"
                                             "or input is from mixed eras";
  }
}

References Exception, and l1tGlobalUtil_.

Referenced by getL1PrescaleValue(), getL1PrescaleValueInDetail(), init(), l1tGlobalUtil(), and prescaleSet().

convertL1PS() [1/3]

template<typename T >

T HLTPrescaleProvider::convertL1PS ( double  val ) const

inlineprivate

Definition at line 100 of file HLTPrescaleProvider.h.

                                  {
    return T(val);
  }

References heppy_batch::val.

convertL1PS() [2/3]

template<>

FractionalPrescale HLTPrescaleProvider::convertL1PS ( double  val ) const

private

Definition at line 106 of file HLTPrescaleProvider.cc.

                                                                                        {
  int numer = static_cast<int>(val * kL1PrescaleDenominator_ + 0.5);
  static constexpr double kL1RoundingEpsilon = 0.001;
  if (std::abs(numer - val * kL1PrescaleDenominator_) > kL1RoundingEpsilon) {
    edm::LogWarning("ValueError") << " Error, L1 prescale val " << val
                                  << "does not appear to precisely expressable as int / " << kL1PrescaleDenominator_
                                  << ", using a FractionalPrescale is a loss of precision";
  }
 
  return {numer, kL1PrescaleDenominator_};
}

References funct::abs(), kL1PrescaleDenominator_, and heppy_batch::val.

convertL1PS() [3/3]

template<>

FractionalPrescale HLTPrescaleProvider::convertL1PS ( double  val ) const

private

getL1PrescaleValue()

double HLTPrescaleProvider::getL1PrescaleValue ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup, const std::string &  trigger  )

private

error - can't handle properly multiple L1GTSeed modules

error - can't handle properly multiple L1TSeed modules

Definition at line 118 of file HLTPrescaleProvider.cc.

                                                                         {
  // get L1T prescale - works only for those hlt trigger paths with
  // exactly one L1GT seed module which has exactly one L1T name as seed
 
  double result = -1;
 
  const unsigned int l1tType(hltConfigProvider_.l1tType());
  if (l1tType == 1) {
    checkL1GtUtils();
    const unsigned int nL1GTSeedModules(hltConfigProvider_.hltL1GTSeeds(trigger).size());
    if (nL1GTSeedModules == 0) {
      // no L1 seed module on path hence no L1 seed hence formally no L1 prescale
      result = 1;
    } else if (nL1GTSeedModules == 1) {
      l1GtUtils_->getL1GtRunCache(iEvent, iSetup, useL1EventSetup, useL1GtTriggerMenuLite);
      const std::string l1tname(hltConfigProvider_.hltL1GTSeeds(trigger).at(0).second);
      int l1error(0);
      result = l1GtUtils_->prescaleFactor(iEvent, l1tname, l1error);
      if (l1error != 0) {
        if (count_[1] < countMax) {
          count_[1] += 1;
          edm::LogError("HLTPrescaleProvider")
              << " Error in determining L1T prescale for HLT path: '" << trigger << "' with L1T seed: '" << l1tname
              << "' using L1GtUtils: error code = " << l1error << "." << std::endl
              << " Note: for this method ('prescaleValues'), only a single L1T name (and not a bit number) is allowed "
                 "as seed!"
              << std::endl
              << " For seeds being complex logical expressions, try the new method 'prescaleValuesInDetail'."
              << std::endl;
        }
        result = -1;
      }
    } else {
      if (count_[2] < countMax) {
        count_[2] += 1;
        std::string dump("'" + hltConfigProvider_.hltL1GTSeeds(trigger).at(0).second + "'");
        for (unsigned int i = 1; i != nL1GTSeedModules; ++i) {
          dump += " * '" + hltConfigProvider_.hltL1GTSeeds(trigger).at(i).second + "'";
        }
        edm::LogError("HLTPrescaleProvider")
            << " Error in determining L1T prescale for HLT path: '" << trigger << "' has multiple L1GTSeed modules, "
            << nL1GTSeedModules << ", with L1 seeds: " << dump
            << ". (Note: at most one L1GTSeed module is allowed for a proper determination of the L1T prescale!)";
      }
      result = -1;
    }
  } else if (l1tType == 2) {
    checkL1TGlobalUtil();
    const unsigned int nL1TSeedModules(hltConfigProvider_.hltL1TSeeds(trigger).size());
    if (nL1TSeedModules == 0) {
      // no L1 seed module on path hence no L1 seed hence formally no L1 prescale
      result = 1;
    } else if (nL1TSeedModules == 1) {
      //    l1tGlobalUtil_->retrieveL1Event(iEvent,iSetup);
      const std::string l1tname(hltConfigProvider_.hltL1TSeeds(trigger).at(0));
      bool l1error(!l1tGlobalUtil_->getPrescaleByName(l1tname, result));
      if (l1error) {
        if (count_[1] < countMax) {
          count_[1] += 1;
          edm::LogError("HLTPrescaleProvider")
              << " Error in determining L1T prescale for HLT path: '" << trigger << "' with L1T seed: '" << l1tname
              << "' using L1TGlobalUtil: error cond = " << l1error << "." << std::endl
              << " Note: for this method ('prescaleValues'), only a single L1T name (and not a bit number) is allowed "
                 "as seed!"
              << std::endl
              << " For seeds being complex logical expressions, try the new method 'prescaleValuesInDetail'."
              << std::endl;
        }
        result = -1;
      }
    } else {
      if (count_[2] < countMax) {
        count_[2] += 1;
        std::string dump("'" + hltConfigProvider_.hltL1TSeeds(trigger).at(0) + "'");
        for (unsigned int i = 1; i != nL1TSeedModules; ++i) {
          dump += " * '" + hltConfigProvider_.hltL1TSeeds(trigger).at(i) + "'";
        }
        edm::LogError("HLTPrescaleProvider")
            << " Error in determining L1T prescale for HLT path: '" << trigger << "' has multiple L1TSeed modules, "
            << nL1TSeedModules << ", with L1T seeds: " << dump
            << ". (Note: at most one L1TSeed module is allowed for a proper determination of the L1T prescale!)";
      }
      result = -1;
    }
  } else {
    if (count_[1] < countMax) {
      count_[1] += 1;
      edm::LogError("HLTPrescaleProvider") << " Unknown L1T Type " << l1tType << " - can not determine L1T prescale! ";
    }
    result = -1;
  }
 
  return result;
}

References checkL1GtUtils(), checkL1TGlobalUtil(), count_, countMax(), submitPVValidationJobs::dump, hltConfigProvider_, HLTConfigProvider::hltL1GTSeeds(), HLTConfigProvider::hltL1TSeeds(), mps_fire::i, iEvent, l1GtUtils_, l1tGlobalUtil_, HLTConfigProvider::l1tType(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, useL1EventSetup(), and useL1GtTriggerMenuLite().

Referenced by prescaleValues().

getL1PrescaleValueInDetail()

std::vector< std::pair< std::string, double > > HLTPrescaleProvider::getL1PrescaleValueInDetail ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup, const std::string &  trigger  )

private

error - can't handle properly multiple L1GTSeed modules

error - can't handle properly multiple L1TSeed modules

Definition at line 217 of file HLTPrescaleProvider.cc.

                                                                                   {
  std::vector<std::pair<std::string, double> > result;
 
  const unsigned int l1tType(hltConfigProvider_.l1tType());
  if (l1tType == 1) {
    checkL1GtUtils();
 
    const unsigned int nL1GTSeedModules(hltConfigProvider_.hltL1GTSeeds(trigger).size());
    if (nL1GTSeedModules == 0) {
      // no L1 seed module on path hence no L1 seed hence formally no L1 prescale
      result.clear();
    } else if (nL1GTSeedModules == 1) {
      l1GtUtils_->getL1GtRunCache(iEvent, iSetup, useL1EventSetup, useL1GtTriggerMenuLite);
      const std::string l1tname(hltConfigProvider_.hltL1GTSeeds(trigger).at(0).second);
      L1GtUtils::LogicalExpressionL1Results l1Logical(l1tname, *l1GtUtils_);
      l1Logical.logicalExpressionRunUpdate(iEvent.getRun(), iSetup, l1tname);
      const std::vector<std::pair<std::string, int> >& errorCodes(l1Logical.errorCodes(iEvent));
      auto resultInt = l1Logical.prescaleFactors();
      result.clear();
      for (const auto& entry : resultInt) {
        result.push_back(entry);
      }
 
      int l1error(l1Logical.isValid() ? 0 : 1);
      for (auto const& errorCode : errorCodes) {
        l1error += std::abs(errorCode.second);
      }
      if (l1error != 0) {
        if (count_[3] < countMax) {
          count_[3] += 1;
          std::ostringstream message;
          message << " Error in determining L1T prescales for HLT path: '" << trigger << "' with complex L1T seed: '"
                  << l1tname << "' using L1GtUtils: " << std::endl
                  << " isValid=" << l1Logical.isValid() << " l1tname/error/prescale " << errorCodes.size() << std::endl;
          for (unsigned int i = 0; i < errorCodes.size(); ++i) {
            message << " " << i << ":" << errorCodes[i].first << "/" << errorCodes[i].second << "/" << result[i].second;
          }
          message << ".";
          edm::LogError("HLTPrescaleProvider") << message.str();
        }
        result.clear();
      }
    } else {
      if (count_[4] < countMax) {
        count_[4] += 1;
        std::string dump("'" + hltConfigProvider_.hltL1GTSeeds(trigger).at(0).second + "'");
        for (unsigned int i = 1; i != nL1GTSeedModules; ++i) {
          dump += " * '" + hltConfigProvider_.hltL1GTSeeds(trigger).at(i).second + "'";
        }
        edm::LogError("HLTPrescaleProvider")
            << " Error in determining L1T prescale for HLT path: '" << trigger << "' has multiple L1GTSeed modules, "
            << nL1GTSeedModules << ", with L1 seeds: " << dump
            << ". (Note: at most one L1GTSeed module is allowed for a proper determination of the L1T prescale!)";
      }
      result.clear();
    }
  } else if (l1tType == 2) {
    checkL1TGlobalUtil();
    const unsigned int nL1TSeedModules(hltConfigProvider_.hltL1TSeeds(trigger).size());
    if (nL1TSeedModules == 0) {
      // no L1 seed module on path hence no L1 seed hence formally no L1 prescale
      result.clear();
    } else if (nL1TSeedModules == 1) {
      //    l1tGlobalUtil_->retrieveL1Event(iEvent,iSetup);
      std::string l1tname(hltConfigProvider_.hltL1TSeeds(trigger).at(0));
      GlobalLogicParser l1tGlobalLogicParser = GlobalLogicParser(l1tname);
      const std::vector<GlobalLogicParser::OperandToken> l1tSeeds = l1tGlobalLogicParser.expressionSeedsOperandList();
      int l1error(0);
      double l1tPrescale(-1);
      for (auto const& i : l1tSeeds) {
        const string& l1tSeed = i.tokenName;
        if (!l1tGlobalUtil_->getPrescaleByName(l1tSeed, l1tPrescale)) {
          l1error += 1;
        }
        result.push_back(std::pair<std::string, double>(l1tSeed, l1tPrescale));
      }
      if (l1error != 0) {
        if (count_[3] < countMax) {
          count_[3] += 1;
          string l1name = l1tname;
          std::ostringstream message;
          message << " Error in determining L1T prescales for HLT path: '" << trigger << "' with complex L1T seed: '"
                  << l1tname << "' using L1TGlobalUtil: " << std::endl
                  << " isValid=" << l1tGlobalLogicParser.checkLogicalExpression(l1name) << " l1tname/error/prescale "
                  << l1tSeeds.size() << std::endl;
          for (unsigned int i = 0; i < l1tSeeds.size(); ++i) {
            const string& l1tSeed = l1tSeeds[i].tokenName;
            message << " " << i << ":" << l1tSeed << "/" << l1tGlobalUtil_->getPrescaleByName(l1tSeed, l1tPrescale)
                    << "/" << result[i].second;
          }
          message << ".";
          edm::LogError("HLTPrescaleProvider") << message.str();
        }
        result.clear();
      }
    } else {
      if (count_[4] < countMax) {
        count_[4] += 1;
        std::string dump("'" + hltConfigProvider_.hltL1TSeeds(trigger).at(0) + "'");
        for (unsigned int i = 1; i != nL1TSeedModules; ++i) {
          dump += " * '" + hltConfigProvider_.hltL1TSeeds(trigger).at(i) + "'";
        }
        edm::LogError("HLTPrescaleProvider")
            << " Error in determining L1T prescale for HLT path: '" << trigger << "' has multiple L1TSeed modules, "
            << nL1TSeedModules << ", with L1T seeds: " << dump
            << ". (Note: at most one L1TSeed module is allowed for a proper determination of the L1T prescale!)";
      }
      result.clear();
    }
  } else {
    if (count_[3] < countMax) {
      count_[3] += 1;
      edm::LogError("HLTPrescaleProvider") << " Unknown L1T Type " << l1tType << " - can not determine L1T prescale! ";
    }
    result.clear();
  }
 
  return result;
}

References funct::abs(), checkL1GtUtils(), checkL1TGlobalUtil(), count_, countMax(), submitPVValidationJobs::dump, mps_splice::entry, hltConfigProvider_, HLTConfigProvider::hltL1GTSeeds(), HLTConfigProvider::hltL1TSeeds(), mps_fire::i, iEvent, l1GtUtils_, l1tGlobalUtil_, HLTConfigProvider::l1tType(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, useL1EventSetup(), and useL1GtTriggerMenuLite().

Referenced by prescaleValuesInDetail().

hltConfigProvider()

HLTConfigProvider const& HLTPrescaleProvider::hltConfigProvider ( ) const

inline

Definition at line 52 of file HLTPrescaleProvider.h.

{ return hltConfigProvider_; }

References hltConfigProvider_.

Referenced by HLTEventAnalyzerAOD::analyze(), IsoTrig::analyze(), HLTEventAnalyzerAOD::analyzeTrigger(), HLTEventAnalyzerAOD::beginRun(), pat::PATTriggerProducer::beginRun(), BPHMonitor::bookHistograms(), CandidateTriggerObjectProducer::produce(), and pat::PATTriggerProducer::produce().

init()

bool HLTPrescaleProvider::init	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup,
		const std::string &	processName,
		bool &	changed
	)

Run-dependent initialisation (non-const method) "init" return value indicates whether intitialisation has succeeded "changed" parameter indicates whether the config has actually changed This must be called at beginRun for most of the other functions in this class to succeed

L1 GTA V3: https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideL1TriggerL1GtUtils#Version_3

Definition at line 21 of file HLTPrescaleProvider.cc.

                                              {
  inited_ = true;
 
  count_[0] = 0;
  count_[1] = 0;
  count_[2] = 0;
  count_[3] = 0;
  count_[4] = 0;
 
  const bool result(hltConfigProvider_.init(iRun, iSetup, processName, changed));
 
  const unsigned int l1tType(hltConfigProvider_.l1tType());
  if (l1tType == 1) {
    checkL1GtUtils();
    l1GtUtils_->getL1GtRunCache(iRun, iSetup, useL1EventSetup, useL1GtTriggerMenuLite);
  } else if (l1tType == 2) {
    checkL1TGlobalUtil();
    l1tGlobalUtil_->retrieveL1Setup(iSetup);
  } else {
    edm::LogError("HLTPrescaleProvider") << " Unknown L1T Type " << l1tType << " - prescales will not be avaiable!";
  }
 
  return result;
}

References checkL1GtUtils(), checkL1TGlobalUtil(), count_, hltConfigProvider_, HLTConfigProvider::init(), inited_, l1GtUtils_, l1tGlobalUtil_, HLTConfigProvider::l1tType(), SimL1EmulatorRepack_CalouGT_cff::processName, mps_fire::result, useL1EventSetup(), and useL1GtTriggerMenuLite().

Referenced by HLTPrescaleExample::beginRun(), CandidateTriggerObjectProducer::beginRun(), HLTEventAnalyzerAOD::beginRun(), pat::PATTriggerProducer::beginRun(), IsoTrig::beginRun(), BPHMonitor::bookHistograms(), EwkElecDQM::dqmBeginRun(), and EwkMuDQM::dqmBeginRun().

l1GtUtils()

L1GtUtils const & HLTPrescaleProvider::l1GtUtils

(

)

const

Definition at line 50 of file HLTPrescaleProvider.cc.

                                                      {
  checkL1GtUtils();
  return *l1GtUtils_;
}

References checkL1GtUtils(), and l1GtUtils_.

Referenced by pat::PATTriggerProducer::produce().

l1PrescaleDenominator()

static int HLTPrescaleProvider::l1PrescaleDenominator ( )

inlinestatic

Definition at line 94 of file HLTPrescaleProvider.h.

{ return kL1PrescaleDenominator_; }

References kL1PrescaleDenominator_.

l1tGlobalUtil()

l1t::L1TGlobalUtil const & HLTPrescaleProvider::l1tGlobalUtil

(

)

const

Definition at line 55 of file HLTPrescaleProvider.cc.

                                                                 {
  checkL1TGlobalUtil();
  return *l1tGlobalUtil_;
}

References checkL1TGlobalUtil(), and l1tGlobalUtil_.

prescaleSet()

int HLTPrescaleProvider::prescaleSet	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

HLT prescale values via (L1) EventSetup current (default) prescale set index - to be taken from L1GtUtil via Event

error - notify user!

Definition at line 60 of file HLTPrescaleProvider.cc.

                                                                                        {
  if (!inited_) {
    throw cms::Exception("LogicError") << "HLTPrescaleProvider::prescaleSet,\n"
                                          "HLTPrescaleProvider::init was not called at beginRun\n";
  }
  const unsigned int l1tType(hltConfigProvider_.l1tType());
  if (l1tType == 1) {
    checkL1GtUtils();
 
    // return hltPrescaleTable_.set();
    l1GtUtils_->getL1GtRunCache(iEvent, iSetup, useL1EventSetup, useL1GtTriggerMenuLite);
    int errorTech(0);
    const int psfsiTech(l1GtUtils_->prescaleFactorSetIndex(iEvent, L1GtUtils::TechnicalTrigger, errorTech));
    int errorPhys(0);
    const int psfsiPhys(l1GtUtils_->prescaleFactorSetIndex(iEvent, L1GtUtils::AlgorithmTrigger, errorPhys));
    assert(psfsiTech == psfsiPhys);
    if ((errorTech == 0) && (errorPhys == 0) && (psfsiTech >= 0) && (psfsiPhys >= 0) && (psfsiTech == psfsiPhys)) {
      return psfsiPhys;
    } else {
      if (count_[0] < countMax) {
        count_[0] += 1;
        edm::LogError("HLTPrescaleProvider")
            << " Using processName '" << hltConfigProvider_.processName() << "':"
            << " Error in determining HLT prescale set index from L1 data using L1GtUtils:"
            << " Tech/Phys error = " << errorTech << "/" << errorPhys << " Tech/Phys psfsi = " << psfsiTech << "/"
            << psfsiPhys;
      }
      return -1;
    }
  } else if (l1tType == 2) {
    checkL1TGlobalUtil();
    l1tGlobalUtil_->retrieveL1Event(iEvent, iSetup);
    return static_cast<int>(l1tGlobalUtil_->prescaleColumn());
  } else {
    if (count_[0] < countMax) {
      count_[0] += 1;
      edm::LogError("HLTPrescaleProvider")
          << " Using processName '" << hltConfigProvider_.processName() << "':"
          << " Unknown L1T Type " << l1tType << " - can not determine prescale set index!";
    }
    return -1;
  }
}

References L1GtUtils::AlgorithmTrigger, cms::cuda::assert(), checkL1GtUtils(), checkL1TGlobalUtil(), count_, countMax(), Exception, hltConfigProvider_, iEvent, inited_, l1GtUtils_, l1tGlobalUtil_, HLTConfigProvider::l1tType(), HLTConfigProvider::processName(), L1GtUtils::TechnicalTrigger, useL1EventSetup(), and useL1GtTriggerMenuLite().

Referenced by EwkMuDQM::analyze(), EwkElecDQM::analyze(), prescaleValue(), and pat::PATTriggerProducer::produce().

prescaleValue() [1/3]

template<typename T = unsigned int>

T HLTPrescaleProvider::prescaleValue ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup, const std::string &  trigger  )

inline

combining the two methods above

Definition at line 63 of file HLTPrescaleProvider.h.

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

References hltConfigProvider_, iEvent, prescaleSet(), and HLTConfigProvider::prescaleValue().

Referenced by HLTPrescaleExample::analyze().

prescaleValue() [2/3]

template<>

unsigned int HLTPrescaleProvider::prescaleValue	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const std::string &	trigger
	)

prescaleValue() [3/3]

template<>

unsigned int HLTPrescaleProvider::prescaleValue	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const std::string &	trigger
	)

Definition at line 365 of file HLTPrescaleProvider.cc.

                                                                                        {
  const int set(prescaleSet(iEvent, iSetup));
  return set < 0 ? 1 : hltConfigProvider_.prescaleValue<unsigned int>(static_cast<unsigned int>(set), trigger);
}

References hltConfigProvider_, iEvent, prescaleSet(), and HLTConfigProvider::prescaleValue().

prescaleValues()

template<typename TL1 = int, typename THLT = TL1>

std::pair<TL1, THLT> HLTPrescaleProvider::prescaleValues ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup, const std::string &  trigger  )

inline

Combined L1T (pair.first) and HLT (pair.second) prescales per HLT path.

Definition at line 72 of file HLTPrescaleProvider.h.

                                                                {
    return {convertL1PS<TL1>(getL1PrescaleValue(iEvent, iSetup, trigger)),
            prescaleValue<THLT>(iEvent, iSetup, trigger)};
  }

References getL1PrescaleValue(), and iEvent.

Referenced by HLTPrescaleExample::analyze(), IsoTrig::analyze(), HLTEventAnalyzerAOD::analyzeTrigger(), and CandidateTriggerObjectProducer::produce().

prescaleValuesInDetail()

template<typename TL1 = int, typename THLT = TL1>

std::pair<std::vector<std::pair<std::string, TL1> >, THLT> HLTPrescaleProvider::prescaleValuesInDetail ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup, const std::string &  trigger  )

inline

Definition at line 82 of file HLTPrescaleProvider.h.

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

References mps_splice::entry, getL1PrescaleValueInDetail(), iEvent, and eostools::move().

Referenced by HLTPrescaleExample::analyze(), HLTEventAnalyzerAOD::analyzeTrigger(), BPHMonitor::Prescale(), and pat::PATTriggerProducer::produce().

rejectedByHLTPrescaler()

bool HLTPrescaleProvider::rejectedByHLTPrescaler	(	const edm::TriggerResults &	triggerResults,
		unsigned int	i
	)		const

Definition at line 340 of file HLTPrescaleProvider.cc.

                                                                                                              {
  return hltConfigProvider_.moduleType(hltConfigProvider_.moduleLabel(i, triggerResults.index(i))) == "HLTPrescaler";
}

References hltConfigProvider_, mps_fire::i, HLTConfigProvider::moduleLabel(), HLTConfigProvider::moduleType(), and triggerResults.

Member Data Documentation

count_

unsigned char HLTPrescaleProvider::count_[5] = {0, 0, 0, 0, 0}

private

Definition at line 112 of file HLTPrescaleProvider.h.

Referenced by getL1PrescaleValue(), getL1PrescaleValueInDetail(), init(), and prescaleSet().

hltConfigProvider_

HLTConfigProvider HLTPrescaleProvider::hltConfigProvider_

private

Definition at line 109 of file HLTPrescaleProvider.h.

Referenced by getL1PrescaleValue(), getL1PrescaleValueInDetail(), hltConfigProvider(), init(), prescaleSet(), prescaleValue(), and rejectedByHLTPrescaler().

inited_

bool HLTPrescaleProvider::inited_ = false

private

Definition at line 113 of file HLTPrescaleProvider.h.

Referenced by init(), and prescaleSet().

kL1PrescaleDenominator_

constexpr int HLTPrescaleProvider::kL1PrescaleDenominator_ = 100

staticconstexprprivate

Definition at line 108 of file HLTPrescaleProvider.h.

Referenced by convertL1PS(), and l1PrescaleDenominator().

l1GtUtils_

std::unique_ptr<L1GtUtils> HLTPrescaleProvider::l1GtUtils_

private

Definition at line 110 of file HLTPrescaleProvider.h.

Referenced by checkL1GtUtils(), getL1PrescaleValue(), getL1PrescaleValueInDetail(), HLTPrescaleProvider(), init(), l1GtUtils(), and prescaleSet().

l1tGlobalUtil_

std::unique_ptr<l1t::L1TGlobalUtil> HLTPrescaleProvider::l1tGlobalUtil_

private

Definition at line 111 of file HLTPrescaleProvider.h.

Referenced by checkL1TGlobalUtil(), getL1PrescaleValue(), getL1PrescaleValueInDetail(), HLTPrescaleProvider(), init(), l1tGlobalUtil(), and prescaleSet().