RawReaderCRU.h

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.
 
#ifndef O2_TPC_RAWREADERCRU_H_
#define O2_TPC_RAWREADERCRU_H_
 
 
// read a file into memory
#include <iostream> // std::cout
#include <fstream>  // std::std::ifstream
#include <cstdint>
#include <iomanip>
#include <vector>
#include <map>
#include <array>
#include <bitset>
#include <cmath>
#include <string_view>
#include <algorithm>
#include <functional>
#include <gsl/span>
#include "DetectorsRaw/RDHUtils.h"
 
#include "TPCBase/CRU.h"
#include "Headers/RAWDataHeader.h"
#include "Headers/RDHAny.h"
#include "TPCBase/PadPos.h"
#include "TPCBase/PadROCPos.h"
#include "TPCBase/RDHUtils.h"
#include "TPCReconstruction/RawProcessingHelpers.h"
 
//#include "git_info.hpp"
namespace o2
{
namespace tpc
{
namespace rawreader
{
 
using RDHUtils = o2::raw::RDHUtils;
using RDH = o2::header::RDHAny;
 
enum DebugLevel : uint8_t {
  SyncPositions = 0, 
  GBTFrames = 1,     
  ADCValues = 2,     
  RDHDump = 3,       
  EventInfo = 5      
};
 
enum class DataType : uint8_t {
  Continuous = 1, 
  HBScaling = 2,  
  Triggered = 3,  
};
 
enum class ReaderType : uint8_t {
  FLP = 0, 
  EPN = 1, 
};
 
enum class RAWDataType : uint8_t {
  GBT = 0,    
  LinkZS = 1, 
};
 
static constexpr int MaxNumberOfLinks = 24; 
 
// ===========================================================================
class ADCRawData
{
 public:
  using DataVector = std::vector<uint32_t>;
 
  ADCRawData()
  {
    for (auto& data : mADCRaw) {
      data.reserve(520 * 16);
    }
  }
 
  void add(int stream, uint32_t v0, uint32_t v1)
  {
    mADCRaw[stream].emplace_back(v0);
    mADCRaw[stream].emplace_back(v1);
  };
 
  void setOutputStream(uint32_t outStream) { mOutputStream = outStream; };
 
  void setNumTimebins(uint32_t numTB)
  {
    if (numTB >= mADCRaw[mOutputStream].size()) {
      mNumTimeBins = mADCRaw[mOutputStream].size();
    } else {
      mNumTimeBins = numTB;
    }
  };
 
  uint32_t getNumTimebins() const { return mADCRaw[mOutputStream].size(); };
 
  void streamTo(std::ostream& output) const;
 
  friend std::ostream& operator<<(std::ostream& output, const ADCRawData& rawData)
  {
    rawData.streamTo(output);
    return output;
  }
 
  const DataVector& getDataVector(int stream) const { return mADCRaw[stream]; }
 
  friend std::ostream& operator<<(std::ostream& output, const ADCRawData& rawData);
 
  void reset()
  {
    mOutputStream = 0;
    mNumTimeBins = 0;
    for (auto& data : mADCRaw) {
      data.clear();
    }
  }
 
  bool hasData() const
  {
    for (auto& data : mADCRaw) {
      if (data.size()) {
        return true;
      }
    }
    return false;
  }
 
 private:
  uint32_t mOutputStream{0};           // variable to set the output stream for the << operator
  uint32_t mNumTimeBins{0};            // variable to set the number of timebins for the << operator
  std::array<DataVector, 5> mADCRaw{}; // array of 5 vectors to hold the raw ADC data for each stream
};                                     // class ADCRawData
 
//==============================================================================
class SyncPosition
{
 public:
  SyncPosition() = default;
 
  void setPos(uint32_t pN, uint32_t fN, uint32_t fP, uint32_t hP)
  {
    mSyncFound = true;
    mPacketNum = pN;
    mFrameNum = fN;
    mFilePos = fP;
    mHalfWordPos = hP;
  };
 
  uint32_t getHalfWordPosition() const { return mHalfWordPos; };
 
