Compressor.cxx

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#include "TOFCompression/Compressor.h"
#include "TOFBase/Geo.h"
#include "DetectorsRaw/RDHUtils.h"
 
#include <fairlogger/Logger.h>
 
#include <cstring>
#include <iostream>
 
// o2::ctf::CTFIOSize iosize;
#define ENCODER_PARANOID
//#define CHECKER_COUNTER
 
#ifdef DECODER_PARANOID
#warning "Building code with DecoderParanoid option. This may limit the speed."
#endif
#ifdef CHECKER_COUNTER
#warning "Building code with CheckerCounter option. This may limit the speed."
#endif
 
#define colorReset "\033[0m"
#define colorRed "\033[1;31m"
#define colorGreen "\033[1;32m"
#define colorYellow "\033[1;33m"
#define colorBlue "\033[1;34m"
 
// decoding macros
#define IS_DRM_COMMON_HEADER(x) ((x & 0xF0000000) == 0x40000000)
#define IS_DRM_GLOBAL_HEADER(x) ((x & 0xF000000F) == 0x40000001)
#define IS_DRM_GLOBAL_TRAILER(x) ((x & 0xF000000F) == 0x50000001)
#define IS_LTM_GLOBAL_HEADER(x) ((x & 0xF000000F) == 0x40000002)
#define IS_LTM_GLOBAL_TRAILER(x) ((x & 0xF000000F) == 0x50000002)
#define IS_TRM_GLOBAL_HEADER(x) ((x & 0xF0000000) == 0x40000000)
#define IS_TRM_GLOBAL_TRAILER(x) ((x & 0xF0000003) == 0x50000003)
#define IS_TRM_CHAINA_HEADER(x) ((x & 0xF0000000) == 0x00000000)
#define IS_TRM_CHAINA_TRAILER(x) ((x & 0xF0000000) == 0x10000000)
#define IS_TRM_CHAINB_HEADER(x) ((x & 0xF0000000) == 0x20000000)
#define IS_TRM_CHAINB_TRAILER(x) ((x & 0xF0000000) == 0x30000000)
#define IS_TRM_CHAIN_TRAILER(x, c) ((x & 0xF0000000) == (c == 0 ? 0x10000000 : 0x30000000))
#define IS_TDC_ERROR(x) ((x & 0xF0000000) == 0x60000000)
#define IS_FILLER(x) ((x & 0xFFFFFFFF) == 0x70000000)
#define IS_TDC_HIT(x) ((x & 0x80000000) == 0x80000000)
#define IS_TDC_HIT_LEADING(x) ((x & 0xA0000000) == 0xA0000000)
#define IS_TDC_HIT_TRAILING(x) ((x & 0xC0000000) == 0xC0000000)
#define IS_DRM_TEST_WORD(x) ((x & 0xF000000F) == 0xE000000F)
 
// DRM getters
#define GET_DRMDATAHEADER_DRMID(x) DRM_DRMID(x)
#define GET_DRMDATAHEADER_EVENTWORDS(x) DRM_EVWORDS(x)
#define GET_DRMHEADW1_PARTSLOTMASK(x) DRM_SLOTID(x)
#define GET_DRMHEADW1_CLOCKSTATUS(x) DRM_CLKFLG(x)
#define GET_DRMHEADW1_DRMHVERSION(x) DRM_VERSID(x)
#define GET_DRMHEADW1_DRMHSIZE(x) DRM_HSIZE(x)
#define GET_DRMHEADW2_ENASLOTMASK(x) DRM_ENABLEID(x)
#define GET_DRMHEADW2_FAULTSLOTMASK(x) DRM_FAULTID(x)
#define GET_DRMHEADW2_READOUTTIMEOUT(x) DRM_RTMO(x)
#define GET_DRMHEADW3_GBTBUNCHCNT(x) DRM_BCGBT(x)
#define GET_DRMHEADW3_LOCBUNCHCNT(x) DRM_BCLOC(x)
#define GET_DRMHEADW5_EVENTCRC(x) DRM_EVCRC(x)
#define GET_DRMDATATRAILER_LOCEVCNT(x) DRM_LOCEVCNT(x)
 
// LTM getters
#define GET_LTMDATAHEADER_EVENTWORDS(x) LTM_EVENTSIZE(x)
 
// TRM getters
#define GET_TRMDATAHEADER_SLOTID(x) TOF_GETGEO(x)
#define GET_TRMDATAHEADER_EVENTCNT(x) TRM_EVCNT_GH(x)
#define GET_TRMDATAHEADER_EVENTWORDS(x) TRM_EVWORDS(x)
#define GET_TRMDATAHEADER_EMPTYBIT(x) TRM_EMPTYBIT(x)
#define GET_TRMDATATRAILER_LUTERRORBIT(x) TRM_LUTERRBIT(x)
#define GET_TRMDATATRAILER_EVENTCRC(x) TRM_EVCRC2(x)
 
// TRM Chain getters
#define GET_TRMCHAINHEADER_SLOTID(x) TOF_GETGEO(x)
#define GET_TRMCHAINHEADER_BUNCHCNT(x) TRM_BUNCHID(x)
#define GET_TRMCHAINTRAILER_EVENTCNT(x) TRM_EVCNT_CT(x)
#define GET_TRMCHAINTRAILER_STATUS(x) TRM_CHAINSTAT(x)
 
// TDC getters
#define GET_TRMDATAHIT_TIME(x) TRM_TIME(x)
#define GET_TRMDATAHIT_CHANID(x) TRM_CHANID(x)
#define GET_TRMDATAHIT_TDCID(x) TRM_TDCID(x)
#define GET_TRMDATAHIT_EBIT(x) ((x & 0x10000000) >> 28)
 
namespace o2
{
namespace tof
{
 
template <typename RDH, bool verbose, bool paranoid>
bool Compressor<RDH, verbose, paranoid>::processHBF()
{
 
  if (verbose && mDecoderVerbose) {
    std::cout << colorBlue
              << "--- PROCESS HBF"
              << colorReset
              << std::endl;
  }
 
  mDecoderRDH = reinterpret_cast<const RDH*>(mDecoderPointer);
  mEncoderRDH = reinterpret_cast<RDH*>(mEncoderPointer);
  auto rdh = mDecoderRDH;
 
  if (!o2::raw::RDHUtils::checkRDH(rdh, false)) {
    LOG(warning) << "Bad RDH found in TOF compressor -> skip it";
    o2::raw::RDHUtils::checkRDH(rdh, true);
    return true;
  }
 
  uint8_t rdhFormat = o2::raw::RDHUtils::getDataFormat(mDecoderPointer);
  setDecoderCRUZEROES(!rdhFormat);
 
  if (!rdh || rdh->stop || rdh->pageCnt != 0) {
    std::cout << colorRed
              << "[FATAL] this does not look like the first RDH in the HBF"
              << colorReset
              << std::endl;
    o2::raw::RDHUtils::printRDH(*rdh);
    return true;
  }
 
  while (!rdh->stop) {
 
    if (verbose && mDecoderVerbose) {
      std::cout << colorBlue
                << "--- RDH open/continue detected"
                << colorReset
                << std::endl;
      o2::raw::RDHUtils::printRDH(*rdh);
    }
 
    if (rdh->feeId != mDecoderRDH->feeId ||
        rdh->orbit != mDecoderRDH->orbit) {
      std::cout << colorRed
                << "[FATAL] something does not match between this and first RDH"
                << colorReset
                << std::endl;
      return true;
    }
 
    auto headerSize = rdh->headerSize;
    auto memorySize = rdh->memorySize;
    auto offsetToNext = rdh->offsetToNext;
    auto drmPayload = memorySize - headerSize;
 
    if (drmPayload < 0) {
      LOG(warning) << "link = " << rdh->feeId << ": memorySize  < headerSize (" << memorySize << " < " << headerSize << ")";
      return true;
    }
 
    if (mDecoderSaveBufferDataSize + drmPayload >= mDecoderSaveBufferSize) {
      // avoid to allocate memory out of the buffer
      LOG(warning) << "link = " << rdh->feeId << ": beyond the buffer size " << mDecoderSaveBufferSize;
      return true;
    }
 
    std::memcpy(mDecoderSaveBuffer + mDecoderSaveBufferDataSize, reinterpret_cast<const char*>(rdh) + headerSize, drmPayload);
    mDecoderSaveBufferDataSize += drmPayload;
 
    rdh = reinterpret_cast<const RDH*>(reinterpret_cast<const char*>(rdh) + offsetToNext);
 
    if (reinterpret_cast<const char*>(rdh) < mDecoderBuffer + mDecoderBufferSize) {
      continue;
    }
 
    return true;
  }
 
  if (verbose && mDecoderVerbose) {
    std::cout << colorBlue
              << "--- RDH close detected"
              << colorReset
              << std::endl;
    o2::raw::RDHUtils::printRDH(*rdh);
  }
 
  if (rdh->feeId != mDecoderRDH->feeId ||
      rdh->orbit != mDecoderRDH->orbit) {
    std::cout << colorRed
              << "[FATAL] something does not match between this and first RDH"
              << colorReset
              << std::endl;
    return true;
  }
 
  if (mEncoderPointer + mDecoderRDH->headerSize >= mEncoderPointerMax) {
    LOG(warning) << "link = " << rdh->feeId << ": beyond the buffer size mEncoderPointer+mDecoderRDH->headerSize = " << mEncoderPointer + mDecoderRDH->headerSize << " >= "
                 << "mEncoderPointerMax = " << mEncoderPointerMax;
    encoderRewind();
    return true;
  }
  std::memcpy(mEncoderPointer, mDecoderRDH, mDecoderRDH->headerSize);
  mEncoderPointer = reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(mEncoderPointer) + rdh->headerSize);
 
