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*/