L1GtUtils Class Reference

#include <L1GtUtils.h>

Classes
class	LogicalExpressionL1Results

Public Types
enum	TriggerCategory { AlgorithmTrigger = 0, TechnicalTrigger = 1 }
enum	UseEventSetupIn { UseEventSetupIn::Run, UseEventSetupIn::Event, UseEventSetupIn::RunAndEvent, UseEventSetupIn::Nothing }

Public Member Functions
const bool	availableL1Configuration (int &errorCode, int &l1ConfCode) const
const bool	decision (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
const bool	decisionAfterMask (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
	return decision after trigger mask for a given algorithm or technical trigger More...
const bool	decisionBeforeMask (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
	return decision before trigger mask for a given algorithm or technical trigger More...
void	getL1GtRunCache (const edm::Run &, const edm::EventSetup &, const bool, const bool)
	get all the run-constant quantities for L1 trigger and cache them More...
void	getL1GtRunCache (const edm::Event &, const edm::EventSetup &, const bool, const bool)
	for use in analyze(const edm::Event&, const edm::EventSetup&) More...
const bool	l1AlgoTechTrigBitNumber (const std::string &nameAlgoTechTrig, TriggerCategory &trigCategory, int &bitNumber) const
	L1GtUtils (edm::ParameterSet const &pset, edm::ConsumesCollector &&iC, bool useL1GtTriggerMenuLite, UseEventSetupIn use=UseEventSetupIn::Run)
	L1GtUtils (edm::ParameterSet const &pset, edm::ConsumesCollector &iC, bool useL1GtTriggerMenuLite, UseEventSetupIn use=UseEventSetupIn::Run)
template<typename T >
	L1GtUtils (edm::ParameterSet const &pset, edm::ConsumesCollector &&iC, bool useL1GtTriggerMenuLite, T &module, UseEventSetupIn use=UseEventSetupIn::Run)
template<typename T >
	L1GtUtils (edm::ParameterSet const &pset, edm::ConsumesCollector &iC, bool useL1GtTriggerMenuLite, T &module, UseEventSetupIn use=UseEventSetupIn::Run)
template<typename T >
	L1GtUtils (edm::ParameterSet const &pset, edm::ConsumesCollector &&iC, bool useL1GtTriggerMenuLite, T &module, edm::InputTag const &l1GtRecordInputTag, edm::InputTag const &l1GtReadoutRecordInputTag, edm::InputTag const &l1GtTriggerMenuLiteInputTag, UseEventSetupIn use=UseEventSetupIn::Run)
template<typename T >
	L1GtUtils (edm::ParameterSet const &pset, edm::ConsumesCollector &iC, bool useL1GtTriggerMenuLite, T &module, edm::InputTag const &l1GtRecordInputTag, edm::InputTag const &l1GtReadoutRecordInputTag, edm::InputTag const &l1GtTriggerMenuLiteInputTag, UseEventSetupIn use=UseEventSetupIn::Run)
const int	l1Results (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, bool &decisionBeforeMask, bool &decisionAfterMask, int &prescaleFactor, int &triggerMask) const
const std::string &	l1TriggerMenu () const
	return the L1 trigger menu name More...
const std::string &	l1TriggerMenuImplementation () const
	return the L1 trigger menu implementation More...
const bool	l1TriggerNameFromBit (const int &bitNumber, const TriggerCategory &trigCategory, std::string &aliasL1Trigger, std::string &nameL1Trigger) const
const int	prescaleFactor (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
	return prescale factor for a given algorithm or technical trigger More...
const std::vector< int > &	prescaleFactorSet (const edm::Event &iEvent, const TriggerCategory &trigCategory, int &errorCode)
const int	prescaleFactorSetIndex (const edm::Event &iEvent, const TriggerCategory &trigCategory, int &errorCode) const
const L1GtTriggerMenuLite *	ptrL1GtTriggerMenuLite (int &errorCode)
	return a pointer to the L1GtTriggerMenuLite product More...
const L1GtTriggerMenu *	ptrL1TriggerMenuEventSetup (int &errorCode)
	return a pointer to the L1 trigger menu from event setup More...
void	retrieveL1EventSetup (const edm::EventSetup &, bool isRun=true)
	retrieve all the relevant L1 trigger event setup records and cache them to improve the speed More...
void	retrieveL1GtTriggerMenuLite (const edm::Run &)
	retrieve L1GtTriggerMenuLite (per run product) and cache it to improve the speed More...
const std::string	triggerCategory (const TriggerCategory &) const
	public methods More...
const int	triggerMask (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
	return trigger mask for a given algorithm or technical trigger More...
const int	triggerMask (const std::string &nameAlgoTechTrig, int &errorCode) const
const std::vector< unsigned int > &	triggerMaskSet (const TriggerCategory &trigCategory, int &errorCode)
virtual	~L1GtUtils ()
	destructor More...

Static Public Member Functions
static void	fillDescription (edm::ParameterSetDescription &desc)

Private Member Functions
	L1GtUtils (edm::ConsumesCollector &, UseEventSetupIn)
const bool	trigResult (const DecisionWord &decWord, const int bitNumber, const std::string &nameAlgoTechTrig, const TriggerCategory &trigCategory, int &errorCode) const

Private Attributes
const AlgorithmMap *	m_algorithmAliasMap
const L1GtTriggerMenuLite::L1TriggerMap *	m_algorithmAliasMapLite
const AlgorithmMap *	m_algorithmMap
const L1GtTriggerMenuLite::L1TriggerMap *	m_algorithmMapLite
bool	m_beginRunCache
	flag for call of getL1GtRunCache in beginRun More...
bool	m_l1EventSetupValid
const L1GtTriggerMenu *	m_l1GtMenu
unsigned long long	m_l1GtMenuCacheID
const L1GtTriggerMenuLite *	m_l1GtMenuLite
	L1GtTriggerMenuLite cached stuff. More...
bool	m_l1GtMenuLiteValid
const L1GtPrescaleFactors *	m_l1GtPfAlgo
	prescale factors More...
unsigned long long	m_l1GtPfAlgoCacheID
const L1GtPrescaleFactors *	m_l1GtPfTech
unsigned long long	m_l1GtPfTechCacheID
edm::ESGetToken< L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd >	m_L1GtPrescaleFactorsAlgoTrigEventToken
edm::ESGetToken< L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd >	m_L1GtPrescaleFactorsAlgoTrigRunToken
edm::ESGetToken< L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd >	m_L1GtPrescaleFactorsTechTrigEventToken
edm::ESGetToken< L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd >	m_L1GtPrescaleFactorsTechTrigRunToken
const L1GtStableParameters *	m_l1GtStablePar
	event setup cached stuff More...
edm::ESGetToken< L1GtStableParameters, L1GtStableParametersRcd >	m_L1GtStableParametersEventToken
edm::ESGetToken< L1GtStableParameters, L1GtStableParametersRcd >	m_L1GtStableParametersRunToken
unsigned long long	m_l1GtStableParCacheID
const L1GtTriggerMask *	m_l1GtTmAlgo
	trigger masks & veto masks More...
unsigned long long	m_l1GtTmAlgoCacheID
const L1GtTriggerMask *	m_l1GtTmTech
unsigned long long	m_l1GtTmTechCacheID
const L1GtTriggerMask *	m_l1GtTmVetoAlgo
unsigned long long	m_l1GtTmVetoAlgoCacheID
const L1GtTriggerMask *	m_l1GtTmVetoTech
unsigned long long	m_l1GtTmVetoTechCacheID
edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd >	m_L1GtTriggerMaskAlgoTrigEventToken
edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd >	m_L1GtTriggerMaskAlgoTrigRunToken
edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd >	m_L1GtTriggerMaskTechTrigEventToken
edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd >	m_L1GtTriggerMaskTechTrigRunToken
edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd >	m_L1GtTriggerMaskVetoAlgoTrigEventToken
edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd >	m_L1GtTriggerMaskVetoAlgoTrigRunToken
edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd >	m_L1GtTriggerMaskVetoTechTrigEventToken
edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd >	m_L1GtTriggerMaskVetoTechTrigRunToken
edm::ESGetToken< L1GtTriggerMenu, L1GtTriggerMenuRcd >	m_L1GtTriggerMenuEventToken
edm::ESGetToken< L1GtTriggerMenu, L1GtTriggerMenuRcd >	m_L1GtTriggerMenuRunToken
std::unique_ptr< L1GtUtilsHelper >	m_l1GtUtilsHelper
unsigned int	m_numberAlgorithmTriggers
	number of algorithm triggers More...
unsigned int	m_numberTechnicalTriggers
	number of technical triggers More...
unsigned int	m_physicsDaqPartition
	index of physics DAQ partition More...
const std::vector< std::vector< int > > *	m_prescaleFactorsAlgoTrig
const std::vector< std::vector< int > > *	m_prescaleFactorsAlgoTrigLite
std::vector< int >	m_prescaleFactorSet
const std::vector< std::vector< int > > *	m_prescaleFactorsTechTrig
const std::vector< std::vector< int > > *	m_prescaleFactorsTechTrigLite
bool	m_retrieveL1EventSetup
	flags to check which method was used to retrieve L1 trigger configuration More...
bool	m_retrieveL1GtTriggerMenuLite
edm::RunID	m_runIDCache
	run cache ID More...
const AlgorithmMap *	m_technicalTriggerMap
const L1GtTriggerMenuLite::L1TriggerMap *	m_technicalTriggerMapLite
const std::vector< unsigned int > *	m_triggerMaskAlgoTrig
const std::vector< unsigned int > *	m_triggerMaskAlgoTrigLite
std::vector< unsigned int >	m_triggerMaskSet
const std::vector< unsigned int > *	m_triggerMaskTechTrig
const std::vector< unsigned int > *	m_triggerMaskTechTrigLite
const std::vector< unsigned int > *	m_triggerMaskVetoAlgoTrig
const std::vector< unsigned int > *	m_triggerMaskVetoTechTrig

Static Private Attributes
static const std::string	EmptyString = ""
static const int	L1GtNotValidError = 99999

Detailed Description

Description: various methods for L1 GT, to be called in an EDM analyzer, producer or filter.

Implementation: <TODO: enter implementation details>

Author

: Vasile Mihai Ghete - HEPHY Vienna

Description: return L1 trigger results for a logical expression.

Implementation: Return L1 trigger results for a logical expression of algorithm or technical triggers. Mixture of algorithm and technical triggers in the logical expression is allowed only if trigger names or aliases are used. Mixing bit numbers and names or aliases is not supported. If the expression has bit numbers, they are assumed to be technical triggers.

Author

: Vasile Mihai Ghete - HEPHY Vienna

Definition at line 66 of file L1GtUtils.h.

Member Enumeration Documentation

TriggerCategory

enum L1GtUtils::TriggerCategory

Enumerator
AlgorithmTrigger
TechnicalTrigger

Definition at line 140 of file L1GtUtils.h.

{ AlgorithmTrigger = 0, TechnicalTrigger = 1 };

UseEventSetupIn

enum L1GtUtils::UseEventSetupIn

strong

Enumerator
Run
Event
RunAndEvent
Nothing

Definition at line 76 of file L1GtUtils.h.

{ Run, Event, RunAndEvent, Nothing };

Constructor & Destructor Documentation

L1GtUtils() [1/7]

L1GtUtils::L1GtUtils	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &&	iC,
		bool	useL1GtTriggerMenuLite,
		UseEventSetupIn	use = UseEventSetupIn::Run
	)

Definition at line 93 of file L1GtUtils.cc.

    : L1GtUtils(pset, iC, useL1GtTriggerMenuLite, useEventSetupIn) {}

L1GtUtils() [2/7]

L1GtUtils::L1GtUtils	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &	iC,
		bool	useL1GtTriggerMenuLite,
		UseEventSetupIn	use = UseEventSetupIn::Run
	)

Definition at line 99 of file L1GtUtils.cc.

References m_l1GtUtilsHelper, muonDTDigis_cfi::pset, and useL1GtTriggerMenuLite().

    : L1GtUtils(iC, useEventSetupIn) {
  m_l1GtUtilsHelper = std::make_unique<L1GtUtilsHelper>(pset, iC, useL1GtTriggerMenuLite);
}

L1GtUtils() [3/7]

template<typename T >

L1GtUtils::L1GtUtils	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &&	iC,
		bool	useL1GtTriggerMenuLite,
		T &	module,
		UseEventSetupIn	use = UseEventSetupIn::Run
	)

Definition at line 497 of file L1GtUtils.h.

    : L1GtUtils(pset, iC, useL1GtTriggerMenuLite, module, useEventSetupIn) {}

L1GtUtils() [4/7]

template<typename T >

L1GtUtils::L1GtUtils	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &	iC,
		bool	useL1GtTriggerMenuLite,
		T &	module,
		UseEventSetupIn	use = UseEventSetupIn::Run
	)

Definition at line 505 of file L1GtUtils.h.

References m_l1GtUtilsHelper, callgraph::module, muonDTDigis_cfi::pset, and useL1GtTriggerMenuLite().

    : L1GtUtils(iC, useEventSetupIn) {
  m_l1GtUtilsHelper = std::make_unique<L1GtUtilsHelper>(pset, iC, useL1GtTriggerMenuLite, module);
}

L1GtUtils() [5/7]

template<typename T >

L1GtUtils::L1GtUtils	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &&	iC,
		bool	useL1GtTriggerMenuLite,
		T &	module,
		edm::InputTag const &	l1GtRecordInputTag,
		edm::InputTag const &	l1GtReadoutRecordInputTag,
		edm::InputTag const &	l1GtTriggerMenuLiteInputTag,
		UseEventSetupIn	use = UseEventSetupIn::Run
	)

Definition at line 515 of file L1GtUtils.h.

    : L1GtUtils(pset,
                iC,
                useL1GtTriggerMenuLite,
                module,
                l1GtRecordInputTag,
                l1GtReadoutRecordInputTag,
                l1GtTriggerMenuLiteInputTag,
                useEventSetupIn) {}

L1GtUtils() [6/7]

template<typename T >