  mDecoderPointer = reinterpret_cast<const uint32_t*>(mDecoderSaveBuffer);
  mDecoderPointerMax = reinterpret_cast<const uint32_t*>(mDecoderSaveBuffer + mDecoderSaveBufferDataSize);
  int nsteps = 0;
  while (mDecoderPointer < mDecoderPointerMax) {
    nsteps++;
    if (nsteps > 3 && !(nsteps % 4)) {
      LOG(debug) << "processHBF: nsteps in while loop = " << nsteps << ", infity loop?";
    }
    mEventCounter++;
    if (processDRM()) {            // if this breaks, we did not run the checker and the summary is not reset!
      mDecoderSummary = {nullptr}; // reset it like this, perhaps a better way can be found
      break;
    }
  }
  mDecoderSaveBufferDataSize = 0;
 
  if (mDecoderFatal) {
    mFatalCounter++;
    mEncoderPointer = mEncoderPointerStart;
    mEncoderRDH->detectorField |= 0x00001000;
  }
 
  mEncoderRDH->memorySize = reinterpret_cast<char*>(mEncoderPointer) - reinterpret_cast<char*>(mEncoderRDH);
  mEncoderRDH->offsetToNext = mEncoderRDH->memorySize;
 
  if (mDecoderError) {
    mErrorCounter++;
  }
 
  // before to move to RDH close check we are not already out of buffer (it is the last chance to call rewind and not to store RDH open)
  if (mEncoderPointer >= mEncoderPointerMax) {
    LOG(error) << "link = " << rdh->feeId << ": beyond the buffer size mEncoderPointer in RDH open = " << mEncoderPointer << " >= "
               << "mEncoderPointerMax = " << mEncoderPointerMax;
    long byteOutOfBuffer = mEncoderPointer + rdh->headerSize - mEncoderPointerMax;
    LOG(error) << "byte out of buffer = " << byteOutOfBuffer;
 
    encoderRewind();
    return true;
  }
 
  if (mEncoderPointer + rdh->headerSize >= mEncoderPointerMax) {
    LOG(warning) << "link = " << rdh->feeId << ": beyond the buffer size mEncoderPointer+rdh->headerSize = " << mEncoderPointer + rdh->headerSize << " >= "
                 << "mEncoderPointerMax = " << mEncoderPointerMax;
    return true;
  }
  mEncoderRDH = reinterpret_cast<RDH*>(mEncoderPointer);
  std::memcpy(mEncoderRDH, rdh, rdh->headerSize);
  mEncoderRDH->memorySize = rdh->headerSize;
  mEncoderRDH->offsetToNext = mEncoderRDH->memorySize;
  mEncoderPointer = reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(mEncoderPointer) + rdh->headerSize);
 
  if (verbose && mDecoderVerbose) {
    std::cout << colorBlue
              << "--- END PROCESS HBF"
              << colorReset
              << std::endl;
  }
 
  mDecoderPointer = reinterpret_cast<const uint32_t*>(reinterpret_cast<const char*>(rdh) + rdh->offsetToNext);
 
  if (reinterpret_cast<const char*>(mDecoderPointer) < mDecoderBuffer + mDecoderBufferSize) {
    return false;
  }
 
  return true;
}
 
