L1GtFdlWord.h

Go to the documentation of this file.

#ifndef L1GlobalTrigger_L1GtFdlWord_h
#define L1GlobalTrigger_L1GtFdlWord_h

// system include files

// 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 L1GtFdlWord {
public:
  L1GtFdlWord();  // empty constructor, all members set to zero;

  // constructor from unpacked values;
  L1GtFdlWord(cms_uint16_t boardIdValue,
              int bxInEventValue,
              cms_uint16_t bxNrValue,
              cms_uint32_t eventNrValue,
              const TechnicalTriggerWord& gtTechnicalTriggerWordValue,
              const DecisionWord& gtDecisionWordValue,
              const DecisionWordExtended& gtDecisionWordExtendedValue,
              cms_uint16_t gtPrescaleFactorIndexTechValue,
              cms_uint16_t gtPrescaleFactorIndexAlgoValue,
              cms_uint16_t noAlgoValue,
              cms_uint16_t finalORValue,
              cms_uint32_t orbitNrValue,
              cms_uint16_t lumiSegmentNrValue,
              cms_uint16_t localBxNrValue);

  virtual ~L1GtFdlWord();

  bool operator==(const L1GtFdlWord&) const;

  bool operator!=(const L1GtFdlWord&) const;

public:

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

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

  void setBoardId(const cms_uint64_t& word64);

  void setBoardIdWord64(cms_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 cms_uint64_t& word64);

  void setBxInEventWord64(cms_uint64_t& word64, const int iWord);

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

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

  void setBxNr(const cms_uint64_t& word64);

  void setBxNrWord64(cms_uint64_t& word64, const int iWord);

  inline const cms_uint32_t eventNr() const { return m_eventNr; }

  void setEventNr(const cms_uint32_t& eventNrValue) { m_eventNr = eventNrValue; }

  void setEventNr(const cms_uint64_t& word64);

  void setEventNrWord64(cms_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 cms_uint64_t& word64);

  void setGtTechnicalTriggerWordWord64(cms_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 cms_uint64_t& word64);

  void setGtDecisionWordB(const cms_uint64_t& word64);

  void setGtDecisionWordAWord64(cms_uint64_t& word64, const int iWord);

  void setGtDecisionWordBWord64(cms_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 cms_uint64_t& word64);

  void setGtDecisionWordExtendedWord64(cms_uint64_t& word64, const int iWord);

  inline const cms_uint16_t physicsDeclared() const { return m_physicsDeclared; }

  void setPhysicsDeclared(const cms_uint16_t& physicsDeclaredValue) { m_physicsDeclared = physicsDeclaredValue; }

  void setPhysicsDeclared(const cms_uint64_t& word64);

  void setPhysicsDeclaredWord64(cms_uint64_t& word64, const int iWord);


  inline const cms_uint16_t gtPrescaleFactorIndexTech() const { return m_gtPrescaleFactorIndexTech; }

  void setGtPrescaleFactorIndexTech(const cms_uint16_t& gtPrescaleFactorIndexTechValue) {
    m_gtPrescaleFactorIndexTech = gtPrescaleFactorIndexTechValue;
  }

  void setGtPrescaleFactorIndexTech(const cms_uint64_t& word64);

  void setGtPrescaleFactorIndexTechWord64(cms_uint64_t& word64, const int iWord);

  inline const cms_uint16_t gtPrescaleFactorIndexAlgo() const { return m_gtPrescaleFactorIndexAlgo; }

  void setGtPrescaleFactorIndexAlgo(const cms_uint16_t& gtPrescaleFactorIndexAlgoValue) {
    m_gtPrescaleFactorIndexAlgo = gtPrescaleFactorIndexAlgoValue;
  }

  void setGtPrescaleFactorIndexAlgo(const cms_uint64_t& word64);

  void setGtPrescaleFactorIndexAlgoWord64(cms_uint64_t& word64, const int iWord);

  inline const cms_uint16_t noAlgo() const { return m_noAlgo; }

  void setNoAlgo(const cms_uint16_t& noAlgoValue) { m_noAlgo = noAlgoValue; }

  void setNoAlgo(const cms_uint64_t& word64);

  void setNoAlgoWord64(cms_uint64_t& word64, const int iWord);

  inline const cms_uint16_t finalOR() const { return m_finalOR; }

  void setFinalOR(const cms_uint16_t& finalORValue) { m_finalOR = finalORValue; }

  void setFinalOR(const cms_uint64_t& word64);

  void setFinalORWord64(cms_uint64_t& word64, const int iWord);

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

  inline const cms_uint32_t orbitNr() const { return m_orbitNr; }

  void setOrbitNr(const cms_uint32_t& orbitNrValue) { m_orbitNr = orbitNrValue; }

  void setOrbitNr(const cms_uint64_t& word64);

  void setOrbitNrWord64(cms_uint64_t& word64, const int iWord);

  inline const cms_uint16_t lumiSegmentNr() const { return m_lumiSegmentNr; }

  void setLumiSegmentNr(const cms_uint16_t& lumiSegmentNrValue) { m_lumiSegmentNr = lumiSegmentNrValue; }

  void setLumiSegmentNr(const cms_uint64_t& word64);

  void setLumiSegmentNrWord64(cms_uint64_t& word64, const int iWord);

  inline const cms_uint16_t localBxNr() const { return m_localBxNr; }

  void setLocalBxNr(const cms_uint16_t& localBxNrValue) { m_localBxNr = localBxNrValue; }

  void setLocalBxNr(const cms_uint64_t& word64);

  void setLocalBxNrWord64(cms_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 cms_uint64_t BoardIdMask;
  static const cms_uint64_t BxInEventMask;
  static const cms_uint64_t BxNrMask;
  static const cms_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 cms_uint64_t GtTechnicalTriggerWordMask;
  static const int GtTechnicalTriggerWordShift;

  // word 2 - WordA: bits 0-63

  static const int GtDecisionWordAWord;
  static const cms_uint64_t GtDecisionWordAMask;
  static const int GtDecisionWordAShift;

  // word 3 - WordB: bits 64-128

  static const int GtDecisionWordBWord;
  static const cms_uint64_t GtDecisionWordBMask;
  static const int GtDecisionWordBShift;

  // word 4
  static const int GtDecisionWordExtendedWord;
  static const cms_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 cms_uint64_t PhysicsDeclaredMask;
  static const cms_uint64_t GtPrescaleFactorIndexTechMask;
  static const cms_uint64_t GtPrescaleFactorIndexAlgoMask;
  static const cms_uint64_t NoAlgoMask;
  static const cms_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 cms_uint64_t OrbitNrMask;
  static const cms_uint64_t LumiSegmentNrMask;
  static const cms_uint64_t LocalBxNrMask;

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

private:
  cms_uint16_t m_boardId;

  int m_bxInEvent;

  cms_uint16_t m_bxNr;

  cms_uint32_t m_eventNr;

  //

  TechnicalTriggerWord m_gtTechnicalTriggerWord;

  DecisionWord m_gtDecisionWord;

  DecisionWordExtended m_gtDecisionWordExtended;

  //
  cms_uint16_t m_physicsDeclared;

  cms_uint16_t m_gtPrescaleFactorIndexTech;
  cms_uint16_t m_gtPrescaleFactorIndexAlgo;

  cms_uint16_t m_noAlgo;

  cms_uint16_t m_finalOR;

  //

  cms_uint32_t m_orbitNr;

  cms_uint16_t m_lumiSegmentNr;

  cms_uint16_t m_localBxNr;
};

#endif /*L1GlobalTrigger_L1GtFdlWord_h*/