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/MuonShowerTemplate.h"
#include "L1Trigger/L1TGlobal/interface/CaloTemplate.h"
#include "L1Trigger/L1TGlobal/interface/EnergySumTemplate.h"
#include "L1Trigger/L1TGlobal/interface/CorrelationTemplate.h"
#include "L1Trigger/L1TGlobal/interface/CorrelationThreeBodyTemplate.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<MuonShowerTemplate> >& vecMuonShowerTemplate() const {
      return m_vecMuonShowerTemplate;
    }
    void setVecMuonShowerTemplate(const std::vector<std::vector<MuonShowerTemplate> >&);

    //
    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<CorrelationThreeBodyTemplate> >& vecCorrelationThreeBodyTemplate() const {
      return m_vecCorrelationThreeBodyTemplate;
    }

    void setVecCorrelationThreeBodyTemplate(const std::vector<std::vector<CorrelationThreeBodyTemplate> >&);

    //
    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 parseMuonShower(tmeventsetup::esCondition condMu, unsigned int chipNr = 0, const bool corrFlag = false);

    /*     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 parseCorrelationThreeBody(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 Upt LUT in Mass calculation for displaced muons
    void parseUpt_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<MuonShowerTemplate> > m_vecMuonShowerTemplate;
    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<CorrelationThreeBodyTemplate> > m_vecCorrelationThreeBodyTemplate;
    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;
  };

}  // namespace l1t
#endif /*L1TGlobal_TriggerMenuParser_h*/