  uint32_t getFrameNumber() const { return mFrameNum; }
 
  uint32_t getPacketNumber() const { return mPacketNum; }
 
  bool synched() const { return mSyncFound; };
 
  friend std::ostream& operator<<(std::ostream& output, const SyncPosition& sp)
  {
    output << "SYNC found at" << std::dec
           << "; Filepos : " << sp.mFilePos
           << "; Packet : " << sp.mPacketNum
           << "; Frame : " << sp.mFrameNum
           << "; Halfword : " << sp.mHalfWordPos
           << '\n';
 
    return output;
  };
 
 private:
  bool mSyncFound{false};   
  uint32_t mPacketNum{0};   
  uint32_t mFrameNum{0};    
  uint32_t mFilePos{0};     
  uint32_t mHalfWordPos{0}; 
};                          // class SyncPosition
 
using SyncArray = std::array<SyncPosition, 5>;
 
// ===========================================================================
class GBTFrame
{
 public:
  using adc_t = uint32_t;
 
  GBTFrame() = default;
 
  void setSyncPositions(const SyncArray& syncArray) { mSyncPos = syncArray; }
 
  bool syncFound(int stream) { return mSyncPos[stream].synched(); };
 
  const SyncArray& getSyncArray() const { return mSyncPos; }
 
  void updateSyncCheck(SyncArray& syncArray);
 
  void updateSyncCheck(bool verbose = false);
 
  void getFrameHalfWords();
 
  void storePrevFrame();
 
  void getAdcValues(ADCRawData& rawData);
 
  void readFromMemory(gsl::span<const std::byte> data);
 
  void streamFrom(std::istream& input);
 
  void streamTo(std::ostream& output) const;
 
  friend std::istream& operator>>(std::istream& input, GBTFrame& frame)
  {
    frame.streamFrom(input);
    return input;
  }
 
  friend std::ostream& operator<<(std::ostream& output, const GBTFrame& frame)
  {
    frame.streamTo(output);
    return output;
  }
 
  void setPacketNumber(uint32_t packetNumber) { mPacketNum = packetNumber; }
 
  void setFrameNumber(uint32_t frameNumber) { mFrameNum = frameNumber; }
 
 private:
  std::array<adc_t, 4> mData{};     
  SyncArray mSyncPos{};             
  adc_t mFrameHalfWords[5][8]{};    
  uint32_t mPrevHWpos{0};           
  uint32_t mSyncCheckRegister[5]{}; 
  uint32_t mFilePos{0};             
  uint32_t mFrameNum{0};            
  uint32_t mPacketNum{0};           
 
  template <typename T>
  T bit(T s, T t) const;
 
  // /// get value of specific bit
  // static constexpr uint32_t getBit(uint32_t value, uint32_t bit)
  //{
  // return (value & (1 << bit)) >> bit;
  //}
 
  template <typename T>
  static constexpr T shiftBit(T value, T from, T to)
  {
    return (value & (1 << from)) >> from << to;
  }
}; // class GBTFrame
class RawReaderCRUManager;
 
class RawReaderCRUEventSync
{
 public:
  static constexpr size_t ExpectedNumberOfPacketsPerHBFrame{8}; 
  static constexpr size_t ExpectedPayloadSize{64000};           
 
  RawReaderCRUEventSync() { reset(); }
 
  // ---------------------------------------------------------------------------
  struct LinkInfo {
    size_t PayloadSize{};                  
    bool HBEndSeen{false};                 
    bool IsPresent{false};                 
    bool WasSeen{false};                   
    std::vector<size_t> PacketPositions{}; 
 
    size_t getNumberOfPackets() const { return PacketPositions.size(); }
 
    bool isComplete() const { return HBEndSeen && (((PacketPositions.size() == ExpectedNumberOfPacketsPerHBFrame)) || (PayloadSize == ExpectedPayloadSize)); }
 
    bool isFirstPacket() const { return (PacketPositions.size() == 0); }
  };
  // using LinkInfoArray_t = std::array<LinkInfo, 24>;
  using LinkInfoArray_t = std::vector<LinkInfo>;
 