L1GtUtils::L1GtUtils	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &	iC,
		bool	useL1GtTriggerMenuLite,
		T &	module,
		edm::InputTag const &	l1GtRecordInputTag,
		edm::InputTag const &	l1GtReadoutRecordInputTag,
		edm::InputTag const &	l1GtTriggerMenuLiteInputTag,
		UseEventSetupIn	use = UseEventSetupIn::Run
	)

Definition at line 533 of file L1GtUtils.h.

References WElectronSkim_cff::l1GtReadoutRecordInputTag, WElectronSkim_cff::l1GtRecordInputTag, l1MenuTree_cfi::l1GtTriggerMenuLiteInputTag, m_l1GtUtilsHelper, callgraph::module, muonDTDigis_cfi::pset, and useL1GtTriggerMenuLite().

    : L1GtUtils(iC, useEventSetupIn) {
  m_l1GtUtilsHelper = std::make_unique<L1GtUtilsHelper>(pset,
                                                        iC,
                                                        useL1GtTriggerMenuLite,
                                                        module,
                                                        l1GtRecordInputTag,
                                                        l1GtReadoutRecordInputTag,
                                                        l1GtTriggerMenuLiteInputTag);
}

~L1GtUtils()

L1GtUtils::~L1GtUtils ( )

virtual

destructor

Definition at line 108 of file L1GtUtils.cc.

                      {
  // empty
}

L1GtUtils() [7/7]

L1GtUtils::L1GtUtils ( edm::ConsumesCollector &  iC, UseEventSetupIn  useEventSetupIn  )

private

Definition at line 30 of file L1GtUtils.cc.

References edm::BeginRun, edm::ConsumesCollector::esConsumes(), Event, m_L1GtPrescaleFactorsAlgoTrigEventToken, m_L1GtPrescaleFactorsAlgoTrigRunToken, m_L1GtPrescaleFactorsTechTrigEventToken, m_L1GtPrescaleFactorsTechTrigRunToken, m_L1GtStableParametersEventToken, m_L1GtStableParametersRunToken, m_L1GtTriggerMaskAlgoTrigEventToken, m_L1GtTriggerMaskAlgoTrigRunToken, m_L1GtTriggerMaskTechTrigEventToken, m_L1GtTriggerMaskTechTrigRunToken, m_L1GtTriggerMaskVetoAlgoTrigEventToken, m_L1GtTriggerMaskVetoAlgoTrigRunToken, m_L1GtTriggerMaskVetoTechTrigEventToken, m_L1GtTriggerMaskVetoTechTrigRunToken, m_L1GtTriggerMenuEventToken, m_L1GtTriggerMenuRunToken, Run, and RunAndEvent.

    :

      m_l1GtStableParCacheID(0ULL),
      m_numberAlgorithmTriggers(0),

      m_numberTechnicalTriggers(0),

      m_l1GtPfAlgoCacheID(0ULL),
      m_l1GtPfTechCacheID(0ULL),

      m_l1GtTmAlgoCacheID(0ULL),
      m_l1GtTmTechCacheID(0ULL),

      m_l1GtTmVetoAlgoCacheID(0ULL),
      m_l1GtTmVetoTechCacheID(0ULL),

      m_l1GtMenuCacheID(0ULL),

      m_l1EventSetupValid(false),

      m_l1GtMenuLiteValid(false),

      m_beginRunCache(false),

      m_runIDCache(0),

      m_physicsDaqPartition(0),

      m_retrieveL1EventSetup(false),

      m_retrieveL1GtTriggerMenuLite(false)

{
  if (useEventSetupIn == UseEventSetupIn::Run || useEventSetupIn == UseEventSetupIn::RunAndEvent) {
    m_L1GtStableParametersRunToken =
        iC.esConsumes<L1GtStableParameters, L1GtStableParametersRcd, edm::Transition::BeginRun>();
    m_L1GtPrescaleFactorsAlgoTrigRunToken =
        iC.esConsumes<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd, edm::Transition::BeginRun>();
    m_L1GtPrescaleFactorsTechTrigRunToken =
        iC.esConsumes<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd, edm::Transition::BeginRun>();
    m_L1GtTriggerMaskAlgoTrigRunToken =
        iC.esConsumes<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd, edm::Transition::BeginRun>();
    m_L1GtTriggerMaskTechTrigRunToken =
        iC.esConsumes<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd, edm::Transition::BeginRun>();
    m_L1GtTriggerMaskVetoAlgoTrigRunToken =
        iC.esConsumes<L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd, edm::Transition::BeginRun>();
    m_L1GtTriggerMaskVetoTechTrigRunToken =
        iC.esConsumes<L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd, edm::Transition::BeginRun>();
    m_L1GtTriggerMenuRunToken = iC.esConsumes<L1GtTriggerMenu, L1GtTriggerMenuRcd, edm::Transition::BeginRun>();
  }
  if (useEventSetupIn == UseEventSetupIn::Event || useEventSetupIn == UseEventSetupIn::RunAndEvent) {
    m_L1GtStableParametersEventToken = iC.esConsumes<L1GtStableParameters, L1GtStableParametersRcd>();
    m_L1GtPrescaleFactorsAlgoTrigEventToken = iC.esConsumes<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd>();
    m_L1GtPrescaleFactorsTechTrigEventToken = iC.esConsumes<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd>();
    m_L1GtTriggerMaskAlgoTrigEventToken = iC.esConsumes<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd>();
    m_L1GtTriggerMaskTechTrigEventToken = iC.esConsumes<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd>();
    m_L1GtTriggerMaskVetoAlgoTrigEventToken = iC.esConsumes<L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd>();
    m_L1GtTriggerMaskVetoTechTrigEventToken = iC.esConsumes<L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd>();
    m_L1GtTriggerMenuEventToken = iC.esConsumes<L1GtTriggerMenu, L1GtTriggerMenuRcd>();
  }
}

Member Function Documentation

availableL1Configuration()

const bool L1GtUtils::availableL1Configuration	(	int &	errorCode,
		int &	l1ConfCode
	)		const

check if L1 trigger configuration is available return false and an error code if configuration is not available

Definition at line 1679 of file L1GtUtils.cc.

References L1GtNotValidError, LogDebug, m_l1EventSetupValid, m_l1GtMenuLiteValid, m_retrieveL1EventSetup, and m_retrieveL1GtTriggerMenuLite.

Referenced by IsoTrackCalib::analyze(), L1GtAnalyzer::analyzeL1GtUtilsCore(), L1GtAnalyzer::analyzeTrigger(), l1Results(), prescaleFactorSetIndex(), ptrL1GtTriggerMenuLite(), ptrL1TriggerMenuEventSetup(), triggerMask(), and triggerMaskSet().

                                                                                    {
  if (m_retrieveL1GtTriggerMenuLite) {
    if (!m_retrieveL1EventSetup) {
      LogDebug("L1GtUtils") << "\nRetrieve L1 trigger configuration from L1GtTriggerMenuLite only.\n" << std::endl;
      l1ConfCode = 0;
    } else {
      LogDebug("L1GtUtils") << "\nFall through: retrieve L1 trigger configuration from L1GtTriggerMenuLite."
                            << "\nIf L1GtTriggerMenuLite not valid, try to retrieve from event setup.\n"
                            << std::endl;
      l1ConfCode = 100000;
    }

    if (m_l1GtMenuLiteValid) {
      LogDebug("L1GtUtils") << "\nRetrieve L1 trigger configuration from L1GtTriggerMenuLite, valid product.\n"
                            << std::endl;
      l1ConfCode = l1ConfCode + 10000;
      errorCode = 0;

      return true;

    } else if (m_retrieveL1EventSetup) {
      if (m_l1EventSetupValid) {
        LogDebug("L1GtUtils") << "\nFall through: retrieve L1 trigger configuration from event setup."
                              << "\nFirst option was L1GtTriggerMenuLite - but product is not valid.\n"
                              << std::endl;
        l1ConfCode = l1ConfCode + 20000;
        errorCode = 0;

        return true;

      } else {
        LogDebug("L1GtUtils") << "\nFall through: L1GtTriggerMenuLite not valid, event setup not valid.\n" << std::endl;
        l1ConfCode = l1ConfCode + L1GtNotValidError;
        errorCode = l1ConfCode;

        return false;
      }

    } else {
      LogDebug("L1GtUtils") << "\nError: L1 trigger configuration requested from L1GtTriggerMenuLite only"
                            << "\nbut L1GtTriggerMenuLite is not valid.\n"
                            << std::endl;
      l1ConfCode = l1ConfCode + L1GtNotValidError;
      errorCode = l1ConfCode;

      return false;
    }
  } else if (m_retrieveL1EventSetup) {
    LogDebug("L1GtUtils") << "\nRetrieve L1 trigger configuration from event setup."
                          << "\nL1GtTriggerMenuLite product was not requested.\n"
                          << std::endl;
    l1ConfCode = 200000;

    if (m_l1EventSetupValid) {
      LogDebug("L1GtUtils") << "\nRetrieve L1 trigger configuration from event setup only."
                            << "\nValid L1 trigger event setup.\n"
                            << std::endl;
      l1ConfCode = l1ConfCode + 10000;
      errorCode = 0;

      return true;

    } else {
      LogDebug("L1GtUtils") << "\nRetrieve L1 trigger configuration from event setup only."
                            << "\nNo valid L1 trigger event setup.\n"
                            << std::endl;
      l1ConfCode = l1ConfCode + L1GtNotValidError;
      errorCode = l1ConfCode;

      return false;
    }

  } else {
    LogDebug("L1GtUtils") << "\nError: no L1 trigger configuration requested to be retrieved."
                          << "\nMust call before getL1GtRunCache in beginRun and analyze.\n"
                          << std::endl;
    l1ConfCode = 300000;
    errorCode = l1ConfCode;

    return false;
  }
}

decision()

const bool L1GtUtils::decision	(	const edm::Event &	iEvent,
		const std::string &	nameAlgoTechTrig,
		int &	errorCode
	)		const

return decision after trigger mask for a given algorithm or technical trigger function identical with decisionAfterMask

Definition at line 1066 of file L1GtUtils.cc.

References decisionAfterMask(), decisionBeforeMask(), iEvent, l1Results(), prescaleFactor(), and triggerMask().

Referenced by IsoTrackCalib::analyze(), L1GtAnalyzer::analyzeL1GtUtilsCore(), L1GtAnalyzer::analyzeTrigger(), and PrescaleWeightProvider::prescaleWeight().

                                                                                                              {
  // initial values
  bool decisionBeforeMask = false;
  bool decisionAfterMask = false;
  int prescaleFactor = -1;
  int triggerMask = -1;

  errorCode = l1Results(iEvent, nameAlgoTechTrig, decisionBeforeMask, decisionAfterMask, prescaleFactor, triggerMask);

  return decisionAfterMask;
}

decisionAfterMask()

const bool L1GtUtils::decisionAfterMask	(	const edm::Event &	iEvent,
		const std::string &	nameAlgoTechTrig,
		int &	errorCode
	)		const

return decision after trigger mask for a given algorithm or technical trigger

Definition at line 1052 of file L1GtUtils.cc.

References decisionBeforeMask(), iEvent, l1Results(), prescaleFactor(), and triggerMask().

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore(), L1GtAnalyzer::analyzeTrigger(), decision(), decisionBeforeMask(), l1Results(), prescaleFactor(), and triggerMask().

                                                              {
  // initial values
  bool decisionBeforeMask = false;
  bool decisionAfterMask = false;
  int prescaleFactor = -1;
  int triggerMask = -1;

  errorCode = l1Results(iEvent, nameAlgoTechTrig, decisionBeforeMask, decisionAfterMask, prescaleFactor, triggerMask);

  return decisionAfterMask;
}

decisionBeforeMask()

const bool L1GtUtils::decisionBeforeMask	(	const edm::Event &	iEvent,
		const std::string &	nameAlgoTechTrig,
		int &	errorCode
	)		const

return decision before trigger mask for a given algorithm or technical trigger

for the functions decisionBeforeMask, decisionAfterMask, decision prescaleFactor, trigger mask:

input: event, event setup algorithm trigger name or alias, or technical trigger name output (by reference): error code return: the corresponding quantity

Definition at line 1038 of file L1GtUtils.cc.

References decisionAfterMask(), iEvent, l1Results(), prescaleFactor(), and triggerMask().

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore(), L1GtAnalyzer::analyzeTrigger(), decision(), decisionAfterMask(), l1Results(), prescaleFactor(), and triggerMask().

                                                               {
  // initial values
  bool decisionBeforeMask = false;
  bool decisionAfterMask = false;
  int prescaleFactor = -1;
  int triggerMask = -1;

  errorCode = l1Results(iEvent, nameAlgoTechTrig, decisionBeforeMask, decisionAfterMask, prescaleFactor, triggerMask);

  return decisionBeforeMask;
}

fillDescription()

static void L1GtUtils::fillDescription ( edm::ParameterSetDescription &  desc )

inlinestatic

Definition at line 137 of file L1GtUtils.h.

References submitPVResolutionJobs::desc, and L1GtUtilsHelper::fillDescription().

Referenced by HLTPrescaleProvider::fillPSetDescription().

{ L1GtUtilsHelper::fillDescription(desc); }

getL1GtRunCache() [1/2]

void L1GtUtils::getL1GtRunCache	(	const edm::Run &	iRun,
		const edm::EventSetup &	evSetup,
		const bool	useL1EventSetup,
		const bool	useL1GtTriggerMenuLite
	)

get all the run-constant quantities for L1 trigger and cache them

for use in beginRun(const edm::Run&, const edm::EventSetup&);

Definition at line 314 of file L1GtUtils.cc.

References m_beginRunCache, retrieveL1EventSetup(), retrieveL1GtTriggerMenuLite(), useL1EventSetup(), and useL1GtTriggerMenuLite().

