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