L1GtUtils.h

Go to the documentation of this file.

#ifndef GlobalTriggerAnalyzer_L1GtUtils_h
#define GlobalTriggerAnalyzer_L1GtUtils_h

// system include files
#include <string>
#include <utility>

// user include files

#include "DataFormats/L1GlobalTrigger/interface/L1GtTriggerMenuLite.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/Run.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"

#include "CondFormats/L1TObjects/interface/L1GtTriggerMenuFwd.h"

// forward declarations
class L1GtStableParameters;
class L1GtPrescaleFactors;
class L1GtTriggerMask;
class L1GtTriggerMenu;

class L1GlobalTriggerReadoutRecord;
class L1GlobalTriggerRecord;

// class declaration

class L1GtUtils {

public:

    explicit L1GtUtils();

    virtual ~L1GtUtils();

public:

    enum TriggerCategory {
        AlgorithmTrigger = 0, TechnicalTrigger = 1
    };

    class LogicalExpressionL1Results {

    public:

        explicit LogicalExpressionL1Results(const std::string&, L1GtUtils&);

        explicit LogicalExpressionL1Results(const std::string&, L1GtUtils&,
                const edm::InputTag&, const edm::InputTag&);

        ~LogicalExpressionL1Results();

    public:

        inline bool isValid() {
            return m_validLogicalExpression;
        }

        const int logicalExpressionRunUpdate(const edm::Run&,
                const edm::EventSetup&, const std::string&);
        //
        const int logicalExpressionRunUpdate(const edm::Run&,
                const edm::EventSetup&);


        inline const std::vector<L1GtLogicParser::OperandToken>& expL1Triggers() {
            return m_expL1Triggers;
        }
        const std::vector<std::pair<std::string, bool> >& decisionsBeforeMask();
        const std::vector<std::pair<std::string, bool> >& decisionsAfterMask();
        const std::vector<std::pair<std::string, int> >& prescaleFactors();
        const std::vector<std::pair<std::string, int> >& triggerMasks();

        const std::vector<std::pair<std::string, int> >& errorCodes(
                const edm::Event&);

    private:

        bool initialize();

        void reset(const std::vector<std::pair<std::string, bool> >&) const;
        void reset(const std::vector<std::pair<std::string, int> >&) const;

        void
        l1Results(const edm::Event& iEvent,
                const edm::InputTag& l1GtRecordInputTag,
                const edm::InputTag& l1GtReadoutRecordInputTag);

    private:


        std::string m_logicalExpression;

        L1GtUtils& m_l1GtUtils;

        edm::InputTag m_l1GtRecordInputTag;
        edm::InputTag m_l1GtReadoutRecordInputTag;

    private:

        // private members

        int m_l1ConfCode;

        bool m_validL1Configuration;

        bool m_validLogicalExpression;

        bool m_l1GtInputTagsFromProv;

        bool m_l1ResultsAlreadyCalled;

        std::vector<L1GtLogicParser::OperandToken> m_expL1Triggers;
        size_t m_expL1TriggersSize;

        std::vector<L1GtUtils::TriggerCategory> m_expTriggerCategory;

        bool m_expBitsTechTrigger;

        std::vector<bool> m_expTriggerInMenu;

        std::vector<std::pair<std::string, bool> > m_decisionsBeforeMask;
        std::vector<std::pair<std::string, bool> > m_decisionsAfterMask;
        std::vector<std::pair<std::string, int> > m_prescaleFactors;
        std::vector<std::pair<std::string, int> > m_triggerMasks;
        std::vector<std::pair<std::string, int> > m_errorCodes;

    };

public:


    // enum to string for TriggerCategory
    const std::string triggerCategory(const TriggerCategory&) const;

    void retrieveL1EventSetup(const edm::EventSetup&);


    void retrieveL1GtTriggerMenuLite(const edm::Run&, const edm::InputTag&);


    void getL1GtRunCache(const edm::Run&, const edm::EventSetup&, const bool,
            const bool, const edm::InputTag&);
    void getL1GtRunCache(const edm::Run&, const edm::EventSetup&, const bool,
            const bool);

    void getL1GtRunCache(const edm::Event&, const edm::EventSetup&, const bool,
            const bool, const edm::InputTag&);
    void getL1GtRunCache(const edm::Event&, const edm::EventSetup&, const bool,
            const bool);

    void getL1GtRecordInputTag(const edm::Event& iEvent,
            edm::InputTag& l1GtRecordInputTag,
            edm::InputTag& l1GtReadoutRecordInputTag) const;

    void getL1GtTriggerMenuLiteInputTag(const edm::Run& iRun,
            edm::InputTag& l1GtTriggerMenuLiteInputTag) const;
    
    inline const edm::InputTag& provL1GtRecordInputTag() {
        return m_provL1GtRecordInputTag;
    }
    
    inline const edm::InputTag& provL1GtReadoutRecordInputTag() {
        return m_provL1GtReadoutRecordInputTag;
    }
    