template <typename RDH, bool verbose, bool paranoid>
bool Compressor<RDH, verbose, paranoid>::processDRM()
{
 
  if (verbose && mDecoderVerbose) {
    std::cout << colorBlue << "--- PROCESS DRM"
              << colorReset
              << std::endl;
  }
 
  mDecoderNextWord = 1;
  mDecoderError = false;
  mDecoderFatal = false;
  mEncoderPointerStart = mEncoderPointer;
 
  if (!IS_DRM_COMMON_HEADER(*mDecoderPointer)) {
    if (verbose) {
      printf("%s %08x [ERROR] fatal error %s \n", colorRed, *mDecoderPointer, colorReset);
    }
    mDecoderFatal = true;
    return true;
  }
  mDecoderSummary.tofDataHeader = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    auto tofDataHeader = reinterpret_cast<const raw::TOFDataHeader_t*>(mDecoderPointer);
    auto bytePayload = tofDataHeader->bytePayload;
    printf(" %08x TOF Data Header       (bytePayload=%d) \n", *mDecoderPointer, bytePayload);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  mDecoderSummary.tofOrbit = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    auto tofOrbit = reinterpret_cast<const raw::TOFOrbit_t*>(mDecoderPointer);
    auto orbit = tofOrbit->orbit;
    printf(" %08x TOF Orbit             (orbit=%u) \n", *mDecoderPointer, orbit);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  if (!IS_DRM_GLOBAL_HEADER(*mDecoderPointer)) {
    if (verbose) {
      printf("%s %08x [ERROR] fatal error %s \n", colorRed, *mDecoderPointer, colorReset);
    }
    mDecoderFatal = true;
    return true;
  }
  mDecoderSummary.drmDataHeader = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    auto drmDataHeader = reinterpret_cast<const raw::DRMDataHeader_t*>(mDecoderPointer);
    auto drmId = drmDataHeader->drmId;
    auto eventWords = drmDataHeader->eventWords;
    printf(" %08x DRM Data Header       (drmId=%d, eventWords=%d) \n", *mDecoderPointer, drmId, eventWords);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  mDecoderSummary.drmHeadW1 = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    auto drmHeadW1 = reinterpret_cast<const raw::DRMHeadW1_t*>(mDecoderPointer);
    auto partSlotMask = drmHeadW1->partSlotMask;
    auto clockStatus = drmHeadW1->clockStatus;
    auto drmHSize = drmHeadW1->drmHSize;
    printf(" %08x DRM Header Word 1     (partSlotMask=0x%03x, clockStatus=%d, drmHSize=%d) \n", *mDecoderPointer, partSlotMask, clockStatus, drmHSize);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  mDecoderSummary.drmHeadW2 = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    auto drmHeadW2 = reinterpret_cast<const raw::DRMHeadW2_t*>(mDecoderPointer);
    auto enaSlotMask = drmHeadW2->enaSlotMask;
    auto faultSlotMask = drmHeadW2->faultSlotMask;
    auto readoutTimeOut = drmHeadW2->readoutTimeOut;
    printf(" %08x DRM Header Word 2     (enaSlotMask=0x%03x, faultSlotMask=0x%03x, readoutTimeOut=%d) \n", *mDecoderPointer, enaSlotMask, faultSlotMask, readoutTimeOut);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  mDecoderSummary.drmHeadW3 = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    auto drmHeadW3 = reinterpret_cast<const raw::DRMHeadW3_t*>(mDecoderPointer);
    auto gbtBunchCnt = drmHeadW3->gbtBunchCnt;
    auto locBunchCnt = drmHeadW3->locBunchCnt;
    printf(" %08x DRM Header Word 3     (gbtBunchCnt=%d, locBunchCnt=%d) \n", *mDecoderPointer, gbtBunchCnt, locBunchCnt);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  mDecoderSummary.drmHeadW4 = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    printf(" %08x DRM Header Word 4   \n", *mDecoderPointer);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  mDecoderSummary.drmHeadW5 = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    printf(" %08x DRM Header Word 5   \n", *mDecoderPointer);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  *mEncoderPointer = 0x80000000;
  *mEncoderPointer |= GET_DRMHEADW1_PARTSLOTMASK(*mDecoderSummary.drmHeadW1) << 12;
  // R+OLD  *mEncoderPointer |= GET_DRMDATAHEADER_DRMID(*mDecoderSummary.drmDataHeader) << 24;
  *mEncoderPointer |= (mDecoderRDH->feeId & 0xFF) << 24;
  *mEncoderPointer |= GET_DRMHEADW3_GBTBUNCHCNT(*mDecoderSummary.drmHeadW3);
  if (verbose && mEncoderVerbose) {
    auto crateHeader = reinterpret_cast<compressed::CrateHeader_t*>(mEncoderPointer);
    auto bunchID = crateHeader->bunchID;
    auto drmID = crateHeader->drmID;
    auto slotPartMask = crateHeader->slotPartMask;
    printf("%s %08x Crate header          (drmID=%d, bunchID=%d, slotPartMask=0x%x) %s \n", colorGreen, *mEncoderPointer, drmID, bunchID, slotPartMask, colorReset);
  }
  if (encoderNext()) {
    encoderRewind();
    return true;
  }
 
  *mEncoderPointer = *mDecoderSummary.tofOrbit;
  if (verbose && mEncoderVerbose) {
    auto crateOrbit = reinterpret_cast<compressed::CrateOrbit_t*>(mEncoderPointer);
    auto orbitID = crateOrbit->orbitID;
    printf("%s %08x Crate orbit           (orbitID=%u) %s \n", colorGreen, *mEncoderPointer, orbitID, colorReset);
  }
  if (encoderNext()) {
    encoderRewind();
    return true;
  }
 
  int nsteps = 0;
  while (true) {
    nsteps++;
    if (nsteps > 19 && !(nsteps % 20)) {
      LOG(debug) << "processDRM: nsteps in while loop = " << nsteps << ", infity loop?";
    }
 
    if (IS_LTM_GLOBAL_HEADER(*mDecoderPointer)) {
      if (processLTM()) {
        return true;
      }
    }
 
    if (IS_TRM_GLOBAL_HEADER(*mDecoderPointer) && GET_TRMDATAHEADER_SLOTID(*mDecoderPointer) > 2) {
      if (processTRM()) {
        return true;
      }
      continue;
    }
 
    if (IS_DRM_GLOBAL_TRAILER(*mDecoderPointer)) {
      mDecoderSummary.drmDataTrailer = mDecoderPointer;
      if (verbose && mDecoderVerbose) {
        auto drmDataTrailer = reinterpret_cast<const raw::DRMDataTrailer_t*>(mDecoderPointer);
        auto locEvCnt = drmDataTrailer->locEvCnt;
        printf(" %08x DRM Data Trailer      (locEvCnt=%d) \n", *mDecoderPointer, locEvCnt);
      }
      decoderNext();
 
      while ((mDecoderPointer < mDecoderPointerMax) && IS_FILLER(*mDecoderPointer)) {
        if (verbose && mDecoderVerbose) {
          printf(" %08x Filler \n", *mDecoderPointer);
        }
        decoderNext();
      }
 
      *mEncoderPointer = 0x80000000;
      *mEncoderPointer |= GET_DRMDATATRAILER_LOCEVCNT(*mDecoderSummary.drmDataTrailer) << 4;
 
      checkerCheck();
      *mEncoderPointer |= mCheckerSummary.nDiagnosticWords;
#if ENCODE_TDC_ERRORS
      *mEncoderPointer |= (mCheckerSummary.nTDCErrors << 16);
#endif
 
      if (verbose && mEncoderVerbose) {
        auto CrateTrailer = reinterpret_cast<compressed::CrateTrailer_t*>(mEncoderPointer);
        auto EventCounter = CrateTrailer->eventCounter;
        auto NumberOfDiagnostics = CrateTrailer->numberOfDiagnostics;
        auto NumberOfErrors = CrateTrailer->numberOfErrors;
        printf("%s %08x Crate trailer         (EventCounter=%d, NumberOfDiagnostics=%d, NumberOfErrors=%d) %s \n", colorGreen, *mEncoderPointer, EventCounter, NumberOfDiagnostics, NumberOfErrors, colorReset);
      }
      if (encoderNext()) {
        encoderRewind();
        return true;
      }
 
      for (int iword = 0; iword < mCheckerSummary.nDiagnosticWords; ++iword) {
        auto itrm = (mCheckerSummary.DiagnosticWord[iword] & 0xF) - 3;
        *mEncoderPointer = mCheckerSummary.DiagnosticWord[iword];
        if (verbose && mEncoderVerbose) {
          auto Diagnostic = reinterpret_cast<compressed::Diagnostic_t*>(mEncoderPointer);
          auto slotId = Diagnostic->slotID;
          auto faultBits = Diagnostic->faultBits;
          printf("%s %08x Diagnostic            (slotId=%d, faultBits=0x%x) %s \n", colorGreen, *mEncoderPointer, slotId, faultBits, colorReset);
        }
        if (encoderNext()) {
          encoderRewind();
          return true;
        }
      }
 
      for (int itrm = 0; itrm < 10; ++itrm) {
        for (int ichain = 0; ichain < 2; ++ichain) {
#if ENCODE_TDC_ERRORS
          for (int ierror = 0; ierror < mDecoderSummary.trmErrors[itrm][ichain]; ++ierror) {
            *mEncoderPointer = *mDecoderSummary.trmError[itrm][ichain][ierror];
            *mEncoderPointer &= 0xFF07FFFF;
            *mEncoderPointer |= ((itrm + 3) << 19);
            *mEncoderPointer |= (ichain << 23);
            if (verbose && mEncoderVerbose) {
              auto Error = reinterpret_cast<compressed::Error_t*>(mEncoderPointer);
              auto errorFlags = Error->errorFlags;
              auto slotID = Error->slotID;
              auto chain = Error->chain;
              auto tdcID = Error->tdcID;
              printf("%s %08x Error                 (slotId=%d, chain=%d, tdcId=%d, errorFlags=0x%x) %s \n", colorGreen, *mEncoderPointer, slotID, chain, tdcID, errorFlags, colorReset);
            }
            if (encoderNext()) {
              encoderRewind();
              return true;
            }
          }
#endif
          mDecoderSummary.trmErrors[itrm][ichain] = 0;
        }
      }
 
      mCheckerSummary.nDiagnosticWords = 0;
      mCheckerSummary.nTDCErrors = 0;
 
      break;
    }
 
    if (IS_DRM_TEST_WORD(*mDecoderPointer)) {
      if (verbose && mDecoderVerbose) {
        printf(" %08x DRM Test Word \n", *mDecoderPointer);
      }
      decoderNext();
      continue;
    }
 
    mDecoderError = true;
    mDecoderSummary.drmDecodeError = true;
 
    if (verbose && mDecoderVerbose) {
      printf("%s %08x [ERROR] trying to recover DRM decode stream %s \n", colorRed, *mDecoderPointer, colorReset);
    }
 
    if (decoderParanoid()) {
      return true;
    }
 
    decoderNext();
 
  } 
  mIntegratedBytes += getDecoderByteCounter();
 
  if (verbose && mDecoderVerbose) {
    std::cout << colorBlue
              << "--- END PROCESS DRM"
              << colorReset
              << std::endl;
  }
 
  return false;
}
 
