L1GtPsbWord.h

Go to the documentation of this file.

#ifndef L1GlobalTrigger_L1GtPsbWord_h
#define L1GlobalTrigger_L1GtPsbWord_h

// system include files
#include <boost/cstdint.hpp>
#include <iosfwd>

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

// forward declarations

// class declaration
class L1GtPsbWord
{

public:

    static const int NumberAData = 8;
    static const int NumberBData = 8;

public:
    L1GtPsbWord();    // empty constructor, all members set to zero;

    L1GtPsbWord(
        boost::uint16_t boardIdValue,
        int bxInEventValue,
        boost::uint16_t bxNrValue,
        boost::uint32_t eventNrValue,
        boost::uint16_t aDataValue[NumberAData],
        boost::uint16_t bDataValue[NumberBData],
        boost::uint16_t localBxNrValue
    );


    virtual ~L1GtPsbWord();

    bool operator==(const L1GtPsbWord&) const;

    bool operator!=(const L1GtPsbWord&) const;


public:

    inline const boost::uint16_t boardId() const
    {
        return m_boardId;
    }

    void setBoardId(boost::uint16_t boardIdValue)
    {
        m_boardId = boardIdValue;
    }

    void setBoardId(const boost::uint64_t& word64, int iWord);

    void setBoardIdWord64(boost::uint64_t& word64, int iWord);



    inline const int bxInEvent() const
    {
        return m_bxInEvent;
    }

    void setBxInEvent(int bxInEventValue)
    {
        m_bxInEvent = bxInEventValue;
    }

    void setBxInEvent(const boost::uint64_t& word64, int iWord);

    void setBxInEventWord64(boost::uint64_t& word64, int iWord);



    inline const boost::uint16_t bxNr() const
    {
        return m_bxNr;
    }

    void setBxNr(boost::uint16_t bxNrValue)
    {
        m_bxNr = bxNrValue;
    }

    void setBxNr(const boost::uint64_t& word64, int iWord);

    void setBxNrWord64(boost::uint64_t& word64, int iWord);



    inline const boost::uint32_t eventNr() const
    {
        return m_eventNr;
    }

    void setEventNr(boost::uint32_t eventNrValue)
    {
        m_eventNr = eventNrValue;
    }

    void setEventNr(const boost::uint64_t& word64, int iWord);

    void setEventNrWord64(boost::uint64_t& word64, int iWord);



    const boost::uint16_t aData(int iA) const;
    void setAData(boost::uint16_t aDataVal, int iA);

    void setAData(const boost::uint64_t& word64, int iWord);

    void setADataWord64(boost::uint64_t& word64, int iWord);



    const boost::uint16_t bData(int iB) const;
    void setBData(boost::uint16_t bDataVal, int iB);

    void setBData(const boost::uint64_t& word64, int iWord);

    void setBDataWord64(boost::uint64_t& word64, int iWord);



    inline const boost::uint16_t localBxNr() const
    {
        return m_localBxNr;
    }

    void setLocalBxNr(boost::uint16_t localBxNrValue)
    {
        m_localBxNr = localBxNrValue;
    }

    void setLocalBxNr(const boost::uint64_t& word64, int iWord);

    void setLocalBxNrWord64(boost::uint64_t& word64, int iWord);


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

        return BlockSize*unitLengthBits;
    }


public:

    void reset();

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

private:

    // block description in the raw GT record

    // block size in 64bits words (BlockSize * 64 bits)
    static const int BlockSize = 6;

    // word 0

    // index of the word in the PSB block containig the variable
    static const int BoardIdWord =   0;
    static const int BxInEventWord = 0;
    static const int BxNrWord =      0;
    static const int EventNrWord =   0;

    // mask to get the 64-bit-value from the corresponding word in the PSB block
    static const boost::uint64_t BoardIdMask =   0xFFFF000000000000ULL;
    static const boost::uint64_t BxInEventMask = 0x0000F00000000000ULL;
    static const boost::uint64_t BxNrMask =      0x00000FFF00000000ULL;
    static const boost::uint64_t EventNrMask =   0x0000000000FFFFFFULL;

    // shift to the right to get the value from the "64-bit-value"
    static const int BoardIdShift =   48;
    static const int BxInEventShift = 44;
    static const int BxNrShift =      32;
    static const int EventNrShift =    0;

    // assume uniform size od A_Data and B_Data
    static const int DataCHSize = 16; // bits
    static const boost::uint64_t DataCHMask = 0x000000000000FFFFULL;

    // word 1
    static const int ADataCH0Word =  1;

    // word 2
    static const int ADataCH4Word =  2;

    // word 3
    static const int BDataCH0Word =  3;

    // word 4
    static const int BDataCH4Word =  4;

    // word 5
    static const int LocalBxNrWord = 5;
    static const boost::uint64_t LocalBxNrMask =  0x0000000000000FFFULL;
    static const int LocalBxNrShift = 0;





private:

    // first number in the comment represents number of bits

    boost::uint16_t m_boardId;        // 16: board identifier
    //
    int m_bxInEvent;      //  4: bunch cross in the GT event record
    //     one keeps 3 bx (F, 0, 1) for standard record,
    //               5 bx (E, F, 0, 1) for debug record
    //
    boost::uint16_t m_bxNr;           // 12: bunch cross number of the actual bx
    boost::uint32_t m_eventNr;        // 24: event number since last L1 reset generated in PSB
    //
    boost::uint16_t m_aData[NumberAData];    // 16: A_Data_ChX
    //
    boost::uint16_t m_bData[NumberBData];    // 16: B_Data_ChX
    //
    boost::uint16_t m_localBxNr;      // 12: local bunch cross number of the actual bx
    //     bx number at which the data were written into the ringbuffer


};

#endif /*L1GlobalTrigger_L1GtPsbWord_h*/