TriggerMenuXmlParser.h

Go to the documentation of this file.

#ifndef L1TGlobal_TriggerMenuXmlParser_h
#define L1TGlobal_TriggerMenuXmlParser_h

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

#include <boost/cstdint.hpp>

#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>

// user include files
// base class
#include "L1TriggerConfig/L1GtConfigProducers/interface/L1GtXmlParserTags.h"

#include "CondFormats/L1TObjects/interface/L1GtFwd.h"
#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 "CondFormats/L1TObjects/interface/L1GtJetCountsTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtCastorTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtHfBitCountsTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtHfRingEtSumsTemplate.h"
#include "L1Trigger/L1TGlobal/interface/CorrelationTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtBptxTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtExternalTemplate.h"

#include "L1Trigger/L1TGlobal/src/L1TMenuEditor/L1TriggerMenu.hxx"


// forward declarations
class GtCondition;
class L1GtAlgorithm;

namespace l1t {

// class declaration
class TriggerMenuXmlParser : public L1GtXmlParserTags
{

public:

    TriggerMenuXmlParser();

    virtual ~TriggerMenuXmlParser();

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

    inline const unsigned int gtNumberTechTriggers() const {
        return m_numberTechTriggers;
    }

    void setGtNumberTechTriggers(const unsigned int&);

    inline const unsigned int gtNumberL1JetCounts() const {
        return m_numberL1JetCounts;
    }

    void setGtNumberL1JetCounts(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 std::string& gtTriggerMenuImplementation() const {
        return m_triggerMenuImplementation;
    }

    void setGtTriggerMenuImplementation(const std::string&);

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

    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<L1GtJetCountsTemplate> >& vecJetCountsTemplate() const {

        return m_vecJetCountsTemplate;
    }

    void setVecJetCountsTemplate(
            const std::vector<std::vector<L1GtJetCountsTemplate> >&);

    //
    inline const std::vector<std::vector<L1GtCastorTemplate> >& vecCastorTemplate() const {

        return m_vecCastorTemplate;
    }

    void setVecCastorTemplate(
            const std::vector<std::vector<L1GtCastorTemplate> >&);

    //
    inline const std::vector<std::vector<L1GtHfBitCountsTemplate> >&
        vecHfBitCountsTemplate() const {

        return m_vecHfBitCountsTemplate;
    }

    void setVecHfBitCountsTemplate(
            const std::vector<std::vector<L1GtHfBitCountsTemplate> >&);

    //
    inline const std::vector<std::vector<L1GtHfRingEtSumsTemplate> >&
        vecHfRingEtSumsTemplate() const {

        return m_vecHfRingEtSumsTemplate;
    }

    void setVecHfRingEtSumsTemplate(
            const std::vector<std::vector<L1GtHfRingEtSumsTemplate> >&);

    //
    inline const std::vector<std::vector<L1GtBptxTemplate> >&
        vecBptxTemplate() const {

        return m_vecBptxTemplate;
    }

    void setVecBptxTemplate(
            const std::vector<std::vector<L1GtBptxTemplate> >&);

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

        return m_vecExternalTemplate;
    }

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

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

        return m_vecCorrelationTemplate;
    }

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

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

    inline const AlgorithmMap& gtTechnicalTriggerMap() const {
        return m_technicalTriggerMap;
    }

    void setGtTechnicalTriggerMap(const AlgorithmMap&);

public:

    void parseXmlFile(const std::string& defXmlFile,
            const std::string& vmeXmlFile);

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 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:

    // XML methods

    XERCES_CPP_NAMESPACE::XercesDOMParser* initXML(const std::string& xmlFile);

    XERCES_CPP_NAMESPACE::DOMNode* findXMLChild(
            XERCES_CPP_NAMESPACE::DOMNode* startChild,
            const std::string& tagName, bool beginOnly = false,
            std::string* rest = 0);

    std::string getXMLAttribute(const XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& name);

    std::string getXMLTextValue(XERCES_CPP_NAMESPACE::DOMNode* node);

    bool hexString2UInt128(const std::string& hexString, boost::uint64_t& dstL,
            boost::uint64_t& dstH);