Referenced by IsoTrackCalib::analyze(), L1GtAnalyzer::analyzeL1GtUtils(), L1GtAnalyzer::analyzeL1GtUtilsEventSetup(), L1GtAnalyzer::analyzeL1GtUtilsMenuLite(), L1GtAnalyzer::analyzeTrigger(), and L1GtAnalyzer::beginRun().

                                                             {
  // first call will turn this to true: the quantities which can be cached in
  // beginRun will not be cached then in analyze
  m_beginRunCache = true;

  // if requested, retrieve and cache L1 event setup
  // keep the caching based on cacheIdentifier() for each record
  if (useL1EventSetup) {
    bool isRun = true;
    retrieveL1EventSetup(evSetup, isRun);
  }

  // cached per run

  // if requested, retrieve and cache the L1GtTriggerMenuLite
  // L1GtTriggerMenuLite is defined per run and produced in prompt reco by L1Reco
  // and put in the Run section
  if (useL1GtTriggerMenuLite) {
    retrieveL1GtTriggerMenuLite(iRun);
  }
}

getL1GtRunCache() [2/2]

void L1GtUtils::getL1GtRunCache	(	const edm::Event &	iEvent,
		const edm::EventSetup &	evSetup,
		const bool	useL1EventSetup,
		const bool	useL1GtTriggerMenuLite
	)

for use in analyze(const edm::Event&, const edm::EventSetup&)

Definition at line 339 of file L1GtUtils.cc.

References edm::RunAuxiliary::id(), iEvent, m_beginRunCache, m_runIDCache, retrieveL1EventSetup(), retrieveL1GtTriggerMenuLite(), edm::Run::runAuxiliary(), useL1EventSetup(), and useL1GtTriggerMenuLite().

                                                                   {
  // if there was no retrieval and caching in beginRun, do it here
  if (!m_beginRunCache) {
    // if requested, retrieve and cache L1 event setup
    // keep the caching based on cacheIdentifier() for each record
    if (useL1EventSetup) {
      bool isRun = false;
      retrieveL1EventSetup(evSetup, isRun);
    }
  }

  // cached per run

  const edm::Run& iRun = iEvent.getRun();
  edm::RunID runID = iRun.runAuxiliary().id();

  if (runID != m_runIDCache) {
    if (!m_beginRunCache) {
      // if requested, retrieve and cache the L1GtTriggerMenuLite
      // L1GtTriggerMenuLite is defined per run and produced in prompt reco by L1Reco
      // and put in the Run section
      if (useL1GtTriggerMenuLite) {
        retrieveL1GtTriggerMenuLite(iRun);
      }
    }
    m_runIDCache = runID;
  }
}

l1AlgoTechTrigBitNumber()

const bool L1GtUtils::l1AlgoTechTrigBitNumber	(	const std::string &	nameAlgoTechTrig,
		TriggerCategory &	trigCategory,
		int &	bitNumber
	)		const

return the trigger "category" trigCategory algorithm trigger alias or algorithm trigger name AlgorithmTrigger = 0, technical trigger TechnicalTrigger = 1 and its bit number

in case the algorithm trigger / technical trigger is not in the menu, the returned function is false, the trigger category is irrelevant (default value is AlgorithmTrigger), and the value of the bit number is -1

Definition at line 371 of file L1GtUtils.cc.

References AlgorithmTrigger, L1TBPTX_cfi::bitNumber, m_algorithmAliasMap, m_algorithmAliasMapLite, m_algorithmMap, m_algorithmMapLite, m_l1GtMenuLiteValid, m_retrieveL1EventSetup, m_retrieveL1GtTriggerMenuLite, m_technicalTriggerMap, m_technicalTriggerMapLite, and TechnicalTrigger.

Referenced by l1Results(), pat::PATTriggerProducer::produce(), and triggerMask().

                                                                    {
  trigCategory = AlgorithmTrigger;
  bitNumber = -1;

  if (m_retrieveL1GtTriggerMenuLite) {
    if (m_l1GtMenuLiteValid) {
      // test if the name is an algorithm alias
      for (L1GtTriggerMenuLite::CItL1Trig itTrig = m_algorithmAliasMapLite->begin();
           itTrig != m_algorithmAliasMapLite->end();
           itTrig++) {
        if (itTrig->second == nameAlgoTechTrig) {
          trigCategory = AlgorithmTrigger;
          bitNumber = itTrig->first;

          return true;
        }
      }

      // test if the name is an algorithm name
      for (L1GtTriggerMenuLite::CItL1Trig itTrig = m_algorithmMapLite->begin(); itTrig != m_algorithmMapLite->end();
           itTrig++) {
        if (itTrig->second == nameAlgoTechTrig) {
          trigCategory = AlgorithmTrigger;
          bitNumber = itTrig->first;

          return true;
        }
      }

      // test if the name is a technical trigger
      for (L1GtTriggerMenuLite::CItL1Trig itTrig = m_technicalTriggerMapLite->begin();
           itTrig != m_technicalTriggerMapLite->end();
           itTrig++) {
        if (itTrig->second == nameAlgoTechTrig) {
          trigCategory = TechnicalTrigger;
          bitNumber = itTrig->first;

          return true;
        }
      }

    } else if (m_retrieveL1EventSetup) {
      // test if the name is an algorithm alias
      CItAlgo itAlgo = m_algorithmAliasMap->find(nameAlgoTechTrig);
      if (itAlgo != m_algorithmAliasMap->end()) {
        trigCategory = AlgorithmTrigger;
        bitNumber = (itAlgo->second).algoBitNumber();

        return true;
      }

      // test if the name is an algorithm name
      itAlgo = m_algorithmMap->find(nameAlgoTechTrig);
      if (itAlgo != m_algorithmMap->end()) {
        trigCategory = AlgorithmTrigger;
        bitNumber = (itAlgo->second).algoBitNumber();

        return true;
      }

      // test if the name is a technical trigger
      itAlgo = m_technicalTriggerMap->find(nameAlgoTechTrig);
      if (itAlgo != m_technicalTriggerMap->end()) {
        trigCategory = TechnicalTrigger;
        bitNumber = (itAlgo->second).algoBitNumber();

        return true;
      }

    } else {
      // only L1GtTriggerMenuLite requested, but it is not valid
      return false;
    }
  } else if (m_retrieveL1EventSetup) {
    // test if the name is an algorithm alias
    CItAlgo itAlgo = m_algorithmAliasMap->find(nameAlgoTechTrig);
    if (itAlgo != m_algorithmAliasMap->end()) {
      trigCategory = AlgorithmTrigger;
      bitNumber = (itAlgo->second).algoBitNumber();

      return true;
    }

    // test if the name is an algorithm name
    itAlgo = m_algorithmMap->find(nameAlgoTechTrig);
    if (itAlgo != m_algorithmMap->end()) {
      trigCategory = AlgorithmTrigger;
      bitNumber = (itAlgo->second).algoBitNumber();

      return true;
    }

    // test if the name is a technical trigger
    itAlgo = m_technicalTriggerMap->find(nameAlgoTechTrig);
    if (itAlgo != m_technicalTriggerMap->end()) {
      trigCategory = TechnicalTrigger;
      bitNumber = (itAlgo->second).algoBitNumber();

      return true;
    }

  } else {
    // L1 trigger configuration not retrieved
    return false;
  }

  // all possibilities already tested, so it should not arrive here
  return false;
}

l1Results()

const int L1GtUtils::l1Results	(	const edm::Event &	iEvent,
		const std::string &	nameAlgoTechTrig,
		bool &	decisionBeforeMask,
		bool &	decisionAfterMask,
		int &	prescaleFactor,
		int &	triggerMask
	)		const

return results for a given algorithm or technical trigger, input: event algorithm trigger name or alias, or technical trigger name output (by reference): decision before mask, decision after mask, prescale factor trigger mask return: integer error code

Definition at line 666 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), L1TBPTX_cfi::bitNumber, decisionAfterMask(), decisionBeforeMask(), L1GlobalTriggerReadoutRecord::decisionWord(), L1GlobalTriggerRecord::decisionWordBeforeMask(), L1GlobalTriggerReadoutRecord::gtFdlWord(), L1GlobalTriggerRecord::gtPrescaleFactorIndexAlgo(), L1GlobalTriggerRecord::gtPrescaleFactorIndexTech(), L1GtTriggerMenuLite::gtTriggerMenuImplementation(), L1GtTriggerMenu::gtTriggerMenuImplementation(), iEvent, edm::HandleBase::isValid(), l1AlgoTechTrigBitNumber(), LogDebug, m_l1GtMenu, m_l1GtMenuLite, m_l1GtMenuLiteValid, m_l1GtUtilsHelper, m_physicsDaqPartition, m_prescaleFactorsAlgoTrig, m_prescaleFactorsAlgoTrigLite, m_prescaleFactorsTechTrig, m_prescaleFactorsTechTrigLite, m_retrieveL1GtTriggerMenuLite, m_triggerMaskAlgoTrig, m_triggerMaskAlgoTrigLite, m_triggerMaskTechTrig, m_triggerMaskTechTrigLite, prescaleFactor(), TechnicalTrigger, L1GlobalTriggerReadoutRecord::technicalTriggerWord(), L1GlobalTriggerRecord::technicalTriggerWordBeforeMask(), triggerCategory(), triggerMask(), and trigResult().

