TriggerMenuParser.h

Go to the documentation of this file.

#ifndef L1TGlobal_TriggerMenuParser_h
#define L1TGlobal_TriggerMenuParser_h

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

#include "L1Trigger/L1TGlobal/interface/TriggerMenuFwd.h"

#include "L1Trigger/L1TGlobal/interface/MuonTemplate.h"
#include "L1Trigger/L1TGlobal/interface/CaloTemplate.h"
#include "L1Trigger/L1TGlobal/interface/EnergySumTemplate.h"
#include "L1Trigger/L1TGlobal/interface/CorrelationTemplate.h"
#include "L1Trigger/L1TGlobal/interface/CorrelationWithOverlapRemovalTemplate.h"
#include "L1Trigger/L1TGlobal/interface/ExternalTemplate.h"

#include "L1Trigger/L1TGlobal/interface/GlobalScales.h"

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

#include "tmEventSetup/esTriggerMenu.hh"
#include "tmEventSetup/esAlgorithm.hh"
#include "tmEventSetup/esCondition.hh"
#include "tmEventSetup/esObject.hh"
#include "tmEventSetup/esCut.hh"
#include "tmEventSetup/esScale.hh"

// forward declarations
class GlobalCondition;
class GlobalAlgorithm;

namespace l1t {


typedef enum { COS, SIN } TrigFunc_t;

// class declaration
class TriggerMenuParser
{


public:

    TriggerMenuParser();

    virtual ~TriggerMenuParser();

public:


    inline const unsigned int gtNumberConditionChips() const {
        return m_numberConditionChips;
    }

    void setGtNumberConditionChips(const unsigned int&);

    inline const unsigned int gtPinsOnConditionChip() const {
        return m_pinsOnConditionChip;
    }

    void setGtPinsOnConditionChip(const unsigned int&);

    inline std::vector<int> gtOrderConditionChip() const {
        return m_orderConditionChip;
    }

    void setGtOrderConditionChip(const std::vector<int>&);

    inline const unsigned int gtNumberPhysTriggers() const {
        return m_numberPhysTriggers;
    }

    void setGtNumberPhysTriggers(const unsigned int&);



public:

    inline const std::vector<ConditionMap>& gtConditionMap() const {
        return m_conditionMap;
    }

    void setGtConditionMap(const std::vector<ConditionMap>&);

    inline const std::string& gtTriggerMenuInterface() const {
        return m_triggerMenuInterface;
    }

    void setGtTriggerMenuInterface(const std::string&);

    //
    inline const std::string& gtTriggerMenuName() const {
        return m_triggerMenuName;
    }

    void setGtTriggerMenuName(const std::string&);

    //
    inline const unsigned long gtTriggerMenuImplementation() const {
        return m_triggerMenuImplementation;
    }

    void setGtTriggerMenuImplementation(const unsigned long&);

    inline const std::string& gtScaleDbKey() const {
        return m_scaleDbKey;
    }

    inline const GlobalScales& gtScales() const {
        return m_gtScales;
    }

    void setGtScaleDbKey(const std::string&);

    inline const std::vector<std::vector<MuonTemplate> >& vecMuonTemplate() const {
        return m_vecMuonTemplate;
    }
    void setVecMuonTemplate(const std::vector<std::vector<MuonTemplate> >&);

    //
    inline const std::vector<std::vector<CaloTemplate> >& vecCaloTemplate() const {
        return m_vecCaloTemplate;
    }

    void setVecCaloTemplate(const std::vector<std::vector<CaloTemplate> >&);

    //
    inline const std::vector<std::vector<EnergySumTemplate> >& vecEnergySumTemplate() const {

        return m_vecEnergySumTemplate;
    }

    void setVecEnergySumTemplate(
            const std::vector<std::vector<EnergySumTemplate> >&);

    //

    inline const std::vector<std::vector<ExternalTemplate> >&
        vecExternalTemplate() const {

        return m_vecExternalTemplate;
    }

    void setVecExternalTemplate(
            const std::vector<std::vector<ExternalTemplate> >&);

    //
    inline const std::vector<std::vector<CorrelationTemplate> >& vecCorrelationTemplate() const {

        return m_vecCorrelationTemplate;
    }

    void setVecCorrelationTemplate(
            const std::vector<std::vector<CorrelationTemplate> >&);

    inline const std::vector<std::vector<CorrelationWithOverlapRemovalTemplate> >& vecCorrelationWithOverlapRemovalTemplate() const {

        return m_vecCorrelationWithOverlapRemovalTemplate;
    }

