/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/L1TriggerConfig/L1GtConfigProducers/interface/L1GtTriggerMenuXmlParser.h

Go to the documentation of this file.

#ifndef L1GtConfigProducers_L1GtTriggerMenuXmlParser_h
#define L1GtConfigProducers_L1GtTriggerMenuXmlParser_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 "CondFormats/L1TObjects/interface/L1GtTriggerMenuFwd.h"

#include "CondFormats/L1TObjects/interface/L1GtMuonTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtCaloTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtEnergySumTemplate.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 "CondFormats/L1TObjects/interface/L1GtCorrelationTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtBptxTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtExternalTemplate.h"

// forward declarations
class L1GtCondition;
class L1GtAlgorithm;

// class declaration
class L1GtTriggerMenuXmlParser : public L1GtXmlParserTags
{

public:

    L1GtTriggerMenuXmlParser();

    virtual ~L1GtTriggerMenuXmlParser();

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<L1GtMuonTemplate> >& vecMuonTemplate() const {
        return m_vecMuonTemplate;
    }
    void setVecMuonTemplate(const std::vector<std::vector<L1GtMuonTemplate> >&);

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

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

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

        return m_vecEnergySumTemplate;
    }

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

    //
    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<L1GtCorrelationTemplate> >& vecCorrelationTemplate() const {

        return m_vecCorrelationTemplate;
    }

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

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

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

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

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

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

        return m_corEnergySumTemplate;
    }

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

    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 getXMLHexTextValue128(XERCES_CPP_NAMESPACE::DOMNode* node,
            boost::uint64_t& dstL, boost::uint64_t& dstH);

    bool getXMLHexTextValue(XERCES_CPP_NAMESPACE::DOMNode* node,
            boost::uint64_t& dst);

    bool countConditionChildMaxBits(XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& childName, unsigned int& dst);

    bool getConditionChildValues(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(L1GtCondition& cond, const int chipNr);

    bool insertAlgorithmIntoMap(const L1GtAlgorithm& alg);

    bool insertTechTriggerIntoMap(const L1GtAlgorithm& alg);

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

    bool parseMuon(XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& name, 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 parseEnergySum(XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& name, 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 workCondition(XERCES_CPP_NAMESPACE::DOMNode* node,
            const std::string& name, unsigned int chipNr);

    bool parseConditions(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);

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

    bool parseAlgorithms(XERCES_CPP_NAMESPACE::XercesDOMParser* parser);

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

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<L1GtMuonTemplate> > m_vecMuonTemplate;
    std::vector<std::vector<L1GtCaloTemplate> > m_vecCaloTemplate;
    std::vector<std::vector<L1GtEnergySumTemplate> > 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<L1GtCorrelationTemplate> > m_vecCorrelationTemplate;
    std::vector<std::vector<L1GtMuonTemplate> > m_corMuonTemplate;
    std::vector<std::vector<L1GtCaloTemplate> > m_corCaloTemplate;
    std::vector<std::vector<L1GtEnergySumTemplate> > m_corEnergySumTemplate;

    AlgorithmMap m_algorithmMap;

    AlgorithmMap m_algorithmAliasMap;

    AlgorithmMap m_technicalTriggerMap;

};

#endif /*L1GtConfigProducers_L1GtTriggerMenuXmlParser_h*/