File indexing completed on 2024-04-06 12:10:46
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016 #include "EventFilter/L1GlobalTriggerRawToDigi/interface/L1GTEvmDigiToRaw.h"
0017
0018
0019 #include <vector>
0020 #include <iostream>
0021 #include <iomanip>
0022
0023
0024 #include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
0025 #include "DataFormats/FEDRawData/interface/FEDNumbering.h"
0026
0027 #include "DataFormats/FEDRawData/interface/FEDHeader.h"
0028 #include "DataFormats/FEDRawData/interface/FEDTrailer.h"
0029 #include "FWCore/Utilities/interface/CRC16.h"
0030
0031 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetup.h"
0032 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerEvmReadoutRecord.h"
0033
0034 #include "DataFormats/L1GlobalTrigger/interface/L1GtfeWord.h"
0035 #include "DataFormats/L1GlobalTrigger/interface/L1GtfeExtWord.h"
0036 #include "DataFormats/L1GlobalTrigger/interface/L1TcsWord.h"
0037 #include "DataFormats/L1GlobalTrigger/interface/L1GtFdlWord.h"
0038
0039 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0040 #include "FWCore/MessageLogger/interface/MessageDrop.h"
0041
0042 #include "FWCore/Framework/interface/EventSetup.h"
0043 #include "FWCore/Framework/interface/ESHandle.h"
0044
0045 #include "CondFormats/L1TObjects/interface/L1GtFwd.h"
0046 #include "CondFormats/L1TObjects/interface/L1GtBoard.h"
0047
0048 #include "CondFormats/L1TObjects/interface/L1GtBoardMaps.h"
0049 #include "CondFormats/DataRecord/interface/L1GtBoardMapsRcd.h"
0050
0051
0052 L1GTEvmDigiToRaw::L1GTEvmDigiToRaw(const edm::ParameterSet& pSet)
0053 : m_evmGtFedId(pSet.getUntrackedParameter<int>("EvmGtFedId", FEDNumbering::MINTriggerGTPFEDID)),
0054 m_evmGtInputToken(consumes<L1GlobalTriggerEvmReadoutRecord>(pSet.getParameter<edm::InputTag>("EvmGtInputTag"))),
0055 m_evmGtInputTag(pSet.getParameter<edm::InputTag>("EvmGtInputTag")),
0056 m_l1GtBMToken(esConsumes<L1GtBoardMaps, L1GtBoardMapsRcd>()),
0057 m_activeBoardsMaskGt(pSet.getParameter<unsigned int>("ActiveBoardsMask")),
0058 m_totalBxInEvent(0),
0059 m_minBxInEvent(0),
0060 m_maxBxInEvent(),
0061 m_verbosity(pSet.getUntrackedParameter<int>("Verbosity", 0)),
0062 m_isDebugEnabled(edm::isDebugEnabled())
0063
0064 {
0065 LogDebug("L1GTEvmDigiToRaw") << "\nMask for active boards (hex format): " << std::hex
0066 << std::setw(sizeof(m_activeBoardsMaskGt) * 2) << std::setfill('0')
0067 << m_activeBoardsMaskGt << std::dec << std::setfill(' ')
0068 << "\nInput tag for EVM GT record: " << m_evmGtInputTag
0069 << "\nFED Id for EVM GT record: " << m_evmGtFedId << " \n"
0070 << std::endl;
0071
0072
0073 produces<FEDRawDataCollection>();
0074 }
0075
0076
0077
0078
0079 void L1GTEvmDigiToRaw::produce(edm::Event& iEvent, const edm::EventSetup& evSetup) {
0080
0081
0082 std::unique_ptr<FEDRawDataCollection> allFedRawData(new FEDRawDataCollection);
0083
0084 FEDRawData& gtRawData = allFedRawData->FEDData(m_evmGtFedId);
0085
0086
0087
0088
0089 edm::ESHandle<L1GtBoardMaps> l1GtBM = evSetup.getHandle(m_l1GtBMToken);
0090
0091 const std::vector<L1GtBoard> boardMaps = l1GtBM->gtBoardMaps();
0092 int boardMapsSize = boardMaps.size();
0093
0094 typedef std::vector<L1GtBoard>::const_iterator CItBoardMaps;
0095
0096
0097
0098
0099 std::vector<L1GtBoard> gtRecordMap;
0100 gtRecordMap.reserve(boardMapsSize);
0101
0102 for (int iPos = 0; iPos < boardMapsSize; ++iPos) {
0103 for (CItBoardMaps itBoard = boardMaps.begin(); itBoard != boardMaps.end(); ++itBoard) {
0104 if (itBoard->gtPositionEvmRecord() == iPos) {
0105 gtRecordMap.push_back(*itBoard);
0106 break;
0107 }
0108 }
0109 }
0110
0111
0112 edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtReadoutRecord;
0113 iEvent.getByToken(m_evmGtInputToken, gtReadoutRecord);
0114
0115 if (!gtReadoutRecord.isValid()) {
0116 edm::LogWarning("L1GTEvmDigiToRaw") << "\nWarning: L1GlobalTriggerEvmReadoutRecord with input tag "
0117 << m_evmGtInputTag
0118 << "\nrequested in configuration, but not found in the event."
0119 << "\nQuit packing this event" << std::endl;
0120
0121
0122 iEvent.put(std::move(allFedRawData));
0123
0124 return;
0125 }
0126
0127 if (m_verbosity && m_isDebugEnabled) {
0128 std::ostringstream myCoutStream;
0129 gtReadoutRecord->print(myCoutStream);
0130 LogTrace("L1GTEvmDigiToRaw") << "\n The following L1 GT EVM readout record will be packed.\n"
0131 << " Some boards could be disabled before packing,"
0132 << " see detailed board packing.\n"
0133 << myCoutStream.str() << "\n"
0134 << std::endl;
0135 }
0136
0137
0138 L1GtfeExtWord gtfeBlock = gtReadoutRecord->gtfeWord();
0139
0140
0141 cms_uint16_t recordLength0 = gtfeBlock.recordLength();
0142 cms_uint16_t recordLength1 = gtfeBlock.recordLength1();
0143
0144
0145 m_bstLengthBytes = static_cast<int>(gtfeBlock.bstLengthBytes());
0146
0147
0148
0149
0150
0151 cms_uint16_t activeBoardsGtInitial = gtfeBlock.activeBoards();
0152 cms_uint16_t altNrBxBoardInitial = gtfeBlock.altNrBxBoard();
0153
0154
0155
0156 cms_uint16_t activeBoardsGt = activeBoardsGtInitial & m_activeBoardsMaskGt;
0157
0158 if (m_verbosity && m_isDebugEnabled) {
0159 LogDebug("L1GTEvmDigiToRaw") << "\nActive boards before masking(hex format): " << std::hex
0160 << std::setw(sizeof(activeBoardsGtInitial) * 2) << std::setfill('0')
0161 << activeBoardsGtInitial << std::dec << std::setfill(' ')
0162 << "\nActive boards after masking(hex format): " << std::hex
0163 << std::setw(sizeof(activeBoardsGt) * 2) << std::setfill('0') << activeBoardsGt
0164 << std::dec << std::setfill(' ') << " \n"
0165 << std::endl;
0166 }
0167
0168
0169
0170 unsigned int gtDataSize = 0;
0171
0172 unsigned int headerSize = 8;
0173 gtDataSize += headerSize;
0174
0175 for (CItBoardMaps itBoard = boardMaps.begin(); itBoard != boardMaps.end(); ++itBoard) {
0176 if (itBoard->gtBoardType() == GTFE) {
0177 gtDataSize += gtfeBlock.getSize();
0178 continue;
0179 }
0180
0181 int iActiveBit = itBoard->gtBitEvmActiveBoards();
0182 bool activeBoardToPack = false;
0183
0184 int altNrBxBoardVal = -1;
0185
0186 if (iActiveBit >= 0) {
0187 activeBoardToPack = activeBoardsGt & (1 << iActiveBit);
0188
0189 altNrBxBoardVal = (altNrBxBoardInitial & (1 << iActiveBit)) >> iActiveBit;
0190
0191 if (altNrBxBoardVal == 1) {
0192 m_totalBxInEvent = recordLength1;
0193 } else if (altNrBxBoardVal == 0) {
0194 m_totalBxInEvent = recordLength0;
0195 } else {
0196 if (m_verbosity) {
0197 edm::LogWarning("L1GTEvmDigiToRaw")
0198 << "\n\nWARNING: Wrong value altNrBxBoardVal = " << altNrBxBoardVal << " for board " << std::hex
0199 << (itBoard->gtBoardId()) << std::dec << "\n iActiveBit = " << iActiveBit
0200 << "\n altNrBxBoardInitial = 0x" << std::hex << altNrBxBoardInitial << std::dec
0201 << "\n activeBoardsGt = 0x" << std::hex << activeBoardsGt << std::dec
0202 << "\n activeBoardToPack = " << activeBoardToPack << "\n Set altNrBxBoardVal tentatively to "
0203 << recordLength0 << "\n Job may crash or produce wrong results!\n\n"
0204 << std::endl;
0205 }
0206
0207 m_totalBxInEvent = recordLength0;
0208 }
0209 } else {
0210
0211 continue;
0212 }
0213
0214 if (activeBoardToPack) {
0215 switch (itBoard->gtBoardType()) {
0216 case GTFE: {
0217
0218 }
0219
0220 break;
0221 case FDL: {
0222 L1GtFdlWord fdlBlock;
0223 gtDataSize += m_totalBxInEvent * fdlBlock.getSize();
0224 }
0225
0226 break;
0227 case TCS: {
0228 L1TcsWord tcsBlock;
0229 gtDataSize += tcsBlock.getSize();
0230 }
0231
0232 break;
0233 case TIM: {
0234
0235 }
0236
0237 break;
0238 default: {
0239
0240 }
0241
0242 break;
0243 }
0244 }
0245 }
0246
0247 unsigned int trailerSize = 8;
0248 gtDataSize += trailerSize;
0249
0250
0251
0252 gtRawData.resize(gtDataSize);
0253
0254
0255
0256 unsigned char* ptrGt = gtRawData.data();
0257 unsigned char* ptrGtBegin = gtRawData.data();
0258
0259 if (m_verbosity && m_isDebugEnabled) {
0260 LogDebug("L1GTEvmDigiToRaw") << "\n Size of raw data: " << gtRawData.size() << "\n" << std::endl;
0261 }
0262
0263
0264
0265
0266 packHeader(ptrGt, iEvent);
0267 ptrGt += headerSize;
0268
0269
0270
0271 for (CItBoardMaps itBoard = gtRecordMap.begin(); itBoard != gtRecordMap.end(); ++itBoard) {
0272 if (itBoard->gtBoardType() == GTFE) {
0273 packGTFE(evSetup, ptrGt, gtfeBlock, activeBoardsGt);
0274
0275 if (m_verbosity && m_isDebugEnabled) {
0276 std::ostringstream myCoutStream;
0277 gtfeBlock.print(myCoutStream);
0278 LogTrace("L1GTEvmDigiToRaw") << myCoutStream.str() << "\n" << std::endl;
0279 }
0280
0281 ptrGt += gtfeBlock.getSize();
0282
0283 continue;
0284 }
0285
0286
0287
0288 int iActiveBit = itBoard->gtBitEvmActiveBoards();
0289 bool activeBoardToPack = false;
0290
0291 int altNrBxBoardVal = -1;
0292
0293 if (iActiveBit >= 0) {
0294 activeBoardToPack = activeBoardsGt & (1 << iActiveBit);
0295
0296 altNrBxBoardVal = (altNrBxBoardInitial & (1 << iActiveBit)) >> iActiveBit;
0297
0298 if (altNrBxBoardVal == 1) {
0299 m_totalBxInEvent = recordLength1;
0300 } else if (altNrBxBoardVal == 0) {
0301 m_totalBxInEvent = recordLength0;
0302 } else {
0303 if (m_verbosity) {
0304 edm::LogWarning("L1GTEvmDigiToRaw")
0305 << "\n\nWARNING: Wrong value altNrBxBoardVal = " << altNrBxBoardVal << " for board " << std::hex
0306 << (itBoard->gtBoardId()) << std::dec << "\n iActiveBit = " << iActiveBit
0307 << "\n altNrBxBoardInitial = 0x" << std::hex << altNrBxBoardInitial << std::dec
0308 << "\n activeBoardsGt = 0x" << std::hex << activeBoardsGt << std::dec
0309 << "\n activeBoardToPack = " << activeBoardToPack << "\n Set altNrBxBoardVal tentatively to "
0310 << recordLength0 << "\n Job may crash or produce wrong results!\n\n"
0311 << std::endl;
0312 }
0313
0314 m_totalBxInEvent = recordLength0;
0315 }
0316
0317 m_minBxInEvent = (m_totalBxInEvent + 1) / 2 - m_totalBxInEvent;
0318 m_maxBxInEvent = (m_totalBxInEvent + 1) / 2 - 1;
0319
0320 } else {
0321
0322 continue;
0323 }
0324
0325 if (activeBoardToPack) {
0326 if (m_verbosity && m_isDebugEnabled) {
0327 LogDebug("L1GTEvmDigiToRaw") << "\nBoard " << std::hex << "0x" << (itBoard->gtBoardId()) << std::dec
0328 << "\n Number of bunch crosses in the record: " << m_totalBxInEvent << " = "
0329 << "[" << m_minBxInEvent << ", " << m_maxBxInEvent << "] BX\n"
0330 << std::endl;
0331 }
0332
0333
0334 switch (itBoard->gtBoardType()) {
0335 case TCS: {
0336 L1TcsWord tcsBlock = gtReadoutRecord->tcsWord();
0337 packTCS(evSetup, ptrGt, tcsBlock);
0338
0339 if (m_verbosity && m_isDebugEnabled) {
0340 std::ostringstream myCoutStream;
0341 tcsBlock.print(myCoutStream);
0342 LogTrace("L1GTEvmDigiToRaw") << myCoutStream.str() << "\n" << std::endl;
0343 }
0344
0345 ptrGt += tcsBlock.getSize();
0346
0347 } break;
0348 case FDL: {
0349 for (int iBxInEvent = m_minBxInEvent; iBxInEvent <= m_maxBxInEvent; ++iBxInEvent) {
0350 L1GtFdlWord fdlBlock = gtReadoutRecord->gtFdlWord(iBxInEvent);
0351 packFDL(evSetup, ptrGt, fdlBlock);
0352
0353 if (m_verbosity && m_isDebugEnabled) {
0354 std::ostringstream myCoutStream;
0355 fdlBlock.print(myCoutStream);
0356 LogTrace("L1GTEvmDigiToRaw") << myCoutStream.str() << "\n" << std::endl;
0357 }
0358
0359 ptrGt += fdlBlock.getSize();
0360 }
0361
0362 } break;
0363 default: {
0364
0365 break;
0366 }
0367 }
0368 }
0369 }
0370
0371
0372 packTrailer(ptrGt, ptrGtBegin, gtDataSize);
0373
0374
0375
0376 iEvent.put(std::move(allFedRawData));
0377 }
0378
0379
0380 void L1GTEvmDigiToRaw::packHeader(unsigned char* ptrGt, edm::Event& iEvent) {
0381
0382
0383
0384 int triggerTypeVal = 0;
0385
0386
0387 int lvl1IdVal = iEvent.id().event();
0388
0389
0390 int bxCross = iEvent.bunchCrossing();
0391 cms_uint16_t bxCrossHw = 0;
0392 if ((bxCross & 0xFFF) == bxCross) {
0393 bxCrossHw = static_cast<cms_uint16_t>(bxCross);
0394 } else {
0395 bxCrossHw = 0;
0396 if (m_verbosity && m_isDebugEnabled) {
0397 LogDebug("L1GTEvmDigiToRaw") << "\nBunch cross number [hex] = " << std::hex << bxCross
0398 << "\n larger than 12 bits. Set to 0! \n"
0399 << std::dec << std::endl;
0400 }
0401 }
0402 int bxIdVal = bxCrossHw;
0403
0404
0405 int sourceIdVal = m_evmGtFedId;
0406
0407
0408 int versionVal = 0;
0409
0410
0411
0412
0413 bool moreHeadersVal = false;
0414
0415 FEDHeader gtFEDHeader(ptrGt);
0416
0417 gtFEDHeader.set(ptrGt, triggerTypeVal, lvl1IdVal, bxIdVal, sourceIdVal, versionVal, moreHeadersVal);
0418 }
0419
0420
0421 void L1GTEvmDigiToRaw::packGTFE(const edm::EventSetup& evSetup,
0422 unsigned char* ptrGt,
0423 L1GtfeExtWord& gtfeBlock,
0424 cms_uint16_t activeBoardsGtValue) {
0425 if (m_verbosity && m_isDebugEnabled) {
0426 LogDebug("L1GTEvmDigiToRaw") << "\nPacking GTFE \n" << std::endl;
0427 }
0428
0429 int uLength = L1GlobalTriggerReadoutSetup::UnitLength;
0430
0431
0432 int nrWord64 = gtfeBlock.getSize() / uLength;
0433 std::vector<cms_uint64_t> tmpWord64;
0434 tmpWord64.resize(nrWord64);
0435
0436 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0437 tmpWord64[iWord] = 0x0000000000000000ULL;
0438 }
0439
0440
0441 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0442 gtfeBlock.setBoardIdWord64(tmpWord64[iWord], iWord);
0443 gtfeBlock.setRecordLength1Word64(tmpWord64[iWord], iWord);
0444 gtfeBlock.setRecordLengthWord64(tmpWord64[iWord], iWord);
0445 gtfeBlock.setBxNrWord64(tmpWord64[iWord], iWord);
0446 gtfeBlock.setSetupVersionWord64(tmpWord64[iWord], iWord);
0447 gtfeBlock.setActiveBoardsWord64(tmpWord64[iWord], iWord, activeBoardsGtValue);
0448 gtfeBlock.setAltNrBxBoardWord64(tmpWord64[iWord], iWord);
0449 gtfeBlock.setTotalTriggerNrWord64(tmpWord64[iWord], iWord);
0450
0451 for (int iBst = 0; iBst < m_bstLengthBytes; ++iBst) {
0452 gtfeBlock.setBstWord64(tmpWord64[iWord], iBst, iWord);
0453 }
0454 }
0455
0456
0457
0458 cms_uint64_t* pw = reinterpret_cast<cms_uint64_t*>(const_cast<unsigned char*>(ptrGt));
0459
0460 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0461 *pw++ = tmpWord64[iWord];
0462
0463 if (m_verbosity && m_isDebugEnabled) {
0464 LogTrace("L1GTEvmDigiToRaw") << std::setw(4) << iWord << " " << std::hex << std::setfill('0') << std::setw(16)
0465 << tmpWord64[iWord] << std::dec << std::setfill(' ') << std::endl;
0466 }
0467 }
0468 }
0469
0470
0471 void L1GTEvmDigiToRaw::packTCS(const edm::EventSetup& evSetup, unsigned char* ptrGt, L1TcsWord& tcsBlock) {
0472 if (m_verbosity && m_isDebugEnabled) {
0473 LogDebug("L1GTEvmDigiToRaw") << "\nPacking TCS \n" << std::endl;
0474 }
0475
0476 int uLength = L1GlobalTriggerReadoutSetup::UnitLength;
0477
0478
0479 int nrWord64 = tcsBlock.getSize() / uLength;
0480 std::vector<cms_uint64_t> tmpWord64;
0481 tmpWord64.resize(nrWord64);
0482
0483 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0484 tmpWord64[iWord] = 0x0000000000000000ULL;
0485 }
0486
0487
0488 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0489 tcsBlock.setBoardIdWord64(tmpWord64[iWord], iWord);
0490 tcsBlock.setBxNrWord64(tmpWord64[iWord], iWord);
0491 tcsBlock.setDaqNrWord64(tmpWord64[iWord], iWord);
0492 tcsBlock.setTriggerTypeWord64(tmpWord64[iWord], iWord);
0493 tcsBlock.setStatusWord64(tmpWord64[iWord], iWord);
0494 tcsBlock.setLuminositySegmentNrWord64(tmpWord64[iWord], iWord);
0495
0496 tcsBlock.setPartRunNrWord64(tmpWord64[iWord], iWord);
0497 tcsBlock.setAssignedPartitionsWord64(tmpWord64[iWord], iWord);
0498
0499 tcsBlock.setPartTrigNrWord64(tmpWord64[iWord], iWord);
0500 tcsBlock.setEventNrWord64(tmpWord64[iWord], iWord);
0501
0502 tcsBlock.setOrbitNrWord64(tmpWord64[iWord], iWord);
0503 }
0504
0505
0506
0507 cms_uint64_t* pw = reinterpret_cast<cms_uint64_t*>(const_cast<unsigned char*>(ptrGt));
0508
0509 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0510 *pw++ = tmpWord64[iWord];
0511
0512 if (m_verbosity && m_isDebugEnabled) {
0513 LogTrace("L1GTEvmDigiToRaw") << std::setw(4) << iWord << " " << std::hex << std::setfill('0') << std::setw(16)
0514 << tmpWord64[iWord] << std::dec << std::setfill(' ') << std::endl;
0515 }
0516 }
0517 }
0518
0519
0520 void L1GTEvmDigiToRaw::packFDL(const edm::EventSetup& evSetup, unsigned char* ptrGt, L1GtFdlWord& fdlBlock) {
0521 if (m_verbosity && m_isDebugEnabled) {
0522 LogDebug("L1GTEvmDigiToRaw") << "\nPacking FDL \n" << std::endl;
0523 }
0524
0525 int uLength = L1GlobalTriggerReadoutSetup::UnitLength;
0526
0527
0528 int nrWord64 = fdlBlock.getSize() / uLength;
0529 std::vector<cms_uint64_t> tmpWord64;
0530 tmpWord64.resize(nrWord64);
0531
0532 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0533 tmpWord64[iWord] = 0x0000000000000000ULL;
0534 }
0535
0536
0537 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0538 fdlBlock.setBoardIdWord64(tmpWord64[iWord], iWord);
0539 fdlBlock.setBxInEventWord64(tmpWord64[iWord], iWord);
0540 fdlBlock.setBxNrWord64(tmpWord64[iWord], iWord);
0541 fdlBlock.setEventNrWord64(tmpWord64[iWord], iWord);
0542
0543 fdlBlock.setGtTechnicalTriggerWordWord64(tmpWord64[iWord], iWord);
0544
0545 fdlBlock.setGtDecisionWordAWord64(tmpWord64[iWord], iWord);
0546 fdlBlock.setGtDecisionWordBWord64(tmpWord64[iWord], iWord);
0547
0548 fdlBlock.setGtDecisionWordExtendedWord64(tmpWord64[iWord], iWord);
0549
0550 fdlBlock.setPhysicsDeclaredWord64(tmpWord64[iWord], iWord);
0551 fdlBlock.setGtPrescaleFactorIndexTechWord64(tmpWord64[iWord], iWord);
0552 fdlBlock.setGtPrescaleFactorIndexAlgoWord64(tmpWord64[iWord], iWord);
0553 fdlBlock.setNoAlgoWord64(tmpWord64[iWord], iWord);
0554 fdlBlock.setFinalORWord64(tmpWord64[iWord], iWord);
0555
0556 fdlBlock.setOrbitNrWord64(tmpWord64[iWord], iWord);
0557 fdlBlock.setLumiSegmentNrWord64(tmpWord64[iWord], iWord);
0558 fdlBlock.setLocalBxNrWord64(tmpWord64[iWord], iWord);
0559 }
0560
0561
0562
0563 cms_uint64_t* pw = reinterpret_cast<cms_uint64_t*>(const_cast<unsigned char*>(ptrGt));
0564
0565 for (int iWord = 0; iWord < nrWord64; ++iWord) {
0566 *pw++ = tmpWord64[iWord];
0567
0568 if (m_verbosity && m_isDebugEnabled) {
0569 LogTrace("L1GTEvmDigiToRaw") << std::setw(4) << iWord << " " << std::hex << std::setfill('0') << std::setw(16)
0570 << tmpWord64[iWord] << std::dec << std::setfill(' ') << std::endl;
0571 }
0572 }
0573 }
0574
0575
0576 void L1GTEvmDigiToRaw::packTrailer(unsigned char* ptrGt, unsigned char* ptrGtBegin, int dataSize) {
0577
0578
0579
0580 int lengthVal = dataSize / 8;
0581
0582
0583 int crcVal = evf::compute_crc(ptrGtBegin, dataSize);
0584
0585
0586 int evtStatusVal = 0;
0587
0588
0589 int ttsBitsVal = 0;
0590
0591
0592
0593
0594 bool moreTrailersVal = false;
0595
0596 FEDTrailer gtFEDTrailer(ptrGt);
0597 gtFEDTrailer.set(ptrGt, lengthVal, crcVal, evtStatusVal, ttsBitsVal, moreTrailersVal);
0598 }
0599
0600