eventlibraries/mvtx_decoder/GBTLink.cxx

0001 // @file GBTLink.cxx
0002 // @brief Definitions of GBTLink class used for the ITS/MFT raw data decoding
0003 // @sa <O2/Detectors/ITSMFT/common/reconstruction/src/GBTLink.cxx>
0004 //     <e5b583efa>
0005
0006 #include "GBTLink.h"
0007
0008 using namespace mvtx;
0009
0010 // using RDHUtils = mvtx::RDHUtils;
0011 // using RDH = mvtx::RAWDataHeader;
0012
0013 ///======================================================================
0014 ///                 GBT Link data decoding class
0015 ///======================================================================
0016
0017 ///_________________________________________________________________
0018 /// create link with given ids
0019 GBTLink::GBTLink(uint16_t _flx, uint16_t _fee)
0020   : flxId(_flx)
0021   , feeId(_fee)
0022 {
0023   //  chipStat.feeID = _fee;
0024   //  statistics.feeID = _fee;
0025   data.expand(RawBufferSize);
0026 }
0027
0028 /////_________________________________________________________________
0029 ///// create string describing the link
0030 // std::string GBTLink::describe() const
0031 //{
0032 //   std::string ss = fmt::format("link cruID:{:#06x}/lID{} feeID:{:#06x}",
0033 //   cruID, int(idInCRU), feeID); if (lanes) {
0034 //     ss += fmt::format(" lanes {}", std::bitset<28>(lanes).to_string());
0035 //   }
0036 //   return ss;
0037 // }
0038
0039 ///_________________________________________________________________
0040 /// reset link
0041 void GBTLink::clear(bool resetStat, bool resetTFRaw)
0042 {
0043   data.clear(RawBufferSize);
0044   if (resetTFRaw)
0045   {
0046     rawData.clear();
0047     mL1TrgTime.clear();
0048     mTrgData.clear();
0049     RDHErrors = 0;
0050     for (auto &&hit : hit_vector)
0051     {
0052       delete hit;
0053     }
0054     hit_vector.clear();
0055     tdt_lanestatus_error_vector.clear();
0056     decoder_error_vector.clear();
0057     dataOffset = 0;
0058     hbf_count = 0;
0059   }
0060
0061   if (resetStat)
0062   {
0063     statistics.clear();
0064   }
0065   hbfEntry = 0;
0066   status = None;
0067 }
0068
0069 ///_________________________________________________________________
0070 /// this function reads in 32 bytes  =  3 GBT words and 2 bytes
0071 int GBTLink::readFlxWord(GBTWord *gbtwords, uint16_t &w16)
0072 {
0073   for (uint8_t k = 0; k < 3; k++)
0074   {
0075     gbtwords[k] = *(reinterpret_cast<GBTWord *>(data.getPtr() + dataOffset));
0076     dataOffset += 10;
0077   }
0078
0079   w16 = *(reinterpret_cast<uint16_t *>(data.getPtr() + dataOffset));
0080   dataOffset += 2;
0081   return 0;
0082 }
0083
0084 //
0085 /////_________________________________________________________________
0086 // void GBTLink::printTrigger(const GBTTrigger* gbtTrg, int offs)
0087 //{
0088 //   std::bitset<12> trb(gbtTrg->triggerType);
0089 //   LOG(info) << "Offs: " << offs << " Trigger : Orbit " << gbtTrg->orbit << "
0090 //   BC: " << gbtTrg->bc << " Trigger: " << trb << " noData:"
0091 //             << gbtTrg->noData << " internal:" << gbtTrg->internal << "
0092 //             continuation:" << gbtTrg->continuation << " on " << describe();
0093 //   gbtTrg->printX();
0094 // }
0095 //
0096 /////_________________________________________________________________
0097 // void GBTLink::printCalibrationWord(const GBTCalibration* gbtCal, int offs)
0098 //{
0099 //   LOGP(info, "Offs: {} Calibration word {:5} | user_data {:#08x} on {}",
0100 //   offs, gbtCal->calibCounter, gbtCal->calibUserField, describe());
0101 //   gbtCal->printX();
0102 // }
0103 //
0104 /////_________________________________________________________________
0105 // void GBTLink::printHeader(const GBTDataHeader* gbtH, int offs)
0106 //{
0107 //   std::bitset<28> LA(gbtH->activeLanes);
0108 //   LOG(info) << "Offs: " << offs << " Header : Active Lanes " << LA << " on "
0109 //   << describe(); gbtH->printX();
0110 // }
0111 //
0112 /////_________________________________________________________________
0113 ////void GBTLink::printHeader(const GBTDataHeaderL* gbtH, int offs)
0114 ////{
0115 ////  std::bitset<28> LA(gbtH->activeLanesL);
0116 ////  LOG(info) << "Offs: " << offs << " HeaderL : Active Lanes " << LA << " on
0117 ///" << describe(); /  gbtH->printX(expectPadding);
0118 ////}
0119 //
0120 /////_________________________________________________________________
0121 // void GBTLink::printTrailer(const GBTDataTrailer* gbtT, int offs)
0122 //{
0123 //   std::bitset<28> LT(gbtT->lanesTimeout), LS(gbtT->lanesStops); // RSTODO
0124 //   LOG(info) << "Offs: " << offs << " Trailer: Done=" << gbtT->packetDone << "
0125 //   Lanes TO: " << LT << " | Lanes ST: " << LS << " on " << describe();
0126 //   gbtT->printX();
0127 // }
0128 //
0129 /////_________________________________________________________________
0130 // void GBTLink::printDiagnostic(const GBTDiagnostic* gbtD, int offs)
0131 //{
0132 //   LOG(info) << "Offs: " << offs << " Diagnostic word on " << describe();
0133 //   gbtD->printX();
0134 // }
0135 //
0136 /////_________________________________________________________________
0137 // void GBTLink::printCableDiagnostic(const GBTCableDiagnostic* gbtD)
0138 //{
0139 //   LOGP(info, "Diagnostic for {} Lane {} | errorID: {} data {:#018x} on {}",
0140 //   "IB", gbtD->getCableID(), gbtD->laneErrorID, gbtD->diagnosticData,
0141 //   describe()); gbtD->printX();
0142 // }
0143 //
0144 /////_________________________________________________________________
0145 // void GBTLink::printCableStatus(const GBTCableStatus* gbtS)
0146 //{
0147 //   LOGP(info, "Status data, not processed at the moment, on {}", describe());
0148 //   gbtS->printX();
0149 // }
0150 //
0151 /////====================================================================
0152
0153 #ifdef _RAW_READER_ERROR_CHECKS_
0154
0155 ///_________________________________________________________________
0156 /// Check RDH correctness
0157 // uint8_t GBTLink::checkErrorsRDH(const RDH& rdh)
0158 //{
0159 //   uint8_t err = uint8_t(NoError);
0160 //   if (!RDHUtils::checkRDH(rdh, true)) {
0161 //     statistics.errorCounts[GBTLinkDecodingStat::ErrNoRDHAtStart]++;
0162 //     gbtErrStatUpadated = true;
0163 //     if
0164 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrNoRDHAtStart]))
0165 //     {
0166 //       err |= uint8_t(ErrorPrinted);
0167 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0168 //       statistics.ErrNames[GBTLinkDecodingStat::ErrNoRDHAtStart];
0169 //     }
0170 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrNoRDHAtStart);
0171 //     err |= uint8_t(Abort);
0172 //     return err; // fatal error
0173 //   }
0174 //   /*
0175 //   if ((RDHUtils::getPacketCounter(rdh) > packetCounter + 1) && packetCounter
0176 //   >= 0) {
0177 //     if (irHBF.isDummy()) {
0178 //       irHBF = RDHUtils::getHeartBeatIR(rdh);
0179 //     }
0180 //     statistics.errorCounts[GBTLinkDecodingStat::ErrPacketCounterJump]++;
0181 //     gbtErrStatUpadated = true;
0182 //     if
0183 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrPacketCounterJump]))
0184 //     {
0185 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0186 //       statistics.ErrNames[GBTLinkDecodingStat::ErrPacketCounterJump]
0187 //                 << " : jump from " << int(packetCounter) << " to " <<
0188 //                 int(RDHUtils::getPacketCounter(rdh));
0189 //       err |= uint8_t(ErrorPrinted);
0190 //     }
0191 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrPacketCounterJump);
0192 //     err |= uint8_t(Warning);
0193 //   }
0194 //   packetCounter = RDHUtils::getPacketCounter(rdh);
0195 //   */
0196 //   return err;
0197 // }
0198 //
0199 ///// Check encountered alignment padding word correctness //YCMTODO
0200 // uint8_t GBTLink::checkErrorsAlignmentPadding()
0201 //{
0202 ////  uint8_t err = uint8_t(NoError);
0203 ////  if (lastPageSize - dataOffset >= CRUPageAlignment) {
0204 ////    statistics.errorCounts[GBTLinkDecodingStat::ErrWrongAlignmentWord]++;
0205 ////    gbtErrStatUpadated = true;
0206 ////    if
0207 ///(needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrWrongAlignmentWord]))
0208 ///{ /      err |= uint8_t(ErrorPrinted); /      LOG(info) << describe() << ' '
0209 ///<< statistics.ErrNames[GBTLinkDecodingStat::ErrWrongAlignmentWord] << " at
0210 /// offset " << dataOffset << " for page size " << lastPageSize; /    } /
0211 /// errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrWrongAlignmentWord); / err
0212 ///|= uint8_t(Warning); /    return err; // fatal error /  }
0213 //  return err;
0214 //}
0215 //
0216 /////_________________________________________________________________
0217 ///// Check RDH Stop correctness
0218 // uint8_t GBTLink::checkErrorsRDHStop(const RDH& rdh)
0219 //{
0220 //   uint8_t err = uint8_t(NoError);
0221 //   if (lastRDH && RDHUtils::getLHCBC(*lastRDH) != RDHUtils::getLHCBC(rdh)
0222 //       && !RDHUtils::getStopBit(*lastRDH)) {
0223 //     statistics.errorCounts[GBTLinkDecodingStat::ErrPageNotStopped]++;
0224 //     gbtErrStatUpadated = true;
0225 //     if
0226 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrPageNotStopped]))
0227 //     {
0228 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0229 //       statistics.ErrNames[GBTLinkDecodingStat::ErrPageNotStopped];
0230 //       RDHUtils::printRDH(*lastRDH);
0231 //       RDHUtils::printRDH(rdh);
0232 //       err |= uint8_t(ErrorPrinted);
0233 //     }
0234 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrPageNotStopped);
0235 //     err |= uint8_t(Warning);
0236 //   }
0237 //   return err;
0238 // }
0239 //
0240 /////_________________________________________________________________
0241 ///// Check if the RDH Stop page is empty
0242 // uint8_t GBTLink::checkErrorsRDHStopPageEmpty(const RDH& rdh)
0243 //{
0244 //   uint8_t err = uint8_t(NoError);
0245 //   if (RDHUtils::getStopBit(rdh) && RDHUtils::getPacketSize(rdh) !=
0246 //   sizeof(RDH) + sizeof(FLXWord)) { // there could be only 1 diagnostic
0247 //   GBTWord after stop
0248 //     statistics.errorCounts[GBTLinkDecodingStat::ErrStopPageNotEmpty]++;
0249 //     gbtErrStatUpadated = true;
0250 //     if
0251 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrStopPageNotEmpty]))
0252 //     {
0253 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0254 //       statistics.ErrNames[GBTLinkDecodingStat::ErrStopPageNotEmpty];
0255 //       RDHUtils::printRDH(rdh);
0256 //       err |= uint8_t(ErrorPrinted);
0257 //     }
0258 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrStopPageNotEmpty);
0259 //     err |= uint8_t(Warning);
0260 //   }
0261 //   return err;
0262 // }
0263 //
0264 /////_________________________________________________________________
0265 ///// Check the GBT Trigger word correctness
0266 // uint8_t GBTLink::checkErrorsTriggerWord(const GBTTrigger* gbtTrg)
0267 //{
0268 //   uint8_t err = uint8_t(NoError);
0269 //   if (!gbtTrg->isTriggerWord()) { // check trigger word
0270 //     statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTTrigger]++;
0271 //     gbtErrStatUpadated = true;
0272 //     if
0273 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTTrigger]))
0274 //     {
0275 //       gbtTrg->printX();
0276 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0277 //       statistics.ErrNames[GBTLinkDecodingStat::ErrMissingGBTTrigger]; err |=
0278 //       uint8_t(ErrorPrinted);
0279 //     }
0280 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrMissingGBTTrigger);
0281 //     err |= uint8_t(Abort);
0282 //   }
0283 //   return err;
0284 // }
0285 //
0286 /////_________________________________________________________________
0287 ///// Check the GBT Calibration word correctness
0288 // uint8_t GBTLink::checkErrorsCalibrationWord(const GBTCalibration* gbtCal)
0289 //{
0290 //   // at the moment do nothing
0291 //   return uint8_t(NoError);
0292 // }
0293 //
0294 /////_________________________________________________________________
0295 ///// Check the GBT Header word correctness
0296 // uint8_t GBTLink::checkErrorsHeaderWord(const GBTDataHeader* gbtH)
0297 //{
0298 //   uint8_t err = uint8_t(NoError);
0299 //   if (!gbtH->isDataHeader()) { // check header word
0300 //     statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTHeader]++;
0301 //     gbtErrStatUpadated = true;
0302 //     if
0303 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTHeader]))
0304 //     {
0305 //       gbtH->printX();
0306 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0307 //       statistics.ErrNames[GBTLinkDecodingStat::ErrMissingGBTHeader]; err |=
0308 //       uint8_t(ErrorPrinted);
0309 //     }
0310 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrMissingGBTHeader);
0311 //     err |= uint8_t(Abort);
0312 //   }
0313 //   return err;
0314 // }
0315 //
0316 /////_________________________________________________________________
0317 ///// Check active lanes status
0318 // uint8_t GBTLink::checkErrorsActiveLanes(int cbl)
0319 //{
0320 //   uint8_t err = uint8_t(NoError);
0321 //   if (~cbl & lanesActive) { // are there wrong lanes?
0322 //     statistics.errorCounts[GBTLinkDecodingStat::ErrInvalidActiveLanes]++;
0323 //     gbtErrStatUpadated = true;
0324 //     if
0325 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrInvalidActiveLanes]))
0326 //     {
0327 //       std::bitset<32> expectL(cbl), gotL(lanesActive);
0328 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0329 //       statistics.ErrNames[GBTLinkDecodingStat::ErrInvalidActiveLanes] << ' '
0330 //                 << gotL << " vs " << expectL << " skip page";
0331 //       err |= uint8_t(ErrorPrinted);
0332 //     }
0333 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrInvalidActiveLanes);
0334 //     err |= uint8_t(Warning);
0335 //   }
0336 //   return err;
0337 // }
0338 //
0339 /////_________________________________________________________________
0340 ///// Check GBT Data word
0341 // uint8_t GBTLink::checkErrorsGBTData(int cablePos)
0342 //{
0343 //   uint8_t err = uint8_t(NoError);
0344 //   lanesWithData |= 0x1 << cablePos;    // flag that the data was seen on this
0345 //   lane if (lanesStop & (0x1 << cablePos)) { // make sure stopped lanes do not
0346 //   transmit the data
0347 //     statistics.errorCounts[GBTLinkDecodingStat::ErrDataForStoppedLane]++;
0348 //     gbtErrStatUpadated = true;
0349 //     if
0350 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrDataForStoppedLane]))
0351 //     {
0352 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0353 //       statistics.ErrNames[GBTLinkDecodingStat::ErrDataForStoppedLane] <<
0354 //       cablePos; err |= uint8_t(ErrorPrinted);
0355 //     }
0356 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrDataForStoppedLane);
0357 //     err |= uint8_t(Warning);
0358 //   }
0359 //
0360 //   return err;
0361 // }
0362 //
0363 /////_________________________________________________________________
0364 ///// Check GBT Data word ID: it might be diagnostic or status data
0365 // uint8_t GBTLink::checkErrorsGBTDataID(const GBTData* gbtD)
0366 //{
0367 //   if (gbtD->isData()) {
0368 //     return uint8_t(NoError);
0369 //   }
0370 //   uint8_t err = uint8_t(NoError);
0371 //   statistics.errorCounts[GBTLinkDecodingStat::ErrGBTWordNotRecognized]++;
0372 //   gbtErrStatUpadated = true;
0373 //   if
0374 //   (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrGBTWordNotRecognized]))
0375 //   {
0376 //     if (gbtD->isCableDiagnostic()) {
0377 //       printCableDiagnostic((GBTCableDiagnostic*)gbtD);
0378 //     } else if (gbtD->isStatus()) {
0379 //       printCableStatus((GBTCableStatus*)gbtD);
0380 //     }
0381 //     gbtD->printX();
0382 //     LOG(info) << describe() << ' ' << irHBF << ' ' <<
0383 //     statistics.ErrNames[GBTLinkDecodingStat::ErrGBTWordNotRecognized]; err |=
0384 //     uint8_t(ErrorPrinted);
0385 //   }
0386 //   err |= uint8_t(Skip);
0387 //   return err;
0388 // }
0389 //
0390 /////_________________________________________________________________
0391 ///// Check the GBT Trailer word correctness
0392 // uint8_t GBTLink::checkErrorsTrailerWord(const GBTDataTrailer* gbtT)
0393 //{
0394 //   uint8_t err = uint8_t(NoError);
0395 //   if (!gbtT->isDataTrailer()) {
0396 //     gbtT->printX();
0397 //     statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTTrailer]++;
0398 //     gbtErrStatUpadated = true;
0399 //     if
0400 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTTrailer]))
0401 //     {
0402 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0403 //       statistics.ErrNames[GBTLinkDecodingStat::ErrMissingGBTTrailer]; err |=
0404 //       uint8_t(ErrorPrinted);
0405 //     }
0406 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrMissingGBTTrailer);
0407 //     err |= uint8_t(Abort);
0408 //     return err;
0409 //   }
0410 //   lanesStatus |= gbtT->lanesStatus; // register timeouts
0411 //   return err;
0412 // }
0413 //
0414 /////_________________________________________________________________
0415 ///// Check the Done status in GBT Trailer word
0416 // uint8_t GBTLink::checkErrorsPacketDoneMissing(const GBTDataTrailer* gbtT,
0417 // bool notEnd)
0418 //{
0419 //   uint8_t err = uint8_t(NoError);
0420 //   if (!gbtT || (!gbtT->packetDone && notEnd)) { // Done may be missing only
0421 //   in case of carry-over to new CRU page
0422 //     statistics.errorCounts[GBTLinkDecodingStat::ErrPacketDoneMissing]++;
0423 //     gbtErrStatUpadated = true;
0424 //     if
0425 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrPacketDoneMissing]))
0426 //     {
0427 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0428 //       statistics.ErrNames[GBTLinkDecodingStat::ErrPacketDoneMissing]; err |=
0429 //       uint8_t(ErrorPrinted);
0430 //     }
0431 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrPacketDoneMissing);
0432 //     err |= uint8_t(Warning);
0433 //   }
0434 //   return err;
0435 // }
0436 //
0437 /////_________________________________________________________________
0438 ///// Check that all active lanes received their stop
0439 // uint8_t GBTLink::checkErrorsLanesStops()
0440 //{
0441 //   // make sure all lane stops for finished page are received
0442 //   uint8_t err = uint8_t(NoError);
0443 //   if ((lanesActive & ~lanesStop)) {
0444 //     if (RDHUtils::getTrgType(*lastRDH) != mvtx::TrgBitMap::SOT) { // only SOT
0445 //     trigger allows unstopped lanes?
0446 //       statistics.errorCounts[GBTLinkDecodingStat::ErrUnstoppedLanes]++;
0447 //       gbtErrStatUpadated = true;
0448 //       if
0449 //       (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrUnstoppedLanes]))
0450 //       {
0451 //         std::bitset<32> active(lanesActive), stopped(lanesStop);
0452 //         LOG(info) << describe() << ' ' << irHBF << ' ' <<
0453 //         statistics.ErrNames[GBTLinkDecodingStat::ErrUnstoppedLanes]
0454 //                   << " | active: " << active << " stopped: " << stopped;
0455 //         err |= uint8_t(ErrorPrinted);
0456 //       }
0457 //       errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrUnstoppedLanes);
0458 //     }
0459 //     err |= uint8_t(Warning);
0460 //   }
0461 //   // make sure all active lanes (except those in time-out) have sent some
0462 //   data if ((~lanesWithData & lanesActive) != lanesTimeOut) {
0463 //     statistics.errorCounts[GBTLinkDecodingStat::ErrNoDataForActiveLane]++;
0464 //     gbtErrStatUpadated = true;
0465 //     if
0466 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrNoDataForActiveLane]))
0467 //     {
0468 //       std::bitset<32> withData(lanesWithData), active(lanesActive),
0469 //       timeOut(lanesTimeOut); LOG(info) << describe() << ' ' << irHBF << ' '
0470 //       << statistics.ErrNames[GBTLinkDecodingStat::ErrNoDataForActiveLane]
0471 //                 << " | with data: " << withData << " active: " << active << "
0472 //                 timeOut: " << timeOut;
0473 //       err |= uint8_t(ErrorPrinted);
0474 //     }
0475 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrNoDataForActiveLane);
0476 //     err |= uint8_t(Warning);
0477 //   }
0478 //   return err;
0479 // }
0480 //
0481 /////_________________________________________________________________
0482 ///// Check diagnostic word
0483 // uint8_t GBTLink::checkErrorsDiagnosticWord(const GBTDiagnostic* gbtD)
0484 //{
0485 //   uint8_t err = uint8_t(NoError);
0486 //   if (RDHUtils::getPacketSize(lastRDH) != sizeof(RDH) + sizeof(FLXWord) ||
0487 //   !gbtD->isDiagnosticWord()) { //
0488 //     statistics.errorCounts[GBTLinkDecodingStat::ErrMissingDiagnosticWord]++;
0489 //     gbtErrStatUpadated = true;
0490 //     if
0491 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrMissingDiagnosticWord]))
0492 //     {
0493 //       gbtD->printX();
0494 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0495 //       statistics.ErrNames[GBTLinkDecodingStat::ErrMissingDiagnosticWord]; err
0496 //       |= uint8_t(ErrorPrinted);
0497 //     }
0498 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrMissingDiagnosticWord);
0499 //     err |= uint8_t(Abort);
0500 //   }
0501 //   return err;
0502 // }
0503 //
0504 /////_________________________________________________________________
0505 ///// Check cable ID validity
0506 // uint8_t GBTLink::checkErrorsCableID(const GBTData* gbtD, uint8_t cableSW)
0507 //{
0508 //   uint8_t err = uint8_t(NoError);
0509 //   if (cableSW == 0xff) {
0510 //     statistics.errorCounts[GBTLinkDecodingStat::ErrWrongeCableID]++;
0511 //     gbtErrStatUpadated = true;
0512 //     if
0513 //     (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrWrongeCableID]))
0514 //     {
0515 //       gbtD->printX();
0516 //       LOG(info) << describe() << ' ' << irHBF << ' ' <<
0517 //       statistics.ErrNames[GBTLinkDecodingStat::ErrWrongeCableID] << ' ' <<
0518 //       gbtD->getCableID(); err |= uint8_t(ErrorPrinted);
0519 //     }
0520 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrWrongeCableID);
0521 //     err |= uint8_t(Skip);
0522 //   }
0523 //   return err;
0524 // }
0525
0526 #endif