  // ---------------------------------------------------------------------------
  struct CRUInfo {
    CRUInfo() : LinkInformation(MaxNumberOfLinks) {}
 
    bool isPresent() const
    {
      for (const auto& link : LinkInformation) {
        if (link.IsPresent) {
          return true;
        }
      }
      return false;
    }
 
    bool isComplete(RAWDataType rawDataType = RAWDataType::GBT) const
    {
      for (const auto& link : LinkInformation) {
        if (link.WasSeen && !link.IsPresent) {
          return false;
        }
        if (rawDataType == RAWDataType::GBT) {
          if (!link.isComplete()) {
            return false;
          }
        }
        if (rawDataType == RAWDataType::LinkZS) {
          if (link.IsPresent && !link.HBEndSeen) {
            return false;
          }
        }
      }
      return true;
    }
 
    size_t totalPayloadSize() const
    {
      size_t totalPayloadSize = 0;
      for (const auto& link : LinkInformation) {
        if (link.IsPresent) {
          totalPayloadSize += link.PayloadSize;
        }
      }
      return totalPayloadSize;
    }
 
    LinkInfoArray_t LinkInformation;
  };
  // using CRUInfoArray_t = std::array<CRUInfo, CRU::MaxCRU>;
  using CRUInfoArray_t = std::vector<CRUInfo>;
 
  // ---------------------------------------------------------------------------
  struct EventInfo {
    EventInfo() : CRUInfoArray(CRU::MaxCRU) {}
    EventInfo(uint32_t heartbeatOrbit) : CRUInfoArray(CRU::MaxCRU) { HeartbeatOrbits.emplace_back(heartbeatOrbit); }
    EventInfo(const EventInfo&) = default;
 
    bool operator<(const EventInfo& other) const { return HeartbeatOrbits.back() < other.HeartbeatOrbits[0]; }
 
    bool hasHearbeatOrbit(uint32_t heartbeatOrbit) const { return std::find(HeartbeatOrbits.begin(), HeartbeatOrbits.end(), heartbeatOrbit) != HeartbeatOrbits.end(); }
 
    uint32_t getFirstOrbit() const { return HeartbeatOrbits.size() ? *std::min_element(HeartbeatOrbits.begin(), HeartbeatOrbits.end()) : 0; }
 
    std::vector<uint32_t> HeartbeatOrbits{}; 
    CRUInfoArray_t CRUInfoArray;             
    bool IsComplete{false};                  
  };
 
  // ---------------------------------------------------------------------------
  using EventInfoVector = std::vector<EventInfo>;
 
  LinkInfo& getLinkInfo(const RDH& rdh, DataType dataType)
  {
    if (!mLastEvent) {
      const auto heartbeatOrbit = RDHUtils::getHeartBeatOrbit(rdh);
      createEvent(heartbeatOrbit, dataType);
    }
 
    const auto detField = o2::raw::RDHUtils::getDetectorField(rdh);
    const auto feeId = RDHUtils::getFEEID(rdh);
    const auto endPoint = rdh_utils::getEndPoint(feeId);
    auto link = rdh_utils::getLink(feeId);
    if (link == 21 && detField == 0x02) {
      link = 0;
    }
    const auto globalLink = link + endPoint * 12;
    const auto cru = rdh_utils::getCRU(feeId);
 
    return mLastEvent->CRUInfoArray[cru].LinkInformation[globalLink];
  }
 
  const LinkInfoArray_t& getLinkInfoArrayForEvent(size_t eventNumber, int cru) const { return mEventInformation[eventNumber].CRUInfoArray[cru].LinkInformation; }
 
  size_t getNumberOfEvents() const { return mEventInformation.size(); }
 
  size_t getNumberOfCompleteEvents() const
  {
    size_t nComplete = 0;
    for (const auto& event : mEventInformation) {
      nComplete += event.IsComplete;
    }
    return nComplete;
  }
 
  size_t getNumberOfEvents(CRU /*cru*/) const { return mEventInformation.size(); }
 
