CMS 3D CMS Logo

Public Types | Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes

L1GtUtils Class Reference

#include <L1GtUtils.h>

List of all members.

Public Types

enum  TriggerCategory { AlgorithmTrigger = 0, TechnicalTrigger = 1 }

Public Member Functions

const bool availableL1Configuration (int &errorCode, int &l1ConfCode) const
const bool decision (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const std::string &nameAlgoTechTrig, int &errorCode) const
const bool decision (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
const bool decisionAfterMask (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const std::string &nameAlgoTechTrig, int &errorCode) const
 return decision after trigger mask for a given algorithm or technical trigger
const bool decisionAfterMask (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
const bool decisionBeforeMask (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const std::string &nameAlgoTechTrig, int &errorCode) const
 return decision before trigger mask for a given algorithm or technical trigger
const bool decisionBeforeMask (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
void getInputTag (const edm::Event &iEvent, edm::InputTag &l1GtRecordInputTag, edm::InputTag &l1GtReadoutRecordInputTag) const
 get the input tags for L1GlobalTriggerRecord and L1GlobalTriggerReadoutRecord
void getL1GtTriggerMenuLiteInputTag (const edm::Event &iEvent, edm::InputTag &l1GtTriggerMenuLiteInputTag) const
 get the input tags for L1GtTriggerMenuLite
const bool l1AlgoTechTrigBitNumber (const std::string &nameAlgoTechTrig, TriggerCategory &trigCategory, int &bitNumber) const
const bool l1AlgTechTrigBitNumber (const std::string &nameAlgoTechTrig, int &triggerAlgoTechTrig, int &bitNumber) const
 deprecated version - use l1AlgoTechTrigBitNumber
 L1GtUtils ()
 constructor
const int l1Results (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const std::string &nameAlgoTechTrig, bool &decisionBeforeMask, bool &decisionAfterMask, int &prescaleFactor, int &triggerMask) const
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
const std::string & l1TriggerMenuImplementation () const
 return the L1 trigger menu implementation
const int prescaleFactor (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const std::string &nameAlgoTechTrig, int &errorCode) const
 return prescale factor for a given algorithm or technical trigger
const int prescaleFactor (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
const std::vector< int > & prescaleFactorSet (const edm::Event &iEvent, const std::string &triggerAlgoTechTrig, int &errorCode)
const std::vector< int > & prescaleFactorSet (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const TriggerCategory &trigCategory, int &errorCode)
const std::vector< int > & prescaleFactorSet (const edm::Event &iEvent, const TriggerCategory &trigCategory, int &errorCode)
const std::vector< int > & prescaleFactorSet (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const std::string &triggerAlgoTechTrig, int &errorCode)
 deprecated versions
const int prescaleFactorSetIndex (const edm::Event &iEvent, const std::string &triggerAlgoTechTrig, int &errorCode) const
const int prescaleFactorSetIndex (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const TriggerCategory &trigCategory, int &errorCode) const
const int prescaleFactorSetIndex (const edm::Event &iEvent, const TriggerCategory &trigCategory, int &errorCode) const
const int prescaleFactorSetIndex (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const std::string &triggerAlgoTechTrig, int &errorCode) const
 deprecated versions
const L1GtTriggerMenuLiteptrL1GtTriggerMenuLite (int &errorCode)
 return a pointer to the L1GtTriggerMenuLite product
const L1GtTriggerMenuptrL1TriggerMenuEventSetup (int &errorCode)
 return a pointer to the L1 trigger menu from event setup
void retrieveL1EventSetup (const edm::EventSetup &)
 retrieve all the relevant L1 trigger event setup records and cache them to improve the speed
void retrieveL1GtTriggerMenuLite (const edm::Event &, edm::InputTag &)
void retrieveL1GtTriggerMenuLite (const edm::Event &)
 input tag found from provenance
const std::string triggerCategory (const TriggerCategory &) const
 public methods
const int triggerMask (const edm::Event &iEvent, const std::string &nameAlgoTechTrig, int &errorCode) const
const int triggerMask (const std::string &nameAlgoTechTrig, int &errorCode) const
const int triggerMask (const edm::Event &iEvent, const edm::InputTag &l1GtRecordInputTag, const edm::InputTag &l1GtReadoutRecordInputTag, const std::string &nameAlgoTechTrig, int &errorCode) const
 return trigger mask for a given algorithm or technical trigger
const std::vector< unsigned int > & triggerMaskSet (const TriggerCategory &trigCategory, int &errorCode)
const std::vector< unsigned int > & triggerMaskSet (const std::string &triggerAlgoTechTrig, int &errorCode)
 deprecated version
virtual ~L1GtUtils ()
 destructor

Private Member Functions

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

Private Attributes

const AlgorithmMapm_algorithmAliasMap
const
L1GtTriggerMenuLite::L1TriggerMap
m_algorithmAliasMapLite
const AlgorithmMapm_algorithmMap
const
L1GtTriggerMenuLite::L1TriggerMap
m_algorithmMapLite
bool m_l1EventSetupValid
const L1GtTriggerMenum_l1GtMenu
unsigned long long m_l1GtMenuCacheID
const L1GtTriggerMenuLitem_l1GtMenuLite
 L1GtTriggerMenuLite cached stuff.
bool m_l1GtMenuLiteValid
const L1GtPrescaleFactorsm_l1GtPfAlgo
 prescale factors
unsigned long long m_l1GtPfAlgoCacheID
const L1GtPrescaleFactorsm_l1GtPfTech
unsigned long long m_l1GtPfTechCacheID
const L1GtStableParametersm_l1GtStablePar
 event setup cached stuff
unsigned long long m_l1GtStableParCacheID
const L1GtTriggerMaskm_l1GtTmAlgo
 trigger masks & veto masks
unsigned long long m_l1GtTmAlgoCacheID
const L1GtTriggerMaskm_l1GtTmTech
unsigned long long m_l1GtTmTechCacheID
const L1GtTriggerMaskm_l1GtTmVetoAlgo
unsigned long long m_l1GtTmVetoAlgoCacheID
const L1GtTriggerMaskm_l1GtTmVetoTech
unsigned long long m_l1GtTmVetoTechCacheID
unsigned int m_numberAlgorithmTriggers
 number of algorithm triggers
unsigned int m_numberTechnicalTriggers
 number of technical triggers
unsigned int m_physicsDaqPartition
 index of physics DAQ partition
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
const edm::RunIDm_provRunIDCache
bool m_retrieveL1EventSetup
 flags to check which method was used to retrieve L1 trigger configuration
bool m_retrieveL1GtTriggerMenuLite
const edm::RunIDm_runIDCache
const AlgorithmMapm_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

$Date$ $Revision$

Definition at line 47 of file L1GtUtils.h.


Member Enumeration Documentation

Enumerator:
AlgorithmTrigger 
TechnicalTrigger 

Definition at line 59 of file L1GtUtils.h.


Constructor & Destructor Documentation

L1GtUtils::L1GtUtils ( ) [explicit]
L1GtUtils::~L1GtUtils ( ) [virtual]

destructor

Definition at line 80 of file L1GtUtils.cc.

                      {

    // empty

}

Member Function Documentation

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 2235 of file L1GtUtils.cc.

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

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore(), l1Results(), prescaleFactorSet(), 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"
                    << "\n  if L1GtTriggerMenuLite not valid, try to retrieve from event setup "
                    << 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 either retrieveL1GtTriggerMenuLite or retrieveL1EventSetup.\n"
                << std::endl;
        l1ConfCode = 300000;
        errorCode = l1ConfCode;

        return false;

    }
}
const bool L1GtUtils::decision ( const edm::Event iEvent,
const edm::InputTag l1GtRecordInputTag,
const edm::InputTag l1GtReadoutRecordInputTag,
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 1184 of file L1GtUtils.cc.

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

Referenced by GenericTriggerEventFlag::acceptL1LogicalExpression(), TriggerHelper::acceptL1LogicalExpression(), L1GtAnalyzer::analyzeL1GtUtilsCore(), and PrescaleWeightProvider::prescaleWeight().

                                                                 {

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

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

    return decisionAfterMask;

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

Definition at line 1203 of file L1GtUtils.cc.

References decisionAfterMask(), 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;

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

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

Definition at line 1147 of file L1GtUtils.cc.

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

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

                                                                 {

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

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

    return decisionAfterMask;

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

Definition at line 1166 of file L1GtUtils.cc.

References decisionAfterMask(), 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;

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

Definition at line 1129 of file L1GtUtils.cc.

References decisionAfterMask(), 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 decisionBeforeMask;

}
const bool L1GtUtils::decisionBeforeMask ( const edm::Event iEvent,
const edm::InputTag l1GtRecordInputTag,
const edm::InputTag l1GtReadoutRecordInputTag,
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 input tag for the L1GlobalTriggerRecord product input tag for the L1GlobalTriggerReadoutRecord product algorithm trigger name or alias, or technical trigger name output (by reference): error code return: the corresponding quantity

if input tags are not given, they are found for the appropriate EDM products from provenance

Definition at line 1110 of file L1GtUtils.cc.

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

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

                                                                 {

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

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

    return decisionBeforeMask;

}
void L1GtUtils::getInputTag ( const edm::Event iEvent,
edm::InputTag l1GtRecordInputTag,
edm::InputTag l1GtReadoutRecordInputTag 
) const

get the input tags for L1GlobalTriggerRecord and L1GlobalTriggerReadoutRecord

Definition at line 339 of file L1GtUtils.cc.

References edm::friendlyname::friendlyName(), and edm::Event::getAllProvenance().

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

                                                      {

    typedef std::vector<edm::Provenance const*> Provenances;
    Provenances provenances;
    std::string friendlyName;
    std::string modLabel;
    std::string instanceName;
    std::string processName;

    // to be sure that the input tags are correctly initialized
    edm::InputTag l1GtRecordInputTagVal;
    edm::InputTag l1GtReadoutRecordInputTagVal;

    bool foundL1GtRecord = false;
    bool foundL1GtReadoutRecord = false;

    //edm::LogVerbatim("L1GtUtils") << "\nTry to get AllProvenance for event "
    //        << iEvent.id().event() << std::endl;

    iEvent.getAllProvenance(provenances);

    //edm::LogVerbatim("L1GtUtils") << "\n" << "Event contains "
    //        << provenances.size() << " product" << (provenances.size()==1 ? "" : "s")
    //        << " with friendlyClassName, moduleLabel, productInstanceName and processName:"
    //        << std::endl;

    for (Provenances::iterator itProv = provenances.begin(), itProvEnd =
            provenances.end(); itProv != itProvEnd; ++itProv) {

        friendlyName = (*itProv)->friendlyClassName();
        modLabel = (*itProv)->moduleLabel();
        instanceName = (*itProv)->productInstanceName();
        processName = (*itProv)->processName();

        //edm::LogVerbatim("L1GtUtils") << friendlyName << " \"" << modLabel
        //        << "\" \"" << instanceName << "\" \"" << processName << "\""
        //        << std::endl;

        if (friendlyName == "L1GlobalTriggerRecord") {
            l1GtRecordInputTagVal = edm::InputTag(modLabel, instanceName,
                    processName);
            foundL1GtRecord = true;
        } else if (friendlyName == "L1GlobalTriggerReadoutRecord") {

            l1GtReadoutRecordInputTagVal = edm::InputTag(modLabel, instanceName,
                    processName);
            foundL1GtReadoutRecord = true;
        }
    }

    // copy the input tags found to the returned arguments
    l1GtRecordInputTag = l1GtRecordInputTagVal;
    l1GtReadoutRecordInputTag = l1GtReadoutRecordInputTagVal;

    //if (foundL1GtRecord) {
    //    edm::LogVerbatim("L1GtUtils")
    //            << "\nL1GlobalTriggerRecord found in the event with \n  "
    //            << l1GtRecordInputTag << std::endl;
    //
    //}

    //if (foundL1GtReadoutRecord) {
    //    edm::LogVerbatim("L1GtUtils")
    //            << "\nL1GlobalTriggerReadoutRecord found in the event with \n  "
    //           << l1GtReadoutRecordInputTag << std::endl;
    //}

}
void L1GtUtils::getL1GtTriggerMenuLiteInputTag ( const edm::Event iEvent,
edm::InputTag l1GtTriggerMenuLiteInputTag 
) const

get the input tags for L1GtTriggerMenuLite

Definition at line 410 of file L1GtUtils.cc.

References edm::friendlyname::friendlyName(), edm::Run::getAllProvenance(), and edm::Event::getRun().

Referenced by retrieveL1GtTriggerMenuLite().

                                                        {

    typedef std::vector<edm::Provenance const*> Provenances;
    Provenances provenances;
    std::string friendlyName;
    std::string modLabel;
    std::string instanceName;
    std::string processName;

    // to be sure that the input tag is correctly initialized
    edm::InputTag l1GtTriggerMenuLiteInputTagVal;
    bool foundL1GtTriggerMenuLite = false;

    // get Run Data
    const edm::Run& iRun = iEvent.getRun();

    //edm::LogVerbatim("L1GtUtils") << "\nTry to get AllProvenance for run "
    //        << iRun.runAuxiliary().run() << " event " << iEvent.id().event()
    //        << std::endl;

    iRun.getAllProvenance(provenances);

    //edm::LogVerbatim("L1GtUtils") << "\n" << "Run contains "
    //        << provenances.size() << " product"
    //        << (provenances.size() == 1 ? "" : "s")
    //        << " with friendlyClassName, moduleLabel, productInstanceName and processName:"
    //        << std::endl;

    for (Provenances::iterator itProv = provenances.begin(), itProvEnd =
            provenances.end(); itProv != itProvEnd; ++itProv) {

        friendlyName = (*itProv)->friendlyClassName();
        modLabel = (*itProv)->moduleLabel();
        instanceName = (*itProv)->productInstanceName();
        processName = (*itProv)->processName();

        //edm::LogVerbatim("L1GtUtils") << friendlyName << " \"" << modLabel
        //        << "\" \"" << instanceName << "\" \"" << processName << "\""
        //        << std::endl;

        if (friendlyName == "L1GtTriggerMenuLite") {
            l1GtTriggerMenuLiteInputTagVal = edm::InputTag(modLabel,
                    instanceName, processName);
            foundL1GtTriggerMenuLite = true;
        }

    }

    // copy the input tags found to the returned arguments
    l1GtTriggerMenuLiteInputTag = l1GtTriggerMenuLiteInputTagVal;

    //if (foundL1GtTriggerMenuLite) {
    //    edm::LogVerbatim("L1GtUtils")
    //            << "\nL1GtTriggerMenuLite found in the event with \n  "
    //            << l1GtTriggerMenuLiteInputTag << std::endl;
    //}

}
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 470 of file L1GtUtils.cc.

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

Referenced by l1AlgTechTrigBitNumber(), 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;


}
const bool L1GtUtils::l1AlgTechTrigBitNumber ( const std::string &  nameAlgoTechTrig,
int &  triggerAlgoTechTrig,
int &  bitNumber 
) const

deprecated version - use l1AlgoTechTrigBitNumber

Definition at line 598 of file L1GtUtils.cc.

References AlgorithmTrigger, and l1AlgoTechTrigBitNumber().

                              {

    TriggerCategory trigCategory = AlgorithmTrigger;
    bitNumber = -1;

    const bool trigCategBitNr = l1AlgoTechTrigBitNumber(nameAlgoTechTrig,
            trigCategory, bitNumber);
    triggerAlgoTechTrig = trigCategory;

    return trigCategBitNr;

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

return results for a given algorithm or technical trigger: input: event input tag for the L1GlobalTriggerRecord product input tag for the L1GlobalTriggerReadoutRecord product 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 614 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), decisionBeforeMask(), edm::Event::getByLabel(), L1GtTriggerMenu::gtTriggerMenuImplementation(), L1GtTriggerMenuLite::gtTriggerMenuImplementation(), edm::HandleBase::isValid(), l1AlgoTechTrigBitNumber(), LogDebug, m_l1GtMenu, m_l1GtMenuLite, m_l1GtMenuLiteValid, m_physicsDaqPartition, m_prescaleFactorsAlgoTrig, m_prescaleFactorsAlgoTrigLite, m_prescaleFactorsTechTrig, m_prescaleFactorsTechTrigLite, m_retrieveL1GtTriggerMenuLite, m_triggerMaskAlgoTrig, m_triggerMaskAlgoTrigLite, m_triggerMaskTechTrig, m_triggerMaskTechTrigLite, TechnicalTrigger, triggerCategory(), and trigResult().

Referenced by decision(), decisionAfterMask(), decisionBeforeMask(), l1Results(), 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 gtRecordValid = false;
    bool gtReadoutRecordValid = false;

    edm::Handle<L1GlobalTriggerRecord> gtRecord;
    iEvent.getByLabel(l1GtRecordInputTag, gtRecord);

    if (gtRecord.isValid()) {

        gtRecordValid = true;
        validRecord = true;

    } else {

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

    edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecord;
    iEvent.getByLabel(l1GtReadoutRecordInputTag, gtReadoutRecord);

    if (gtReadoutRecord.isValid()) {

        gtReadoutRecordValid = true;
        validRecord = true;

    } else {

        iErrorRecord = iErrorRecord + 100;
        LogDebug("L1GtUtils") << "\nL1GlobalTriggerReadoutRecord with \n  "
                << 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  "
                << l1GtRecordInputTag << "\nfound in the event."
                << "\nNo valid L1GlobalTriggerReadoutRecord with \n  "
                << 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 = 0;
    const std::vector<unsigned int>* triggerMasksSet = 0;

    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;

}
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 tag for the an appropriate EDM product will be found from provenance 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 1083 of file L1GtUtils.cc.

References getInputTag(), and l1Results().

                                                                              {

    edm::InputTag l1GtRecordInputTag;
    edm::InputTag l1GtReadoutRecordInputTag;

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

    getInputTag(iEvent, l1GtRecordInputTag, l1GtReadoutRecordInputTag);

    int l1ErrorCode = 0;

    l1ErrorCode = l1Results(iEvent, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, nameAlgoTechTrig, decisionBeforeMask,
            decisionAfterMask, prescaleFactor, triggerMask);

    return l1ErrorCode;

}
const std::string & L1GtUtils::l1TriggerMenu ( ) const

return the L1 trigger menu name

Definition at line 2120 of file L1GtUtils.cc.

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

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

                                                {

    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;

    }

}
const std::string & L1GtUtils::l1TriggerMenuImplementation ( ) const

return the L1 trigger menu implementation

Definition at line 2145 of file L1GtUtils.cc.

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

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore().

                                                              {

    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;

    }

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

return prescale factor for a given algorithm or technical trigger

Definition at line 1221 of file L1GtUtils.cc.

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

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

                                                                 {

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

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

    return prescaleFactor;

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

Definition at line 1240 of file L1GtUtils.cc.

References decisionAfterMask(), 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 prescaleFactor;

}
const std::vector< int > & L1GtUtils::prescaleFactorSet ( const edm::Event iEvent,
const edm::InputTag l1GtRecordInputTag,
const edm::InputTag l1GtReadoutRecordInputTag,
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 1800 of file L1GtUtils.cc.

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

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore(), and prescaleFactorSet().

                                                             {

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

    // initialize error code
    int iError = 0;

    const int pfIndex = prescaleFactorSetIndex(iEvent, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, 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;

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

Definition at line 1875 of file L1GtUtils.cc.

References getInputTag(), m_prescaleFactorSet, and prescaleFactorSet().

                                                             {

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

    // initialize error code
    int iError = 0;

    edm::InputTag l1GtRecordInputTag;
    edm::InputTag l1GtReadoutRecordInputTag;

    getInputTag(iEvent, l1GtRecordInputTag, l1GtReadoutRecordInputTag);

    m_prescaleFactorSet = prescaleFactorSet(iEvent, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, trigCategory, iError);

    errorCode = iError;
    return m_prescaleFactorSet;

}
const std::vector< int > & L1GtUtils::prescaleFactorSet ( const edm::Event iEvent,
const edm::InputTag l1GtRecordInputTag,
const edm::InputTag l1GtReadoutRecordInputTag,
const std::string &  triggerAlgoTechTrig,
int &  errorCode 
)

deprecated versions

Definition at line 1899 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), LogDebug, m_prescaleFactorSet, prescaleFactorSet(), and TechnicalTrigger.

                                                              {

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

    // 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 m_prescaleFactorSet;
    }

    // test if the argument for the "trigger algorithm type" is correct
    TriggerCategory trigCategory = AlgorithmTrigger;

    if (triggerAlgoTechTrig == "TechnicalTriggers") {
        trigCategory = TechnicalTrigger;

    } else if (triggerAlgoTechTrig == "PhysicsAlgorithms") {
        trigCategory = AlgorithmTrigger;

    } else {

        LogDebug("L1GtUtils")
                << "\nErrr : prescale factor set cannot be retrieved for the argument "
                << triggerAlgoTechTrig
                << "\n  Supported arguments: 'PhysicsAlgorithms' or 'TechnicalTriggers'"
                << "\nWarning: this method is deprecated, please use method with TriggerCategory."
                << std::endl;

        iError = l1ConfCode + 6000;

        errorCode = iError;
        return m_prescaleFactorSet;

    }

    m_prescaleFactorSet = prescaleFactorSet(iEvent, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, trigCategory, iError);

    errorCode = iError;
    return m_prescaleFactorSet;
}
const std::vector< int > & L1GtUtils::prescaleFactorSet ( const edm::Event iEvent,
const std::string &  triggerAlgoTechTrig,
int &  errorCode 
)

Definition at line 1952 of file L1GtUtils.cc.

References getInputTag(), m_prescaleFactorSet, and prescaleFactorSet().

                                                              {

    // initialize error code
    int iError = 0;

    edm::InputTag l1GtRecordInputTag;
    edm::InputTag l1GtReadoutRecordInputTag;

    getInputTag(iEvent, l1GtRecordInputTag, l1GtReadoutRecordInputTag);

    m_prescaleFactorSet = prescaleFactorSet(iEvent, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, triggerAlgoTechTrig, iError);

    errorCode = iError;
    return m_prescaleFactorSet;

}
const int L1GtUtils::prescaleFactorSetIndex ( const edm::Event iEvent,
const std::string &  triggerAlgoTechTrig,
int &  errorCode 
) const

Definition at line 1778 of file L1GtUtils.cc.

References getInputTag(), and prescaleFactorSetIndex().

                                                                    {

    // initialize error code and return value
    int iError = 0;
    int pfIndex = -1;

    edm::InputTag l1GtRecordInputTag;
    edm::InputTag l1GtReadoutRecordInputTag;

    getInputTag(iEvent, l1GtRecordInputTag, l1GtReadoutRecordInputTag);

    pfIndex = prescaleFactorSetIndex(iEvent, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, triggerAlgoTechTrig, iError);

    // return the error code and the index value
    // if the  error code is not 0, the index returned is -1
    errorCode = iError;
    return pfIndex;

}
const int L1GtUtils::prescaleFactorSetIndex ( const edm::Event iEvent,
const edm::InputTag l1GtRecordInputTag,
const edm::InputTag l1GtReadoutRecordInputTag,
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 1496 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), edm::Event::getByLabel(), edm::HandleBase::isValid(), LogDebug, m_l1GtMenuLiteValid, m_prescaleFactorsAlgoTrig, m_prescaleFactorsAlgoTrigLite, m_prescaleFactorsTechTrig, m_prescaleFactorsTechTrigLite, m_retrieveL1GtTriggerMenuLite, and TechnicalTrigger.

Referenced by HLTInfo::analyze(), L1GtAnalyzer::analyzeL1GtUtilsCore(), prescaleFactorSet(), and prescaleFactorSetIndex().

                                                                   {

    // 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 gtRecordValid = false;
    bool gtReadoutRecordValid = false;

    edm::Handle<L1GlobalTriggerRecord> gtRecord;
    iEvent.getByLabel(l1GtRecordInputTag, gtRecord);

    if (gtRecord.isValid()) {

        gtRecordValid = true;
        validRecord = true;

    } else {

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

    edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecord;
    iEvent.getByLabel(l1GtReadoutRecordInputTag, gtReadoutRecord);

    if (gtReadoutRecord.isValid()) {

        gtReadoutRecordValid = true;
        validRecord = true;

    } else {

        iErrorRecord = iErrorRecord + 100;
        LogDebug("L1GtUtils") << "\nL1GlobalTriggerReadoutRecord with \n  "
                << 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  "
                << l1GtRecordInputTag << "\nfound in the event."
                << "\nNo valid L1GlobalTriggerReadoutRecord with \n  "
                << 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;

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

Definition at line 1703 of file L1GtUtils.cc.

References getInputTag(), and prescaleFactorSetIndex().

                                                                   {

    // initialize error code and return value
    int iError = 0;
    int pfIndex = -1;

    edm::InputTag l1GtRecordInputTag;
    edm::InputTag l1GtReadoutRecordInputTag;

    getInputTag(iEvent, l1GtRecordInputTag, l1GtReadoutRecordInputTag);

    pfIndex = prescaleFactorSetIndex(iEvent, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, trigCategory, iError);

    // return the error code and the index value
    // if the  error code is 0, the index returned is -1
    errorCode = iError;
    return pfIndex;

}
const int L1GtUtils::prescaleFactorSetIndex ( const edm::Event iEvent,
const edm::InputTag l1GtRecordInputTag,
const edm::InputTag l1GtReadoutRecordInputTag,
const std::string &  triggerAlgoTechTrig,
int &  errorCode 
) const

deprecated versions

Definition at line 1727 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), LogDebug, prescaleFactorSetIndex(), and TechnicalTrigger.

                                                                    {

    // initialize error code and return value
    int iError = 0;
    int l1ConfCode = 0;
    int pfIndex = -1;

    // check if L1 configuration is available

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

    // test if the argument for the "trigger algorithm type" is correct
    TriggerCategory trigCategory = AlgorithmTrigger;

    if (triggerAlgoTechTrig == "TechnicalTriggers") {
        trigCategory = TechnicalTrigger;

    } else if (triggerAlgoTechTrig == "PhysicsAlgorithms") {
        trigCategory = AlgorithmTrigger;

    } else {

        LogDebug("L1GtUtils")
                << "\nErrr : prescale factor set index cannot be retrieved for the argument "
                << triggerAlgoTechTrig
                << "\n  Supported arguments: 'PhysicsAlgorithms' or 'TechnicalTriggers'"
                << "\nWarning: this method is deprecated, please use method with TriggerCategory."
                << std::endl;

        iError = l1ConfCode + 6000;

        errorCode = iError;
        return pfIndex;

    }

    pfIndex = prescaleFactorSetIndex(iEvent, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, trigCategory, errorCode);

    errorCode = iError;
    return pfIndex;

}
const L1GtTriggerMenuLite * L1GtUtils::ptrL1GtTriggerMenuLite ( int &  errorCode)

return a pointer to the L1GtTriggerMenuLite product

Definition at line 2198 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 0;
    }

    if (m_retrieveL1GtTriggerMenuLite) {
        if (m_l1GtMenuLiteValid) {

            errorCode = iError;
            return m_l1GtMenuLite;

        } else {
            iError = l1ConfCode;

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

        errorCode = iError;
        return 0;
    }

    errorCode = iError;
    return m_l1GtMenuLite;

}
const L1GtTriggerMenu * L1GtUtils::ptrL1TriggerMenuEventSetup ( int &  errorCode)

return a pointer to the L1 trigger menu from event setup

Definition at line 2170 of file L1GtUtils.cc.

References availableL1Configuration(), m_l1GtMenu, and m_retrieveL1EventSetup.

                                                                           {

    // 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 0;
    }

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

        errorCode = iError;
        return 0;

    }

    errorCode = iError;
    return m_l1GtMenu;
}
void L1GtUtils::retrieveL1EventSetup ( const edm::EventSetup evSetup)

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

Definition at line 107 of file L1GtUtils.cc.

References 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_l1GtStablePar, m_l1GtStableParCacheID, m_l1GtTmAlgo, m_l1GtTmAlgoCacheID, m_l1GtTmTech, m_l1GtTmTechCacheID, m_l1GtTmVetoAlgo, m_l1GtTmVetoAlgoCacheID, m_l1GtTmVetoTech, m_l1GtTmVetoTechCacheID, m_numberAlgorithmTriggers, m_numberTechnicalTriggers, m_prescaleFactorsAlgoTrig, m_prescaleFactorSet, m_prescaleFactorsTechTrig, m_retrieveL1EventSetup, m_technicalTriggerMap, m_triggerMaskAlgoTrig, m_triggerMaskSet, m_triggerMaskTechTrig, m_triggerMaskVetoAlgoTrig, m_triggerMaskVetoTechTrig, max(), and edm::ESHandle< T >::product().

Referenced by GenericTriggerEventFlag::acceptL1(), TriggerHelper::acceptL1(), HLTInfo::analyze(), L1GtAnalyzer::analyzeL1GtUtilsEventSetup(), PrescaleWeightProvider::prescaleWeight(), and pat::PATTriggerProducer::produce().

                                                                 {

    //
    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

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

    if (m_l1GtStableParCacheID != l1GtStableParCacheID) {

        edm::ESHandle<L1GtStableParameters> l1GtStablePar;
        evSetup.get<L1GtStableParametersRcd>().get(l1GtStablePar);
        m_l1GtStablePar = l1GtStablePar.product();

        // 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

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

    if (m_l1GtPfAlgoCacheID != l1GtPfAlgoCacheID) {

        edm::ESHandle<L1GtPrescaleFactors> l1GtPfAlgo;
        evSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo);
        m_l1GtPfAlgo = l1GtPfAlgo.product();

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

        m_l1GtPfAlgoCacheID = l1GtPfAlgoCacheID;

    }

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

    if (m_l1GtPfTechCacheID != l1GtPfTechCacheID) {

        edm::ESHandle<L1GtPrescaleFactors> l1GtPfTech;
        evSetup.get<L1GtPrescaleFactorsTechTrigRcd>().get(l1GtPfTech);
        m_l1GtPfTech = l1GtPfTech.product();

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

        m_l1GtPfTechCacheID = l1GtPfTechCacheID;

    }

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

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

    if (m_l1GtTmAlgoCacheID != l1GtTmAlgoCacheID) {

        edm::ESHandle<L1GtTriggerMask> l1GtTmAlgo;
        evSetup.get<L1GtTriggerMaskAlgoTrigRcd>().get(l1GtTmAlgo);
        m_l1GtTmAlgo = l1GtTmAlgo.product();

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

        m_l1GtTmAlgoCacheID = l1GtTmAlgoCacheID;

    }

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

    if (m_l1GtTmTechCacheID != l1GtTmTechCacheID) {

        edm::ESHandle<L1GtTriggerMask> l1GtTmTech;
        evSetup.get<L1GtTriggerMaskTechTrigRcd>().get(l1GtTmTech);
        m_l1GtTmTech = l1GtTmTech.product();

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

        m_l1GtTmTechCacheID = l1GtTmTechCacheID;

    }

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

    if (m_l1GtTmVetoAlgoCacheID != l1GtTmVetoAlgoCacheID) {

        edm::ESHandle<L1GtTriggerMask> l1GtTmVetoAlgo;
        evSetup.get<L1GtTriggerMaskVetoAlgoTrigRcd>().get(l1GtTmVetoAlgo);
        m_l1GtTmVetoAlgo = l1GtTmVetoAlgo.product();

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

        m_l1GtTmVetoAlgoCacheID = l1GtTmVetoAlgoCacheID;

    }

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

    if (m_l1GtTmVetoTechCacheID != l1GtTmVetoTechCacheID) {

        edm::ESHandle<L1GtTriggerMask> l1GtTmVetoTech;
        evSetup.get<L1GtTriggerMaskVetoTechTrigRcd>().get(l1GtTmVetoTech);
        m_l1GtTmVetoTech = l1GtTmVetoTech.product();

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

        m_l1GtTmVetoTechCacheID = l1GtTmVetoTechCacheID;

    }

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

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

    if (m_l1GtMenuCacheID != l1GtMenuCacheID) {

        edm::ESHandle<L1GtTriggerMenu> l1GtMenu;
        evSetup.get<L1GtTriggerMenuRcd>().get(l1GtMenu);
        m_l1GtMenu = l1GtMenu.product();

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

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

        m_l1GtMenuCacheID = l1GtMenuCacheID;

    }

}
void L1GtUtils::retrieveL1GtTriggerMenuLite ( const edm::Event iEvent,
edm::InputTag l1GtMenuLiteInputTag 
)

retrieve L1GtTriggerMenuLite (per run product) and cache it to improve the speed input tag explicitly given

Definition at line 283 of file L1GtUtils.cc.

References edm::Run::getByLabel(), edm::Event::getRun(), 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_prescaleFactorsAlgoTrigLite, m_prescaleFactorsTechTrigLite, m_retrieveL1GtTriggerMenuLite, m_runIDCache, m_technicalTriggerMapLite, m_triggerMaskAlgoTrigLite, m_triggerMaskTechTrigLite, edm::Handle< T >::product(), and edm::Run::runAuxiliary().

Referenced by L1GtAnalyzer::analyzeL1GtUtilsMenuLite(), and retrieveL1GtTriggerMenuLite().

                                           {

    //
    m_retrieveL1GtTriggerMenuLite = true;

    // get Run Data - the same code can be run in beginRun, with getByLabel from edm::Run
    const edm::Run& iRun = iEvent.getRun();
    const edm::RunID* runID = &(iRun.runAuxiliary().id());

    if (runID != m_runIDCache) {

        // get L1GtTriggerMenuLite
        edm::Handle<L1GtTriggerMenuLite> l1GtMenuLite;
        iRun.getByLabel(l1GtMenuLiteInputTag, l1GtMenuLite);

        if (!l1GtMenuLite.isValid()) {

            LogDebug("L1GtUtils") << "\nL1GtTriggerMenuLite with \n  "
                    << l1GtMenuLiteInputTag
                    << "\nrequested in configuration, but not found in the event."
                    << std::endl;

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

            LogDebug("L1GtUtils") << "\nL1GtTriggerMenuLite with \n  "
                    << l1GtMenuLiteInputTag << "\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());

        }

        m_runIDCache = runID;
    }

}
void L1GtUtils::retrieveL1GtTriggerMenuLite ( const edm::Event iEvent)

input tag found from provenance

Definition at line 264 of file L1GtUtils.cc.

References getL1GtTriggerMenuLiteInputTag(), edm::Event::getRun(), m_provRunIDCache, retrieveL1GtTriggerMenuLite(), and edm::Run::runAuxiliary().

                                                                  {

    // cache the L1GtTriggerMenuLite

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

    if (runID != m_provRunIDCache) {

        edm::InputTag l1GtTriggerMenuLiteInputTag;
        getL1GtTriggerMenuLiteInputTag(iEvent, l1GtTriggerMenuLiteInputTag);

        retrieveL1GtTriggerMenuLite(iEvent, l1GtTriggerMenuLiteInputTag);

        m_provRunIDCache = runID;

    }
}
const std::string L1GtUtils::triggerCategory ( const TriggerCategory trigCategory) const

public methods

Definition at line 86 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;
    }
}
const int L1GtUtils::triggerMask ( const edm::Event iEvent,
const std::string &  nameAlgoTechTrig,
int &  errorCode 
) const

Definition at line 1275 of file L1GtUtils.cc.

References decisionAfterMask(), 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 triggerMask;

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

return trigger mask for a given algorithm or technical trigger

Definition at line 1256 of file L1GtUtils.cc.

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

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

                                                                 {

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

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

    return triggerMask;

}
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 1291 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), L1GtTriggerMenu::gtTriggerMenuImplementation(), L1GtTriggerMenuLite::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 = 0;

    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;

}
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 1972 of file L1GtUtils.cc.

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