template <typename RDH, bool verbose, bool paranoid>
bool Compressor<RDH, verbose, paranoid>::processLTM()
{
  mDecoderSummary.ltmDataHeader = mDecoderPointer;
  uint32_t eventWords = GET_LTMDATAHEADER_EVENTWORDS(*mDecoderPointer); // this is the total event size, including header/trailer
  uint32_t payload = eventWords - 2;
  if (verbose && mDecoderVerbose) {
    auto ltmDataHeader = reinterpret_cast<const raw::LTMDataHeader_t*>(mDecoderPointer);
    auto eventWords = ltmDataHeader->eventWords;
    auto cycloneErr = ltmDataHeader->cycloneErr;
    auto fault = ltmDataHeader->cycloneErr;
    printf(" %08x LTM Data Header       (eventWords=%d, cycloneErr=%d, fault=%d) \n", *mDecoderPointer, eventWords, cycloneErr, fault);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  for (int i = 0; i < payload; ++i) {
    if (verbose && mDecoderVerbose) {
      printf(" %08x LTM Data \n", *mDecoderPointer);
    }
    decoderNext();
    if (paranoid && decoderParanoid()) {
      return true;
    }
  }
 
  if (IS_LTM_GLOBAL_TRAILER(*mDecoderPointer)) {
    mDecoderSummary.ltmDataTrailer = mDecoderPointer;
    if (verbose && mDecoderVerbose) {
      printf(" %08x LTM Global Trailer \n", *mDecoderPointer);
    }
    decoderNext();
    if (paranoid && decoderParanoid()) {
      return true;
    }
  }
 
  return false;
}
 
template <typename RDH, bool verbose, bool paranoid>
bool Compressor<RDH, verbose, paranoid>::processTRM()
{
  uint32_t slotId = GET_TRMDATAHEADER_SLOTID(*mDecoderPointer);
  int itrm = slotId - 3;
  mDecoderSummary.trmDataHeader[itrm] = mDecoderPointer;
  if (verbose && mDecoderVerbose) {
    auto trmDataHeader = reinterpret_cast<const raw::TRMDataHeader_t*>(mDecoderPointer);
    auto eventWords = trmDataHeader->eventWords;
    auto eventCnt = trmDataHeader->eventCnt;
    auto emptyBit = trmDataHeader->emptyBit;
    printf(" %08x TRM Data Header       (slotId=%u, eventWords=%d, eventCnt=%d, emptyBit=%01x) \n", *mDecoderPointer, slotId, eventWords, eventCnt, emptyBit);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  int nsteps = 0;
  while (true) {
    nsteps++;
    if (nsteps > 19 && !(nsteps % 20)) {
      LOG(debug) << "processTRM: nsteps in while loop = " << nsteps << ", infity loop?";
    }
 
    if (IS_TRM_CHAINA_HEADER(*mDecoderPointer) && GET_TRMCHAINHEADER_SLOTID(*mDecoderPointer) == slotId) {
      if (processTRMchain(itrm, 0)) {
        return true;
      }
    }
 
    if (IS_TRM_CHAINB_HEADER(*mDecoderPointer) && GET_TRMCHAINHEADER_SLOTID(*mDecoderPointer) == slotId) {
      if (processTRMchain(itrm, 1)) {
        return true;
      }
    }
 
    if (IS_TRM_GLOBAL_TRAILER(*mDecoderPointer)) {
      mDecoderSummary.trmDataTrailer[itrm] = mDecoderPointer;
      if (verbose && mDecoderVerbose) {
        auto trmDataTrailer = reinterpret_cast<const raw::TRMDataTrailer_t*>(mDecoderPointer);
        auto eventCRC = trmDataTrailer->eventCRC;
        auto lutErrorBit = trmDataTrailer->lutErrorBit;
        printf(" %08x TRM Data Trailer      (slotId=%u, eventCRC=%d, lutErrorBit=%d) \n", *mDecoderPointer, slotId, eventCRC, lutErrorBit);
      }
      decoderNext();
      if (paranoid && decoderParanoid()) {
        return true;
      }
 
      if (IS_FILLER(*mDecoderPointer)) {
        if (verbose && mDecoderVerbose) {
          printf(" %08x Filler \n", *mDecoderPointer);
        }
        decoderNext();
        if (paranoid && decoderParanoid()) {
          return true;
        }
      }
 
      if (mDecoderSummary.hasHits[itrm][0] || mDecoderSummary.hasHits[itrm][1]) {
        if (encoderSpider(itrm)) {
          encoderRewind();
          return true;
        }
      }
 
      return false;
    }
 
    mDecoderError = true;
    mDecoderSummary.trmDecodeError[itrm] = true;
    if (verbose && mDecoderVerbose) {
      printf("%s %08x [ERROR] breaking TRM decode stream %s \n", colorRed, *mDecoderPointer, colorReset);
    }
    decoderNext();
    if (decoderParanoid()) { 
      return true;
    }
 
    return false;
 
  } 
  return false;
}
 
template <typename RDH, bool verbose, bool paranoid>
bool Compressor<RDH, verbose, paranoid>::processTRMchain(int itrm, int ichain)
{
  int slotId = itrm + 3;
 
  mDecoderSummary.trmChainHeader[itrm][ichain] = mDecoderPointer;
  mDecoderSummary.hasHits[itrm][ichain] = false;
  mDecoderSummary.hasErrors[itrm][ichain] = false;
  if (verbose && mDecoderVerbose) {
    auto trmChainHeader = reinterpret_cast<const raw::TRMChainHeader_t*>(mDecoderPointer);
    auto bunchCnt = trmChainHeader->bunchCnt;
    printf(" %08x TRM Chain-%c Header    (slotId=%u, bunchCnt=%d) \n", *mDecoderPointer, ichain == 0 ? 'A' : 'B', slotId, bunchCnt);
  }
  decoderNext();
  if (paranoid && decoderParanoid()) {
    return true;
  }
 
  int nsteps = 0;
  while (true) {
    nsteps++;
    if (nsteps > 99 && !(nsteps % 100)) {
      LOG(debug) << "processTRMchain: nsteps in while loop = " << nsteps << ", infity loop?";
    }
    if (IS_TDC_HIT(*mDecoderPointer)) {
      mDecoderSummary.hasHits[itrm][ichain] = true;
      auto itdc = GET_TRMDATAHIT_TDCID(*mDecoderPointer);
      auto ihit = mDecoderSummary.trmDataHits[ichain][itdc];
      mDecoderSummary.trmDataHit[ichain][itdc][ihit] = mDecoderPointer;
      mDecoderSummary.trmDataHits[ichain][itdc]++;
      if (verbose && mDecoderVerbose) {
        auto trmDataHit = reinterpret_cast<const raw::TRMDataHit_t*>(mDecoderPointer);
        auto time = trmDataHit->time;
        auto chanId = trmDataHit->chanId;
        auto tdcId = trmDataHit->tdcId;
        auto dataId = trmDataHit->dataId;
        printf(" %08x TRM Data Hit          (time=%d, chanId=%d, tdcId=%d, dataId=0x%x) \n", *mDecoderPointer, time, chanId, tdcId, dataId);
      }
      decoderNext();
      if (paranoid && decoderParanoid()) {
        return true;
      }
      continue;
    }
 
    if (IS_TDC_ERROR(*mDecoderPointer)) {
      mDecoderSummary.hasErrors[itrm][ichain] = true;
      auto ierror = mDecoderSummary.trmErrors[itrm][ichain];
      mDecoderSummary.trmError[itrm][ichain][ierror] = mDecoderPointer;
      mDecoderSummary.trmErrors[itrm][ichain]++;
      if (verbose && mDecoderVerbose) {
        printf("%s %08x TDC error %s \n", colorRed, *mDecoderPointer, colorReset);
      }
      decoderNext();
      if (paranoid && decoderParanoid()) {
        return true;
      }
      continue;
    }
 
    if (IS_TRM_CHAIN_TRAILER(*mDecoderPointer, ichain)) {
      mDecoderSummary.trmChainTrailer[itrm][ichain] = mDecoderPointer;
      if (verbose && mDecoderVerbose) {
        auto trmChainTrailer = reinterpret_cast<const raw::TRMChainTrailer_t*>(mDecoderPointer);
        auto eventCnt = trmChainTrailer->eventCnt;
        printf(" %08x TRM Chain-A Trailer   (slotId=%u, eventCnt=%d) \n", *mDecoderPointer, slotId, eventCnt);
      }
      decoderNext();
      if (paranoid && decoderParanoid()) {
        return true;
      }
      break;
    }
 
    mDecoderError = true;
    mDecoderSummary.trmDecodeError[itrm] = true;
    if (verbose && mDecoderVerbose) {
      printf("%s %08x [ERROR] breaking TRM Chain-%c decode stream %s \n", colorRed, *mDecoderPointer, ichain == 0 ? 'A' : 'B', colorReset);
    }
    decoderNext();
    if (decoderParanoid()) { 
      return true;
    }
 
    break;
 
  } 
  return false;
}
 
template <typename RDH, bool verbose, bool paranoid>
bool Compressor<RDH, verbose, paranoid>::decoderParanoid()
{
  if (mDecoderPointer >= mDecoderPointerMax) {
    if (verbose) {
      printf("%s %08x [ERROR] fatal error: beyond memory size %s \n", colorRed, *mDecoderPointer, colorReset);
    }
    mDecoderFatal = true;
    return true;
  }
  return false;
}
 
template <typename RDH, bool verbose, bool paranoid>
int Compressor<RDH, verbose, paranoid>::encoderSpider(int itrm)
{
  int slotId = itrm + 3;
 
  int firstFilledFrame = 255;
  int lastFilledFrame = 0;
 
  for (int ichain = 0; ichain < 2; ++ichain) {
 
    if (!mDecoderSummary.hasHits[itrm][ichain]) {
      continue;
    }
 
    for (int itdc = 0; itdc < 15; ++itdc) {
 
      auto nhits = mDecoderSummary.trmDataHits[ichain][itdc];
      if (nhits == 0) {
        continue;
      }
 
      for (int ihit = 0; ihit < nhits; ++ihit) {
 
        auto lhit = *mDecoderSummary.trmDataHit[ichain][itdc][ihit];
        if (!IS_TDC_HIT_LEADING(lhit)) { // must be a leading hit
          continue;
        }
 
        auto chan = GET_TRMDATAHIT_CHANID(lhit);
        auto hitTime = GET_TRMDATAHIT_TIME(lhit);
        auto eBit = GET_TRMDATAHIT_EBIT(lhit);
        uint32_t totWidth = 0;
 
        // check next hits for packing
        for (int jhit = ihit + 1; jhit < nhits; ++jhit) {
          auto thit = *mDecoderSummary.trmDataHit[ichain][itdc][jhit];
          if (IS_TDC_HIT_TRAILING(thit) && GET_TRMDATAHIT_CHANID(thit) == chan) {      // must be a trailing hit from same channel
            totWidth = (GET_TRMDATAHIT_TIME(thit) - hitTime) / Geo::RATIO_TOT_TDC_BIN; // compute TOT
            lhit = 0x0;                                                                // mark as used
            break;
          }
        }
 
        auto iframe = hitTime >> 13;
        auto phit = mSpiderSummary.nFramePackedHits[iframe];
 
        mSpiderSummary.FramePackedHit[iframe][phit] = 0x00000000;
        mSpiderSummary.FramePackedHit[iframe][phit] |= (totWidth & 0x7FF) << 0;
        mSpiderSummary.FramePackedHit[iframe][phit] |= (hitTime & 0x1FFF) << 11;
        mSpiderSummary.FramePackedHit[iframe][phit] |= chan << 24;
        mSpiderSummary.FramePackedHit[iframe][phit] |= itdc << 27;
        mSpiderSummary.FramePackedHit[iframe][phit] |= ichain << 31;
        mSpiderSummary.nFramePackedHits[iframe]++;
 
        if (iframe < firstFilledFrame) {
          firstFilledFrame = iframe;
        }
        if (iframe > lastFilledFrame) {
          lastFilledFrame = iframe;
        }
      }
 
      mDecoderSummary.trmDataHits[ichain][itdc] = 0;
    }
  }
 
  for (int iframe = firstFilledFrame; iframe < lastFilledFrame + 1; iframe++) {
 
    if (mSpiderSummary.nFramePackedHits[iframe] == 0) {
      continue;
    }
 
    // encode Frame Header
    *mEncoderPointer = 0x00000000;
    *mEncoderPointer |= slotId << 24;
    *mEncoderPointer |= iframe << 16;
    *mEncoderPointer |= mSpiderSummary.nFramePackedHits[iframe];
    if (verbose && mEncoderVerbose) {
      auto FrameHeader = reinterpret_cast<const compressed::FrameHeader_t*>(mEncoderPointer);
      auto NumberOfHits = FrameHeader->numberOfHits;
      auto FrameID = FrameHeader->frameID;
      auto TRMID = FrameHeader->trmID;
      printf("%s %08x Frame header          (TRMID=%d, FrameID=%d, NumberOfHits=%d) %s \n", colorGreen, *mEncoderPointer, TRMID, FrameID, NumberOfHits, colorReset);
    }
    if (encoderNext()) {
      encoderRewind();
      return true;
    }
 
    // packed hits
    for (int ihit = 0; ihit < mSpiderSummary.nFramePackedHits[iframe]; ++ihit) {
      *mEncoderPointer = mSpiderSummary.FramePackedHit[iframe][ihit];
      if (verbose && mEncoderVerbose) {
        auto PackedHit = reinterpret_cast<const compressed::PackedHit_t*>(mEncoderPointer);
        auto Chain = PackedHit->chain;
        auto TDCID = PackedHit->tdcID;
        auto Channel = PackedHit->channel;
        auto Time = PackedHit->time;
        auto TOT = PackedHit->tot;
        printf("%s %08x Packed hit            (Chain=%d, TDCID=%d, Channel=%d, Time=%d, TOT=%d) %s \n", colorGreen, *mEncoderPointer, Chain, TDCID, Channel, Time, TOT, colorReset);
      }
      if (encoderNext()) {
        encoderRewind();
        return true;
      }
    }
 
    mSpiderSummary.nFramePackedHits[iframe] = 0;
  }
  return 0;
}
 
template <typename RDH, bool verbose, bool paranoid>
bool Compressor<RDH, verbose, paranoid>::checkerCheck()
{
  mCheckerSummary.nDiagnosticWords = 0;
 
  if (verbose && mCheckerVerbose) {
    std::cout << colorBlue
              << "--- CHECK EVENT"
              << colorReset
              << std::endl;
  }
 
  //    mCheckerCounter++;
 
  mCheckerSummary.DiagnosticWord[0] = 0x00000001;
 
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking DRM Data Header: %p \n", mDecoderSummary.drmDataHeader);
  }
  if (!mDecoderSummary.drmDataHeader) {
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_HEADER_MISSING;
    if (verbose && mCheckerVerbose) {
      printf(" Missing DRM Data Header \n");
    }
    mDecoderSummary = {nullptr};
    mCheckerSummary.nDiagnosticWords++;
    for (int itrm = 0; itrm < 10; ++itrm) {
      mDecoderSummary.trmDataHeader[itrm] = nullptr;
      mDecoderSummary.trmDataTrailer[itrm] = nullptr;
      for (int ichain = 0; ichain < 2; ++ichain) {
        mDecoderSummary.trmChainHeader[itrm][ichain] = nullptr;
        mDecoderSummary.trmChainTrailer[itrm][ichain] = nullptr;
        mDecoderSummary.trmErrors[itrm][ichain] = 0;
        mDecoderSummary.trmErrors[itrm][ichain] = 0;
      }
    }
    return true;
  }
 
  if (mDecoderSummary.drmDecodeError) {
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_DECODE_ERROR;
    if (verbose && mCheckerVerbose) {
      printf(" DRM decode error \n");
    }
    mDecoderSummary.drmDecodeError = false;
  }
 
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking DRM Data Trailer: %p \n", mDecoderSummary.drmDataTrailer);
  }
  if (!mDecoderSummary.drmDataTrailer) {
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_TRAILER_MISSING;
    if (verbose && mCheckerVerbose) {
      printf(" Missing DRM Data Trailer \n");
    }
    mDecoderSummary = {nullptr};
    mCheckerSummary.nDiagnosticWords++;
 
    return true;
  }
 
  uint32_t partSlotMask = GET_DRMHEADW1_PARTSLOTMASK(*mDecoderSummary.drmHeadW1) & 0x7FE; // remove LTM bit
  uint32_t enaSlotMask = GET_DRMHEADW2_ENASLOTMASK(*mDecoderSummary.drmHeadW2) & 0x7FE;   // remove LTM bit
  uint32_t gbtBunchCnt = GET_DRMHEADW3_GBTBUNCHCNT(*mDecoderSummary.drmHeadW3);
  uint32_t locEvCnt = GET_DRMDATATRAILER_LOCEVCNT(*mDecoderSummary.drmDataTrailer);
 
  if (!mDecoderCONET) {
    checkerCheckRDH();
  }
 
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking Enable/participating mask: %03x/%03x \n", enaSlotMask, partSlotMask);
  }
  if (partSlotMask != enaSlotMask) {
    if (verbose && mCheckerVerbose) {
      printf(" Enable/participating mask differ: %03x/%03x \n", enaSlotMask, partSlotMask);
    }
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_ENAPARTMASK_DIFFER;
  }
 
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking DRM clock status: %d \n", GET_DRMHEADW1_CLOCKSTATUS(*mDecoderSummary.drmHeadW1));
  }
  if (GET_DRMHEADW1_CLOCKSTATUS(*mDecoderSummary.drmHeadW1) != 2) {
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_CLOCKSTATUS_WRONG;
    if (verbose && mCheckerVerbose) {
      printf("%s DRM wrong clock status: %d %s\n", colorRed, GET_DRMHEADW1_CLOCKSTATUS(*mDecoderSummary.drmHeadW1), colorReset);
    }
  }
 
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking DRM fault slot mask: %x \n", GET_DRMHEADW2_FAULTSLOTMASK(*mDecoderSummary.drmHeadW2));
  }
  if (GET_DRMHEADW2_FAULTSLOTMASK(*mDecoderSummary.drmHeadW2)) {
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_FAULTSLOTMASK_NOTZERO;
    if (verbose && mCheckerVerbose) {
      printf(" DRM fault slot mask: %x \n", GET_DRMHEADW2_FAULTSLOTMASK(*mDecoderSummary.drmHeadW2));
    }
  }
 
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking DRM readout timeout: %d \n", GET_DRMHEADW2_READOUTTIMEOUT(*mDecoderSummary.drmHeadW2));
  }
  if (GET_DRMHEADW2_READOUTTIMEOUT(*mDecoderSummary.drmHeadW2)) {
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_READOUTTIMEOUT_NOTZERO;
    if (verbose && mCheckerVerbose) {
      printf(" DRM readout timeout \n");
    }
  }
 
  auto drmEventWords = mDecoderSummary.drmDataTrailer - mDecoderSummary.drmDataHeader + 1;
  if (mDecoderNextWordStep) {
    drmEventWords -= (drmEventWords / 4) * 2;
  }
  drmEventWords -= 6;
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking DRM declared/detected event words: %u/%ld \n", GET_DRMDATAHEADER_EVENTWORDS(*mDecoderSummary.drmDataHeader), drmEventWords);
  }
  if (GET_DRMDATAHEADER_EVENTWORDS(*mDecoderSummary.drmDataHeader) != drmEventWords) {
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_EVENTWORDS_MISMATCH;
    if (verbose && mCheckerVerbose) {
      printf(" DRM declared/detected event words mismatch: %u/%ld \n", GET_DRMDATAHEADER_EVENTWORDS(*mDecoderSummary.drmDataHeader), drmEventWords);
    }
  }
 
  auto iword = mCheckerSummary.nDiagnosticWords;
  if (mCheckerSummary.DiagnosticWord[iword] & 0xFFFFFFF0) {
    mCheckerSummary.nDiagnosticWords++;
    iword++;
  }
 
  mCheckerSummary.DiagnosticWord[iword] = 0x00000002;
 
  if (!(partSlotMask & 1)) {
    if (mDecoderSummary.ltmDataHeader != nullptr) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::LTM_HEADER_UNEXPECTED;
      if (verbose && mCheckerVerbose) {
        printf(" Non-participating LTM header found \n");
      }
    }
  } else {
    if (verbose && mCheckerVerbose) {
      printf(" --- Checking LTM Data Header: %p \n", mDecoderSummary.ltmDataHeader);
    }
    if (!mDecoderSummary.ltmDataHeader) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::LTM_HEADER_MISSING;
      if (verbose && mCheckerVerbose) {
        printf(" Missing LTM Data Header \n");
      }
    }
 
    if (verbose && mCheckerVerbose) {
      printf(" --- Checking LTM Data Trailer: %p \n", mDecoderSummary.ltmDataTrailer);
    }
    if (!mDecoderSummary.ltmDataTrailer) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::LTM_TRAILER_MISSING;
      if (verbose && mCheckerVerbose) {
        printf(" Missing LTM Data Trailer \n");
      }
    }
  }
 
  mDecoderSummary.ltmDataHeader = nullptr;
  mDecoderSummary.ltmDataTrailer = nullptr;
 
  for (int itrm = 0; itrm < 10; ++itrm) {
    uint32_t slotId = itrm + 3;
 
    if (mCheckerSummary.DiagnosticWord[iword] & 0xFFFFFFF0) {
      mCheckerSummary.nDiagnosticWords++;
      iword++;
    }
 
    mCheckerSummary.DiagnosticWord[iword] = slotId;
 
    if (!(partSlotMask & 1 << (itrm + 1))) {
      if (mDecoderSummary.trmDataHeader[itrm]) {
        mCheckerSummary.DiagnosticWord[iword] |= diagnostic::TRM_HEADER_UNEXPECTED;
        if (verbose && mCheckerVerbose) {
          printf(" Non-participating header found (slotId=%u) \n", slotId);
        }
      } else {
        continue;
      }
    }
 
    if (GET_DRMHEADW2_FAULTSLOTMASK(*mDecoderSummary.drmHeadW2) & 1 << (itrm + 1)) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::TRM_FAULTSLOTBIT_NOTZERO;
      if (verbose && mCheckerVerbose) {
        printf(" Fault slot bit set (slotId=%u) \n", slotId);
      }
    }
 
    if (!mDecoderSummary.trmDataHeader[itrm]) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::TRM_HEADER_MISSING;
      if (verbose && mCheckerVerbose) {
        printf(" Missing TRM Data Header (slotId=%u) \n", slotId);
      }
      mDecoderSummary.trmErrors[itrm][0] = 0;
      mDecoderSummary.trmErrors[itrm][1] = 0;
      continue;
    }
 
    if (mDecoderSummary.trmDecodeError[itrm]) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::TRM_DECODE_ERROR;
      if (verbose && mCheckerVerbose) {
        printf(" Decode error in TRM (slotId=%u) \n", slotId);
      }
      mDecoderSummary.trmDecodeError[itrm] = false;
    }
 
    if (!mDecoderSummary.trmDataTrailer[itrm]) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::TRM_TRAILER_MISSING;
      if (verbose && mCheckerVerbose) {
        printf(" Missing TRM Trailer (slotId=%u) \n", slotId);
      }
      mDecoderSummary.trmDataHeader[itrm] = nullptr;
      mDecoderSummary.trmErrors[itrm][0] = 0;
      mDecoderSummary.trmErrors[itrm][1] = 0;
      continue;
    }
 
