HLTPrescaleProvider Class Reference

#include <HLTPrescaleProvider.h>

Public Member Functions
template<>
FractionalPrescale	convertL1PS (double val) const
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<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 void	fillPSetDescription (edm::ParameterSetDescription &desc, unsigned int stageL1Trigger, edm::InputTag const &l1tAlgBlkInputTag, edm::InputTag const &l1tExtBlkInputTag, bool readPrescalesFromFile)
static int	l1PrescaleDenominator ()

Private Member Functions
void	checkL1GtUtils () const
void	checkL1TGlobalUtil () const
template<typename T >
T	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
static constexpr const char *	l1tGlobalDecisionKeyword_ = "L1GlobalDecision"

Detailed Description

This class provides access routines to get hold of the HLT Configuration, as well as the prescales of Level-1 and High-Level triggers.

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 39 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 139 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 143 of file HLTPrescaleProvider.h.

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

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

Member Function Documentation

checkL1GtUtils()

void HLTPrescaleProvider::checkL1GtUtils ( ) const

private

Definition at line 370 of file HLTPrescaleProvider.cc.

References Exception, and l1GtUtils_.

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

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

checkL1TGlobalUtil()

void HLTPrescaleProvider::checkL1TGlobalUtil ( ) const

private

Definition at line 380 of file HLTPrescaleProvider.cc.

References Exception, and l1tGlobalUtil_.

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

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

convertL1PS() [1/2]

template<typename T >

T HLTPrescaleProvider::convertL1PS ( double  val ) const

inlineprivate

Definition at line 110 of file HLTPrescaleProvider.h.

References or, and heppy_batch::val.

                                  {
    static_assert(std::is_same_v<T, double> or std::is_same_v<T, FractionalPrescale>,
                  "\n\n\tPlease use convertL1PS<double> or convertL1PS<FractionalPrescale>"
                  " (other types for L1T prescales are not supported anymore by HLTPrescaleProvider)"
                  "\n\tconvertL1PS is used inside prescaleValues and prescaleValuesInDetail,"
                  " so it might be necessary to specify template arguments for those calls,"
                  "\n\te.g. prescaleValues<double, FractionalPrescale>"
                  " (the 1st argument applies to L1T prescales, the 2nd to HLT prescales)\n");
    return T(val);
  }

convertL1PS() [2/2]

FractionalPrescale HLTPrescaleProvider::convertL1PS

(

double

val

)

const

Definition at line 107 of file HLTPrescaleProvider.cc.

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

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

fillPSetDescription()

void HLTPrescaleProvider::fillPSetDescription ( edm::ParameterSetDescription &  desc, unsigned int  stageL1Trigger, edm::InputTag const &  l1tAlgBlkInputTag, edm::InputTag const &  l1tExtBlkInputTag, bool  readPrescalesFromFile  )

static

Definition at line 390 of file HLTPrescaleProvider.cc.

References submitPVResolutionJobs::desc, l1t::L1TGlobalUtil::fillDescription(), L1GtUtils::fillDescription(), WElectronSkim_cff::l1tAlgBlkInputTag, WElectronSkim_cff::l1tExtBlkInputTag, and gammaJetAnalysis_cfi::stageL1Trigger.

Referenced by BPHMonitor::fillDescriptions().

                                                                          {
  desc.add<unsigned int>("stageL1Trigger", stageL1Trigger);
  L1GtUtils::fillDescription(desc);
  l1t::L1TGlobalUtil::fillDescription(desc, l1tAlgBlkInputTag, l1tExtBlkInputTag, readPrescalesFromFile);
}

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 119 of file HLTPrescaleProvider.cc.

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

Referenced by prescaleValues().

                                                                         {
  // 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);
      if (l1tname == l1tGlobalDecisionKeyword_) {
        LogDebug("HLTPrescaleProvider") << "Undefined L1T prescale for HLT path: '" << trigger << "' with L1T seed '"
                                        << l1tGlobalDecisionKeyword_ << "' (keyword for global decision of L1T)";
        result = -1;
      } else {
        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));
      if (l1tname == l1tGlobalDecisionKeyword_) {
        LogDebug("HLTPrescaleProvider") << "Undefined L1T prescale for HLT path: '" << trigger << "' with L1T seed '"
                                        << l1tGlobalDecisionKeyword_ << "' (keyword for global decision of L1T)";
        result = -1;
      } else {
        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;
}

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 228 of file HLTPrescaleProvider.cc.