Referenced by decision(), decisionAfterMask(), decisionBeforeMask(), L1GtUtils::LogicalExpressionL1Results::errorCodes(), prescaleFactor(), pat::PATTriggerProducer::produce(), and triggerMask().

                                                       {
  // initial values for returned results
  decisionBeforeMask = false;
  decisionAfterMask = false;
  prescaleFactor = -1;
  triggerMask = -1;

  // initialize error code and L1 configuration code
  int iError = 0;
  int l1ConfCode = 0;

  // check if L1 configuration is available

  if (!availableL1Configuration(iError, l1ConfCode)) {
    return iError;
  }

  // at this point, a valid L1 configuration is available, so the if/else if/else
  // can be simplified

  // if the given name is not an algorithm trigger alias, an algorithm trigger name
  // or a technical trigger in the current menu, return with error code 1

  TriggerCategory trigCategory = AlgorithmTrigger;
  int bitNumber = -1;

  if (!l1AlgoTechTrigBitNumber(nameAlgoTechTrig, trigCategory, bitNumber)) {
    iError = l1ConfCode + 1;

    if (m_retrieveL1GtTriggerMenuLite) {
      if (m_l1GtMenuLiteValid) {
        LogDebug("L1GtUtils") << "\nAlgorithm/technical trigger \n  " << nameAlgoTechTrig
                              << "\not found in the trigger menu \n  " << m_l1GtMenuLite->gtTriggerMenuImplementation()
                              << "\nretrieved from L1GtTriggerMenuLite" << std::endl;

      } else {
        // fall through: L1 trigger configuration from event setup
        LogDebug("L1GtUtils") << "\nAlgorithm/technical trigger \n  " << nameAlgoTechTrig
                              << "\not found in the trigger menu \n  " << m_l1GtMenu->gtTriggerMenuImplementation()
                              << "\nretrieved from Event Setup" << std::endl;
      }

    } else {
      // L1 trigger configuration from event setup only
      LogDebug("L1GtUtils") << "\nAlgorithm/technical trigger \n  " << nameAlgoTechTrig
                            << "\not found in the trigger menu \n  " << m_l1GtMenu->gtTriggerMenuImplementation()
                            << "\nretrieved from Event Setup" << std::endl;
    }

    return iError;
  }

  // check here if a positive bit number was retrieved
  // exit in case of negative bit number, before retrieving L1 GT products, saving time

  if (bitNumber < 0) {
    iError = l1ConfCode + 2;

    if (m_retrieveL1GtTriggerMenuLite) {
      if (m_l1GtMenuLiteValid) {
        LogDebug("L1GtUtils") << "\nNegative bit number for " << triggerCategory(trigCategory) << "\n  "
                              << nameAlgoTechTrig << "\nfrom menu \n  " << m_l1GtMenuLite->gtTriggerMenuImplementation()
                              << "\nretrieved from L1GtTriggerMenuLite" << std::endl;

      } else {
        // fall through: L1 trigger configuration from event setup
        LogDebug("L1GtUtils") << "\nNegative bit number for " << triggerCategory(trigCategory) << "\n  "
                              << nameAlgoTechTrig << "\nfrom menu \n  " << m_l1GtMenu->gtTriggerMenuImplementation()
                              << "\nretrieved from Event Setup" << std::endl;
      }

    } else {
      // L1 trigger configuration from event setup only
      LogDebug("L1GtUtils") << "\nNegative bit number for " << triggerCategory(trigCategory) << "\n  "
                            << nameAlgoTechTrig << "\nfrom menu \n  " << m_l1GtMenu->gtTriggerMenuImplementation()
                            << "\nretrieved from Event Setup" << std::endl;
    }

    return iError;
  }

  // retrieve L1GlobalTriggerRecord and 1GlobalTriggerReadoutRecord product
  // intermediate error code for the records
  // the module returns an error code only if both the lite and the readout record are missing

  int iErrorRecord = 0;

  bool validRecord = false;
  bool gtReadoutRecordValid = false;

  edm::Handle<L1GlobalTriggerRecord> gtRecord;
  if (!m_l1GtUtilsHelper->l1GtRecordToken().isUninitialized()) {
    iEvent.getByToken(m_l1GtUtilsHelper->l1GtRecordToken(), gtRecord);
  }
  if (gtRecord.isValid()) {
    validRecord = true;

  } else {
    iErrorRecord = 10;
    LogDebug("L1GtUtils") << "\nL1GlobalTriggerRecord with \n  " << m_l1GtUtilsHelper->l1GtRecordInputTag()
                          << "\nnot found in the event." << std::endl;
  }

  edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecord;
  if (!m_l1GtUtilsHelper->l1GtReadoutRecordToken().isUninitialized()) {
    iEvent.getByToken(m_l1GtUtilsHelper->l1GtReadoutRecordToken(), gtReadoutRecord);
  }
  if (gtReadoutRecord.isValid()) {
    gtReadoutRecordValid = true;
    validRecord = true;

  } else {
    iErrorRecord = iErrorRecord + 100;
    LogDebug("L1GtUtils") << "\nL1GlobalTriggerReadoutRecord with \n  "
                          << m_l1GtUtilsHelper->l1GtReadoutRecordInputTag() << "\nnot found in the event." << std::endl;
  }

  // get the prescale factor index from
  //  L1GlobalTriggerReadoutRecord if valid
  //  if not, from L1GlobalTriggerRecord if valid
  //  else return an error

  int pfIndexTechTrig = -1;
  int pfIndexAlgoTrig = -1;

  if (validRecord) {
    if (gtReadoutRecordValid) {
      pfIndexTechTrig = (gtReadoutRecord->gtFdlWord()).gtPrescaleFactorIndexTech();
      pfIndexAlgoTrig = (gtReadoutRecord->gtFdlWord()).gtPrescaleFactorIndexAlgo();

    } else {
      pfIndexTechTrig = static_cast<int>(gtRecord->gtPrescaleFactorIndexTech());
      pfIndexAlgoTrig = static_cast<int>(gtRecord->gtPrescaleFactorIndexAlgo());
    }

  } else {
    LogDebug("L1GtUtils") << "\nError: "
                          << "\nNo valid L1GlobalTriggerRecord with \n  " << m_l1GtUtilsHelper->l1GtRecordInputTag()
                          << "\nfound in the event."
                          << "\nNo valid L1GlobalTriggerReadoutRecord with \n  "
                          << m_l1GtUtilsHelper->l1GtReadoutRecordInputTag() << "\nfound in the event." << std::endl;

    iError = l1ConfCode + iErrorRecord;
    return iError;
  }

  // depending on trigger category (algorithm trigger or technical trigger)
  // get the correct quantities

  // number of sets of prescale factors
  // index of prescale factor set retrieved from data
  // pointer to the actual prescale factor set
  // pointer to the set of trigger masks

  size_t pfSetsSize = 0;
  int pfIndex = -1;
  const std::vector<int>* prescaleFactorsSubset = nullptr;
  const std::vector<unsigned int>* triggerMasksSet = nullptr;

  switch (trigCategory) {
    case AlgorithmTrigger: {
      if (m_retrieveL1GtTriggerMenuLite) {
        if (m_l1GtMenuLiteValid) {
          pfSetsSize = m_prescaleFactorsAlgoTrigLite->size();
          triggerMasksSet = m_triggerMaskAlgoTrigLite;

        } else {
          // fall through: L1 trigger configuration from event setup
          pfSetsSize = m_prescaleFactorsAlgoTrig->size();
          triggerMasksSet = m_triggerMaskAlgoTrig;
        }

      } else {
        // L1 trigger configuration from event setup only
        pfSetsSize = m_prescaleFactorsAlgoTrig->size();
        triggerMasksSet = m_triggerMaskAlgoTrig;
      }

      pfIndex = pfIndexAlgoTrig;

    } break;
    case TechnicalTrigger: {
      if (m_retrieveL1GtTriggerMenuLite) {
        if (m_l1GtMenuLiteValid) {
          pfSetsSize = m_prescaleFactorsTechTrigLite->size();
          triggerMasksSet = m_triggerMaskTechTrigLite;

        } else {
          // fall through: L1 trigger configuration from event setup
          pfSetsSize = m_prescaleFactorsTechTrig->size();
          triggerMasksSet = m_triggerMaskTechTrig;
        }

      } else {
        // L1 trigger configuration from event setup only
        pfSetsSize = m_prescaleFactorsTechTrig->size();
        triggerMasksSet = m_triggerMaskTechTrig;
      }

      pfIndex = pfIndexTechTrig;

    } break;
    default: {
      // should not be the case
      iError = l1ConfCode + iErrorRecord + 3;
      return iError;

    } break;
  }

  // test prescale factor set index correctness, then retrieve the actual set of prescale factors

  if (pfIndex < 0) {
    iError = l1ConfCode + iErrorRecord + 1000;
    LogDebug("L1GtUtils") << "\nError: index of prescale factor set retrieved from the data \n"
                          << "less than zero."
                          << "\n  Value of index retrieved from data = " << pfIndex << std::endl;

    return iError;

  } else if (pfIndex >= (static_cast<int>(pfSetsSize))) {
    iError = l1ConfCode + iErrorRecord + 2000;
    LogDebug("L1GtUtils") << "\nError: index of prescale factor set retrieved from the data \n"
                          << "greater than the size of the vector of prescale factor sets."
                          << "\n  Value of index retrieved from data = " << pfIndex
                          << "\n  Vector size = " << pfSetsSize << std::endl;

    return iError;

  } else {
    switch (trigCategory) {
      case AlgorithmTrigger: {
        if (m_retrieveL1GtTriggerMenuLite) {
          if (m_l1GtMenuLiteValid) {
            prescaleFactorsSubset = &((*m_prescaleFactorsAlgoTrigLite).at(pfIndex));

          } else {
            // fall through: L1 trigger configuration from event setup
            prescaleFactorsSubset = &((*m_prescaleFactorsAlgoTrig).at(pfIndex));
          }

        } else {
          // L1 trigger configuration from event setup only
          prescaleFactorsSubset = &((*m_prescaleFactorsAlgoTrig).at(pfIndex));
        }

      } break;
      case TechnicalTrigger: {
        if (m_retrieveL1GtTriggerMenuLite) {
          if (m_l1GtMenuLiteValid) {
            prescaleFactorsSubset = &((*m_prescaleFactorsTechTrigLite).at(pfIndex));

          } else {
            // fall through: L1 trigger configuration from event setup
            prescaleFactorsSubset = &((*m_prescaleFactorsTechTrig).at(pfIndex));
          }

        } else {
          // L1 trigger configuration from event setup only
          prescaleFactorsSubset = &((*m_prescaleFactorsTechTrig).at(pfIndex));
        }

      } break;
      default: {
        // do nothing - it was tested before, with return

      } break;
    }
  }

  // algorithm result before applying the trigger masks
  // the bit number is positive (tested previously)

  switch (trigCategory) {
    case AlgorithmTrigger: {
      if (gtReadoutRecordValid) {
        const DecisionWord& decWord = gtReadoutRecord->decisionWord();
        decisionBeforeMask = trigResult(decWord, bitNumber, nameAlgoTechTrig, trigCategory, iError);
        if (iError) {
          return (iError + l1ConfCode + iErrorRecord);
        }

      } else {
        const DecisionWord& decWord = gtRecord->decisionWordBeforeMask();
        decisionBeforeMask = trigResult(decWord, bitNumber, nameAlgoTechTrig, trigCategory, iError);
        if (iError) {
          return (iError + l1ConfCode + iErrorRecord);
        }
      }

    } break;
    case TechnicalTrigger: {
      if (gtReadoutRecordValid) {
        const DecisionWord& decWord = gtReadoutRecord->technicalTriggerWord();
        decisionBeforeMask = trigResult(decWord, bitNumber, nameAlgoTechTrig, trigCategory, iError);
        if (iError) {
          return (iError + l1ConfCode + iErrorRecord);
        }

      } else {
        const DecisionWord& decWord = gtRecord->technicalTriggerWordBeforeMask();
        decisionBeforeMask = trigResult(decWord, bitNumber, nameAlgoTechTrig, trigCategory, iError);
        if (iError) {
          return (iError + l1ConfCode + iErrorRecord);
        }
      }

    } break;
    default: {
      // do nothing - it was tested before, with return

    } break;
  }

  // prescale factor
  // the bit number is positive (tested previously)

  if (bitNumber < (static_cast<int>(prescaleFactorsSubset->size()))) {
    prescaleFactor = (*prescaleFactorsSubset)[bitNumber];
  } else {
    iError = l1ConfCode + iErrorRecord + 4000;
    LogDebug("L1GtUtils") << "\nError: bit number " << bitNumber << " retrieved for " << triggerCategory(trigCategory)
                          << "\n  " << nameAlgoTechTrig << "\ngreater than size of actual L1 GT prescale factor set: "
                          << prescaleFactorsSubset->size() << "\nError: Inconsistent L1 trigger configuration!"
                          << std::endl;

    return iError;
  }

  // trigger mask and trigger result after applying the trigger masks

  if (bitNumber < (static_cast<int>((*triggerMasksSet).size()))) {
    if (m_retrieveL1GtTriggerMenuLite) {
      if (m_l1GtMenuLiteValid) {
        triggerMask = (*triggerMasksSet)[bitNumber];

      } else {
        // fall through: L1 trigger configuration from event setup
        // masks in event setup are for all partitions
        triggerMask = ((*triggerMasksSet)[bitNumber]) & (1 << m_physicsDaqPartition);
      }

    } else {
      // L1 trigger configuration from event setup only
      // masks in event setup are for all partitions
      triggerMask = ((*triggerMasksSet)[bitNumber]) & (1 << m_physicsDaqPartition);
    }

  } else {
    iError = l1ConfCode + iErrorRecord + 5000;
    LogDebug("L1GtUtils") << "\nError: bit number " << bitNumber << " retrieved for " << triggerCategory(trigCategory)
                          << "\n  " << nameAlgoTechTrig
                          << "\ngreater than size of L1 GT trigger mask set: " << (*triggerMasksSet).size()
                          << "\nError: Inconsistent L1 trigger configuration!" << std::endl;

    return iError;
  }

  decisionAfterMask = decisionBeforeMask;

  if (triggerMask) {
    decisionAfterMask = false;
  }

  return iError;
}

l1TriggerMenu()

const std::string & L1GtUtils::l1TriggerMenu

(

)

const

return the L1 trigger menu name

Definition at line 1577 of file L1GtUtils.cc.

References EmptyString, L1GtTriggerMenuLite::gtTriggerMenuName(), L1GtTriggerMenu::gtTriggerMenuName(), m_l1GtMenu, m_l1GtMenuLite, m_l1GtMenuLiteValid, m_retrieveL1EventSetup, and m_retrieveL1GtTriggerMenuLite.

Referenced by L1MenuTreeProducer::analyze(), L1GtAnalyzer::analyzeL1GtUtilsCore(), L1GtAnalyzer::analyzeTrigger(), and L1Analysis::L1AnalysisL1Menu::SetPrescaleFactorIndex().

                                                {
  if (m_retrieveL1GtTriggerMenuLite) {
    if (m_l1GtMenuLiteValid) {
      return m_l1GtMenuLite->gtTriggerMenuName();

    } else if (m_retrieveL1EventSetup) {
      return m_l1GtMenu->gtTriggerMenuName();

    } else {
      // only L1GtTriggerMenuLite requested, but it is not valid
      return EmptyString;
    }
  } else if (m_retrieveL1EventSetup) {
    return m_l1GtMenu->gtTriggerMenuName();

  } else {
    // L1 trigger configuration not retrieved
    return EmptyString;
  }
}

l1TriggerMenuImplementation()

const std::string & L1GtUtils::l1TriggerMenuImplementation

(

)

const

return the L1 trigger menu implementation

Definition at line 1598 of file L1GtUtils.cc.

References EmptyString, L1GtTriggerMenuLite::gtTriggerMenuImplementation(), L1GtTriggerMenu::gtTriggerMenuImplementation(), m_l1GtMenu, m_l1GtMenuLite, m_l1GtMenuLiteValid, m_retrieveL1EventSetup, and m_retrieveL1GtTriggerMenuLite.

Referenced by L1MenuTreeProducer::analyze(), L1GtAnalyzer::analyzeL1GtUtilsCore(), and L1GtAnalyzer::analyzeTrigger().

                                                              {
  if (m_retrieveL1GtTriggerMenuLite) {
    if (m_l1GtMenuLiteValid) {
      return m_l1GtMenuLite->gtTriggerMenuImplementation();

    } else if (m_retrieveL1EventSetup) {
      return m_l1GtMenu->gtTriggerMenuImplementation();

    } else {
      // only L1GtTriggerMenuLite requested, but it is not valid
      return EmptyString;
    }
  } else if (m_retrieveL1EventSetup) {
    return m_l1GtMenu->gtTriggerMenuImplementation();

  } else {
    // L1 trigger configuration not retrieved
    return EmptyString;
  }
}

l1TriggerNameFromBit()

const bool L1GtUtils::l1TriggerNameFromBit	(	const int &	bitNumber,
		const TriggerCategory &	trigCategory,
		std::string &	aliasL1Trigger,
		std::string &	nameL1Trigger
	)		const

return the trigger name and alias for a given trigger category and a given bit number

in case no algorithm trigger / technical trigger is defined for that bit in the menu, the returned function is false, and the name and the alias is empty

Definition at line 483 of file L1GtUtils.cc.

