GlobalObjectMap.h

Go to the documentation of this file.

#ifndef L1GlobalTrigger_L1TGtObjectMap_h
#define L1GlobalTrigger_L1TGtObjectMap_h

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

#include <iosfwd>

// user include files
#include "DataFormats/L1TGlobal/interface/GlobalObjectMapFwd.h"

#include "DataFormats/L1TGlobal/interface/GlobalLogicParser.h"

// forward declarations

// class declaration
class GlobalObjectMap
{
public:

  GlobalObjectMap(){}

  //~GlobalObjectMap(){}

public:

    inline const std::string & algoName() const
    {
        return m_algoName;
    }

    void setAlgoName(const std::string& algoNameValue) {
        m_algoName = algoNameValue;
    }

    inline int algoBitNumber() const
    {
        return m_algoBitNumber;
    }

    void setAlgoBitNumber(int algoBitNumberValue)
    {
        m_algoBitNumber = algoBitNumberValue;
    }

    inline bool algoGtlResult() const {
        return m_algoGtlResult;
    }

    void setAlgoGtlResult(bool algoGtlResultValue) {
        m_algoGtlResult = algoGtlResultValue;
    }

    inline const std::vector<CombinationsInCond>& combinationVector() const
    {
        return m_combinationVector;
    }

    void setCombinationVector(const std::vector<CombinationsInCond>& combinationVectorValue) {
        m_combinationVector = combinationVectorValue;
    }
    void swapCombinationVector(std::vector<CombinationsInCond>& combinationVectorValue) {
      m_combinationVector.swap(combinationVectorValue);
    }

    inline const std::vector<GlobalLogicParser::OperandToken>& operandTokenVector() const {
        return m_operandTokenVector;
    }
    
    void setOperandTokenVector(const std::vector<GlobalLogicParser::OperandToken>& operandTokenVectorValue) {
        m_operandTokenVector = operandTokenVectorValue;
    }
    void swapOperandTokenVector(std::vector<GlobalLogicParser::OperandToken>& operandTokenVectorValue) {
      m_operandTokenVector.swap(operandTokenVectorValue);
    }


    inline const std::vector<L1TObjectTypeInCond>& objectTypeVector() const {
        return m_objectTypeVector;
    }
    void setObjectTypeVector(const std::vector<L1TObjectTypeInCond>& objectTypeVectorValue) {
        m_objectTypeVector = objectTypeVectorValue;
    }
    void swapObjectTypeVector(std::vector<L1TObjectTypeInCond>& objectTypeVectorValue) {
      m_objectTypeVector.swap(objectTypeVectorValue);
    }
    
public:

    const CombinationsInCond* getCombinationsInCond(const std::string& condNameVal) const;

    const CombinationsInCond* getCombinationsInCond(const int condNumberVal) const;

    const bool getConditionResult(const std::string& condNameVal) const;

public:

    void reset();
    
    void print(std::ostream& myCout) const;
    
private:

    // name of the algorithm
    std::string m_algoName;

    // bit number for algorithm
    int m_algoBitNumber;

    // GTL result of the algorithm
    bool m_algoGtlResult;

    std::vector<GlobalLogicParser::OperandToken> m_operandTokenVector;
    
    // vector of combinations for all conditions in an algorithm
    std::vector<CombinationsInCond> m_combinationVector;

    // vector of object type vectors for all conditions in an algorithm
    std::vector<L1TObjectTypeInCond> m_objectTypeVector;

};

#endif /* L1GlobalTrigger_L1TGtObjectMap_h */