Referenced by L1GtAnalyzer::analyzeL1GtUtilsCore(), and triggerMaskSet().

                                                             {

    // 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;

}
const std::vector< unsigned int > & L1GtUtils::triggerMaskSet ( const std::string &  triggerAlgoTechTrig,
int &  errorCode 
)

deprecated version

Definition at line 2071 of file L1GtUtils.cc.

References AlgorithmTrigger, availableL1Configuration(), LogDebug, m_triggerMaskSet, TechnicalTrigger, and triggerMaskSet().

                                                              {

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

    // 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 m_triggerMaskSet;
    }

    // test if the argument for the "trigger algorithm type" is correct
    TriggerCategory trigCategory = AlgorithmTrigger;

    if (triggerAlgoTechTrig == "TechnicalTriggers") {
        trigCategory = TechnicalTrigger;

    } else if (triggerAlgoTechTrig == "PhysicsAlgorithms") {
        trigCategory = AlgorithmTrigger;

    } else {

        LogDebug("L1GtUtils")
                << "\nErrr : trigger mask set cannot be retrieved for the argument "
                << triggerAlgoTechTrig
                << "\n  Supported arguments: 'PhysicsAlgorithms' or 'TechnicalTriggers'"
                << "\nWarning: this method is deprecated, please use method with TriggerCategory."
                << std::endl;

        iError = l1ConfCode + 6000;

        errorCode = iError;
        return m_triggerMaskSet;

    }

    m_triggerMaskSet = triggerMaskSet(trigCategory, iError);

    errorCode = iError;
    return m_triggerMaskSet;

}
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 2339 of file L1GtUtils.cc.