References MillePedeAlignmentAlgorithm_cfi::algoName, AlgorithmTrigger, L1TBPTX_cfi::bitNumber, m_algorithmAliasMap, m_algorithmAliasMapLite, m_algorithmMapLite, m_l1GtMenuLiteValid, m_retrieveL1EventSetup, m_retrieveL1GtTriggerMenuLite, m_technicalTriggerMap, m_technicalTriggerMapLite, and TechnicalTrigger.

                                                                           {
  aliasL1Trigger.clear();
  nameL1Trigger.clear();

  if (m_retrieveL1GtTriggerMenuLite) {
    if (m_l1GtMenuLiteValid) {
      // for an algorithm trigger
      if (trigCategory == AlgorithmTrigger) {
        bool trigAliasFound = false;
        bool trigNameFound = false;

        for (L1GtTriggerMenuLite::CItL1Trig itTrig = m_algorithmAliasMapLite->begin();
             itTrig != m_algorithmAliasMapLite->end();
             itTrig++) {
          if (static_cast<int>(itTrig->first) == bitNumber) {
            aliasL1Trigger = itTrig->second;
            trigAliasFound = true;
            break;
          }
        }

        for (L1GtTriggerMenuLite::CItL1Trig itTrig = m_algorithmMapLite->begin(); itTrig != m_algorithmMapLite->end();
             itTrig++) {
          if (static_cast<int>(itTrig->first) == bitNumber) {
            nameL1Trigger = itTrig->second;
            trigNameFound = true;
            break;
          }
        }

        if (!(trigAliasFound && trigNameFound)) {
          return false;
        }

        return true;

      } else if (trigCategory == TechnicalTrigger) {
        // for a technical trigger

        bool trigNameFound = false;

        for (L1GtTriggerMenuLite::CItL1Trig itTrig = m_technicalTriggerMapLite->begin();
             itTrig != m_technicalTriggerMapLite->end();
             itTrig++) {
          if (static_cast<int>(itTrig->first) == bitNumber) {
            nameL1Trigger = itTrig->second;

            // technically, no alias is defined for technical triggers
            // users use mainly aliases, so just return the name here
            aliasL1Trigger = itTrig->second;

            trigNameFound = true;
            break;
          }
        }

        if (!(trigNameFound)) {
          return false;
        }

        return true;

      } else {
        // non-existing trigger category...
        return false;
      }

    } else if (m_retrieveL1EventSetup) {
      // for an algorithm trigger
      if (trigCategory == AlgorithmTrigger) {
        bool trigAliasFound = false;

        for (CItAlgo itTrig = m_algorithmAliasMap->begin(); itTrig != m_algorithmAliasMap->end(); itTrig++) {
          if ((itTrig->second).algoBitNumber() == bitNumber) {
            aliasL1Trigger = itTrig->first;
            // get the name here, avoiding a loop on m_algorithmMap
            nameL1Trigger = (itTrig->second).algoName();

            trigAliasFound = true;
            break;
          }
        }

        if (!(trigAliasFound)) {
          return false;
        }

        return true;

      } else if (trigCategory == TechnicalTrigger) {
        // for a technical trigger

        bool trigNameFound = false;

        for (CItAlgo itTrig = m_technicalTriggerMap->begin(); itTrig != m_technicalTriggerMap->end(); itTrig++) {
          if ((itTrig->second).algoBitNumber() == bitNumber) {
            nameL1Trigger = (itTrig->second).algoName();
            // technically, no alias is defined for technical triggers
            // users use mainly aliases, so just return the name here
            aliasL1Trigger = nameL1Trigger;

            trigNameFound = true;
            break;
          }
        }

        if (!(trigNameFound)) {
          return false;
        }

        return true;

      } else {
        // non-existing trigger category...
        return false;
      }

    } else {
      // only L1GtTriggerMenuLite requested, but it is not valid
      return false;
    }
  } else if (m_retrieveL1EventSetup) {
    // for an algorithm trigger
    if (trigCategory == AlgorithmTrigger) {
      bool trigAliasFound = false;

      for (CItAlgo itTrig = m_algorithmAliasMap->begin(); itTrig != m_algorithmAliasMap->end(); itTrig++) {
        if ((itTrig->second).algoBitNumber() == bitNumber) {
          aliasL1Trigger = itTrig->first;
          // get the name here, avoiding a loop on m_algorithmMap
          nameL1Trigger = (itTrig->second).algoName();

          trigAliasFound = true;
          break;
        }
      }

      if (!(trigAliasFound)) {
        return false;
      }

      return true;

    } else if (trigCategory == TechnicalTrigger) {
      // for a technical trigger

      bool trigNameFound = false;

      for (CItAlgo itTrig = m_technicalTriggerMap->begin(); itTrig != m_technicalTriggerMap->end(); itTrig++) {
        if ((itTrig->second).algoBitNumber() == bitNumber) {
          nameL1Trigger = (itTrig->second).algoName();
          // technically, no alias is defined for technical triggers
          // users use mainly aliases, so just return the name here
          aliasL1Trigger = itTrig->first;

          trigNameFound = true;
          break;
        }
      }

      if (!(trigNameFound)) {
        return false;
      }

      return true;

    } else {
      // non-existing trigger category...
      return false;
    }

  } else {
    // L1 trigger configuration not retrieved
    return false;
  }

  // all possibilities already tested, so it should not arrive here
  return false;
}

prescaleFactor()

const int L1GtUtils::prescaleFactor	(	const edm::Event &	iEvent,
		const std::string &	nameAlgoTechTrig,
		int &	errorCode
	)		const

return prescale factor for a given algorithm or technical trigger

Definition at line 1078 of file L1GtUtils.cc.

References decisionAfterMask(), decisionBeforeMask(), iEvent, l1Results(), and triggerMask().

Referenced by HLTInfo::analyze(), L1GtAnalyzer::analyzeL1GtUtilsCore(), L1GtAnalyzer::analyzeTrigger(), decision(), decisionAfterMask(), decisionBeforeMask(), l1Results(), PrescaleWeightProvider::prescaleWeight(), and triggerMask().

                                                          {
  // initial values
  bool decisionBeforeMask = false;
  bool decisionAfterMask = false;
  int prescaleFactor = -1;
  int triggerMask = -1;

  errorCode = l1Results(iEvent, nameAlgoTechTrig, decisionBeforeMask, decisionAfterMask, prescaleFactor, triggerMask);

  return prescaleFactor;
}

prescaleFactorSet()

const std::vector< int > & L1GtUtils::prescaleFactorSet	(	const edm::Event &	iEvent,
		const TriggerCategory &	trigCategory,
		int &	errorCode
	)

return the actual set of prescale factors used for the event (must be the same for all events in the luminosity block, if no errors)

Definition at line 1441 of file L1GtUtils.cc.

References AlgorithmTrigger, iEvent, m_l1GtMenuLiteValid, m_prescaleFactorSet, m_retrieveL1GtTriggerMenuLite, prescaleFactorSetIndex(), and TechnicalTrigger.

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

                                                                     {
  // clear the vector before filling it
  m_prescaleFactorSet.clear();

  // initialize error code
  int iError = 0;

  const int pfIndex = prescaleFactorSetIndex(iEvent, trigCategory, iError);

  if (iError == 0) {
    switch (trigCategory) {
      case AlgorithmTrigger: {
        if (m_retrieveL1GtTriggerMenuLite) {
          if (m_l1GtMenuLiteValid) {
            m_prescaleFactorSet = (*m_prescaleFactorsAlgoTrigLite).at(pfIndex);

          } else {
            // fall through: L1 trigger configuration from event setup
            m_prescaleFactorSet = (*m_prescaleFactorsAlgoTrig).at(pfIndex);
          }

        } else {
          // L1 trigger configuration from event setup only
          m_prescaleFactorSet = (*m_prescaleFactorsAlgoTrig).at(pfIndex);
        }

      } break;
      case TechnicalTrigger: {
        if (m_retrieveL1GtTriggerMenuLite) {
          if (m_l1GtMenuLiteValid) {
            m_prescaleFactorSet = (*m_prescaleFactorsTechTrigLite).at(pfIndex);

          } else {
            // fall through: L1 trigger configuration from event setup
            m_prescaleFactorSet = (*m_prescaleFactorsTechTrig).at(pfIndex);
          }

        } else {
          // L1 trigger configuration from event setup only
          m_prescaleFactorSet = (*m_prescaleFactorsTechTrig).at(pfIndex);
        }

      } break;
      default: {
        // do nothing - it was tested before, with return

      } break;
    }
  }

  errorCode = iError;
  return m_prescaleFactorSet;
}

prescaleFactorSetIndex()

const int L1GtUtils::prescaleFactorSetIndex	(	const edm::Event &	iEvent,
		const TriggerCategory &	trigCategory,
		int &	errorCode
	)		const

return the index of the actual set of prescale factors used for the event (must be the same for all events in the luminosity block, if no errors)

Definition at line 1269 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), L1GlobalTriggerReadoutRecord::gtFdlWord(), L1GlobalTriggerRecord::gtPrescaleFactorIndexAlgo(), L1GlobalTriggerRecord::gtPrescaleFactorIndexTech(), iEvent, edm::HandleBase::isValid(), LogDebug, m_l1GtMenuLiteValid, m_l1GtUtilsHelper, m_prescaleFactorsAlgoTrig, m_prescaleFactorsAlgoTrigLite, m_prescaleFactorsTechTrig, m_prescaleFactorsTechTrigLite, m_retrieveL1GtTriggerMenuLite, and TechnicalTrigger.

Referenced by HLTInfo::analyze(), L1GtAnalyzer::analyzeL1GtUtilsCore(), prescaleFactorSet(), and L1Analysis::L1AnalysisL1Menu::SetPrescaleFactorIndex().

                                                                  {
  // initialize the index to a negative value
  int pfIndex = -1;

  // initialize error code and L1 configuration code
  int iError = 0;
  int l1ConfCode = 0;

  // check if L1 configuration is available

  if (!availableL1Configuration(iError, l1ConfCode)) {
    errorCode = iError;
    return pfIndex;
  }

  // at this point, a valid L1 configuration is available, so the if/else if/else
  // can be simplified

  // retrieve L1GlobalTriggerRecord and 1GlobalTriggerReadoutRecord product
  // intermediate error code for the records
  // the module returns an error code only if both the lite and the readout record are missing

  int iErrorRecord = 0;

  bool validRecord = false;
  bool gtReadoutRecordValid = false;

  edm::Handle<L1GlobalTriggerRecord> gtRecord;
  if (!m_l1GtUtilsHelper->l1GtRecordToken().isUninitialized()) {
    iEvent.getByToken(m_l1GtUtilsHelper->l1GtRecordToken(), gtRecord);
  }
  if (gtRecord.isValid()) {
    validRecord = true;

  } else {
    iErrorRecord = 10;
    LogDebug("L1GtUtils") << "\nL1GlobalTriggerRecord with \n  " << m_l1GtUtilsHelper->l1GtRecordInputTag()
                          << "\nnot found in the event." << std::endl;
  }

  edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecord;
  if (!m_l1GtUtilsHelper->l1GtReadoutRecordToken().isUninitialized()) {
    iEvent.getByToken(m_l1GtUtilsHelper->l1GtReadoutRecordToken(), gtReadoutRecord);
  }
  if (gtReadoutRecord.isValid()) {
    gtReadoutRecordValid = true;
    validRecord = true;

  } else {
    iErrorRecord = iErrorRecord + 100;
    LogDebug("L1GtUtils") << "\nL1GlobalTriggerReadoutRecord with \n  "
                          << m_l1GtUtilsHelper->l1GtReadoutRecordInputTag() << "\nnot found in the event." << std::endl;
  }

  // get the prescale factor index from
  //  L1GlobalTriggerReadoutRecord if valid
  //  if not, from L1GlobalTriggerRecord if valid
  //  else return an error

  int pfIndexTechTrig = -1;
  int pfIndexAlgoTrig = -1;

  if (validRecord) {
    if (gtReadoutRecordValid) {
      pfIndexTechTrig = (gtReadoutRecord->gtFdlWord()).gtPrescaleFactorIndexTech();
      pfIndexAlgoTrig = (gtReadoutRecord->gtFdlWord()).gtPrescaleFactorIndexAlgo();

    } else {
      pfIndexTechTrig = static_cast<int>(gtRecord->gtPrescaleFactorIndexTech());
      pfIndexAlgoTrig = static_cast<int>(gtRecord->gtPrescaleFactorIndexAlgo());
    }

  } else {
    LogDebug("L1GtUtils") << "\nError: "
                          << "\nNo valid L1GlobalTriggerRecord with \n  " << m_l1GtUtilsHelper->l1GtRecordInputTag()
                          << "\nfound in the event."
                          << "\nNo valid L1GlobalTriggerReadoutRecord with \n  "
                          << m_l1GtUtilsHelper->l1GtReadoutRecordInputTag() << "\nfound in the event." << std::endl;

    iError = l1ConfCode + iErrorRecord;

    errorCode = iError;
    return pfIndex;
  }

  // depending on trigger category (algorithm trigger or technical trigger)
  // get the correct quantities

  // number of sets of prescale factors
  // index of prescale factor set retrieved from data
  // pointer to the actual prescale factor set
  // pointer to the set of trigger masks

  size_t pfSetsSize = 0;

  switch (trigCategory) {
    case AlgorithmTrigger: {
      if (m_retrieveL1GtTriggerMenuLite) {
        if (m_l1GtMenuLiteValid) {
          pfSetsSize = m_prescaleFactorsAlgoTrigLite->size();

        } else {
          // fall through: L1 trigger configuration from event setup
          pfSetsSize = m_prescaleFactorsAlgoTrig->size();
        }

      } else {
        // L1 trigger configuration from event setup only
        pfSetsSize = m_prescaleFactorsAlgoTrig->size();
      }

      pfIndex = pfIndexAlgoTrig;

    } break;
    case TechnicalTrigger: {
      if (m_retrieveL1GtTriggerMenuLite) {
        if (m_l1GtMenuLiteValid) {
          pfSetsSize = m_prescaleFactorsTechTrigLite->size();

        } else {
          // fall through: L1 trigger configuration from event setup
          pfSetsSize = m_prescaleFactorsTechTrig->size();
        }

      } else {
        // L1 trigger configuration from event setup only
        pfSetsSize = m_prescaleFactorsTechTrig->size();
      }

      pfIndex = pfIndexTechTrig;

    } break;
    default: {
      // should not be the case
      iError = l1ConfCode + iErrorRecord + 3;
      return iError;

    } break;
  }

  // test prescale factor set index correctness, then retrieve the actual set of prescale factors

  if (pfIndex < 0) {
    iError = l1ConfCode + iErrorRecord + 1000;
    LogDebug("L1GtUtils") << "\nError: index of prescale factor set retrieved from the data \n"
                          << "less than zero."
                          << "\n  Value of index retrieved from data = " << pfIndex << std::endl;

    errorCode = iError;
    return pfIndex;

  } else if (pfIndex >= (static_cast<int>(pfSetsSize))) {
    iError = l1ConfCode + iErrorRecord + 2000;
    LogDebug("L1GtUtils") << "\nError: index of prescale factor set retrieved from the data \n"
                          << "greater than the size of the vector of prescale factor sets."
                          << "\n  Value of index retrieved from data = " << pfIndex
                          << "\n  Vector size = " << pfSetsSize << std::endl;

    errorCode = iError;
    return pfIndex;

  } else {
    errorCode = iError;
    return pfIndex;
  }

  errorCode = iError;
  return pfIndex;
}

ptrL1GtTriggerMenuLite()

const L1GtTriggerMenuLite * L1GtUtils::ptrL1GtTriggerMenuLite

(

int &

errorCode

)

return a pointer to the L1GtTriggerMenuLite product

Definition at line 1645 of file L1GtUtils.cc.