#ifdef CHECKER_COUNTER
    mTRMCounters[itrm].Headers++;
#endif
 
#ifdef CHECKER_COUNTER
    if (!mDecoderSummary.hasHits[itrm][0] && !mDecoderSummary.hasHits[itrm][1])
      mTRMCounters[itrm].Empty++;
#endif
 
    uint32_t eventCnt = GET_TRMDATAHEADER_EVENTCNT(*mDecoderSummary.trmDataHeader[itrm]);
    if (eventCnt != locEvCnt % 1024) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::TRM_EVENTCNT_MISMATCH;
#ifdef CHECKER_COUNTER
      mTRMCounters[itrm].EventCounterMismatch++;
#endif
      if (verbose && mCheckerVerbose) {
        printf(" TRM EventCounter / DRM LocalEventCounter mismatch: %u / %u (slotId=%u) \n", eventCnt, locEvCnt, slotId);
      }
    }
 
    if (GET_TRMDATAHEADER_EMPTYBIT(*mDecoderSummary.trmDataHeader[itrm])) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::TRM_EMPTYBIT_NOTZERO;
#ifdef CHECKER_COUNTER
      mTRMCounters[itrm].EBit++;
#endif
      if (verbose && mCheckerVerbose) {
        printf(" TRM empty bit is on (slotId=%u) \n", slotId);
      }
    }
 
    auto trmEventWords = mDecoderSummary.trmDataTrailer[itrm] - mDecoderSummary.trmDataHeader[itrm] + 1;
    if (mDecoderNextWordStep) {
      trmEventWords -= (trmEventWords / 4) * 2;
    }
    if (verbose && mCheckerVerbose) {
      printf(" --- Checking TRM (slotId=%u) declared/detected event words: %d/%ld \n", slotId, GET_TRMDATAHEADER_EVENTWORDS(*mDecoderSummary.trmDataHeader[itrm]), trmEventWords);
    }
    if (GET_TRMDATAHEADER_EVENTWORDS(*mDecoderSummary.trmDataHeader[itrm]) != trmEventWords) {
      mCheckerSummary.DiagnosticWord[iword] |= diagnostic::TRM_EVENTWORDS_MISMATCH;
      if (verbose && mCheckerVerbose) {
        printf(" TRM (slotId=%u) declared/detected event words mismatch: %d/%ld \n", slotId, GET_TRMDATAHEADER_EVENTWORDS(*mDecoderSummary.trmDataHeader[itrm]), trmEventWords);
      }
    }
 
    for (int ichain = 0; ichain < 2; ichain++) {
 
      if (!mDecoderSummary.trmChainHeader[itrm][ichain]) {
        mCheckerSummary.DiagnosticWord[iword] |= (diagnostic::TRMCHAIN_HEADER_MISSING << (ichain * 8));
        if (verbose && mCheckerVerbose) {
          printf(" Missing TRM Chain Header (slotId=%u, chain=%d) \n", slotId, ichain);
        }
        mDecoderSummary.trmErrors[itrm][ichain] = 0;
        continue;
      }
 
      if (!mDecoderSummary.trmChainTrailer[itrm][ichain]) {
        mCheckerSummary.DiagnosticWord[iword] |= (diagnostic::TRMCHAIN_TRAILER_MISSING << (ichain * 8));
        if (verbose && mCheckerVerbose) {
          printf(" Missing TRM Chain Trailer (slotId=%u, chain=%d) \n", slotId, ichain);
        }
        mDecoderSummary.trmChainHeader[itrm][ichain] = nullptr;
        mDecoderSummary.trmErrors[itrm][ichain] = 0;
        continue;
      }
 
#ifdef CHECKER_COUNTER
      mTRMChainCounters[itrm][ichain].Headers++;
#endif
 
      if (mDecoderSummary.hasErrors[itrm][ichain]) {
        mCheckerSummary.DiagnosticWord[iword] |= (diagnostic::TRMCHAIN_TDCERROR_DETECTED << (ichain * 8));
        mCheckerSummary.nTDCErrors += mDecoderSummary.trmErrors[itrm][ichain];
#ifdef CHECKER_COUNTER
        mTRMChainCounters[itrm][ichain].TDCerror++;
#endif
        if (verbose && mCheckerVerbose) {
          printf(" TDC error detected (slotId=%u, chain=%d) \n", slotId, ichain);
        }
      }
 
      uint32_t eventCnt = GET_TRMCHAINTRAILER_EVENTCNT(*mDecoderSummary.trmChainTrailer[itrm][ichain]);
      if (eventCnt != locEvCnt) {
        mCheckerSummary.DiagnosticWord[iword] |= (diagnostic::TRMCHAIN_EVENTCNT_MISMATCH << (ichain * 8));
#ifdef CHECKER_COUNTER
        mTRMChainCounters[itrm][ichain].EventCounterMismatch++;
#endif
        if (verbose && mCheckerVerbose) {
          printf(" TRM Chain EventCounter / DRM LocalEventCounter mismatch: %u / %u (slotId=%u, chain=%d) \n", eventCnt, locEvCnt, slotId, ichain);
        }
      }
 
      uint32_t status = GET_TRMCHAINTRAILER_STATUS(*mDecoderSummary.trmChainTrailer[itrm][ichain]);
      if (status != 0) {
        mCheckerSummary.DiagnosticWord[iword] |= (diagnostic::TRMCHAIN_STATUS_NOTZERO << (ichain * 8));
#ifdef CHECKER_COUNTER
        mTRMChainCounters[itrm][ichain].BadStatus++;
#endif
        if (verbose && mCheckerVerbose) {
          printf(" TRM Chain bad Status: %u (slotId=%u, chain=%d) \n", status, slotId, ichain);
        }
      }
 
      uint32_t bunchCnt = GET_TRMCHAINHEADER_BUNCHCNT(*mDecoderSummary.trmChainHeader[itrm][ichain]);
      if (bunchCnt != gbtBunchCnt) {
        mCheckerSummary.DiagnosticWord[iword] |= (diagnostic::TRMCHAIN_BUNCHCNT_MISMATCH << (ichain * 8));
#ifdef CHECKER_COUNTER
        mTRMChainCounters[itrm][ichain].BunchIDMismatch++;
#endif
        if (verbose && mCheckerVerbose) {
          printf(" TRM Chain BunchID / DRM L0BCID mismatch: %u / %u (slotId=%u, chain=%d) \n", bunchCnt, gbtBunchCnt, slotId, ichain);
        }
      }
 
      mDecoderSummary.trmChainHeader[itrm][ichain] = nullptr;
      mDecoderSummary.trmChainTrailer[itrm][ichain] = nullptr;
 
    } 
    mDecoderSummary.trmDataHeader[itrm] = nullptr;
    mDecoderSummary.trmDataTrailer[itrm] = nullptr;
 
  } 
  if (mCheckerSummary.DiagnosticWord[iword] & 0xFFFFFFF0) {
    mCheckerSummary.nDiagnosticWords++;
  }
 
  if (verbose && mCheckerVerbose) {
    std::cout << colorBlue
              << "--- END CHECK EVENT: " << mCheckerSummary.nDiagnosticWords << " diagnostic words"
              << colorReset
              << std::endl;
  }
 
  mDecoderSummary.tofDataHeader = nullptr;
  mDecoderSummary.drmDataHeader = nullptr;
  mDecoderSummary.drmDataTrailer = nullptr;
 
  return false;
}
 