  bool isEventComplete(size_t eventNumber) const
  {
    if (eventNumber >= mEventInformation.size()) {
      return false;
    }
    return mEventInformation[eventNumber].IsComplete;
  }
 
  void sortEvents() { std::sort(mEventInformation.begin(), mEventInformation.end()); }
 
  EventInfo& createEvent(const uint32_t heartbeatOrbit, DataType dataType);
 
  void analyse(RAWDataType rawDataType = RAWDataType::GBT);
 
  const EventInfoVector& getEventInfoVector() const { return mEventInformation; }
 
  const EventInfo& getEventInfo(size_t eventNumber) const { return mEventInformation[eventNumber]; }
 
  void streamTo(std::ostream& output) const;
 
  void setLinksSeen(const CRU cru, const std::bitset<MaxNumberOfLinks>& links);
 
  void setCRUSeen(const CRU cru, const uint16_t reader = 0) { mCRUSeen[cru] = reader; }
 
  const auto& getCRUSeen() const { return mCRUSeen; }
 
  uint32_t getReaderNumber(uint32_t cru) { return mCRUSeen[cru]; }
 
  void reset()
  {
    mEventInformation.clear();
    mCRUSeen.fill(-1);
  }
 
  friend std::ostream& operator<<(std::ostream& output, const RawReaderCRUEventSync& eventSync)
  {
    eventSync.streamTo(output);
    return output;
  }
 
 private:
  EventInfoVector mEventInformation{};         
  EventInfo* mLastEvent{nullptr};              
  std::array<int16_t, CRU::MaxCRU> mCRUSeen{}; 
 
  ClassDefNV(RawReaderCRUEventSync, 0); // event synchronisation for raw reader instances
};                                      // class RawReaderCRUEventSync
 
// =============================================================================
// =============================================================================
// =============================================================================
class RawReaderCRU
{
 public:
  class PacketDescriptor;
  using PacketDescriptorMap = std::vector<PacketDescriptor>;
  using PacketDescriptorMapArray = std::array<PacketDescriptorMap, MaxNumberOfLinks>;
 
  RawReaderCRU(const std::string_view inputFileName,
               uint32_t numTimeBins = 0,
               uint32_t link = 0,
               uint32_t stream = 0,
               uint32_t debugLevel = 0,
               uint32_t verbosity = 0,
               const std::string_view outputFilePrefix = "",
               uint32_t readerNumber = 0)
    : mDebugLevel(debugLevel),
      mVerbosity(verbosity),
      mNumTimeBins(numTimeBins),
      mLink(link),
      mStream(stream),
      mReaderNumber(readerNumber),
      mCRU(),
      mFileSize(-1),
      mPacketsPerLink(),
      mLinkPresent(),
      mPacketDescriptorMaps(),
      mInputFileName(inputFileName),
      mOutputFilePrefix(outputFilePrefix)
  {
    if (mOutputFilePrefix.empty()) {
      mOutputFilePrefix = mInputFileName.substr(0, mInputFileName.rfind('.'));
    }
  }
 
  class Error : public std::runtime_error
  {
   public:
    Error(const std::string& what_arg) : std::runtime_error("Decoding error:" + what_arg) {}
  };
 
  int scanFile();
 
  void setLink(uint32_t link) { mLink = link; }
 
  void setVerbosity(uint32_t verbosity = 1) { mVerbosity = verbosity; }
 
  void setDebugLevel(uint32_t debugLevel = 1) { mDebugLevel = debugLevel; }
 
  void setEventNumber(uint32_t eventNumber = 0) { mEventNumber = eventNumber; }
 
  void setReaderNumber(uint32_t readerNumber) { mReaderNumber = readerNumber; }
 
  void setFillADCdataMap(bool fill) { mFillADCdataMap = fill; }
 
  bool getFillADCdataMap() const { return mFillADCdataMap; }
 
  uint32_t getEventNumber() const { return mEventNumber; }
 
  size_t getNumberOfEvents() const;
 
  bool checkLinkPresent(uint32_t link) { return mLinkPresent[link]; }
 
  int processDataFile();
 
  void processLinkZS();
 
  void processDataMemory();
 