References availableL1Configuration(), m_l1GtMenuLite, m_l1GtMenuLiteValid, and m_retrieveL1GtTriggerMenuLite.

                                                                           {
  // initialize error code and return value
  int iError = 0;
  int l1ConfCode = 0;

  // check if L1 configuration is available

  if (!availableL1Configuration(iError, l1ConfCode)) {
    errorCode = iError;
    return nullptr;
  }

  if (m_retrieveL1GtTriggerMenuLite) {
    if (m_l1GtMenuLiteValid) {
      errorCode = iError;
      return m_l1GtMenuLite;

    } else {
      iError = l1ConfCode;

      errorCode = iError;
      return nullptr;
    }
  } else {
    iError = l1ConfCode;

    errorCode = iError;
    return nullptr;
  }

  errorCode = iError;
  return m_l1GtMenuLite;
}

ptrL1TriggerMenuEventSetup()

const L1GtTriggerMenu * L1GtUtils::ptrL1TriggerMenuEventSetup

(

int &

errorCode

)

return a pointer to the L1 trigger menu from event setup

Definition at line 1619 of file L1GtUtils.cc.

References availableL1Configuration(), m_l1GtMenu, and m_retrieveL1EventSetup.

Referenced by IsoTrackCalib::beginRun().

                                                                           {
  // initialize error code and return value
  int iError = 0;
  int l1ConfCode = 0;

  // check if L1 configuration is available

  if (!availableL1Configuration(iError, l1ConfCode)) {
    errorCode = iError;
    return nullptr;
  }

  if (m_retrieveL1EventSetup) {
    errorCode = iError;
    return m_l1GtMenu;
  } else {
    iError = l1ConfCode;

    errorCode = iError;
    return nullptr;
  }

  errorCode = iError;
  return m_l1GtMenu;
}

retrieveL1EventSetup()

void L1GtUtils::retrieveL1EventSetup	(	const edm::EventSetup &	evSetup,
		bool	isRun = true
	)

retrieve all the relevant L1 trigger event setup records and cache them to improve the speed

Definition at line 128 of file L1GtUtils.cc.

References edm::eventsetup::EventSetupRecord::cacheIdentifier(), edm::EventSetup::get(), L1GtTriggerMenu::gtAlgorithmAliasMap(), L1GtTriggerMenu::gtAlgorithmMap(), L1GtStableParameters::gtNumberPhysTriggers(), L1GtStableParameters::gtNumberTechnicalTriggers(), L1GtPrescaleFactors::gtPrescaleFactors(), L1GtTriggerMenu::gtTechnicalTriggerMap(), L1GtTriggerMask::gtTriggerMask(), m_algorithmAliasMap, m_algorithmMap, m_l1EventSetupValid, m_l1GtMenu, m_l1GtMenuCacheID, m_l1GtPfAlgo, m_l1GtPfAlgoCacheID, m_l1GtPfTech, m_l1GtPfTechCacheID, m_L1GtPrescaleFactorsAlgoTrigEventToken, m_L1GtPrescaleFactorsAlgoTrigRunToken, m_L1GtPrescaleFactorsTechTrigEventToken, m_L1GtPrescaleFactorsTechTrigRunToken, m_l1GtStablePar, m_L1GtStableParametersEventToken, m_L1GtStableParametersRunToken, m_l1GtStableParCacheID, m_l1GtTmAlgo, m_l1GtTmAlgoCacheID, m_l1GtTmTech, m_l1GtTmTechCacheID, m_l1GtTmVetoAlgo, m_l1GtTmVetoAlgoCacheID, m_l1GtTmVetoTech, m_l1GtTmVetoTechCacheID, m_L1GtTriggerMaskAlgoTrigEventToken, m_L1GtTriggerMaskAlgoTrigRunToken, m_L1GtTriggerMaskTechTrigEventToken, m_L1GtTriggerMaskTechTrigRunToken, m_L1GtTriggerMaskVetoAlgoTrigEventToken, m_L1GtTriggerMaskVetoAlgoTrigRunToken, m_L1GtTriggerMaskVetoTechTrigEventToken, m_L1GtTriggerMaskVetoTechTrigRunToken, m_L1GtTriggerMenuEventToken, m_L1GtTriggerMenuRunToken, m_numberAlgorithmTriggers, m_numberTechnicalTriggers, m_prescaleFactorsAlgoTrig, m_prescaleFactorSet, m_prescaleFactorsTechTrig, m_retrieveL1EventSetup, m_technicalTriggerMap, m_triggerMaskAlgoTrig, m_triggerMaskSet, m_triggerMaskTechTrig, m_triggerMaskVetoAlgoTrig, m_triggerMaskVetoTechTrig, and SiStripPI::max.

Referenced by L1MenuTreeProducer::analyze(), L1TRate_Offline::bookHistograms(), L1TRate::bookHistograms(), L1TSync::bookHistograms(), L1TSync_Offline::bookHistograms(), and getL1GtRunCache().

                                                                             {
  //
  m_retrieveL1EventSetup = true;

  m_l1EventSetupValid = true;
  // FIXME test for each record if valid; if not set m_l1EventSetupValid = false;

  // get / update the stable parameters from the EventSetup
  // local cache & check on cacheIdentifier

  auto l1GtStableParametersRcd = evSetup.get<L1GtStableParametersRcd>();
  unsigned long long l1GtStableParCacheID = l1GtStableParametersRcd.cacheIdentifier();

  if (m_l1GtStableParCacheID != l1GtStableParCacheID) {
    if (isRun) {
      m_l1GtStablePar = &l1GtStableParametersRcd.get(m_L1GtStableParametersRunToken);
    } else {
      m_l1GtStablePar = &l1GtStableParametersRcd.get(m_L1GtStableParametersEventToken);
    }

    // number of algorithm triggers
    m_numberAlgorithmTriggers = m_l1GtStablePar->gtNumberPhysTriggers();

    // number of technical triggers
    m_numberTechnicalTriggers = m_l1GtStablePar->gtNumberTechnicalTriggers();

    int maxNumberTrigger = std::max(m_numberAlgorithmTriggers, m_numberTechnicalTriggers);

    m_triggerMaskSet.reserve(maxNumberTrigger);
    m_prescaleFactorSet.reserve(maxNumberTrigger);

    //
    m_l1GtStableParCacheID = l1GtStableParCacheID;
  }

  // get / update the prescale factors from the EventSetup
  // local cache & check on cacheIdentifier

  auto l1GtPrescaleFactorsAlgoTrigRcd = evSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>();
  unsigned long long l1GtPfAlgoCacheID = l1GtPrescaleFactorsAlgoTrigRcd.cacheIdentifier();

  if (m_l1GtPfAlgoCacheID != l1GtPfAlgoCacheID) {
    if (isRun) {
      m_l1GtPfAlgo = &l1GtPrescaleFactorsAlgoTrigRcd.get(m_L1GtPrescaleFactorsAlgoTrigRunToken);
    } else {
      m_l1GtPfAlgo = &l1GtPrescaleFactorsAlgoTrigRcd.get(m_L1GtPrescaleFactorsAlgoTrigEventToken);
    }

    m_prescaleFactorsAlgoTrig = &(m_l1GtPfAlgo->gtPrescaleFactors());

    m_l1GtPfAlgoCacheID = l1GtPfAlgoCacheID;
  }

  auto l1GtPrescaleFactorsTechTrigRcd = evSetup.get<L1GtPrescaleFactorsTechTrigRcd>();
  unsigned long long l1GtPfTechCacheID = l1GtPrescaleFactorsTechTrigRcd.cacheIdentifier();

  if (m_l1GtPfTechCacheID != l1GtPfTechCacheID) {
    if (isRun) {
      m_l1GtPfTech = &l1GtPrescaleFactorsTechTrigRcd.get(m_L1GtPrescaleFactorsTechTrigRunToken);
    } else {
      m_l1GtPfTech = &l1GtPrescaleFactorsTechTrigRcd.get(m_L1GtPrescaleFactorsTechTrigEventToken);
    }

    m_prescaleFactorsTechTrig = &(m_l1GtPfTech->gtPrescaleFactors());

    m_l1GtPfTechCacheID = l1GtPfTechCacheID;
  }

  // get / update the trigger mask from the EventSetup
  // local cache & check on cacheIdentifier

  auto l1GtTriggerMaskAlgoTrigRcd = evSetup.get<L1GtTriggerMaskAlgoTrigRcd>();
  unsigned long long l1GtTmAlgoCacheID = l1GtTriggerMaskAlgoTrigRcd.cacheIdentifier();

  if (m_l1GtTmAlgoCacheID != l1GtTmAlgoCacheID) {
    if (isRun) {
      m_l1GtTmAlgo = &l1GtTriggerMaskAlgoTrigRcd.get(m_L1GtTriggerMaskAlgoTrigRunToken);
    } else {
      m_l1GtTmAlgo = &l1GtTriggerMaskAlgoTrigRcd.get(m_L1GtTriggerMaskAlgoTrigEventToken);
    }

    m_triggerMaskAlgoTrig = &(m_l1GtTmAlgo->gtTriggerMask());

    m_l1GtTmAlgoCacheID = l1GtTmAlgoCacheID;
  }

  auto l1GtTriggerMaskTechTrigRcd = evSetup.get<L1GtTriggerMaskTechTrigRcd>();
  unsigned long long l1GtTmTechCacheID = l1GtTriggerMaskTechTrigRcd.cacheIdentifier();

  if (m_l1GtTmTechCacheID != l1GtTmTechCacheID) {
    if (isRun) {
      m_l1GtTmTech = &l1GtTriggerMaskTechTrigRcd.get(m_L1GtTriggerMaskTechTrigRunToken);
    } else {
      m_l1GtTmTech = &l1GtTriggerMaskTechTrigRcd.get(m_L1GtTriggerMaskTechTrigEventToken);
    }

    m_triggerMaskTechTrig = &(m_l1GtTmTech->gtTriggerMask());

    m_l1GtTmTechCacheID = l1GtTmTechCacheID;
  }

  auto l1GtTriggerMaskVetoAlgoTrigRcd = evSetup.get<L1GtTriggerMaskVetoAlgoTrigRcd>();
  unsigned long long l1GtTmVetoAlgoCacheID = l1GtTriggerMaskVetoAlgoTrigRcd.cacheIdentifier();

  if (m_l1GtTmVetoAlgoCacheID != l1GtTmVetoAlgoCacheID) {
    if (isRun) {
      m_l1GtTmVetoAlgo = &l1GtTriggerMaskVetoAlgoTrigRcd.get(m_L1GtTriggerMaskVetoAlgoTrigRunToken);
    } else {
      m_l1GtTmVetoAlgo = &l1GtTriggerMaskVetoAlgoTrigRcd.get(m_L1GtTriggerMaskVetoAlgoTrigEventToken);
    }

    m_triggerMaskVetoAlgoTrig = &(m_l1GtTmVetoAlgo->gtTriggerMask());

    m_l1GtTmVetoAlgoCacheID = l1GtTmVetoAlgoCacheID;
  }

  auto l1GtTriggerMaskVetoTechTrigRcd = evSetup.get<L1GtTriggerMaskVetoTechTrigRcd>();
  unsigned long long l1GtTmVetoTechCacheID = l1GtTriggerMaskVetoTechTrigRcd.cacheIdentifier();

  if (m_l1GtTmVetoTechCacheID != l1GtTmVetoTechCacheID) {
    if (isRun) {
      m_l1GtTmVetoTech = &l1GtTriggerMaskVetoTechTrigRcd.get(m_L1GtTriggerMaskVetoTechTrigRunToken);
    } else {
      m_l1GtTmVetoTech = &l1GtTriggerMaskVetoTechTrigRcd.get(m_L1GtTriggerMaskVetoTechTrigEventToken);
    }

    m_triggerMaskVetoTechTrig = &(m_l1GtTmVetoTech->gtTriggerMask());

    m_l1GtTmVetoTechCacheID = l1GtTmVetoTechCacheID;
  }

  // get / update the trigger menu from the EventSetup
  // local cache & check on cacheIdentifier

  auto l1GtTriggerMenuRcd = evSetup.get<L1GtTriggerMenuRcd>();
  unsigned long long l1GtMenuCacheID = l1GtTriggerMenuRcd.cacheIdentifier();

  if (m_l1GtMenuCacheID != l1GtMenuCacheID) {
    if (isRun) {
      m_l1GtMenu = &l1GtTriggerMenuRcd.get(m_L1GtTriggerMenuRunToken);
    } else {
      m_l1GtMenu = &l1GtTriggerMenuRcd.get(m_L1GtTriggerMenuEventToken);
    }

    m_algorithmMap = &(m_l1GtMenu->gtAlgorithmMap());
    m_algorithmAliasMap = &(m_l1GtMenu->gtAlgorithmAliasMap());

    m_technicalTriggerMap = &(m_l1GtMenu->gtTechnicalTriggerMap());

    m_l1GtMenuCacheID = l1GtMenuCacheID;
  }
}

retrieveL1GtTriggerMenuLite()

void L1GtUtils::retrieveL1GtTriggerMenuLite

(

const edm::Run &

iRun

)

retrieve L1GtTriggerMenuLite (per run product) and cache it to improve the speed

for use in beginRun(const edm::Run&, const edm::EventSetup&);

Definition at line 281 of file L1GtUtils.cc.

References edm::Run::getByToken(), L1GtTriggerMenuLite::gtAlgorithmAliasMap(), L1GtTriggerMenuLite::gtAlgorithmMap(), L1GtTriggerMenuLite::gtPrescaleFactorsAlgoTrig(), L1GtTriggerMenuLite::gtPrescaleFactorsTechTrig(), L1GtTriggerMenuLite::gtTechnicalTriggerMap(), L1GtTriggerMenuLite::gtTriggerMaskAlgoTrig(), L1GtTriggerMenuLite::gtTriggerMaskTechTrig(), edm::HandleBase::isValid(), LogDebug, m_algorithmAliasMapLite, m_algorithmMapLite, m_l1GtMenuLite, m_l1GtMenuLiteValid, m_l1GtUtilsHelper, m_prescaleFactorsAlgoTrigLite, m_prescaleFactorsTechTrigLite, m_retrieveL1GtTriggerMenuLite, m_technicalTriggerMapLite, m_triggerMaskAlgoTrigLite, m_triggerMaskTechTrigLite, edm::Handle< T >::product(), edm::RunAuxiliary::run(), and edm::Run::runAuxiliary().