References 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

const std::string L1GtUtils::EmptyString = "" [static, private]

Definition at line 277 of file L1GtUtils.h.

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

const int L1GtUtils::L1GtNotValidError = 99999 [static, private]

Definition at line 278 of file L1GtUtils.h.

Referenced by availableL1Configuration().

Definition at line 335 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), and retrieveL1EventSetup().

Definition at line 347 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), and retrieveL1GtTriggerMenuLite().

Definition at line 334 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), and retrieveL1EventSetup().

Definition at line 346 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), and retrieveL1GtTriggerMenuLite().

Definition at line 338 of file L1GtUtils.h.

Referenced by availableL1Configuration(), and retrieveL1EventSetup().

unsigned long long L1GtUtils::m_l1GtMenuCacheID [private]

Definition at line 332 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

prescale factors

Definition at line 302 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned long long L1GtUtils::m_l1GtPfAlgoCacheID [private]

Definition at line 303 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

Definition at line 305 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned long long L1GtUtils::m_l1GtPfTechCacheID [private]

Definition at line 306 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

event setup cached stuff

stable parameters

Definition at line 292 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned long long L1GtUtils::m_l1GtStableParCacheID [private]

Definition at line 293 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

trigger masks & veto masks

Definition at line 312 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned long long L1GtUtils::m_l1GtTmAlgoCacheID [private]

