L1GtFdlWord.h

Go to the documentation of this file.

#ifndef L1GlobalTrigger_L1GtFdlWord_h
#define L1GlobalTrigger_L1GtFdlWord_h

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

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

// forward declarations

// class interface

class L1GtFdlWord
{

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

    // constructor from unpacked values;
    L1GtFdlWord(
        boost::uint16_t boardIdValue,
        int bxInEventValue,
        boost::uint16_t bxNrValue,
        boost::uint32_t eventNrValue,
        TechnicalTriggerWord gtTechnicalTriggerWordValue,
        DecisionWord gtDecisionWordValue,
        DecisionWordExtended gtDecisionWordExtendedValue,
        boost::uint16_t gtPrescaleFactorIndexTechValue,
        boost::uint16_t gtPrescaleFactorIndexAlgoValue,
        boost::uint16_t noAlgoValue,
        boost::uint16_t finalORValue,
        boost::uint32_t orbitNrValue,
        boost::uint16_t lumiSegmentNrValue,
        boost::uint16_t localBxNrValue
    );


    virtual ~L1GtFdlWord();

    bool operator==(const L1GtFdlWord&) const;

    bool operator!=(const L1GtFdlWord&) const;

public:


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

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

    void setBoardId(const boost::uint64_t& word64);

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



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

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

    void setBxInEvent(const boost::uint64_t& word64);

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



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

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

    void setBxNr(const boost::uint64_t& word64);

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



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

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

    void setEventNr(const boost::uint64_t& word64);

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


    inline const TechnicalTriggerWord & gtTechnicalTriggerWord() const
    {
        return m_gtTechnicalTriggerWord;
    }

    void setGtTechnicalTriggerWord (const TechnicalTriggerWord& gtTechnicalTriggerWordValue)
    {
        m_gtTechnicalTriggerWord = gtTechnicalTriggerWordValue;
    }

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

    void setGtTechnicalTriggerWord(const boost::uint64_t& word64);

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



    inline const DecisionWord & gtDecisionWord() const
    {
        return m_gtDecisionWord;
    }

    void setGtDecisionWord(const DecisionWord& gtDecisionWordValue)
    {
        m_gtDecisionWord = gtDecisionWordValue;
    }

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

    void setGtDecisionWordA(const boost::uint64_t& word64);

    void setGtDecisionWordB(const boost::uint64_t& word64);

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

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


    inline const DecisionWordExtended & gtDecisionWordExtended() const
    {
        return m_gtDecisionWordExtended;
    }

    void setGtDecisionWordExtended (const DecisionWordExtended& gtDecisionWordExtendedValue)
    {
        m_gtDecisionWordExtended = gtDecisionWordExtendedValue;
    }

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

    void setGtDecisionWordExtended(const boost::uint64_t& word64);

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





    inline const boost::uint16_t physicsDeclared() const
    {
        return m_physicsDeclared;
    }

    void setPhysicsDeclared(const boost::uint16_t& physicsDeclaredValue)
    {
        m_physicsDeclared = physicsDeclaredValue;
    }

    void setPhysicsDeclared(const boost::uint64_t& word64);

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




    inline const boost::uint16_t gtPrescaleFactorIndexTech() const
    {
        return m_gtPrescaleFactorIndexTech;
    }

    void setGtPrescaleFactorIndexTech(const boost::uint16_t& gtPrescaleFactorIndexTechValue)
    {
        m_gtPrescaleFactorIndexTech = gtPrescaleFactorIndexTechValue;
    }

    void setGtPrescaleFactorIndexTech(const boost::uint64_t& word64);

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



    inline const boost::uint16_t gtPrescaleFactorIndexAlgo() const
    {
        return m_gtPrescaleFactorIndexAlgo;
    }

    void setGtPrescaleFactorIndexAlgo(const boost::uint16_t& gtPrescaleFactorIndexAlgoValue)
    {
        m_gtPrescaleFactorIndexAlgo = gtPrescaleFactorIndexAlgoValue;
    }

    void setGtPrescaleFactorIndexAlgo(const boost::uint64_t& word64);

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


    inline const boost::uint16_t noAlgo() const
    {
        return m_noAlgo;
    }

    void setNoAlgo(const boost::uint16_t& noAlgoValue)
    {
        m_noAlgo = noAlgoValue;
    }

    void setNoAlgo(const boost::uint64_t& word64);

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