Referenced by getL1GtRunCache().

                                                              {
  m_retrieveL1GtTriggerMenuLite = true;

  // get L1GtTriggerMenuLite
  edm::Handle<L1GtTriggerMenuLite> l1GtMenuLite;
  if (!m_l1GtUtilsHelper->l1GtTriggerMenuLiteToken().isUninitialized()) {
    iRun.getByToken(m_l1GtUtilsHelper->l1GtTriggerMenuLiteToken(), l1GtMenuLite);
  }

  if (!l1GtMenuLite.isValid()) {
    LogDebug("L1GtUtils") << "\nL1GtTriggerMenuLite with \n  " << m_l1GtUtilsHelper->l1GtTriggerMenuLiteInputTag()
                          << "\nrequested, but not found in the run." << std::endl;

    m_l1GtMenuLiteValid = false;
  } else {
    m_l1GtMenuLite = l1GtMenuLite.product();
    m_l1GtMenuLiteValid = true;

    LogDebug("L1GtUtils") << "\nL1GtTriggerMenuLite with \n  " << m_l1GtUtilsHelper->l1GtTriggerMenuLiteInputTag()
                          << "\nretrieved for run " << iRun.runAuxiliary().run() << std::endl;

    m_algorithmMapLite = &(m_l1GtMenuLite->gtAlgorithmMap());
    m_algorithmAliasMapLite = &(m_l1GtMenuLite->gtAlgorithmAliasMap());
    m_technicalTriggerMapLite = &(m_l1GtMenuLite->gtTechnicalTriggerMap());

    m_triggerMaskAlgoTrigLite = &(m_l1GtMenuLite->gtTriggerMaskAlgoTrig());
    m_triggerMaskTechTrigLite = &(m_l1GtMenuLite->gtTriggerMaskTechTrig());

    m_prescaleFactorsAlgoTrigLite = &(m_l1GtMenuLite->gtPrescaleFactorsAlgoTrig());
    m_prescaleFactorsTechTrigLite = &(m_l1GtMenuLite->gtPrescaleFactorsTechTrig());
  }
}

triggerCategory()

const std::string L1GtUtils::triggerCategory

(

const TriggerCategory &

trigCategory

)

const

public methods

Definition at line 112 of file L1GtUtils.cc.

References AlgorithmTrigger, EmptyString, and TechnicalTrigger.

Referenced by l1Results(), triggerMask(), and trigResult().

                                                                                    {
  switch (trigCategory) {
    case AlgorithmTrigger: {
      return "Algorithm Trigger";
    } break;
    case TechnicalTrigger: {
      return "Technical Trigger";
    }

    break;
    default: {
      return EmptyString;
    } break;
  }
}

triggerMask() [1/2]

const int L1GtUtils::triggerMask	(	const edm::Event &	iEvent,
		const std::string &	nameAlgoTechTrig,
		int &	errorCode
	)		const

return trigger mask for a given algorithm or technical trigger

Definition at line 1092 of file L1GtUtils.cc.

References decisionAfterMask(), decisionBeforeMask(), iEvent, l1Results(), and prescaleFactor().

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore(), L1GtAnalyzer::analyzeTrigger(), decision(), decisionAfterMask(), decisionBeforeMask(), L1TMenuHelper::getLUSOTrigger(), l1Results(), and prescaleFactor().

                                                                                                                {
  // initial values
  bool decisionBeforeMask = false;
  bool decisionAfterMask = false;
  int prescaleFactor = -1;
  int triggerMask = -1;

  errorCode = l1Results(iEvent, nameAlgoTechTrig, decisionBeforeMask, decisionAfterMask, prescaleFactor, triggerMask);

  return triggerMask;
}

triggerMask() [2/2]

const int L1GtUtils::triggerMask	(	const std::string &	nameAlgoTechTrig,
		int &	errorCode
	)		const

faster than previous two methods - one needs in fact for the masks the event setup only

Definition at line 1104 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), L1TBPTX_cfi::bitNumber, L1GtTriggerMenuLite::gtTriggerMenuImplementation(), L1GtTriggerMenu::gtTriggerMenuImplementation(), l1AlgoTechTrigBitNumber(), LogDebug, m_l1GtMenu, m_l1GtMenuLite, m_l1GtMenuLiteValid, m_physicsDaqPartition, m_retrieveL1GtTriggerMenuLite, m_triggerMaskAlgoTrig, m_triggerMaskAlgoTrigLite, m_triggerMaskTechTrig, m_triggerMaskTechTrigLite, TechnicalTrigger, and triggerCategory().

                                                                                        {
  // initial values for returned results
  int triggerMaskValue = -1;

  // initialize error code and L1 configuration code
  int iError = 0;
  int l1ConfCode = 0;

  // check if L1 configuration is available

  if (!availableL1Configuration(iError, l1ConfCode)) {
    errorCode = iError;
    return triggerMaskValue;
  }

  // at this point, a valid L1 configuration is available, so the if/else if/else
  // can be simplified

  // if the given name is not an algorithm trigger alias, an algorithm trigger name
  // or a technical trigger in the current menu, return with error code 1

  TriggerCategory trigCategory = AlgorithmTrigger;
  int bitNumber = -1;

  if (!l1AlgoTechTrigBitNumber(nameAlgoTechTrig, trigCategory, bitNumber)) {
    iError = l1ConfCode + 1;

    if (m_retrieveL1GtTriggerMenuLite) {
      if (m_l1GtMenuLiteValid) {
        LogDebug("L1GtUtils") << "\nAlgorithm/technical trigger \n  " << nameAlgoTechTrig
                              << "\not found in the trigger menu \n  " << m_l1GtMenuLite->gtTriggerMenuImplementation()
                              << "\nretrieved from L1GtTriggerMenuLite" << std::endl;

      } else {
        // fall through: L1 trigger configuration from event setup
        LogDebug("L1GtUtils") << "\nAlgorithm/technical trigger \n  " << nameAlgoTechTrig
                              << "\not found in the trigger menu \n  " << m_l1GtMenu->gtTriggerMenuImplementation()
                              << "\nretrieved from Event Setup" << std::endl;
      }

    } else {
      // L1 trigger configuration from event setup only
      LogDebug("L1GtUtils") << "\nAlgorithm/technical trigger \n  " << nameAlgoTechTrig
                            << "\not found in the trigger menu \n  " << m_l1GtMenu->gtTriggerMenuImplementation()
                            << "\nretrieved from Event Setup" << std::endl;
    }

    errorCode = iError;
    return triggerMaskValue;
  }

  // check here if a positive bit number was retrieved
  // exit in case of negative bit number, before retrieving L1 GT products, saving time

  if (bitNumber < 0) {
    iError = l1ConfCode + 2;

    if (m_retrieveL1GtTriggerMenuLite) {
      if (m_l1GtMenuLiteValid) {
        LogDebug("L1GtUtils") << "\nNegative bit number for " << triggerCategory(trigCategory) << "\n  "
                              << nameAlgoTechTrig << "\nfrom menu \n  " << m_l1GtMenuLite->gtTriggerMenuImplementation()
                              << "\nretrieved from L1GtTriggerMenuLite" << std::endl;

      } else {
        // fall through: L1 trigger configuration from event setup
        LogDebug("L1GtUtils") << "\nNegative bit number for " << triggerCategory(trigCategory) << "\n  "
                              << nameAlgoTechTrig << "\nfrom menu \n  " << m_l1GtMenu->gtTriggerMenuImplementation()
                              << "\nretrieved from Event Setup" << std::endl;
      }

    } else {
      // L1 trigger configuration from event setup only
      LogDebug("L1GtUtils") << "\nNegative bit number for " << triggerCategory(trigCategory) << "\n  "
                            << nameAlgoTechTrig << "\nfrom menu \n  " << m_l1GtMenu->gtTriggerMenuImplementation()
                            << "\nretrieved from Event Setup" << std::endl;
    }

    errorCode = iError;
    return triggerMaskValue;
  }

  // depending on trigger category (algorithm trigger or technical trigger)
  // get the correct quantities

  // pointer to the set of trigger masks

  const std::vector<unsigned int>* triggerMasksSet = nullptr;

  switch (trigCategory) {
    case AlgorithmTrigger: {
      if (m_retrieveL1GtTriggerMenuLite) {
        if (m_l1GtMenuLiteValid) {
          triggerMasksSet = m_triggerMaskAlgoTrigLite;

        } else {
          // fall through: L1 trigger configuration from event setup
          triggerMasksSet = m_triggerMaskAlgoTrig;
        }

      } else {
        // L1 trigger configuration from event setup only
        triggerMasksSet = m_triggerMaskAlgoTrig;
      }

    } break;
    case TechnicalTrigger: {
      if (m_retrieveL1GtTriggerMenuLite) {
        if (m_l1GtMenuLiteValid) {
          triggerMasksSet = m_triggerMaskTechTrigLite;

        } else {
          // fall through: L1 trigger configuration from event setup
          triggerMasksSet = m_triggerMaskTechTrig;
        }

      } else {
        // L1 trigger configuration from event setup only
        triggerMasksSet = m_triggerMaskTechTrig;
      }

    } break;
    default: {
      // should not be the case
      iError = l1ConfCode + 3;

      errorCode = iError;
      return triggerMaskValue;

    } break;
  }

  // trigger mask

  if (bitNumber < (static_cast<int>((*triggerMasksSet).size()))) {
    if (m_retrieveL1GtTriggerMenuLite) {
      if (m_l1GtMenuLiteValid) {
        triggerMaskValue = (*triggerMasksSet)[bitNumber];

      } else {
        // fall through: L1 trigger configuration from event setup
        // masks in event setup are for all partitions
        triggerMaskValue = ((*triggerMasksSet)[bitNumber]) & (1 << m_physicsDaqPartition);
      }

    } else {
      // L1 trigger configuration from event setup only
      // masks in event setup are for all partitions
      triggerMaskValue = ((*triggerMasksSet)[bitNumber]) & (1 << m_physicsDaqPartition);
    }

  } else {
    iError = l1ConfCode + 5000;
    LogDebug("L1GtUtils") << "\nError: bit number " << bitNumber << " retrieved for " << triggerCategory(trigCategory)
                          << "\n  " << nameAlgoTechTrig
                          << "\ngreater than size of L1 GT trigger mask set: " << (*triggerMasksSet).size()
                          << "\nError: Inconsistent L1 trigger configuration!" << std::endl;

    errorCode = iError;
    return triggerMaskValue;
  }

  errorCode = iError;
  return triggerMaskValue;
}

triggerMaskSet()

const std::vector< unsigned int > & L1GtUtils::triggerMaskSet	(	const TriggerCategory &	trigCategory,
		int &	errorCode
	)

return the set of trigger masks for the physics partition (partition zero) used for the event (remain the same in the whole run, if no errors)

Definition at line 1497 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), mps_fire::i, m_l1GtMenuLiteValid, m_physicsDaqPartition, m_retrieveL1GtTriggerMenuLite, m_triggerMaskAlgoTrig, m_triggerMaskAlgoTrigLite, m_triggerMaskSet, m_triggerMaskTechTrig, m_triggerMaskTechTrigLite, and TechnicalTrigger.

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

                                                                                                            {
  // clear the vector before filling it
  m_triggerMaskSet.clear();

  // initialize error code and L1 configuration code
  int iError = 0;
  int l1ConfCode = 0;

  // check if L1 configuration is available

  if (!availableL1Configuration(iError, l1ConfCode)) {
    errorCode = iError;
    return m_triggerMaskSet;
  }

  // at this point, a valid L1 configuration is available, so the if/else if/else
  // can be simplified

  // depending on trigger category (algorithm trigger or technical trigger)
  // get the correct quantities

  // pointer to the set of trigger masks

  switch (trigCategory) {
    case AlgorithmTrigger: {
      if (m_retrieveL1GtTriggerMenuLite) {
        // L1GtTriggerMenuLite has masks for physics partition only
        // avoid copy to m_triggerMaskSet, return directly m_triggerMaskAlgoTrigLite
        if (m_l1GtMenuLiteValid) {
          errorCode = iError;
          return (*m_triggerMaskAlgoTrigLite);

        } else {
          // fall through: L1 trigger configuration from event setup
          for (unsigned i = 0; i < m_triggerMaskAlgoTrig->size(); i++) {
            m_triggerMaskSet.push_back(((*m_triggerMaskAlgoTrig)[i]) & (1 << m_physicsDaqPartition));
          }
        }

      } else {
        // L1 trigger configuration from event setup only
        for (unsigned i = 0; i < m_triggerMaskAlgoTrig->size(); i++) {
          m_triggerMaskSet.push_back(((*m_triggerMaskAlgoTrig)[i]) & (1 << m_physicsDaqPartition));
        }
      }
    } break;
    case TechnicalTrigger: {
      if (m_retrieveL1GtTriggerMenuLite) {
        if (m_l1GtMenuLiteValid) {
          errorCode = iError;
          return (*m_triggerMaskTechTrigLite);

        } else {
          // fall through: L1 trigger configuration from event setup
          for (unsigned i = 0; i < m_triggerMaskTechTrig->size(); i++) {
            m_triggerMaskSet.push_back(((*m_triggerMaskTechTrig)[i]) & (1 << m_physicsDaqPartition));
          }
        }

      } else {
        // L1 trigger configuration from event setup only
        for (unsigned i = 0; i < m_triggerMaskTechTrig->size(); i++) {
          m_triggerMaskSet.push_back(((*m_triggerMaskTechTrig)[i]) & (1 << m_physicsDaqPartition));
        }
      }
    } break;
    default: {
      // should not be the case
      iError = l1ConfCode + 3;

      errorCode = iError;
      return m_triggerMaskSet;

    } break;
  }

  errorCode = iError;
  return m_triggerMaskSet;
}

trigResult()

const bool L1GtUtils::trigResult ( const DecisionWord &  decWord, const int  bitNumber, const std::string &  nameAlgoTechTrig, const TriggerCategory &  trigCategory, int &  errorCode  ) const

private