Definition at line 313 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

Definition at line 315 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned long long L1GtUtils::m_l1GtTmTechCacheID [private]

Definition at line 316 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

Definition at line 318 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned long long L1GtUtils::m_l1GtTmVetoAlgoCacheID [private]

Definition at line 319 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

Definition at line 321 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned long long L1GtUtils::m_l1GtTmVetoTechCacheID [private]

Definition at line 322 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned int L1GtUtils::m_numberAlgorithmTriggers [private]

number of algorithm triggers

Definition at line 296 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned int L1GtUtils::m_numberTechnicalTriggers [private]

number of technical triggers

Definition at line 299 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

unsigned int L1GtUtils::m_physicsDaqPartition [private]

index of physics DAQ partition

Definition at line 367 of file L1GtUtils.h.

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

const std::vector<std::vector<int> >* L1GtUtils::m_prescaleFactorsAlgoTrig [private]

Definition at line 308 of file L1GtUtils.h.

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

const std::vector<std::vector<int> >* L1GtUtils::m_prescaleFactorsAlgoTrigLite [private]

Definition at line 353 of file L1GtUtils.h.

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

std::vector<int> L1GtUtils::m_prescaleFactorSet [private]

Definition at line 370 of file L1GtUtils.h.

Referenced by prescaleFactorSet(), and retrieveL1EventSetup().

