L1GtUtils.h

Go to the documentation of this file.

#ifndef GlobalTriggerAnalyzer_L1GtUtils_h
#define GlobalTriggerAnalyzer_L1GtUtils_h

// system include files
#include <memory>
#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"

#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtUtilsHelper.h"

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

class L1GlobalTriggerReadoutRecord;
class L1GlobalTriggerRecord;

// class declaration

class L1GtUtils {

public:

    // Using this constructor will require InputTags to be specified in the configuration
    L1GtUtils(edm::ParameterSet const& pset,
              edm::ConsumesCollector&& iC,
              bool useL1GtTriggerMenuLite);

    L1GtUtils(edm::ParameterSet const& pset,
              edm::ConsumesCollector& iC,
              bool useL1GtTriggerMenuLite);

    // Using this constructor will cause it to look for valid InputTags in
    // the following ways in the specified order until they are found.
    //   1. The configuration
    //   2. Search all products from the preferred input tags for the required type
    //   3. Search all products from any other process for the required type
    template <typename T>
    L1GtUtils(edm::ParameterSet const& pset,
              edm::ConsumesCollector&& iC,
              bool useL1GtTriggerMenuLite,
              T& module);

    template <typename T>
    L1GtUtils(edm::ParameterSet const& pset,
              edm::ConsumesCollector& iC,
              bool useL1GtTriggerMenuLite,
              T& module);

    // Using this constructor will cause it to look for valid InputTags in
    // the following ways in the specified order until they are found.
    //   1. The constructor arguments
    //   2. The configuration
    //   3. Search all products from the preferred input tags for the required type
    //   4. Search all products from any other process for the required type
    template <typename T>
    L1GtUtils(edm::ParameterSet const& pset,
              edm::ConsumesCollector&& iC,
              bool useL1GtTriggerMenuLite,
              T& module,
              edm::InputTag const& l1GtRecordInputTag,
              edm::InputTag const& l1GtReadoutRecordInputTag,
              edm::InputTag const& l1GtTriggerMenuLiteInputTag);

    template <typename T>
    L1GtUtils(edm::ParameterSet const& pset,
              edm::ConsumesCollector& iC,
              bool useL1GtTriggerMenuLite,
              T& module,
              edm::InputTag const& l1GtRecordInputTag,
              edm::InputTag const& l1GtReadoutRecordInputTag,
              edm::InputTag const& l1GtTriggerMenuLiteInputTag);

    virtual ~L1GtUtils();

    static void fillDescription(edm::ParameterSetDescription & desc) {
      L1GtUtilsHelper::fillDescription(desc);
    }

public:

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

    class LogicalExpressionL1Results {

    public:

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

        ~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);

    private:


        std::string m_logicalExpression;

        L1GtUtils& m_l1GtUtils;

    private:

        // private members

        int m_l1ConfCode;

        bool m_validL1Configuration;

        bool m_validLogicalExpression;

        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&);


    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 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 std::string& nameAlgoTechTrig,
                        bool& decisionBeforeMask, bool& decisionAfterMask,
                        int& prescaleFactor, int& triggerMask) const;


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

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

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

    const int triggerMask(const std::string& nameAlgoTechTrig, 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 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:

    L1GtUtils();


    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;

    edm::RunID m_runIDCache;

private:

    unsigned int m_physicsDaqPartition;

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

    bool m_retrieveL1EventSetup;
    bool m_retrieveL1GtTriggerMenuLite;

    std::unique_ptr<L1GtUtilsHelper> m_l1GtUtilsHelper;
};

template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset,
                     edm::ConsumesCollector&& iC,
                     bool useL1GtTriggerMenuLite,
                     T& module) :
    L1GtUtils(pset, iC, useL1GtTriggerMenuLite, module) { }

template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset,
                     edm::ConsumesCollector& iC,
                     bool useL1GtTriggerMenuLite,
                     T& module) :
    L1GtUtils() {
    m_l1GtUtilsHelper.reset(new L1GtUtilsHelper(pset,
                                                iC,
                                                useL1GtTriggerMenuLite,
                                                module));
}

template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset,
                     edm::ConsumesCollector&& iC,
                     bool useL1GtTriggerMenuLite,
                     T& module,
                     edm::InputTag const& l1GtRecordInputTag,
                     edm::InputTag const& l1GtReadoutRecordInputTag,
                     edm::InputTag const& l1GtTriggerMenuLiteInputTag) :
  L1GtUtils(pset, iC, useL1GtTriggerMenuLite, module, l1GtRecordInputTag,
            l1GtReadoutRecordInputTag, l1GtTriggerMenuLiteInputTag) { }

template <typename T>
L1GtUtils::L1GtUtils(edm::ParameterSet const& pset,
                     edm::ConsumesCollector& iC,
                     bool useL1GtTriggerMenuLite,
                     T& module,
                     edm::InputTag const& l1GtRecordInputTag,
                     edm::InputTag const& l1GtReadoutRecordInputTag,
                     edm::InputTag const& l1GtTriggerMenuLiteInputTag) :
    L1GtUtils() {
    m_l1GtUtilsHelper.reset(new L1GtUtilsHelper(pset,
                                                iC,
                                                useL1GtTriggerMenuLite,
                                                module,
                                                l1GtRecordInputTag,
                                                l1GtReadoutRecordInputTag,
                                                l1GtTriggerMenuLiteInputTag));
}

#endif /*GlobalTriggerAnalyzer_L1GtUtils_h*/