L1GtfeWord.cc

Go to the documentation of this file.

 
// this class header
#include "DataFormats/L1GlobalTrigger/interface/L1GtfeWord.h"
 
// system include files
#include <iomanip>
 
// user include files
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"
 
// constructors
 
// empty constructor, all members set to zero;
L1GtfeWord::L1GtfeWord()
    : m_boardId(0),
      m_recordLength1(0),
      m_recordLength(0),
      m_bxNr(0),
      m_setupVersion(0),
      m_activeBoards(0),
      m_altNrBxBoard(0),
      m_totalTriggerNr(0) {
  // empty
}
 
// constructor from unpacked values;
L1GtfeWord::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)
    : m_boardId(boardIdValue),
      m_recordLength1(recordLength1Value),
      m_recordLength(recordLengthValue),
      m_bxNr(bxNrValue),
      m_setupVersion(setupVersionValue),
      m_activeBoards(activeBoardsValue),
      m_altNrBxBoard(altNrBxBoardValue),
      m_totalTriggerNr(totalTriggerNrValue)
 
{
  // empty
}
 
// destructor
L1GtfeWord::~L1GtfeWord() {
  // empty now
}
 
// equal operator
bool L1GtfeWord::operator==(const L1GtfeWord& result) const {
  if (m_boardId != result.m_boardId) {
    return false;
  }
 
  if (m_recordLength1 != result.m_recordLength1) {
    return false;
  }
 
  if (m_recordLength != result.m_recordLength) {
    return false;
  }
 
  if (m_bxNr != result.m_bxNr) {
    return false;
  }
 
  if (m_setupVersion != result.m_setupVersion) {
    return false;
  }
 
  if (m_activeBoards != result.m_activeBoards) {
    return false;
  }
 
  if (m_altNrBxBoard != result.m_altNrBxBoard) {
    return false;
  }
 
  if (m_totalTriggerNr != result.m_totalTriggerNr) {
    return false;
  }
 
  // all members identical
  return true;
}
 
// unequal operator
bool L1GtfeWord::operator!=(const L1GtfeWord& result) const { return !(result == *this); }
 
// methods
 
// set the BoardId value from a 64-bits word
void L1GtfeWord::setBoardId(const cms_uint64_t& word64) { m_boardId = (word64 & BoardIdMask) >> BoardIdShift; }
 
// set the BoardId value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtfeWord::setBoardIdWord64(cms_uint64_t& word64, int iWord) {
  if (iWord == BoardIdWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(m_boardId) << BoardIdShift);
  }
}
 
// set the RecordLength1 value from a 64-bits word
void L1GtfeWord::setRecordLength1(const cms_uint64_t& word64) {
  m_recordLength1 = (word64 & RecordLength1Mask) >> RecordLength1Shift;
}
 
// set the RecordLength1 value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtfeWord::setRecordLength1Word64(cms_uint64_t& word64, int iWord) {
  if (iWord == RecordLength1Word) {
    word64 = word64 | (static_cast<cms_uint64_t>(m_recordLength1) << RecordLength1Shift);
  }
}
 
// set the RecordLength value from a 64-bits word
void L1GtfeWord::setRecordLength(const cms_uint64_t& word64) {
  m_recordLength = (word64 & RecordLengthMask) >> RecordLengthShift;
}
 
// set the RecordLength value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtfeWord::setRecordLengthWord64(cms_uint64_t& word64, int iWord) {
  if (iWord == RecordLengthWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(m_recordLength) << RecordLengthShift);
  }
}
 
// set the BxNr value from a 64-bits word
void L1GtfeWord::setBxNr(const cms_uint64_t& word64) { m_bxNr = (word64 & BxNrMask) >> BxNrShift; }
 
// set the BxNr value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtfeWord::setBxNrWord64(cms_uint64_t& word64, int iWord) {
  if (iWord == BxNrWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(m_bxNr) << BxNrShift);
  }
}
 
// set the SetupVersion value from a 64-bits word
void L1GtfeWord::setSetupVersion(const cms_uint64_t& word64) {
  m_setupVersion = (word64 & SetupVersionMask) >> SetupVersionShift;
}
 
// set the SetupVersion value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtfeWord::setSetupVersionWord64(cms_uint64_t& word64, int iWord) {
  if (iWord == SetupVersionWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(m_setupVersion) << SetupVersionShift);
  }
}
 