    inline const edm::InputTag& provL1GtTriggerMenuLiteInputTag() {
        return m_provL1GtTriggerMenuLiteInputTag;
    }


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


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


    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 bool decisionBeforeMask(const edm::Event& iEvent,
            const edm::InputTag& l1GtRecordInputTag,
            const edm::InputTag& l1GtReadoutRecordInputTag,
            const std::string& nameAlgoTechTrig, int& errorCode) const;

    const bool decisionBeforeMask(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;

    const bool decisionAfterMask(const edm::Event& iEvent,
            const std::string& nameAlgoTechTrig, int& errorCode) 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 int prescaleFactor(const edm::Event& iEvent,
            const edm::InputTag& l1GtRecordInputTag,
            const edm::InputTag& l1GtReadoutRecordInputTag,
            const std::string& nameAlgoTechTrig, int& errorCode) const;

    const int prescaleFactor(const edm::Event& iEvent,
            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;

    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 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 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<unsigned int>& triggerMaskSet(
            const TriggerCategory& trigCategory, int& errorCode);


    const std::string& l1TriggerMenu() const;

    const std::string& l1TriggerMenuImplementation() const;

    const L1GtTriggerMenu* ptrL1TriggerMenuEventSetup(int& errorCode);

    const L1GtTriggerMenuLite* ptrL1GtTriggerMenuLite(int& errorCode);

    const bool availableL1Configuration(int& errorCode, int& l1ConfCode) const;

private:

    static const std::string EmptyString;
    static const int L1GtNotValidError;

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

private:


    const L1GtStableParameters* m_l1GtStablePar;
    unsigned long long m_l1GtStableParCacheID;

    unsigned int m_numberAlgorithmTriggers;

    unsigned int m_numberTechnicalTriggers;

    const L1GtPrescaleFactors* m_l1GtPfAlgo;
    unsigned long long m_l1GtPfAlgoCacheID;

    const L1GtPrescaleFactors* m_l1GtPfTech;
    unsigned long long m_l1GtPfTechCacheID;

    const std::vector<std::vector<int> >* m_prescaleFactorsAlgoTrig;
    const std::vector<std::vector<int> >* m_prescaleFactorsTechTrig;

    const L1GtTriggerMask* m_l1GtTmAlgo;
    unsigned long long m_l1GtTmAlgoCacheID;

    const L1GtTriggerMask* m_l1GtTmTech;
    unsigned long long m_l1GtTmTechCacheID;

    const L1GtTriggerMask* m_l1GtTmVetoAlgo;
    unsigned long long m_l1GtTmVetoAlgoCacheID;

    const L1GtTriggerMask* m_l1GtTmVetoTech;
    unsigned long long m_l1GtTmVetoTechCacheID;

    const std::vector<unsigned int>* m_triggerMaskAlgoTrig;
    const std::vector<unsigned int>* m_triggerMaskTechTrig;

    const std::vector<unsigned int>* m_triggerMaskVetoAlgoTrig;
    const std::vector<unsigned int>* m_triggerMaskVetoTechTrig;

    // trigger menu
    const L1GtTriggerMenu* m_l1GtMenu;
    unsigned long long m_l1GtMenuCacheID;

    const AlgorithmMap* m_algorithmMap;
    const AlgorithmMap* m_algorithmAliasMap;
    const AlgorithmMap* m_technicalTriggerMap;

    bool m_l1EventSetupValid;



    const L1GtTriggerMenuLite* m_l1GtMenuLite;

    const L1GtTriggerMenuLite::L1TriggerMap* m_algorithmMapLite;
    const L1GtTriggerMenuLite::L1TriggerMap* m_algorithmAliasMapLite;
    const L1GtTriggerMenuLite::L1TriggerMap* m_technicalTriggerMapLite;

    const std::vector<unsigned int>* m_triggerMaskAlgoTrigLite;
    const std::vector<unsigned int>* m_triggerMaskTechTrigLite;

    const std::vector<std::vector<int> >* m_prescaleFactorsAlgoTrigLite;
    const std::vector<std::vector<int> >* m_prescaleFactorsTechTrigLite;

    bool m_l1GtMenuLiteValid;

    bool m_beginRunCache;


    mutable edm::InputTag m_provL1GtRecordInputTag;
    mutable edm::InputTag m_provL1GtReadoutRecordInputTag;
    mutable edm::InputTag m_provL1GtTriggerMenuLiteInputTag;
    
    edm::RunID m_runIDCache;
    edm::RunID m_provRunIDCache;


private:

    unsigned int m_physicsDaqPartition;

    std::vector<unsigned int> m_triggerMaskSet;
    std::vector<int> m_prescaleFactorSet;

    bool m_retrieveL1EventSetup;
    bool m_retrieveL1GtTriggerMenuLite;

};

#endif /*GlobalTriggerAnalyzer_L1GtUtils_h*/