text: #ifndef L1GlobalTrigger_L1GtfeWord_h
  #define L1GlobalTrigger_L1GtfeWord_h
  
  /**
   * \class L1GtfeWord
   *
   *
   * Description: L1 Global Trigger - GTFE words in the readout record.
   *
   * Implementation:
   *    <TODO: enter implementation details>
   *
   * \author: Vasile Mihai Ghete - HEPHY Vienna
   *
   *
   */
  
  // 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:
  
      /// constructors
      L1GtfeWord();    // empty constructor, all members set to zero;
  
      /// constructor from unpacked values;
      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
      );
  
  
      /// destructor
      virtual ~L1GtfeWord();
  
      /// equal operator
      bool operator==(const L1GtfeWord&) const;
  
      /// unequal operator
      bool operator!=(const L1GtfeWord&) const;
  
  public:
  
      /// get/set board ID
  
      /// get BoardId value
      inline const cms_uint16_t boardId() const
      {
          return m_boardId;
      }
  
      /// set BoardId from a BoardId value
      void setBoardId(cms_uint16_t boardIdValue)
      {
          m_boardId = boardIdValue;
      }
  
      /// set the BoardId value from a 64-bits word
      void setBoardId(const cms_uint64_t& word64);
  
      /// set the BoardId value in a 64-bits word, having the index iWord
      /// in the GTFE raw record
      void setBoardIdWord64(cms_uint64_t& word64, int iWord);
  
  
      /// get/set record length for alternative 1
      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);
  
      /// set the RecordLength value in a 64-bits word, having the index iWord
      /// in the GTFE raw record
      void setRecordLength1Word64(cms_uint64_t& word64, int iWord);
  
  
  
      /// get/set record length for alternative 0
      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);
  
      /// set the RecordLength value in a 64-bits word, having the index iWord
      /// in the GTFE raw record
      void setRecordLengthWord64(cms_uint64_t& word64, int iWord);
  
  
      /// get/set bunch cross number as counted in the GTFE board
      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);
  
      /// set the BxNr value in a 64-bits word, having the index iWord
      /// in the GTFE raw record
      void setBxNrWord64(cms_uint64_t& word64, int iWord);
  
  
      /// get/set setup version
      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);
  
      /// set the SetupVersion value in a 64-bits word, having the index iWord
      /// in the GTFE raw record
      void setSetupVersionWord64(cms_uint64_t& word64, int iWord);
  
  
      /// get / set BST flag: 0 or 1 - via setup version (no private member)
      const int bstFlag() const;
      void setBstFlag(const int);
  
  
      /// get/set boards contributing to EVM respectively DAQ record
      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);
  
      /// set the ActiveBoards value in a 64-bits word, having the index iWord
      /// in the GTFE raw record
      void setActiveBoardsWord64(cms_uint64_t& word64, int iWord);
  
      /// set the ActiveBoards value in a 64-bits word, having the index iWord
      /// in the GTFE raw record from the value activeBoardsValue
      void setActiveBoardsWord64(cms_uint64_t& word64, int iWord,
                                 cms_int16_t activeBoardsValue);
  
  
  
      /// get/set alternative for number of BX per board
      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);
  
      /// set the AltNrBxBoard value in a 64-bits word, having the index iWord
      /// in the GTFE raw record
      void setAltNrBxBoardWord64(cms_uint64_t& word64, int iWord);
  
      /// set the AltNrBxBoard value in a 64-bits word, having the index iWord
      /// in the GTFE raw record from the value altNrBxBoardValue
      void setAltNrBxBoardWord64(cms_uint64_t& word64, int iWord,
                                 cms_int16_t altNrBxBoardValue);
  
  
  
      /// get/set total number of L1A sent since start of run
      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);
  
      /// set the TotalTriggerNr value in a 64-bits word, having the index iWord
      /// in the GTFE raw record
      void setTotalTriggerNrWord64(cms_uint64_t& word64, int iWord);
  
  
      /// get the size of the GTFE block in GT DAQ record (in multiple of 8 bits)
      inline const unsigned int getSize() const
      {
          int unitLengthBits = L1GlobalTriggerReadoutSetup::UnitLength;
  
          return BlockSize*unitLengthBits;
      }
  
  public:
  
      /// reset the content of a L1GtfeWord
      virtual void reset();
  
      /// pretty print the content of a L1GtfeWord
      virtual void print(std::ostream& myCout) const;
  
      /// unpack GTFE
      /// gtfePtr pointer to the beginning of the GTFE block in the raw data
      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:
  
      /// board identifier
      cms_uint16_t m_boardId;
  
      /// record length for alternative 1
      cms_uint16_t m_recordLength1;
  
      /// record length  for alternative 0
      cms_uint16_t m_recordLength;
  
      /// bunch cross number as counted in the GTFE board
      cms_uint16_t m_bxNr;
      cms_uint32_t m_setupVersion;
  
      /// active boards contributing to EVM respectively DAQ record
      cms_uint16_t m_activeBoards;
  
      /// alternative for number of BX per board
      ///     correlated with active boards
      ///     bit value is 0: take alternative 0
      ///     bit value is 1: take alternative 1
      cms_uint16_t m_altNrBxBoard;
  
      /// total number of L1A sent since start of run
      cms_uint32_t m_totalTriggerNr;
  
  };
  
  #endif /*L1GlobalTrigger_L1GtfeWord_h*/
  