    void setVecCorrelationWithOverlapRemovalTemplate(
            const std::vector<std::vector<CorrelationWithOverlapRemovalTemplate> >&);

    // get / set the vectors containing the conditions for correlation templates
    //
    inline const std::vector<std::vector<MuonTemplate> >& corMuonTemplate() const {
        return m_corMuonTemplate;
    }

    void setCorMuonTemplate(const std::vector<std::vector<MuonTemplate> >&);

    //
    inline const std::vector<std::vector<CaloTemplate> >& corCaloTemplate() const {
        return m_corCaloTemplate;
    }

    void setCorCaloTemplate(const std::vector<std::vector<CaloTemplate> >&);

    //
    inline const std::vector<std::vector<EnergySumTemplate> >& corEnergySumTemplate() const {

        return m_corEnergySumTemplate;
    }

    void setCorEnergySumTemplate(
            const std::vector<std::vector<EnergySumTemplate> >&);

    inline const AlgorithmMap& gtAlgorithmMap() const {
        return m_algorithmMap;
    }

    void setGtAlgorithmMap(const AlgorithmMap&);

    inline const AlgorithmMap& gtAlgorithmAliasMap() const {
        return m_algorithmAliasMap;
    }

    void setGtAlgorithmAliasMap(const AlgorithmMap&);


public:


    void parseCondFormats(const L1TUtmTriggerMenu* utmMenu);


    std::map<std::string, unsigned int> getExternalSignals(const L1TUtmTriggerMenu* utmMenu);

public:

    inline const std::string& gtTriggerMenuInterfaceDate() const {
        return m_triggerMenuInterfaceDate;
    }

    void setGtTriggerMenuInterfaceDate(const std::string&);

    inline const std::string& gtTriggerMenuInterfaceAuthor() const {
        return m_triggerMenuInterfaceAuthor;
    }

    void setGtTriggerMenuInterfaceAuthor(const std::string&);

    inline const std::string& gtTriggerMenuInterfaceDescription() const {
        return m_triggerMenuInterfaceDescription;
    }

    void setGtTriggerMenuInterfaceDescription(const std::string&);

    //

    inline const int gtTriggerMenuUUID() const {
        return m_triggerMenuUUID;
    }

    void setGtTriggerMenuUUID(const int);

    inline const std::string& gtTriggerMenuDate() const {
        return m_triggerMenuDate;
    }

    void setGtTriggerMenuDate(const std::string&);

    inline const std::string& gtTriggerMenuAuthor() const {
        return m_triggerMenuAuthor;
    }

    void setGtTriggerMenuAuthor(const std::string&);

    inline const std::string& gtTriggerMenuDescription() const {
        return m_triggerMenuDescription;
    }

    void setGtTriggerMenuDescription(const std::string&);


    inline const std::string& gtAlgorithmImplementation() const {
        return m_algorithmImplementation;
    }

    void setGtAlgorithmImplementation(const std::string&);


private:

    // methods for conditions and algorithms

    void clearMaps();

    bool insertConditionIntoMap(GlobalCondition& cond, const int chipNr);

    bool insertAlgorithmIntoMap(const GlobalAlgorithm& alg);

    template <typename T> std::string l1t2string( T );
    int l1tstr2int( const std::string data );


/*     bool parseScale(tmeventsetup::esScale scale); */
//    bool parseScales( tmeventsetup::esScale scale);
    bool parseScales(std::map<std::string, tmeventsetup::esScale> scaleMap);


/*     bool parseMuon(XERCES_CPP_NAMESPACE::DOMNode* node, */
/*             const std::string& name, unsigned int chipNr = 0, */
/*             const bool corrFlag = false); */
    bool parseMuon( tmeventsetup::esCondition condMu,
            unsigned int chipNr = 0, const bool corrFlag = false);

    bool parseMuonCorr(const tmeventsetup::esObject* condMu,
             unsigned int chipNr = 0);


/*     bool parseCalo(XERCES_CPP_NAMESPACE::DOMNode* node, */
/*             const std::string& name, unsigned int chipNr = 0, */
/*             const bool corrFlag = false); */
    bool parseCalo( tmeventsetup::esCondition condCalo,
            unsigned int chipNr = 0, const bool corrFlag = false);

    bool parseCaloCorr(const tmeventsetup::esObject* corrCalo,
            unsigned int chipNr = 0);