return the trigger result given bit number and decision word errorCode != 0 if bit number greater than size of decision word print in debug mode a message in case of error

Definition at line 1764 of file L1GtUtils.cc.

References L1TBPTX_cfi::bitNumber, LogDebug, and triggerCategory().

Referenced by l1Results().

                                                       {
  bool trigRes = false;
  errorCode = 0;

  if (bitNumber < (static_cast<int>(decWord.size()))) {
    trigRes = decWord[bitNumber];
  } else {
    errorCode = 3000;
    LogDebug("L1GtUtils") << "\nError: bit number " << bitNumber << " retrieved for " << triggerCategory(trigCategory)
                          << "\n  " << nameAlgoTechTrig
                          << "\ngreater than size of L1 GT decision word: " << decWord.size()
                          << "\nError: Inconsistent L1 trigger configuration!" << std::endl;
  }

  return trigRes;
}

Member Data Documentation

EmptyString

const std::string L1GtUtils::EmptyString = ""

staticprivate

Definition at line 373 of file L1GtUtils.h.

Referenced by l1TriggerMenu(), l1TriggerMenuImplementation(), and triggerCategory().

L1GtNotValidError

const int L1GtUtils::L1GtNotValidError = 99999

staticprivate

Definition at line 374 of file L1GtUtils.h.

Referenced by availableL1Configuration().

m_algorithmAliasMap

const AlgorithmMap* L1GtUtils::m_algorithmAliasMap

private

Definition at line 434 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), l1TriggerNameFromBit(), and retrieveL1EventSetup().

m_algorithmAliasMapLite

const L1GtTriggerMenuLite::L1TriggerMap* L1GtUtils::m_algorithmAliasMapLite

private

Definition at line 445 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), l1TriggerNameFromBit(), and retrieveL1GtTriggerMenuLite().

m_algorithmMap

const AlgorithmMap* L1GtUtils::m_algorithmMap

private

Definition at line 433 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), and retrieveL1EventSetup().

m_algorithmMapLite

const L1GtTriggerMenuLite::L1TriggerMap* L1GtUtils::m_algorithmMapLite

private

Definition at line 444 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), l1TriggerNameFromBit(), and retrieveL1GtTriggerMenuLite().

m_beginRunCache

bool L1GtUtils::m_beginRunCache

private

flag for call of getL1GtRunCache in beginRun

Definition at line 457 of file L1GtUtils.h.

Referenced by getL1GtRunCache().

m_l1EventSetupValid

bool L1GtUtils::m_l1EventSetupValid

private

Definition at line 437 of file L1GtUtils.h.

Referenced by availableL1Configuration(), and retrieveL1EventSetup().

m_l1GtMenu

const L1GtTriggerMenu* L1GtUtils::m_l1GtMenu

private

Definition at line 430 of file L1GtUtils.h.

Referenced by l1Results(), l1TriggerMenu(), l1TriggerMenuImplementation(), ptrL1TriggerMenuEventSetup(), retrieveL1EventSetup(), and triggerMask().

m_l1GtMenuCacheID

unsigned long long L1GtUtils::m_l1GtMenuCacheID

private

Definition at line 431 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtMenuLite

const L1GtTriggerMenuLite* L1GtUtils::m_l1GtMenuLite

private

L1GtTriggerMenuLite cached stuff.

L1GtTriggerMenuLite

Definition at line 442 of file L1GtUtils.h.

Referenced by l1Results(), l1TriggerMenu(), l1TriggerMenuImplementation(), ptrL1GtTriggerMenuLite(), retrieveL1GtTriggerMenuLite(), and triggerMask().

m_l1GtMenuLiteValid

bool L1GtUtils::m_l1GtMenuLiteValid

private

Definition at line 454 of file L1GtUtils.h.

Referenced by availableL1Configuration(), l1AlgoTechTrigBitNumber(), l1Results(), l1TriggerMenu(), l1TriggerMenuImplementation(), l1TriggerNameFromBit(), prescaleFactorSet(), prescaleFactorSetIndex(), ptrL1GtTriggerMenuLite(), retrieveL1GtTriggerMenuLite(), triggerMask(), and triggerMaskSet().

m_l1GtPfAlgo

const L1GtPrescaleFactors* L1GtUtils::m_l1GtPfAlgo

private

prescale factors

Definition at line 401 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtPfAlgoCacheID

unsigned long long L1GtUtils::m_l1GtPfAlgoCacheID

private

Definition at line 402 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtPfTech

const L1GtPrescaleFactors* L1GtUtils::m_l1GtPfTech

private

Definition at line 404 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtPfTechCacheID

unsigned long long L1GtUtils::m_l1GtPfTechCacheID

private

Definition at line 405 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_L1GtPrescaleFactorsAlgoTrigEventToken

edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd> L1GtUtils::m_L1GtPrescaleFactorsAlgoTrigEventToken

private

Definition at line 487 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtPrescaleFactorsAlgoTrigRunToken

edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd> L1GtUtils::m_L1GtPrescaleFactorsAlgoTrigRunToken

private

Definition at line 477 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtPrescaleFactorsTechTrigEventToken

edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd> L1GtUtils::m_L1GtPrescaleFactorsTechTrigEventToken

private

Definition at line 488 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtPrescaleFactorsTechTrigRunToken

edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd> L1GtUtils::m_L1GtPrescaleFactorsTechTrigRunToken

private

Definition at line 478 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_l1GtStablePar

const L1GtStableParameters* L1GtUtils::m_l1GtStablePar

private

event setup cached stuff

stable parameters

Definition at line 391 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_L1GtStableParametersEventToken

edm::ESGetToken<L1GtStableParameters, L1GtStableParametersRcd> L1GtUtils::m_L1GtStableParametersEventToken

private

Definition at line 486 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtStableParametersRunToken

edm::ESGetToken<L1GtStableParameters, L1GtStableParametersRcd> L1GtUtils::m_L1GtStableParametersRunToken

private

Definition at line 476 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_l1GtStableParCacheID

unsigned long long L1GtUtils::m_l1GtStableParCacheID

private

Definition at line 392 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtTmAlgo

const L1GtTriggerMask* L1GtUtils::m_l1GtTmAlgo

private

trigger masks & veto masks

Definition at line 411 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtTmAlgoCacheID

unsigned long long L1GtUtils::m_l1GtTmAlgoCacheID

private

Definition at line 412 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtTmTech

const L1GtTriggerMask* L1GtUtils::m_l1GtTmTech

private

Definition at line 414 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtTmTechCacheID

unsigned long long L1GtUtils::m_l1GtTmTechCacheID

private

Definition at line 415 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtTmVetoAlgo

const L1GtTriggerMask* L1GtUtils::m_l1GtTmVetoAlgo

private

Definition at line 417 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtTmVetoAlgoCacheID

unsigned long long L1GtUtils::m_l1GtTmVetoAlgoCacheID

private

Definition at line 418 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtTmVetoTech

const L1GtTriggerMask* L1GtUtils::m_l1GtTmVetoTech

private

Definition at line 420 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_l1GtTmVetoTechCacheID

unsigned long long L1GtUtils::m_l1GtTmVetoTechCacheID

private

Definition at line 421 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_L1GtTriggerMaskAlgoTrigEventToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd> L1GtUtils::m_L1GtTriggerMaskAlgoTrigEventToken

private

Definition at line 489 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMaskAlgoTrigRunToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd> L1GtUtils::m_L1GtTriggerMaskAlgoTrigRunToken

private

Definition at line 479 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMaskTechTrigEventToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd> L1GtUtils::m_L1GtTriggerMaskTechTrigEventToken

private

Definition at line 490 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMaskTechTrigRunToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd> L1GtUtils::m_L1GtTriggerMaskTechTrigRunToken

private

Definition at line 480 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMaskVetoAlgoTrigEventToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd> L1GtUtils::m_L1GtTriggerMaskVetoAlgoTrigEventToken

private

Definition at line 491 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMaskVetoAlgoTrigRunToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd> L1GtUtils::m_L1GtTriggerMaskVetoAlgoTrigRunToken

private

Definition at line 481 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMaskVetoTechTrigEventToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd> L1GtUtils::m_L1GtTriggerMaskVetoTechTrigEventToken

private

Definition at line 492 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMaskVetoTechTrigRunToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd> L1GtUtils::m_L1GtTriggerMaskVetoTechTrigRunToken

private

Definition at line 482 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMenuEventToken

edm::ESGetToken<L1GtTriggerMenu, L1GtTriggerMenuRcd> L1GtUtils::m_L1GtTriggerMenuEventToken

private

Definition at line 493 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_L1GtTriggerMenuRunToken

edm::ESGetToken<L1GtTriggerMenu, L1GtTriggerMenuRcd> L1GtUtils::m_L1GtTriggerMenuRunToken

private

Definition at line 483 of file L1GtUtils.h.

Referenced by L1GtUtils(), and retrieveL1EventSetup().

m_l1GtUtilsHelper

std::unique_ptr<L1GtUtilsHelper> L1GtUtils::m_l1GtUtilsHelper

private

Definition at line 473 of file L1GtUtils.h.

Referenced by L1GtUtils(), l1Results(), prescaleFactorSetIndex(), and retrieveL1GtTriggerMenuLite().

m_numberAlgorithmTriggers

unsigned int L1GtUtils::m_numberAlgorithmTriggers

private

number of algorithm triggers

Definition at line 395 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_numberTechnicalTriggers

unsigned int L1GtUtils::m_numberTechnicalTriggers

private

number of technical triggers

Definition at line 398 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_physicsDaqPartition

unsigned int L1GtUtils::m_physicsDaqPartition

private

index of physics DAQ partition

Definition at line 464 of file L1GtUtils.h.

Referenced by l1Results(), triggerMask(), and triggerMaskSet().

m_prescaleFactorsAlgoTrig

const std::vector<std::vector<int> >* L1GtUtils::m_prescaleFactorsAlgoTrig

private

Definition at line 407 of file L1GtUtils.h.

Referenced by l1Results(), prescaleFactorSetIndex(), and retrieveL1EventSetup().

m_prescaleFactorsAlgoTrigLite

const std::vector<std::vector<int> >* L1GtUtils::m_prescaleFactorsAlgoTrigLite

private

Definition at line 451 of file L1GtUtils.h.

Referenced by l1Results(), prescaleFactorSetIndex(), and retrieveL1GtTriggerMenuLite().

m_prescaleFactorSet

std::vector<int> L1GtUtils::m_prescaleFactorSet

private

Definition at line 467 of file L1GtUtils.h.

Referenced by prescaleFactorSet(), and retrieveL1EventSetup().

m_prescaleFactorsTechTrig

const std::vector<std::vector<int> >* L1GtUtils::m_prescaleFactorsTechTrig

private

Definition at line 408 of file L1GtUtils.h.

Referenced by l1Results(), prescaleFactorSetIndex(), and retrieveL1EventSetup().

m_prescaleFactorsTechTrigLite

const std::vector<std::vector<int> >* L1GtUtils::m_prescaleFactorsTechTrigLite

private

Definition at line 452 of file L1GtUtils.h.

Referenced by l1Results(), prescaleFactorSetIndex(), and retrieveL1GtTriggerMenuLite().

m_retrieveL1EventSetup

bool L1GtUtils::m_retrieveL1EventSetup

private

flags to check which method was used to retrieve L1 trigger configuration

Definition at line 470 of file L1GtUtils.h.

Referenced by availableL1Configuration(), l1AlgoTechTrigBitNumber(), l1TriggerMenu(), l1TriggerMenuImplementation(), l1TriggerNameFromBit(), ptrL1TriggerMenuEventSetup(), and retrieveL1EventSetup().

m_retrieveL1GtTriggerMenuLite

bool L1GtUtils::m_retrieveL1GtTriggerMenuLite

private

Definition at line 471 of file L1GtUtils.h.

Referenced by availableL1Configuration(), l1AlgoTechTrigBitNumber(), l1Results(), l1TriggerMenu(), l1TriggerMenuImplementation(), l1TriggerNameFromBit(), prescaleFactorSet(), prescaleFactorSetIndex(), ptrL1GtTriggerMenuLite(), retrieveL1GtTriggerMenuLite(), triggerMask(), and triggerMaskSet().

m_runIDCache

edm::RunID L1GtUtils::m_runIDCache

private

run cache ID

Definition at line 460 of file L1GtUtils.h.

Referenced by getL1GtRunCache().

m_technicalTriggerMap

const AlgorithmMap* L1GtUtils::m_technicalTriggerMap

private

Definition at line 435 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), l1TriggerNameFromBit(), and retrieveL1EventSetup().

m_technicalTriggerMapLite

const L1GtTriggerMenuLite::L1TriggerMap* L1GtUtils::m_technicalTriggerMapLite

private

Definition at line 446 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), l1TriggerNameFromBit(), and retrieveL1GtTriggerMenuLite().

m_triggerMaskAlgoTrig

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskAlgoTrig

private

Definition at line 423 of file L1GtUtils.h.

Referenced by l1Results(), retrieveL1EventSetup(), triggerMask(), and triggerMaskSet().

m_triggerMaskAlgoTrigLite

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskAlgoTrigLite

private

Definition at line 448 of file L1GtUtils.h.

Referenced by l1Results(), retrieveL1GtTriggerMenuLite(), triggerMask(), and triggerMaskSet().

m_triggerMaskSet

std::vector<unsigned int> L1GtUtils::m_triggerMaskSet

private

Definition at line 466 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup(), and triggerMaskSet().

m_triggerMaskTechTrig

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskTechTrig

private

Definition at line 424 of file L1GtUtils.h.

Referenced by l1Results(), retrieveL1EventSetup(), triggerMask(), and triggerMaskSet().

m_triggerMaskTechTrigLite

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskTechTrigLite

private

Definition at line 449 of file L1GtUtils.h.

Referenced by l1Results(), retrieveL1GtTriggerMenuLite(), triggerMask(), and triggerMaskSet().

m_triggerMaskVetoAlgoTrig

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskVetoAlgoTrig

private

Definition at line 426 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

m_triggerMaskVetoTechTrig

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskVetoTechTrig

private

Definition at line 427 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().