  int processPacket(GBTFrame& gFrame, uint32_t startPos, uint32_t size, ADCRawData& rawData);
 
  int processMemory(const std::vector<std::byte>& data, ADCRawData& rawData);
 
  void processLinks(const uint32_t linkMask = 0);
 
  void findSyncPositions();
 
  bool syncFoundForLink(const int link) const
  {
    const auto& arr = mSyncPositions[link];
    return arr[0].synched() && arr[1].synched() && arr[2].synched() && arr[3].synched() && arr[4].synched();
  }
 
  static void
    processFile(const std::string_view inputFile, uint32_t timeBins = 0, uint32_t linkMask = 0, uint32_t stream = 0, uint32_t debugLevel = 0, uint32_t verbosity = 0, const std::string_view outputFilePrefix = "");
 
  const std::map<PadPos, std::vector<uint16_t>>& getADCMap() const { return mADCdata; }
 
  void clearMap() { mADCdata.clear(); }
 
  const CRU& getCRU() const { return mCRU; }
 
  void forceCRU(int cru)
  {
    mCRU = cru;
    mForceCRU = true;
  }
 
  void setManager(RawReaderCRUManager* manager) { mManager = manager; }
 
  RawReaderCRUManager* getManager() { return mManager; }
 
  void copyEvents(const std::vector<uint32_t>& eventNumbers, std::string outputDirectory, std::ios_base::openmode mode = std::ios_base::openmode(0));
 
  void writeGBTDataPerLink(std::string_view outputDirectory, int maxEvents = -1);
 
  void runADCDataCallback(const ADCRawData& rawData);
 
  void setOutputFilePrefix(std::string_view prefix) { mOutputFilePrefix = prefix; }
 
  const std::string& getOutputFilePrefix() const { return mOutputFilePrefix; }
 
  const PacketDescriptorMapArray& getPacketDescriptorMaps() const { return mPacketDescriptorMaps; }
 
  std::ifstream& getFileHandle()
  {
    if (!mFileHandle.is_open()) {
      mFileHandle.open(mInputFileName, std::ios::binary);
      if (!mFileHandle.good()) {
        throw std::runtime_error("Unable to open or access file " + mInputFileName);
      }
    }
 
    return mFileHandle;
  }
 
  //===========================================================================
  //===| Nested helper classes |===============================================
  //
 
 public:
  // ===========================================================================
  class PacketDescriptor
  {
   public:
    using FEEIDType = rdh_utils::FEEIDType;
 
    PacketDescriptor(size_t headOff, uint32_t cru, uint32_t link, uint32_t endPoint,
                     uint16_t memorySize = 7840, uint16_t packetSize = 8192,
                     uint32_t heartbeatOrbit = 0) : mHeaderOffset(headOff),
                                                    mFEEID(rdh_utils::getFEEID(cru, endPoint, link)),
                                                    mMemorySize(memorySize),
                                                    mPacketSize(packetSize),
                                                    mHeartbeatOrbit(heartbeatOrbit)
    {
    }
 
    constexpr uint32_t getHeaderSize() const
    {
      return sizeof(RDH);
    }
 
    uint32_t getHeartBeatOrbit() const { return mHeartbeatOrbit; }
    size_t getHeaderOffset() const { return mHeaderOffset; }
    size_t getPayloadOffset() const { return mHeaderOffset + getHeaderSize(); }
    uint32_t getPayloadSize() const { return mMemorySize - getHeaderSize(); }
    uint32_t getPacketSize() const { return mPacketSize; }
 
    FEEIDType getFEEID() const { return mFEEID; }
    FEEIDType getCRUID() const { return rdh_utils::getCRU(mFEEID); }
    FEEIDType getLinkID() const { return rdh_utils::getLink(mFEEID); }
    FEEIDType getGlobalLinkID() const { return getLinkID() + getEndPoint() * 12; }
    FEEIDType getEndPoint() const { return rdh_utils::getEndPoint(mFEEID); }
 
    void streamTo(std::ostream& output) const;
 
