GlobalAlgorithm.h

Go to the documentation of this file.

#ifndef L1Trigger_L1TGlobal_GtAlgorithm_h
#define L1Trigger_L1TGlobal_GtAlgorithm_h

// system include files
#include "CondFormats/Serialization/interface/Serializable.h"

#include <vector>
#include <iosfwd>

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

// forward declarations

// class declaration
class GlobalAlgorithm
{

public:

    GlobalAlgorithm();

    GlobalAlgorithm(const std::string& algoNameValue);

    GlobalAlgorithm(const std::string&, const std::string&);

    GlobalAlgorithm(const std::string&, const std::string&, const int);

    virtual ~GlobalAlgorithm();

public:

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

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

    inline std::string const & algoAlias() const
    {
        return m_algoAlias;
    }

    inline void setAlgoAlias(const std::string& algoAliasValue)
    {
        m_algoAlias = algoAliasValue;
    }

    inline std::string const & algoLogicalExpression() const
    {
        return m_algoLogicalExpression;
    }

    inline void setAlgoLogicalExpresssion(const std::string& logicalExpression)
    {
        m_algoLogicalExpression = logicalExpression;
    }

    inline const std::vector<GlobalLogicParser::TokenRPN>& algoRpnVector() const {
        return m_algoRpnVector;
    }

    inline int algoBitNumber() const
    {
        return m_algoBitNumber;
    }

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

    inline const int algoChipNumber() const
    {
        return m_algoChipNumber;
    }

    inline void setAlgoChipNumber(const int algoChipNumberValue)
    {
        m_algoChipNumber = algoChipNumberValue;
    }


public:

    const int algoChipNumber(const int numberConditionChips,
                         const int pinsOnConditionChip,
                         const std::vector<int>& orderConditionChip) const;

    const int algoOutputPin(const int numberConditionChips,
                            const int pinsOnConditionChip,
                            const std::vector<int>& orderConditionChip) const;

    virtual void print(std::ostream& myCout) const;

    friend std::ostream& operator<<(std::ostream&, const GlobalAlgorithm&);


private:

    std::string m_algoName;

    std::string m_algoAlias;

    std::string m_algoLogicalExpression;

    std::vector<GlobalLogicParser::TokenRPN> m_algoRpnVector;

    int m_algoBitNumber;

    int m_algoChipNumber;


    COND_SERIALIZABLE;
};

#endif /*L1Trigger_L1TGlobal_GtAlgorithm_h*/