template <typename RDH, bool verbose, bool paranoid>
void Compressor<RDH, verbose, paranoid>::checkerCheckRDH()
{
  uint32_t orbit = *mDecoderSummary.tofOrbit;
  uint32_t drmId = GET_DRMDATAHEADER_DRMID(*mDecoderSummary.drmDataHeader);
 
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking DRM/RDH orbit: %08x/%08x \n", orbit, mDecoderRDH->orbit);
  }
  if (orbit != mDecoderRDH->orbit) {
    if (verbose && mCheckerVerbose) {
      printf(" DRM/RDH orbit mismatch: %08x/%08x \n", orbit, mDecoderRDH->orbit);
    }
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_ORBIT_MISMATCH;
  }
 
  if (verbose && mCheckerVerbose) {
    printf(" --- Checking DRM/RDH FEE id: %d/%d \n", drmId, mDecoderRDH->feeId & 0xFF);
  }
  if (drmId != (mDecoderRDH->feeId & 0xFF)) {
    if (verbose && mCheckerVerbose) {
      printf(" DRM/RDH FEE id mismatch: %d/%d \n", drmId, mDecoderRDH->feeId & 0xFF);
    }
    mCheckerSummary.DiagnosticWord[0] |= diagnostic::DRM_FEEID_MISMATCH;
  }
}
 