    friend std::ostream& operator<<(std::ostream& output, const PacketDescriptor& packetDescriptor)
    {
      packetDescriptor.streamTo(output);
      return output;
    }
 
   private:
    size_t mHeaderOffset;     
    uint32_t mHeartbeatOrbit; 
    uint16_t mMemorySize;     
    uint16_t mPacketSize;     
    FEEIDType mFEEID;         
  };
 
  // ===========================================================================
  // ===| data members |========================================================
  //
 
 private:
  uint32_t mDebugLevel;                                     
  uint32_t mVerbosity;                                      
  uint32_t mNumTimeBins;                                    
  uint32_t mLink;                                           
  uint32_t mStream;                                         
  uint32_t mEventNumber = 0;                                
  uint32_t mReaderNumber = 0;                               
  CRU mCRU;                                                 
  size_t mFileSize;                                         
  bool mDumpTextFiles = false;                              
  bool mFillADCdataMap = true;                              
  bool mForceCRU = false;                                   
  bool mFileIsScanned = false;                              
  std::array<uint32_t, MaxNumberOfLinks> mPacketsPerLink;   
  std::bitset<MaxNumberOfLinks> mLinkPresent;               
  PacketDescriptorMapArray mPacketDescriptorMaps;           
  std::string mInputFileName;                               
  std::string mOutputFilePrefix;                            
  std::array<SyncArray, MaxNumberOfLinks> mSyncPositions{}; 
  // not so nice but simplest way to store the ADC data
  std::map<PadPos, std::vector<uint16_t>> mADCdata; 
  RawReaderCRUManager* mManager{nullptr};           
 
  std::ifstream mFileHandle; 
 
  void collectGBTData(std::vector<std::byte>& data);
 
  void fillADCdataMap(const ADCRawData& rawData);
 