const std::vector<std::vector<int> >* L1GtUtils::m_prescaleFactorsTechTrig [private]

Definition at line 309 of file L1GtUtils.h.

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

const std::vector<std::vector<int> >* L1GtUtils::m_prescaleFactorsTechTrigLite [private]

Definition at line 354 of file L1GtUtils.h.

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

Definition at line 359 of file L1GtUtils.h.

Referenced by retrieveL1GtTriggerMenuLite().

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

Definition at line 373 of file L1GtUtils.h.

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

Definition at line 356 of file L1GtUtils.h.

Referenced by retrieveL1GtTriggerMenuLite().

Definition at line 336 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), and retrieveL1EventSetup().

Definition at line 348 of file L1GtUtils.h.

Referenced by l1AlgoTechTrigBitNumber(), and retrieveL1GtTriggerMenuLite().

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskAlgoTrig [private]

Definition at line 324 of file L1GtUtils.h.

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

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskAlgoTrigLite [private]

Definition at line 350 of file L1GtUtils.h.

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

std::vector<unsigned int> L1GtUtils::m_triggerMaskSet [private]

Definition at line 369 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup(), and triggerMaskSet().

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskTechTrig [private]

Definition at line 325 of file L1GtUtils.h.

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

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskTechTrigLite [private]

Definition at line 351 of file L1GtUtils.h.

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

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskVetoAlgoTrig [private]

Definition at line 327 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().

const std::vector<unsigned int>* L1GtUtils::m_triggerMaskVetoTechTrig [private]

Definition at line 328 of file L1GtUtils.h.

Referenced by retrieveL1EventSetup().