Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-04-06 12:04:30

0001 /**
0002  * \class L1GtPsbWord
0003  * 
0004  * 
0005  * Description: PSB block in the L1 GT readout record.  
0006  *
0007  * Implementation:
0008  *    <TODO: enter implementation details>
0009  *   
0010  * \author: Vasile Mihai Ghete - HEPHY Vienna
0011  * 
0012  *
0013  */
0014 
0015 // this class header
0016 #include "DataFormats/L1GlobalTrigger/interface/L1GtPsbWord.h"
0017 
0018 // system include files
0019 #include <iomanip>
0020 
0021 // user include files
0022 #include "FWCore/Utilities/interface/EDMException.h"
0023 
0024 // constructors
0025 
0026 // empty constructor, all members set to zero;
0027 L1GtPsbWord::L1GtPsbWord() {
0028   m_boardId = 0;
0029   m_bxInEvent = 0;
0030   m_bxNr = 0;
0031   m_eventNr = 0;
0032 
0033   for (int iA = 0; iA < NumberAData; ++iA) {
0034     m_aData[iA] = 0;
0035   }
0036 
0037   for (int iB = 0; iB < NumberBData; ++iB) {
0038     m_bData[iB] = 0;
0039   }
0040 
0041   m_localBxNr = 0;
0042 }
0043 
0044 // constructor from unpacked values;
0045 L1GtPsbWord::L1GtPsbWord(cms_uint16_t boardIdValue,
0046                          int bxInEventValue,
0047                          cms_uint16_t bxNrValue,
0048                          cms_uint32_t eventNrValue,
0049                          cms_uint16_t aDataValue[NumberAData],
0050                          cms_uint16_t bDataValue[NumberBData],
0051                          cms_uint16_t localBxNrValue) {
0052   m_boardId = boardIdValue;
0053   m_bxInEvent = bxInEventValue;
0054   m_bxNr = bxNrValue;
0055   m_eventNr = eventNrValue;
0056 
0057   for (int iA = 0; iA < NumberAData; ++iA) {
0058     m_aData[iA] = aDataValue[iA];
0059   }
0060 
0061   for (int iB = 0; iB < NumberBData; ++iB) {
0062     m_bData[iB] = bDataValue[iB];
0063   }
0064 
0065   m_localBxNr = localBxNrValue;
0066 }
0067 
0068 // destructor
0069 L1GtPsbWord::~L1GtPsbWord() {
0070   // empty now
0071 }
0072 
0073 // equal operator
0074 bool L1GtPsbWord::operator==(const L1GtPsbWord& result) const {
0075   if (m_boardId != result.m_boardId) {
0076     return false;
0077   }
0078   if (m_bxInEvent != result.m_bxInEvent) {
0079     return false;
0080   }
0081   if (m_bxNr != result.m_bxNr) {
0082     return false;
0083   }
0084   if (m_eventNr != result.m_eventNr) {
0085     return false;
0086   }
0087 
0088   for (int iA = 0; iA < NumberAData; ++iA) {
0089     if (m_aData[iA] != result.m_aData[iA]) {
0090       return false;
0091     }
0092   }
0093 
0094   for (int iB = 0; iB < NumberBData; ++iB) {
0095     if (m_bData[iB] != result.m_bData[iB]) {
0096       return false;
0097     }
0098   }
0099 
0100   if (m_localBxNr != result.m_localBxNr) {
0101     return false;
0102   }
0103 
0104   // all members identical
0105   return true;
0106 }
0107 
0108 // unequal operator
0109 bool L1GtPsbWord::operator!=(const L1GtPsbWord& result) const { return !(result == *this); }
0110 
0111 // methods
0112 
0113 // set the BoardId value from a 64-bits word, having the index iWord
0114 // in the GTFE raw record
0115 void L1GtPsbWord::setBoardId(const cms_uint64_t& word64, int iWord) {
0116   if (iWord == BoardIdWord) {
0117     m_boardId = (word64 & BoardIdMask) >> BoardIdShift;
0118   }
0119 }
0120 
0121 // set the BoardId value in a 64-bits word, having the index iWord
0122 // in the GTFE raw record
0123 void L1GtPsbWord::setBoardIdWord64(cms_uint64_t& word64, int iWord) {
0124   if (iWord == BoardIdWord) {
0125     word64 = word64 | (static_cast<cms_uint64_t>(m_boardId) << BoardIdShift);
0126   }
0127 }
0128 
0129 // set the BxInEvent value from a 64-bits word, having the index iWord
0130 // in the GTFE raw record
0131 void L1GtPsbWord::setBxInEvent(const cms_uint64_t& word64, int iWord) {
0132   if (iWord == BxInEventWord) {
0133     int baseValue = 16;  // using hexadecimal values;
0134     int hexBxInEvent = (word64 & BxInEventMask) >> BxInEventShift;
0135     m_bxInEvent = (hexBxInEvent + baseValue / 2) % baseValue - baseValue / 2;
0136   }
0137 }
0138 
0139 // set the BxInEvent value in a 64-bits word, having the index iWord
0140 // in the GTFE raw record
0141 void L1GtPsbWord::setBxInEventWord64(cms_uint64_t& word64, int iWord) {
0142   if (iWord == BxInEventWord) {
0143     int baseValue = 16;  // using hexadecimal values;
0144     int hexBxInEvent = (m_bxInEvent + baseValue) % baseValue;
0145     word64 = word64 | (static_cast<cms_uint64_t>(hexBxInEvent) << BxInEventShift);
0146   }
0147 }
0148 
0149 // set the BxNr value from a 64-bits word, having the index iWord in the GTFE raw record
0150 void L1GtPsbWord::setBxNr(const cms_uint64_t& word64, int iWord) {
0151   if (iWord == BxNrWord) {
0152     m_bxNr = (word64 & BxNrMask) >> BxNrShift;
0153   }
0154 }
0155 
0156 // set the BxNr value in a 64-bits word, having the index iWord
0157 // in the GTFE raw record
0158 void L1GtPsbWord::setBxNrWord64(cms_uint64_t& word64, int iWord) {
0159   if (iWord == BxNrWord) {
0160     word64 = word64 | (static_cast<cms_uint64_t>(m_bxNr) << BxNrShift);
0161   }
0162 }
0163 
0164 // set the EventNr value from a 64-bits word, having the index iWord in the GTFE raw record
0165 void L1GtPsbWord::setEventNr(const cms_uint64_t& word64, int iWord) {
0166   if (iWord == EventNrWord) {
0167     m_eventNr = (word64 & EventNrMask) >> EventNrShift;
0168   }
0169 }
0170 
0171 // set the EventNr value in a 64-bits word, having the index iWord
0172 // in the GTFE raw record
0173 void L1GtPsbWord::setEventNrWord64(cms_uint64_t& word64, int iWord) {
0174   if (iWord == EventNrWord) {
0175     word64 = word64 | (static_cast<cms_uint64_t>(m_eventNr) << EventNrShift);
0176   }
0177 }
0178 
0179 // get/set A_DATA_CH_IA
0180 
0181 const cms_uint16_t L1GtPsbWord::aData(int iA) const {
0182   if (iA < 0 || iA > NumberAData) {
0183     throw cms::Exception("aDataIndexError")
0184         << "\nError: index for A_DATA array out of range. Allowed range: [0, " << NumberAData << ") " << std::endl;
0185 
0186   } else {
0187     return m_aData[iA];
0188   }
0189 }
0190 
0191 void L1GtPsbWord::setAData(cms_uint16_t aDataVal, int iA) {
0192   if (iA < 0 || iA > NumberAData) {
0193     throw cms::Exception("aDataIndexError")
0194         << "\nError: index for A_DATA array out of range. Allowed range: [0, " << NumberAData << ") " << std::endl;
0195 
0196   } else {
0197     m_aData[iA] = aDataVal;
0198   }
0199 }
0200 
0201 // set the AData value from a 64-bits word, having the index iWord
0202 // in the GTFE raw record
0203 void L1GtPsbWord::setAData(const cms_uint64_t& word64, int iWord) {
0204   int sizeW64 = sizeof(word64) * 8;
0205   int nSubWords = sizeW64 / DataCHSize;
0206 
0207   if (iWord == ADataCH0Word) {
0208     for (int i = 0; i < nSubWords; ++i) {
0209       int dataShift = i * DataCHSize;
0210       m_aData[i] = (word64 & (DataCHMask << dataShift)) >> dataShift;
0211 
0212       //            LogTrace("L1GtPsbWord")
0213       //            << "\n  A_Data_CH" << i << " = "
0214       //            << m_aData[i]
0215       //            << std::endl;
0216     }
0217 
0218   } else if (iWord == ADataCH4Word) {
0219     for (int i = 0; i < nSubWords; ++i) {
0220       int dataShift = i * DataCHSize;
0221       m_aData[i + nSubWords] = (word64 & (DataCHMask << dataShift)) >> dataShift;
0222 
0223       //            LogTrace("L1GtPsbWord")
0224       //            << "\n  A_Data_CH" << i + nSubWords << " = "
0225       //            << m_aData[i]
0226       //            << std::endl;
0227     }
0228   }
0229 }
0230 
0231 // set the AData value in a 64-bits word, having the index iWord
0232 // in the GTFE raw record
0233 void L1GtPsbWord::setADataWord64(cms_uint64_t& word64, int iWord) {
0234   int sizeW64 = sizeof(word64) * 8;
0235   int nSubWords = sizeW64 / DataCHSize;
0236 
0237   if (iWord == ADataCH0Word) {
0238     for (int i = 0; i < nSubWords; ++i) {
0239       int dataShift = i * DataCHSize;
0240       word64 = word64 | (static_cast<cms_uint64_t>(m_aData[i]) << dataShift);
0241     }
0242 
0243   } else if (iWord == ADataCH4Word) {
0244     for (int i = 0; i < nSubWords; ++i) {
0245       int dataShift = i * DataCHSize;
0246       word64 = word64 | (static_cast<cms_uint64_t>(m_aData[i + nSubWords]) << dataShift);
0247     }
0248   }
0249 }
0250 
0251 // get/set B_DATA_CH_IB
0252 
0253 const cms_uint16_t L1GtPsbWord::bData(int iB) const {
0254   if (iB < 0 || iB > NumberBData) {
0255     throw cms::Exception("bDataIndexError")
0256         << "\nError: index for B_DATA array out of range. Allowed range: [0, " << NumberBData << ") " << std::endl;
0257 
0258   } else {
0259     return m_bData[iB];
0260   }
0261 }
0262 
0263 void L1GtPsbWord::setBData(cms_uint16_t bDataVal, int iB) {
0264   if (iB < 0 || iB > NumberBData) {
0265     throw cms::Exception("bDataIndexError")
0266         << "\nError: index for B_DATA array out of range. Allowed range: [0, " << NumberBData << ") " << std::endl;
0267 
0268   } else {
0269     m_bData[iB] = bDataVal;
0270   }
0271 }
0272 
0273 // set the BData value from a 64-bits word, having the index iWord
0274 // in the GTFE raw record
0275 void L1GtPsbWord::setBData(const cms_uint64_t& word64, int iWord) {
0276   int sizeW64 = sizeof(word64) * 8;
0277   int nSubWords = sizeW64 / DataCHSize;
0278 
0279   if (iWord == BDataCH0Word) {
0280     for (int i = 0; i < nSubWords; ++i) {
0281       int dataShift = i * DataCHSize;
0282       m_bData[i] = (word64 & (DataCHMask << dataShift)) >> dataShift;
0283     }
0284 
0285   } else if (iWord == BDataCH4Word) {
0286     for (int i = 0; i < nSubWords; ++i) {
0287       int dataShift = i * DataCHSize;
0288       m_bData[i + nSubWords] = (word64 & (DataCHMask << dataShift)) >> dataShift;
0289     }
0290   }
0291 }
0292 
0293 // set the BData value in a 64-bits word, having the index iWord
0294 // in the GTFE raw record
0295 void L1GtPsbWord::setBDataWord64(cms_uint64_t& word64, int iWord) {
0296   int sizeW64 = sizeof(word64) * 8;
0297   int nSubWords = sizeW64 / DataCHSize;
0298 
0299   if (iWord == BDataCH0Word) {
0300     for (int i = 0; i < nSubWords; ++i) {
0301       int dataShift = i * DataCHSize;
0302       word64 = word64 | (static_cast<cms_uint64_t>(m_bData[i]) << dataShift);
0303     }
0304 
0305   } else if (iWord == BDataCH4Word) {
0306     for (int i = 0; i < nSubWords; ++i) {
0307       int dataShift = i * DataCHSize;
0308       word64 = word64 | (static_cast<cms_uint64_t>(m_bData[i + nSubWords]) << dataShift);
0309     }
0310   }
0311 }
0312 
0313 // set the LocalBxNr value from a 64-bits word,
0314 // having the index iWord in the GTFE raw record
0315 void L1GtPsbWord::setLocalBxNr(const cms_uint64_t& word64, int iWord) {
0316   if (iWord == LocalBxNrWord) {
0317     m_localBxNr = (word64 & LocalBxNrMask) >> LocalBxNrShift;
0318   }
0319 }
0320 
0321 // set the LocalBxNr value in a 64-bits word, having the index iWord
0322 // in the GTFE raw record
0323 void L1GtPsbWord::setLocalBxNrWord64(cms_uint64_t& word64, int iWord) {
0324   if (iWord == LocalBxNrWord) {
0325     word64 = word64 | (static_cast<cms_uint64_t>(m_localBxNr) << LocalBxNrShift);
0326   }
0327 }
0328 
0329 // reset the content of a L1GtPsbWord
0330 void L1GtPsbWord::reset() {
0331   m_boardId = 0;
0332   m_bxInEvent = 0;
0333   m_bxNr = 0;
0334   m_eventNr = 0;
0335 
0336   for (int iA = 0; iA < NumberAData; ++iA) {
0337     m_aData[iA] = 0;
0338   }
0339 
0340   for (int iB = 0; iB < NumberBData; ++iB) {
0341     m_bData[iB] = 0;
0342   }
0343 
0344   m_localBxNr = 0;
0345 }
0346 
0347 // pretty print
0348 void L1GtPsbWord::print(std::ostream& myCout) const {
0349   myCout << "\n L1GtPsbWord::print \n" << std::endl;
0350 
0351   myCout << "  Board Id:  " << std::hex << " hex:     " << std::setw(4) << std::setfill('0') << m_boardId
0352          << std::setfill(' ') << std::dec << " dec: " << m_boardId << std::endl;
0353 
0354   int baseValue = 16;  // using hexadecimal values;
0355   int hexBxInEvent = (m_bxInEvent + baseValue) % baseValue;
0356 
0357   myCout << "  BxInEvent: " << std::hex << " hex:     "
0358          << "   " << std::setw(1) << hexBxInEvent << std::dec << " dec: " << m_bxInEvent << std::endl;
0359 
0360   myCout << "  BxNr:      " << std::hex << " hex:     "
0361          << " " << std::setw(3) << std::setfill('0') << m_bxNr << std::setfill(' ') << std::dec << " dec: " << m_bxNr
0362          << std::endl;
0363 
0364   myCout << "  EventNr:   " << std::hex << " hex: "
0365          << "  " << std::setw(6) << std::setfill('0') << m_eventNr << std::setfill(' ') << std::dec
0366          << " dec: " << m_eventNr << std::endl;
0367 
0368   int sizeW64 = 64;
0369   int dataBlocksPerLine = sizeW64 / DataCHSize;  // 4x16 bits per line
0370 
0371   myCout << "\n        "
0372          << "A_Data_CH3 "
0373          << "A_Data_CH2 "
0374          << "A_Data_CH1 "
0375          << "A_Data_CH0 "
0376          << "\n"
0377          << std::hex << "  hex:  " << std::setfill('0');
0378 
0379   for (int i = 0; i < dataBlocksPerLine; ++i) {
0380     int iCh = dataBlocksPerLine - (i + 1);  // reverse
0381     myCout << std::setw(4) << m_aData[iCh] << "       ";
0382   }
0383 
0384   myCout << "\n" << std::dec << "  dec:  ";
0385 
0386   for (int i = 0; i < dataBlocksPerLine; ++i) {
0387     int iCh = dataBlocksPerLine - (i + 1);  // reverse
0388     myCout << std::setw(5) << m_aData[iCh] << "      ";
0389   }
0390 
0391   myCout << "\n\n        "
0392          << "A_Data_CH7 "
0393          << "A_Data_CH6 "
0394          << "A_Data_CH5 "
0395          << "A_Data_CH4 "
0396          << "\n"
0397          << std::hex << "  hex:  " << std::setfill('0');
0398 
0399   for (int i = 0; i < dataBlocksPerLine; ++i) {
0400     int iCh = dataBlocksPerLine - (i + 1);  // reverse
0401     myCout << std::setw(4) << m_aData[iCh + dataBlocksPerLine] << "       ";
0402   }
0403 
0404   myCout << "\n" << std::dec << "  dec:  ";
0405 
0406   for (int i = 0; i < dataBlocksPerLine; ++i) {
0407     int iCh = dataBlocksPerLine - (i + 1);  // reverse
0408     myCout << std::setw(5) << m_aData[iCh + dataBlocksPerLine] << "      ";
0409   }
0410 
0411   myCout << std::endl;
0412 
0413   myCout << "\n        "
0414          << "B_Data_CH3 "
0415          << "B_Data_CH2 "
0416          << "B_Data_CH1 "
0417          << "B_Data_CH0 "
0418          << "\n"
0419          << std::hex << "  hex:  " << std::setfill('0');
0420 
0421   for (int i = 0; i < dataBlocksPerLine; ++i) {
0422     int iCh = dataBlocksPerLine - (i + 1);  // reverse
0423     myCout << std::setw(4) << m_bData[iCh] << "       ";
0424   }
0425 
0426   myCout << "\n" << std::dec << "  dec:  ";
0427 
0428   for (int i = 0; i < dataBlocksPerLine; ++i) {
0429     int iCh = dataBlocksPerLine - (i + 1);  // reverse
0430     myCout << std::setw(5) << m_bData[iCh] << "      ";
0431   }
0432 
0433   myCout << "\n\n        "
0434          << "B_Data_CH7 "
0435          << "B_Data_CH6 "
0436          << "B_Data_CH5 "
0437          << "B_Data_CH4 "
0438          << "\n"
0439          << std::hex << "  hex:  " << std::setfill('0');
0440 
0441   for (int i = 0; i < dataBlocksPerLine; ++i) {
0442     int iCh = dataBlocksPerLine - (i + 1);  // reverse
0443     myCout << std::setw(4) << m_bData[iCh + dataBlocksPerLine] << "       ";
0444   }
0445 
0446   myCout << "\n" << std::dec << "  dec:  ";
0447 
0448   for (int i = 0; i < dataBlocksPerLine; ++i) {
0449     int iCh = dataBlocksPerLine - (i + 1);  // reverse
0450     myCout << std::setw(5) << m_bData[iCh + dataBlocksPerLine] << "      ";
0451   }
0452 
0453   myCout << "\n" << std::endl;
0454 
0455   myCout << "  LocalBxNr: " << std::hex << " hex:     "
0456          << " " << std::setw(3) << std::setfill('0') << m_localBxNr << std::setfill(' ') << std::dec
0457          << " dec: " << m_localBxNr << std::endl;
0458 }
0459 
0460 // static class members
0461 const int L1GtPsbWord::NumberAData;
0462 const int L1GtPsbWord::NumberBData;