  ClassDefNV(RawReaderCRU, 0); // raw reader class
 
}; // class RawReaderCRU
 
// ===| inline definitions |====================================================
template <typename T>
inline T GBTFrame::bit(T s, T t) const
{
  const T dataWord = s >> 5;
  return shiftBit(mData[dataWord], s, t);
};
 
inline void GBTFrame::updateSyncCheck(SyncArray& syncArray)
{
  const auto offset = mPrevHWpos ^ 4;
 
  for (int s = 0; s < 5; s++) {
    for (int h = 0; h < 4; h++) {
      const auto hPos = h + offset; // set position of last filled HW
      // shift in a 1 if the halfword is 0x15
      if (mFrameHalfWords[s][hPos] == 0x15) {
        mSyncCheckRegister[s] = (mSyncCheckRegister[s] << 1) | 1;
        // shift in a 0 if the halfword is 0xA
      } else if (mFrameHalfWords[s][hPos] == 0xA) {
        mSyncCheckRegister[s] = (mSyncCheckRegister[s] << 1);
        // otherwise reset the register to 0
      } else {
        mSyncCheckRegister[s] = 0;
      }
      // std::cout << " SReg : " << s << " : " << std::hex << mSyncCheckRegister[s] << std::endl;
      // check the register content for the SYNC pattern
      // Patterh is : 1100.1100.1100.1100.1111.0000.1111.0000 = 0xCCCCF0F0
      // alternative Pattern for first corrupted SYNC word : 0100.1100.1100.1100.1111.0000.1111.0000 = 4CCC.F0F0
      if (mSyncCheckRegister[s] == 0xCCCCF0F0 or mSyncCheckRegister[s] == 0x4CCCF0F0 or mSyncCheckRegister[s] == 0x0CCCF0F0) {
        syncArray[s].setPos(mPacketNum, mFrameNum, mFilePos, h);
      };
    }
  };
}
 
inline void GBTFrame::updateSyncCheck(bool verbose)
{
  const auto offset = mPrevHWpos ^ 4;
 
  for (int s = 0; s < 5; s++) {
    for (int h = 0; h < 4; h++) {
      const auto hPos = h + offset; // set position of last filled HW
      // shift in a 1 if the halfword is 0x15
      if (mFrameHalfWords[s][hPos] == 0x15) {
        mSyncCheckRegister[s] = (mSyncCheckRegister[s] << 1) | 1;
        // shift in a 0 if the halfword is 0xA
      } else if (mFrameHalfWords[s][hPos] == 0xA) {
        mSyncCheckRegister[s] = (mSyncCheckRegister[s] << 1);
        // otherwise reset the register to 0
      } else {
        mSyncCheckRegister[s] = 0;
      }
      // std::cout << " SReg : " << s << " : " << std::hex << mSyncCheckRegister[s] << std::endl;
      // check the register content for the SYNC pattern
      // Patterh is : 1100.1100.1100.1100.1111.0000.1111.0000 = 0xCCCCF0F0
      // alternative Pattern for first corrupted SYNC word : 0100.1100.1100.1100.1111.0000.1111.0000 = 4CCC.F0F0
      if (mSyncCheckRegister[s] == 0xCCCCF0F0 or mSyncCheckRegister[s] == 0x4CCCF0F0 or mSyncCheckRegister[s] == 0x0CCCF0F0) {
        mSyncPos[s].setPos(mPacketNum, mFrameNum, mFilePos, h);
        if (verbose) {
          std::cout << s << " : " << mSyncPos[s];
        }
      }
    }
  }
}
 
inline void GBTFrame::getFrameHalfWords()
{
  constexpr adc_t P[5][4] = {{19, 18, 17, 16}, {39, 38, 37, 36}, {63, 62, 61, 60}, {83, 82, 81, 80}, {107, 106, 105, 104}};
  // i = Stream, j = Halfword
  for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 4; j++) {
      mFrameHalfWords[i][j + mPrevHWpos] = bit(P[i][j], adc_t(4)) |
                                           bit(adc_t(P[i][j] - 4), adc_t(3)) |
                                           bit(adc_t(P[i][j] - 8), adc_t(2)) |
                                           bit(adc_t(P[i][j] - 12), adc_t(1)) |
                                           bit(adc_t(P[i][j] - 16), adc_t(0));
      // std::cout << " S : " << i << " H : " << j << " : " << std::hex << res << std::endl;
    };
  }
  mPrevHWpos ^= 4; // toggle position of previous HW position
}
 
inline void GBTFrame::getAdcValues(ADCRawData& rawData)
{
  // loop over all the 5 data streams
  for (int s = 0; s < 5; s++) {
    if (!mSyncPos[s].synched()) {
      continue;
    }
 
    // assemble the 2 ADC words from 4 half-words. Which halfwords are
    // used depends on the position of the SYNC pattern.
    const uint32_t pos = mSyncPos[s].getHalfWordPosition();
    const uint32_t v0 = (mFrameHalfWords[s][(pos + 2 + mPrevHWpos) & 7] << 5) | mFrameHalfWords[s][(pos + 1 + mPrevHWpos) & 7];
    const uint32_t v1 = (mFrameHalfWords[s][(pos + 4 + mPrevHWpos) & 7] << 5) | mFrameHalfWords[s][(pos + 3 + mPrevHWpos) & 7];
 
    // add the two ADC values for the current processed stream
    rawData.add(s, v0, v1);
  };
  // std::cout << std::endl;
}
 
inline void GBTFrame::readFromMemory(gsl::span<const std::byte> data)
{
  assert(sizeof(mData) == data.size_bytes());
  memcpy(mData.data(), data.data(), data.size_bytes());
}
 
// =============================================================================
// =============================================================================
// =============================================================================
class RawReaderCRUManager
{
 public:
  using ADCDataCallback = std::function<Int_t(const PadROCPos&, const CRU&, const gsl::span<const uint32_t>)>;
  using LinkZSCallback = o2::tpc::raw_processing_helpers::ADCCallback;
  using EndReaderCallback = std::function<void()>;
 
  RawReaderCRUManager() = default;
 