    inline const boost::uint16_t finalOR() const
    {
        return m_finalOR;
    }

    void setFinalOR(const boost::uint16_t& finalORValue)
    {
        m_finalOR = finalORValue;
    }

    void setFinalOR(const boost::uint64_t& word64);

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



    inline const bool globalDecision() const
    {
        return static_cast<bool> (m_finalOR);
    }


    inline const boost::uint32_t orbitNr() const
    {
        return m_orbitNr;
    }

    void setOrbitNr(const boost::uint32_t& orbitNrValue)
    {
        m_orbitNr = orbitNrValue;
    }

    void setOrbitNr(const boost::uint64_t& word64);

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



    inline const boost::uint16_t lumiSegmentNr() const
    {
        return m_lumiSegmentNr;
    }

    void setLumiSegmentNr(const boost::uint16_t& lumiSegmentNrValue)
    {
        m_lumiSegmentNr = lumiSegmentNrValue;
    }

    void setLumiSegmentNr(const boost::uint64_t& word64);

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



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

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

    void setLocalBxNr(const boost::uint64_t& word64);

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



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

        return BlockSize*unitLengthBits;
    }

public:

    void reset();

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

    void unpack(const unsigned char* fdlPtr);

private:

    // block description in the raw GT record

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

    // word 0

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

    // mask to get the 64-bit-value from the corresponding word in the FDL block
    static const boost::uint64_t BoardIdMask;
    static const boost::uint64_t BxInEventMask;
    static const boost::uint64_t BxNrMask;
    static const boost::uint64_t EventNrMask;

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

    // word 1

    static const int GtTechnicalTriggerWordWord;
    static const boost::uint64_t GtTechnicalTriggerWordMask;
    static const int GtTechnicalTriggerWordShift;

    // word 2 - WordA: bits 0-63

    static const int GtDecisionWordAWord;
    static const boost::uint64_t GtDecisionWordAMask;
    static const int GtDecisionWordAShift;

    // word 3 - WordB: bits 64-128

    static const int GtDecisionWordBWord;
    static const boost::uint64_t GtDecisionWordBMask;
    static const int GtDecisionWordBShift;


    // word 4
    static const int GtDecisionWordExtendedWord;
    static const boost::uint64_t GtDecisionWordExtendedMask;
    static const int GtDecisionWordExtendedShift;

    // word 5
    static const int PhysicsDeclaredWord;
    static const int GtPrescaleFactorIndexTechWord;
    static const int GtPrescaleFactorIndexAlgoWord;
    static const int NoAlgoWord;
    static const int FinalORWord;

    static const boost::uint64_t PhysicsDeclaredMask;
    static const boost::uint64_t GtPrescaleFactorIndexTechMask;
    static const boost::uint64_t GtPrescaleFactorIndexAlgoMask;
    static const boost::uint64_t NoAlgoMask;
    static const boost::uint64_t FinalORMask;

    static const int PhysicsDeclaredShift;
    static const int GtPrescaleFactorIndexTechShift;
    static const int GtPrescaleFactorIndexAlgoShift;
    static const int NoAlgoShift;
    static const int FinalORShift;

    // word 6
    static const int OrbitNrWord;
    static const int LumiSegmentNrWord;
    static const int LocalBxNrWord;

    static const boost::uint64_t OrbitNrMask;
    static const boost::uint64_t LumiSegmentNrMask;
    static const boost::uint64_t LocalBxNrMask;

    static const int OrbitNrShift;
    static const int LumiSegmentNrShift;
    static const int LocalBxNrShift;

private:


    boost::uint16_t m_boardId;

    int m_bxInEvent;

    boost::uint16_t m_bxNr;

    boost::uint32_t m_eventNr;

    //

    TechnicalTriggerWord m_gtTechnicalTriggerWord;

    DecisionWord m_gtDecisionWord;

    DecisionWordExtended m_gtDecisionWordExtended;

    //
    boost::uint16_t m_physicsDeclared;

    boost::uint16_t m_gtPrescaleFactorIndexTech;
    boost::uint16_t m_gtPrescaleFactorIndexAlgo;

    boost::uint16_t m_noAlgo;

    boost::uint16_t m_finalOR;

    //

    boost::uint32_t m_orbitNr;

    boost::uint16_t m_lumiSegmentNr;

    boost::uint16_t m_localBxNr;



};

#endif /*L1GlobalTrigger_L1GtFdlWord_h*/