References funct::abs(), checkL1GtUtils(), checkL1TGlobalUtil(), GlobalLogicParser::checkLogicalExpression(), count_, countMax(), GCP_Ntuples_cfg::dump, mps_splice::entry, L1GtUtils::LogicalExpressionL1Results::errorCodes(), GlobalLogicParser::expressionSeedsOperandList(), hltConfigProvider_, HLTConfigProvider::hltL1GTSeeds(), HLTConfigProvider::hltL1TSeeds(), mps_fire::i, iEvent, L1GtUtils::LogicalExpressionL1Results::isValid(), l1GtUtils_, l1tGlobalDecisionKeyword_, l1tGlobalUtil_, HLTConfigProvider::l1tType(), LogDebug, L1GtUtils::LogicalExpressionL1Results::logicalExpressionRunUpdate(), L1GtUtils::LogicalExpressionL1Results::prescaleFactors(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, useL1EventSetup(), and useL1GtTriggerMenuLite().

Referenced by prescaleValuesInDetail().

                                                                                   {
  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);
      if (l1tname == l1tGlobalDecisionKeyword_) {
        LogDebug("HLTPrescaleProvider") << "Undefined L1T prescales for HLT path: '" << trigger << "' with L1T seed '"
                                        << l1tGlobalDecisionKeyword_ << "' (keyword for global decision of L1T)";
        result.clear();
      } else {
        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();
        result.reserve(resultInt.size());
        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) {
      std::string l1tname(hltConfigProvider_.hltL1TSeeds(trigger).at(0));
      if (l1tname == l1tGlobalDecisionKeyword_) {
        LogDebug("HLTPrescaleProvider") << "Undefined L1T prescales for HLT path: '" << trigger << "' with L1T seed '"
                                        << l1tGlobalDecisionKeyword_ << "' (keyword for global decision of L1T)";
        result.clear();
      } else {
        GlobalLogicParser l1tGlobalLogicParser = GlobalLogicParser(l1tname);
        const std::vector<GlobalLogicParser::OperandToken> l1tSeeds = l1tGlobalLogicParser.expressionSeedsOperandList();
        int l1error(0);
        double l1tPrescale(-1);
        result.clear();
        result.reserve(l1tSeeds.size());
        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;
}

hltConfigProvider()

HLTConfigProvider const& HLTPrescaleProvider::hltConfigProvider ( ) const

inline

Definition at line 53 of file HLTPrescaleProvider.h.

References hltConfigProvider_.

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

{ return hltConfigProvider_; }

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 22 of file HLTPrescaleProvider.cc.

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().

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

l1GtUtils()

L1GtUtils const & HLTPrescaleProvider::l1GtUtils

(

)

const

Definition at line 51 of file HLTPrescaleProvider.cc.

References checkL1GtUtils(), and l1GtUtils_.

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

                                                      {
  checkL1GtUtils();
  return *l1GtUtils_;
}

l1PrescaleDenominator()

static int HLTPrescaleProvider::l1PrescaleDenominator ( )

inlinestatic

Definition at line 95 of file HLTPrescaleProvider.h.

References kL1PrescaleDenominator_.

{ return kL1PrescaleDenominator_; }

l1tGlobalUtil()

l1t::L1TGlobalUtil const & HLTPrescaleProvider::l1tGlobalUtil

(

)

const

Definition at line 56 of file HLTPrescaleProvider.cc.

References checkL1TGlobalUtil(), and l1tGlobalUtil_.

                                                                 {
  checkL1TGlobalUtil();
  return *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 61 of file HLTPrescaleProvider.cc.

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().

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

prescaleValue()

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 64 of file HLTPrescaleProvider.h.

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

Referenced by HLTPrescaleExample::analyze().

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

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 73 of file HLTPrescaleProvider.h.

References getL1PrescaleValue(), and iEvent.

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

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

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 83 of file HLTPrescaleProvider.h.

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

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

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

rejectedByHLTPrescaler()

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

Definition at line 366 of file HLTPrescaleProvider.cc.

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

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

Member Data Documentation

count_

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

private

Definition at line 134 of file HLTPrescaleProvider.h.

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

hltConfigProvider_

HLTConfigProvider HLTPrescaleProvider::hltConfigProvider_

private

Definition at line 129 of file HLTPrescaleProvider.h.

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

inited_

bool HLTPrescaleProvider::inited_ = false

private

Definition at line 135 of file HLTPrescaleProvider.h.

Referenced by init(), and prescaleSet().

kL1PrescaleDenominator_

constexpr int HLTPrescaleProvider::kL1PrescaleDenominator_ = 100

staticprivate

Definition at line 127 of file HLTPrescaleProvider.h.

Referenced by convertL1PS(), and l1PrescaleDenominator().

l1GtUtils_

std::unique_ptr<L1GtUtils> HLTPrescaleProvider::l1GtUtils_

private

Definition at line 131 of file HLTPrescaleProvider.h.

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

l1tGlobalDecisionKeyword_

constexpr const char* HLTPrescaleProvider::l1tGlobalDecisionKeyword_ = "L1GlobalDecision"

staticprivate

Definition at line 104 of file HLTPrescaleProvider.h.

Referenced by getL1PrescaleValue(), and getL1PrescaleValueInDetail().

l1tGlobalUtil_

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

private

Definition at line 132 of file HLTPrescaleProvider.h.

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