// get / set BST flag: 0 or 1 - via setup version (no private member)
const int L1GtfeWord::bstFlag() const {
  int bstFlagValue = 0;
  bstFlagValue = static_cast<int>(m_setupVersion & BstFlagMask);
 
  return bstFlagValue;
}
 
void L1GtfeWord::setBstFlag(const int bstFlagValue) {
  m_setupVersion = m_setupVersion | (static_cast<cms_uint32_t>(bstFlagValue) & BstFlagMask);
}
 
// set the ActiveBoards value from a 64-bits word
void L1GtfeWord::setActiveBoards(const cms_uint64_t& word64) {
  m_activeBoards = (word64 & ActiveBoardsMask) >> ActiveBoardsShift;
}
 
// set the ActiveBoards value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtfeWord::setActiveBoardsWord64(cms_uint64_t& word64, int iWord) {
  if (iWord == ActiveBoardsWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(m_activeBoards) << ActiveBoardsShift);
  }
}
 
// set the ActiveBoards value in a 64-bits word, having the index iWord
// in the GTFE raw record from the value activeBoardsValue
void L1GtfeWord::setActiveBoardsWord64(cms_uint64_t& word64, int iWord, cms_int16_t activeBoardsValue) {
  if (iWord == ActiveBoardsWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(activeBoardsValue) << ActiveBoardsShift);
  }
}
 
// set the AltNrBxBoard value from a 64-bits word
void L1GtfeWord::setAltNrBxBoard(const cms_uint64_t& word64) {
  m_altNrBxBoard = (word64 & AltNrBxBoardMask) >> AltNrBxBoardShift;
}
 
// set the AltNrBxBoard value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtfeWord::setAltNrBxBoardWord64(cms_uint64_t& word64, int iWord) {
  if (iWord == AltNrBxBoardWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(m_altNrBxBoard) << AltNrBxBoardShift);
  }
}
 
// set the AltNrBxBoard value in a 64-bits word, having the index iWord
// in the GTFE raw record from the value altNrBxBoardValue
void L1GtfeWord::setAltNrBxBoardWord64(cms_uint64_t& word64, int iWord, cms_int16_t altNrBxBoardValue) {
  if (iWord == AltNrBxBoardWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(altNrBxBoardValue) << AltNrBxBoardShift);
  }
}
 
// set the TotalTriggerNr value from a 64-bits word
void L1GtfeWord::setTotalTriggerNr(const cms_uint64_t& word64) {
  m_totalTriggerNr = (word64 & TotalTriggerNrMask) >> TotalTriggerNrShift;
}
 
// set the TotalTriggerNr value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtfeWord::setTotalTriggerNrWord64(cms_uint64_t& word64, int iWord) {
  if (iWord == TotalTriggerNrWord) {
    word64 = word64 | (static_cast<cms_uint64_t>(m_totalTriggerNr) << TotalTriggerNrShift);
  }
}
 
// reset the content of a L1GtfeWord
void L1GtfeWord::reset() {
  m_boardId = 0;
  m_recordLength1 = 0;
  m_recordLength = 0;
  m_bxNr = 0;
  m_setupVersion = 0;
  //
  m_activeBoards = 0;
  m_altNrBxBoard = 0;
  m_totalTriggerNr = 0;
}
 
// pretty print the content of a L1GtfeWord
void L1GtfeWord::print(std::ostream& myCout) const {
  myCout << "\n L1GtfeWord::print \n" << std::endl;
 
  myCout << "  BoardId:              " << std::hex << " hex: "
         << "      " << std::setw(2) << std::setfill('0') << m_boardId << std::setfill(' ') << std::dec
         << " dec: " << m_boardId << std::endl;
 
  myCout << "  BX for alternative 1: " << std::hex << " hex: "
         << "       " << std::setw(1) << m_recordLength1 << std::dec << " dec: " << m_recordLength1 << std::endl;
 
  myCout << "  BX for alternative 0: " << std::hex << " hex: "
         << "       " << std::setw(1) << m_recordLength << std::dec << " dec: " << m_recordLength << std::endl;
 
  myCout << "  BxNr:                 " << std::hex << " hex: "
         << "     " << std::setw(3) << std::setfill('0') << m_bxNr << std::setfill(' ') << std::dec
         << " dec: " << m_bxNr << std::endl;
 
  myCout << "  SetupVersion:         " << std::hex << " hex: " << std::setw(8) << std::setfill('0') << m_setupVersion
         << std::setfill(' ') << std::dec << " dec: " << m_setupVersion << std::endl;
 
  //
 
  myCout << "  ActiveBoards:         " << std::hex << " hex: "
         << "    " << std::setw(4) << std::setfill('0') << m_activeBoards << std::setfill(' ') << std::dec
         << " dec: " << m_activeBoards << std::endl;
 
  myCout << "  AltNrBxBoard:         " << std::hex << " hex: "
         << "    " << std::setw(4) << std::setfill('0') << m_altNrBxBoard << std::setfill(' ') << std::dec
         << " dec: " << m_altNrBxBoard << std::endl;
 
  myCout << "  TotalTriggerNr:       " << std::hex << " hex: " << std::setw(8) << std::setfill('0') << m_totalTriggerNr
         << std::setfill(' ') << std::dec << " dec: " << m_totalTriggerNr << std::endl;
}
 