template <typename RDH, bool verbose, bool paranoid>
void Compressor<RDH, verbose, paranoid>::resetCounters()
{
  mEventCounter = 0;
  mFatalCounter = 0;
  mErrorCounter = 0;
  mDRMCounters = {0};
  for (int itrm = 0; itrm < 10; ++itrm) {
    mTRMCounters[itrm] = {0};
    for (int ichain = 0; ichain < 2; ++ichain) {
      mTRMChainCounters[itrm][ichain] = {0};
    }
  }
}
 
template <typename RDH, bool verbose, bool paranoid>
void Compressor<RDH, verbose, paranoid>::checkSummary()
{
  char chname[2] = {'a', 'b'};
 
  std::cout << colorBlue
            << "--- SUMMARY COUNTERS: " << mEventCounter << " events "
            << " | " << mFatalCounter << " decode fatals "
            << " | " << mErrorCounter << " decode errors "
            << colorReset
            << std::endl;
#ifndef CHECKER_COUNTER
  return;
#endif
  if (mEventCounter == 0) {
    return;
  }
  printf("\n");
  printf("    DRM ");
  float drmheaders = 100. * (float)mDRMCounters.Headers / (float)mEventCounter;
  printf("  \033%sheaders: %5.1f %%\033[0m ", drmheaders < 100. ? "[1;31m" : "[0m", drmheaders);
  if (mDRMCounters.Headers == 0) {
    printf("\n");
    return;
  }
  float cbit = 100. * (float)mDRMCounters.clockStatus / float(mDRMCounters.Headers);
  printf("     \033%sCbit: %5.1f %%\033[0m ", cbit > 0. ? "[1;31m" : "[0m", cbit);
  float fault = 100. * (float)mDRMCounters.Fault / float(mDRMCounters.Headers);
  printf("    \033%sfault: %5.1f %%\033[0m ", fault > 0. ? "[1;31m" : "[0m", cbit);
  float rtobit = 100. * (float)mDRMCounters.RTOBit / float(mDRMCounters.Headers);
  printf("   \033%sRTObit: %5.1f %%\033[0m ", rtobit > 0. ? "[1;31m" : "[0m", cbit);
  printf("\n");
  //      std::cout << "-----------------------------------------------------------" << std::endl;
  //      printf("    LTM | headers: %5.1f %% \n", 0.);
  for (int itrm = 0; itrm < 10; ++itrm) {
    printf("\n");
    printf(" %2d TRM ", itrm + 3);
    float trmheaders = 100. * (float)mTRMCounters[itrm].Headers / float(mDRMCounters.Headers);
    printf("  \033%sheaders: %5.1f %%\033[0m ", trmheaders < 100. ? "[1;31m" : "[0m", trmheaders);
    if (mTRMCounters[itrm].Headers == 0.) {
      printf("\n");
      continue;
    }
    float empty = 100. * (float)mTRMCounters[itrm].Empty / (float)mTRMCounters[itrm].Headers;
    printf("    \033%sempty: %5.1f %%\033[0m ", empty > 0. ? "[1;31m" : "[0m", empty);
    float evCount = 100. * (float)mTRMCounters[itrm].EventCounterMismatch / (float)mTRMCounters[itrm].Headers;
    printf("  \033%sevCount: %5.1f %%\033[0m ", evCount > 0. ? "[1;31m" : "[0m", evCount);
    float ebit = 100. * (float)mTRMCounters[itrm].EBit / (float)mTRMCounters[itrm].Headers;
    printf("     \033%sEbit: %5.1f %%\033[0m ", ebit > 0. ? "[1;31m" : "[0m", ebit);
    printf(" \n");
    for (int ichain = 0; ichain < 2; ++ichain) {
      printf("      %c ", chname[ichain]);
      float chainheaders = 100. * (float)mTRMChainCounters[itrm][ichain].Headers / (float)mTRMCounters[itrm].Headers;
      printf("  \033%sheaders: %5.1f %%\033[0m ", chainheaders < 100. ? "[1;31m" : "[0m", chainheaders);
      if (mTRMChainCounters[itrm][ichain].Headers == 0) {
        printf("\n");
        continue;
      }
      float status = 100. * mTRMChainCounters[itrm][ichain].BadStatus / (float)mTRMChainCounters[itrm][ichain].Headers;
      printf("   \033%sstatus: %5.1f %%\033[0m ", status > 0. ? "[1;31m" : "[0m", status);
      float bcid = 100. * mTRMChainCounters[itrm][ichain].BunchIDMismatch / (float)mTRMChainCounters[itrm][ichain].Headers;
      printf("     \033%sbcID: %5.1f %%\033[0m ", bcid > 0. ? "[1;31m" : "[0m", bcid);
      float tdcerr = 100. * mTRMChainCounters[itrm][ichain].TDCerror / (float)mTRMChainCounters[itrm][ichain].Headers;
      printf("   \033%sTDCerr: %5.1f %%\033[0m ", tdcerr > 0. ? "[1;31m" : "[0m", tdcerr);
      printf("\n");
    }
  }
  printf("\n");
}
 
template class Compressor<o2::header::RAWDataHeader, false, false>;
template class Compressor<o2::header::RAWDataHeader, false, true>;
template class Compressor<o2::header::RAWDataHeader, true, false>;
template class Compressor<o2::header::RAWDataHeader, true, true>;
 
} // namespace tof
} // namespace o2