    bool getXMLHexTextValue128Old(XERCES_CPP_NAMESPACE::DOMNode* node,
            boost::uint64_t& dstL, boost::uint64_t& dstH);
    bool getXMLHexTextValue128(const std::string& childName,
            boost::uint64_t& dstL, boost::uint64_t& dstH);

    bool getXMLHexTextValueOld(XERCES_CPP_NAMESPACE::DOMNode* node,
            boost::uint64_t& dst);
    bool getXMLHexTextValue(const std::string& childName,
            boost::uint64_t& dst);

    bool countConditionChildMaxBits(const std::string& childName, 
        unsigned int& dst);

    bool getConditionChildValuesOld(XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& childName, unsigned int num,
            std::vector<boost::uint64_t>& dst);

    void cleanupXML(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);


private:

    // methods for the VME file

    bool parseVmeXML(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);

private:

    // methods for conditions and algorithms

    void clearMaps();

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

    bool insertAlgorithmIntoMap(const L1GtAlgorithm& alg);

    bool insertTechTriggerIntoMap(const L1GtAlgorithm& alg);

    l1t::GtConditionType getTypeFromType(const std::string& type);

    int getNumFromType(const std::string& type);

    int getBitFromNode(XERCES_CPP_NAMESPACE::DOMNode* node);

    int getGEqFlag(XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& nodeName);

    bool getMuonMipIsoBits(XERCES_CPP_NAMESPACE::DOMNode* node,
            unsigned int num, std::vector<bool>& mipDst,
            std::vector<bool>& isoEnDst, std::vector<bool>& isoReqDst);

    template <typename T> std::string l1t2string( T );
    std::string l1tDateTime2string( l1t::DateTime );
    int l1t2int( l1t::RelativeBx );

/*     bool parseMuon(XERCES_CPP_NAMESPACE::DOMNode* node, */
/*             const std::string& name, unsigned int chipNr = 0, */
/*             const bool corrFlag = false); */
    bool parseMuon( l1t::MuonCondition 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( l1t::CalorimeterCondition condCalo,
            unsigned int chipNr = 0, const bool corrFlag = false);

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

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

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

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

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

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

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

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

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

    //bool parseId(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);
    bool parseId( std::auto_ptr<l1t::L1TriggerMenu> tm );
    bool parseId( l1t::Meta meta );

    bool workCondition(XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& name, unsigned int chipNr);

    //bool parseConditions(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);
    //bool parseConditions( std::auto_ptr<l1t::L1TriggerMenu> tm );
    bool parseConditions( l1t::ConditionList conditions );

/*     bool workAlgorithm(XERCES_CPP_NAMESPACE::DOMNode* node, */
/*             const std::string& name, unsigned int chipNr); */
    bool workAlgorithm( l1t::Algorithm algorithm, 
            unsigned int chipNr);

    //bool parseAlgorithms(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);
    bool parseAlgorithms( l1t::AlgorithmList algorithms );

    bool workTechTrigger(XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& name);

    bool parseTechTriggers(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);

    //bool workXML(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);
    bool workXML( std::auto_ptr<l1t::L1TriggerMenu> tm );

private:

    XERCES_CPP_NAMESPACE::ErrorHandler* m_xmlErrHandler;


    unsigned int m_numberConditionChips;

    unsigned int m_pinsOnConditionChip;

    std::vector<int> m_orderConditionChip;

    unsigned int m_numberPhysTriggers;

    unsigned int m_numberTechTriggers;

    unsigned int m_numberL1JetCounts;

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;
    std::string m_triggerMenuImplementation;

    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<L1GtJetCountsTemplate> > m_vecJetCountsTemplate;
    std::vector<std::vector<L1GtCastorTemplate> > m_vecCastorTemplate;
    std::vector<std::vector<L1GtHfBitCountsTemplate> > m_vecHfBitCountsTemplate;
    std::vector<std::vector<L1GtHfRingEtSumsTemplate> > m_vecHfRingEtSumsTemplate;
    std::vector<std::vector<L1GtBptxTemplate> > m_vecBptxTemplate;
    std::vector<std::vector<L1GtExternalTemplate> > m_vecExternalTemplate;

    std::vector<std::vector<CorrelationTemplate> > m_vecCorrelationTemplate;
    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;

    AlgorithmMap m_technicalTriggerMap;

};

}
#endif /*L1TGlobal_TriggerMenuXmlParser_h*/