// unpack GTFE
// gtfePtr pointer to the beginning of the GTFE block in the raw data
 
void L1GtfeWord::unpack(const unsigned char* gtfePtr) {
  LogDebug("L1GtfeWord") << "\nUnpacking GTFE block.\n" << std::endl;
 
  const cms_uint64_t* payload = reinterpret_cast<cms_uint64_t const*>(gtfePtr);
 
  setBoardId(payload[BoardIdWord]);
  setRecordLength1(payload[RecordLength1Word]);
  setRecordLength(payload[RecordLengthWord]);
  setBxNr(payload[BxNrWord]);
  setSetupVersion(payload[SetupVersionWord]);
  setActiveBoards(payload[ActiveBoardsWord]);
  setAltNrBxBoard(payload[AltNrBxBoardWord]);
  setTotalTriggerNr(payload[TotalTriggerNrWord]);
 
  if (edm::isDebugEnabled()) {
    for (int iWord = 0; iWord < BlockSize; ++iWord) {
      LogTrace("L1GtfeWord") << std::setw(4) << iWord << "  " << std::hex << std::setfill('0') << std::setw(16)
                             << payload[iWord] << std::dec << std::setfill(' ') << std::endl;
    }
  }
}
 
// static class members
 
// block description in the raw GT record
 
// block size in 64bits words
const int L1GtfeWord::BlockSize = 2;  // 2 x 64bits
 
const int L1GtfeWord::BoardIdWord = 0;
const int L1GtfeWord::RecordLength1Word = 0;
const int L1GtfeWord::RecordLengthWord = 0;
const int L1GtfeWord::BxNrWord = 0;
const int L1GtfeWord::SetupVersionWord = 0;
 
const cms_uint64_t L1GtfeWord::BoardIdMask = 0xFF00000000000000ULL;
const cms_uint64_t L1GtfeWord::RecordLength1Mask = 0x00F0000000000000ULL;
const cms_uint64_t L1GtfeWord::RecordLengthMask = 0x000F000000000000ULL;
const cms_uint64_t L1GtfeWord::BxNrMask = 0x00000FFF00000000ULL;
const cms_uint64_t L1GtfeWord::SetupVersionMask = 0x00000000FFFFFFFFULL;
 
const cms_uint32_t L1GtfeWord::BstFlagMask = 0x0001;
 
// shifts could be computed from masks...
const int L1GtfeWord::BoardIdShift = 56;
const int L1GtfeWord::RecordLength1Shift = 52;
const int L1GtfeWord::RecordLengthShift = 48;
const int L1GtfeWord::BxNrShift = 32;
const int L1GtfeWord::SetupVersionShift = 0;
 
//
const int L1GtfeWord::ActiveBoardsWord = 1;
const int L1GtfeWord::AltNrBxBoardWord = 1;
const int L1GtfeWord::TotalTriggerNrWord = 1;
 
const cms_uint64_t L1GtfeWord::ActiveBoardsMask = 0xFFFF000000000000ULL;
const cms_uint64_t L1GtfeWord::AltNrBxBoardMask = 0x0000FFFF00000000ULL;
const cms_uint64_t L1GtfeWord::TotalTriggerNrMask = 0x00000000FFFFFFFFULL;
 
const int L1GtfeWord::ActiveBoardsShift = 48;
const int L1GtfeWord::AltNrBxBoardShift = 32;
const int L1GtfeWord::TotalTriggerNrShift = 0;