    /* bool parseEnergySum(XERCES_CPP_NAMESPACE::DOMNode* node, */
    /*         const std::string& name, unsigned int chipNr = 0, */
    /*         const bool corrFlag = false); */

    bool parseEnergySum( tmeventsetup::esCondition condEnergySums,
            unsigned int chipNr = 0, const bool corrFlag = false);


    bool parseEnergySumCorr(const tmeventsetup::esObject* corrESum,
            unsigned int chipNr = 0);


      bool parseExternal(tmeventsetup::esCondition condExt,
        unsigned int chipNr = 0);


    bool parseCorrelation(tmeventsetup::esCondition corrCond, unsigned int chipNr = 0);

    bool parseCorrelationWithOverlapRemoval(const tmeventsetup::esCondition& corrCond, unsigned int chipNr = 0);


    //bool parseAlgorithms(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);
    bool parseAlgorithm( tmeventsetup::esAlgorithm algorithm,
            unsigned int chipNr = 0 );

    // Parse LUT for Cal Mu Eta
    void parseCalMuEta_LUTS(std::map<std::string, tmeventsetup::esScale> scaleMap,
                std::string obj1, std::string obj2);


    // Parse LUT for Cal Mu Phi
    void parseCalMuPhi_LUTS(std::map<std::string, tmeventsetup::esScale> scaleMap,
                std::string obj1, std::string obj2);

    // Parse LUT for Pt LUT in Mass calculation
    void parsePt_LUTS(std::map<std::string, tmeventsetup::esScale> scaleMap,
                std::string lutpfx, std::string obj1, unsigned int prec);

    // Parse LUT for Delta Eta and Cosh
    void parseDeltaEta_Cosh_LUTS(std::map<std::string, tmeventsetup::esScale> scaleMap,
            std::string obj1, std::string obj2,
        unsigned int prec1, unsigned int prec2) ;

    // Parse LUT for Delta Eta and Cosh
    void parseDeltaPhi_Cos_LUTS(const std::map<std::string, tmeventsetup::esScale> & scaleMap,
            const std::string & obj1, const std::string & obj2,
        unsigned int prec1, unsigned int prec2) ;

    // Parse LUT for Sin(Phi),Cos(Phi) in TwoBodyPt algorithm calculation
    void parsePhi_Trig_LUTS(const std::map<std::string, tmeventsetup::esScale> & scaleMap,
            const std::string & obj, TrigFunc_t func,
        unsigned int prec) ;


private:



    unsigned int m_numberConditionChips;

    unsigned int m_pinsOnConditionChip;

    std::vector<int> m_orderConditionChip;

    unsigned int m_numberPhysTriggers;

    //unsigned int m_numberTechTriggers;


private:


    std::string m_triggerMenuInterfaceDate;
    std::string m_triggerMenuInterfaceAuthor;
    std::string m_triggerMenuInterfaceDescription;

    std::string m_triggerMenuDate;
    std::string m_triggerMenuAuthor;
    std::string m_triggerMenuDescription;

    std::string m_algorithmImplementation;


private:

    std::vector<ConditionMap> m_conditionMap;

private:

    std::string m_triggerMenuInterface;
    std::string m_triggerMenuName;
    unsigned long m_triggerMenuImplementation;
    unsigned long m_triggerMenuUUID;

    std::string m_scaleDbKey;

    std::vector<std::vector<MuonTemplate> > m_vecMuonTemplate;
    std::vector<std::vector<CaloTemplate> > m_vecCaloTemplate;
    std::vector<std::vector<EnergySumTemplate> > m_vecEnergySumTemplate;
    std::vector<std::vector<ExternalTemplate> > m_vecExternalTemplate;

    std::vector<std::vector<CorrelationTemplate> > m_vecCorrelationTemplate;
    std::vector<std::vector<CorrelationWithOverlapRemovalTemplate> > m_vecCorrelationWithOverlapRemovalTemplate;
    std::vector<std::vector<MuonTemplate> > m_corMuonTemplate;
    std::vector<std::vector<CaloTemplate> > m_corCaloTemplate;
    std::vector<std::vector<EnergySumTemplate> > m_corEnergySumTemplate;

    AlgorithmMap m_algorithmMap;

    AlgorithmMap m_algorithmAliasMap;

    // class containing the scales from the L1 Menu XML
    GlobalScales m_gtScales;

};

}
#endif /*L1TGlobal_TriggerMenuParser_h*/