L1GtfeWord.h

Go to the documentation of this file.

#ifndef L1GlobalTrigger_L1GtfeWord_h
#define L1GlobalTrigger_L1GtfeWord_h

// system include files
#include <iosfwd>

// user include files
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetup.h"
#include "FWCore/Utilities/interface/typedefs.h"

// forward declarations

// class interface

class L1GtfeWord
{

public:

    L1GtfeWord();    // empty constructor, all members set to zero;

    L1GtfeWord(
        cms_uint16_t boardIdValue,
        cms_uint16_t recordLength1Value,
        cms_uint16_t recordLengthValue,
        cms_uint16_t bxNrValue,
        cms_uint32_t setupVersionValue,
        cms_uint16_t activeBoardsValue,
        cms_uint16_t altNrBxBoardValue,
        cms_uint32_t totalTriggerNrValue
    );


    virtual ~L1GtfeWord();

    bool operator==(const L1GtfeWord&) const;

    bool operator!=(const L1GtfeWord&) const;

public:


    inline const cms_uint16_t boardId() const
    {
        return m_boardId;
    }

    void setBoardId(cms_uint16_t boardIdValue)
    {
        m_boardId = boardIdValue;
    }

    void setBoardId(const cms_uint64_t& word64);

    void setBoardIdWord64(cms_uint64_t& word64, int iWord);


    inline const cms_uint16_t recordLength1() const
    {
        return m_recordLength1;
    }

    void setRecordLength1(cms_uint16_t recordLengthValue)
    {
        m_recordLength1 = recordLengthValue;
    }

    void setRecordLength1(const cms_uint64_t& word64);

    void setRecordLength1Word64(cms_uint64_t& word64, int iWord);



    inline const cms_uint16_t recordLength() const
    {
        return m_recordLength;
    }

    void setRecordLength(cms_uint16_t recordLengthValue)
    {
        m_recordLength = recordLengthValue;
    }

    void setRecordLength(const cms_uint64_t& word64);

    void setRecordLengthWord64(cms_uint64_t& word64, int iWord);


    inline const cms_uint16_t bxNr() const
    {
        return m_bxNr;
    }

    void setBxNr(cms_uint16_t bxNrValue)
    {
        m_bxNr = bxNrValue;
    }

    void setBxNr(const cms_uint64_t& word64);

    void setBxNrWord64(cms_uint64_t& word64, int iWord);


    inline const cms_uint32_t setupVersion() const
    {
        return m_setupVersion;
    }

    void setSetupVersion(cms_uint32_t setupVersionValue)
    {
        m_setupVersion = setupVersionValue;
    }

    void setSetupVersion(const cms_uint64_t& word64);

    void setSetupVersionWord64(cms_uint64_t& word64, int iWord);


    const int bstFlag() const;
    void setBstFlag(const int);


    inline const cms_uint16_t activeBoards() const
    {
        return m_activeBoards;
    }

    void setActiveBoards(cms_uint16_t activeBoardsValue)
    {
        m_activeBoards = activeBoardsValue;
    }

    void setActiveBoards(const cms_uint64_t& word64);

    void setActiveBoardsWord64(cms_uint64_t& word64, int iWord);

    void setActiveBoardsWord64(cms_uint64_t& word64, int iWord,
                               cms_int16_t activeBoardsValue);



    inline const cms_uint16_t altNrBxBoard() const
    {
        return m_altNrBxBoard;
    }

    void setAltNrBxBoard(cms_uint16_t altNrBxBoardValue)
    {
        m_altNrBxBoard = altNrBxBoardValue;
    }

    void setAltNrBxBoard(const cms_uint64_t& word64);

    void setAltNrBxBoardWord64(cms_uint64_t& word64, int iWord);

    void setAltNrBxBoardWord64(cms_uint64_t& word64, int iWord,
                               cms_int16_t altNrBxBoardValue);



    inline const cms_uint32_t totalTriggerNr() const
    {
        return m_totalTriggerNr;
    }

    void setTotalTriggerNr(cms_uint32_t totalTriggerNrValue)
    {
        m_totalTriggerNr = totalTriggerNrValue;
    }

    void setTotalTriggerNr(const cms_uint64_t& word64);

    void setTotalTriggerNrWord64(cms_uint64_t& word64, int iWord);


    inline const unsigned int getSize() const
    {
        int unitLengthBits = L1GlobalTriggerReadoutSetup::UnitLength;

        return BlockSize*unitLengthBits;
    }

public:

    virtual void reset();

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

    virtual void unpack(const unsigned char* gtfePtr);

private:

    // block description in the raw GT record

    // block size in 64bits words
    static const int BlockSize;

    static const int BoardIdWord;
    static const int RecordLength1Word;
    static const int RecordLengthWord;
    static const int BxNrWord;
    static const int SetupVersionWord;

    static const cms_uint64_t BoardIdMask;
    static const cms_uint64_t RecordLength1Mask;
    static const cms_uint64_t RecordLengthMask;
    static const cms_uint64_t BxNrMask;
    static const cms_uint64_t SetupVersionMask;

    static const cms_uint32_t BstFlagMask;

    // shifts could be computed from masks...
    static const int BoardIdShift;
    static const int RecordLength1Shift;
    static const int RecordLengthShift;
    static const int BxNrShift;
    static const int SetupVersionShift;

    //
    static const int ActiveBoardsWord;
    static const int AltNrBxBoardWord;
    static const int TotalTriggerNrWord;

    static const cms_uint64_t ActiveBoardsMask;
    static const cms_uint64_t AltNrBxBoardMask;
    static const cms_uint64_t TotalTriggerNrMask;

    static const int ActiveBoardsShift;
    static const int AltNrBxBoardShift;
    static const int TotalTriggerNrShift;


private:

    cms_uint16_t m_boardId;

    cms_uint16_t m_recordLength1;

    cms_uint16_t m_recordLength;

    cms_uint16_t m_bxNr;
    cms_uint32_t m_setupVersion;

    cms_uint16_t m_activeBoards;

    cms_uint16_t m_altNrBxBoard;

    cms_uint32_t m_totalTriggerNr;

};

#endif /*L1GlobalTrigger_L1GtfeWord_h*/