  RawReaderCRU& createReader(const std::string_view inputFileName,
                             uint32_t numTimeBins = 0,
                             uint32_t link = 0,
                             uint32_t stream = 0,
                             uint32_t debugLevel = 0,
                             uint32_t verbosity = 0,
                             const std::string_view outputFilePrefix = "")
  // RawReaderCRU& createReader(std::string_view fileName, uint32_t numTimeBins)
  {
    mRawReadersCRU.emplace_back(std::make_unique<RawReaderCRU>(inputFileName, numTimeBins, 0, stream, debugLevel, verbosity, outputFilePrefix, mRawReadersCRU.size()));
    mRawReadersCRU.back()->setManager(this);
    return *mRawReadersCRU.back().get();
  }
 
  void setupReaders(const std::string_view inputFileNames,
                    uint32_t numTimeBins = 1000,
                    uint32_t debugLevel = 0,
                    uint32_t verbosity = 0,
                    const std::string_view outputFilePrefix = "");
 
  void init();
 
  auto& getReaders() { return mRawReadersCRU; }
 
  const auto& getReaders() const { return mRawReadersCRU; }
 
  auto getNumberOfReaders() const { return mRawReadersCRU.size(); }
 
  RawReaderCRU& getLastReader() { return *mRawReadersCRU.back().get(); }
 
  const RawReaderCRU& getLastReader() const { return *mRawReadersCRU.back().get(); }
 
  void resetReaders() { mRawReadersCRU.clear(); }
 
  void resetEventSync() { mEventSync.reset(); }
 
  void reset()
  {
    resetReaders();
    resetEventSync();
    mIsInitialized = false;
  }
 
  void setEventNumber(uint32_t eventNumber)
  {
    for (auto& reader : mRawReadersCRU) {
      reader->setEventNumber(eventNumber);
    }
  }
 
  const RawReaderCRUEventSync& getEventSync() const { return mEventSync; }
 
  size_t getNumberOfEvents() const { return mEventSync.getNumberOfEvents(); }
 
  size_t getNumberOfCompleteEvents() const { return mEventSync.getNumberOfCompleteEvents(); }
 
  bool isEventComplete(size_t eventNumber) const { return mEventSync.isEventComplete(eventNumber); }
 
  void setDebugLevel(uint32_t debugLevel) { mDebugLevel = debugLevel; }
 
  void setDataType(DataType dataType, RAWDataType rawType)
  {
    mDataType = dataType;
    mRawDataType = rawType;
    mDetectDataType = false;
  }
 
  DataType getDataType() const { return mDataType; }
 
  void copyEvents(const std::vector<uint32_t> eventNumbers, std::string_view outputDirectory, std::ios_base::openmode mode = std::ios_base::openmode(0));
 
  static void copyEvents(const std::string_view inputFileNames, const std::vector<uint32_t> eventNumbers, std::string_view outputDirectory, std::ios_base::openmode mode = std::ios_base::openmode(0));
 
  void writeGBTDataPerLink(std::string_view outputDirectory, int maxEvents = -1);
 
  static void writeGBTDataPerLink(const std::string_view inputFileNames, std::string_view outputDirectory, int maxEvents = -1);
 
  void setADCDataCallback(ADCDataCallback function) { mADCDataCallback = function; }
 
  void setLinkZSCallback(LinkZSCallback function) { mLinkZSCallback = function; }
 
  LinkZSCallback getLinkZSCallback() { return mLinkZSCallback; }
 
  void processEvent(uint32_t eventNumber, EndReaderCallback endReader = nullptr);
 
 private:
  std::vector<std::unique_ptr<RawReaderCRU>> mRawReadersCRU{}; 
  RawReaderCRUEventSync mEventSync{};                          
  uint32_t mDebugLevel{0};                                     
  DataType mDataType{DataType::Continuous};                    
  RAWDataType mRawDataType{RAWDataType::GBT};                  
  bool mDetectDataType{true};                                  
  bool mIsInitialized{false};                                  
  ADCDataCallback mADCDataCallback{nullptr};                   
  LinkZSCallback mLinkZSCallback{nullptr};                     
 
  friend class RawReaderCRU;
 
  ClassDefNV(RawReaderCRUManager, 0); // Manager class for CRU raw readers
};
 
} // namespace rawreader
} // namespace tpc
} // namespace o2
#endif