rich/UnpackMS.h

Go to the documentation of this file.

/* Copyright (C) 2021 Goethe-University Frankfurt, Frankfurt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pascal Raisig, Dominik Smith [committer] */
#pragma once
 
#include "CbmRichDigi.h"
#include "Timeslice.hpp"
#include "algo/base/Definitions.h"
#include "algo/unpack/UnpackMSBase.h"
 
#include <cstddef>
#include <cstdint>
#include <iomanip>
#include <memory>
#include <sstream>
#include <utility>
 
namespace cbm::algo::rich
{
  class MicrosliceReader;
 
  enum class TdcWordType
  {
    TimeData,
    Header,
    Epoch,
    Trailer,
    Debug,
    Error
  };
 
 
  struct TdcTimeData {
    uint32_t fCoarse       = 0;  // 11 bits
    uint32_t fIsRisingEdge = 0;  // 1 bit
    uint32_t fFine         = 0;  // 10 bits
    uint32_t fChannel      = 0;  // 7 bits
  };
 

  struct UnpackElinkPar {
    std::vector<double> fToTshift;  
    int64_t fTimeOffset = 0;        
  };
 

  struct UnpackPar {
    std::map<uint32_t, UnpackElinkPar> fElinkParams = {};  
  };
 

  struct UnpackMonitorData {
    uint32_t fNumDebugMessage            = 0;  
    uint32_t fNumCtsAndUnmappedDirich    = 0;  
    uint32_t fNumErrInvalidFirstMessage  = 0;  
    uint32_t fNumErrInvalidSecondMessage = 0;  
    uint32_t fNumErrInvalidLastMessage   = 0;  
    uint32_t fNumErrWildHeaderMessage    = 0;  
    uint32_t fNumErrWildTrailerMessage   = 0;  
    uint32_t fNumErrWildEpoch            = 0;  
    uint32_t fNumErrWildTdcTime          = 0;  
    uint32_t fNumErrTdcErrorWord         = 0;  
    uint32_t fNumErrChannelOutOfBounds   = 0;  
    uint32_t fNumErrOrphanRecovTimeData  = 0;  
    uint32_t fNumWarnRecoveredLastDigi   = 0;  
    uint32_t fNumErrInvalidHubId         = 0;  
    uint32_t fNumErrInvalidHubSize       = 0;  
    uint32_t fNumErrExcessLastWords      = 0;  
    uint32_t fNumSkippedSubsubevent      = 0;  
 
    bool HasErrors() const
    {
      uint32_t numErrors = fNumDebugMessage + fNumErrInvalidFirstMessage + fNumErrInvalidSecondMessage
                           + fNumErrInvalidLastMessage + fNumErrWildHeaderMessage + fNumErrWildTrailerMessage
                           + fNumErrWildEpoch + fNumErrWildTdcTime + fNumErrTdcErrorWord + fNumErrChannelOutOfBounds
                           + fNumErrOrphanRecovTimeData + fNumErrInvalidHubId + fNumErrInvalidHubSize
                           + fNumErrExcessLastWords;
      return (numErrors > 0 ? true : false);
    }
    std::string print() const
    {
      std::stringstream ss;
      ss << "errors " << fNumDebugMessage << " | " << fNumCtsAndUnmappedDirich << " | " << fNumErrInvalidFirstMessage
         << " | " << fNumErrInvalidSecondMessage << " | " << fNumErrInvalidLastMessage << " | "
         << fNumErrWildHeaderMessage << " | " << fNumErrWildTrailerMessage << " | " << fNumErrWildEpoch << " | "
         << fNumErrWildTdcTime << " | " << fNumErrTdcErrorWord << " | " << fNumErrChannelOutOfBounds << " | "
         << fNumErrOrphanRecovTimeData << " | " << fNumWarnRecoveredLastDigi << " | " << fNumErrInvalidHubId << " | "
         << fNumErrInvalidHubSize << " | " << fNumErrExcessLastWords << " | " << fNumSkippedSubsubevent;
      return ss.str();
    }
    void add(const UnpackMonitorData& rhs)
    {
      fNumDebugMessage += rhs.fNumDebugMessage;
      fNumCtsAndUnmappedDirich += rhs.fNumCtsAndUnmappedDirich;
      fNumErrInvalidFirstMessage += rhs.fNumErrInvalidFirstMessage;
      fNumErrInvalidSecondMessage += rhs.fNumErrInvalidSecondMessage;
      fNumErrInvalidLastMessage += rhs.fNumErrInvalidLastMessage;
      fNumErrWildHeaderMessage += rhs.fNumErrWildHeaderMessage;
      fNumErrWildTrailerMessage += rhs.fNumErrWildTrailerMessage;
      fNumErrWildEpoch += rhs.fNumErrWildEpoch;
      fNumErrWildTdcTime += rhs.fNumErrWildTdcTime;
      fNumErrTdcErrorWord += rhs.fNumErrTdcErrorWord;
      fNumErrChannelOutOfBounds += rhs.fNumErrChannelOutOfBounds;
      fNumErrOrphanRecovTimeData += rhs.fNumErrOrphanRecovTimeData;
      fNumWarnRecoveredLastDigi += rhs.fNumWarnRecoveredLastDigi;
      fNumErrInvalidHubId += rhs.fNumErrInvalidHubId;
      fNumErrInvalidHubSize += rhs.fNumErrInvalidHubSize;
      fNumErrExcessLastWords += rhs.fNumErrExcessLastWords;
      fNumSkippedSubsubevent += rhs.fNumSkippedSubsubevent;
    }
  };

  struct UnpackAuxData {
  };
 
  class UnpackMS : public UnpackMSBase<CbmRichDigi, UnpackMonitorData, UnpackAuxData> {
 
   public:
    UnpackMS(const UnpackPar& pars);
 

    ~UnpackMS() override;
 

    Result_t operator()(const uint8_t* msContent, const fles::MicrosliceDescriptor& msDescr,
                        const uint64_t tTimeslice) const override;

    void SetParams(std::unique_ptr<UnpackPar> params) { fParams = *(std::move(params)); }
 
   private:
    struct MSContext {
      u64 cbmTimeMS     = 0;  // CbmTime of MS. Used to get time offset of subtriggers to MS start
      u64 cbmTimePacket = 0;
      u64 refTime       = 0;
 
      // FIXME: Magic number, should be named.
      //
      // Comment from RICH expert (Martin Beyer):
      //  > This number will also be valid for the Cbm Rich, 1 Rich backplane contains max. 12 DiRICHes.
      //  > For the Cbm Rich the number of backplanes will be scaled
      //  > up. Nevertheless it is very likely that fewer DiRiches(maybe not constant)
      //  > per backplane are used in the day1 setup.
      double prevLastCh0ReTime[13];  // 12 DiRICHes chnl0 + 1 CTS chnl0
      double mbsCorr = 0.;
 
      uint16_t currentSubSubEvent = 0;
 
      std::vector<CbmRichDigi> digis;
      UnpackMonitorData monitor;
    };
 
   private:
    void ProcessTrbPacket(MicrosliceReader& reader, MSContext& ctx) const;
 
    void ProcessHubBlock(MicrosliceReader& reader, MSContext& ctx) const;
 
    int ProcessCtsHeader(MicrosliceReader& reader, uint32_t subSubEventSize, uint32_t subSubEventId) const;
 
    void ProcessSubSubEvent(MicrosliceReader& reader, int nofTimeWords, uint32_t subSubEventId, MSContext& ctx) const;
 
    bool ProcessTimeDataWord(uint32_t epoch, uint32_t tdcWord, uint32_t subSubEventId, std::vector<double>& raisingTime,
                             MSContext& ctx) const;
 
    TdcWordType GetTdcWordType(uint32_t tdcWord) const;
 
    TdcTimeData ProcessTimeData(uint32_t tdcWord) const;
 
    uint32_t ProcessEpoch(uint32_t tdcWord) const;
 
    uint16_t ProcessHeader(uint32_t tdcWord) const;
 
    uint16_t ProcessTrailer(uint32_t tdcWord) const;
 
    void WriteOutputDigi(int32_t fpgaID, int32_t channel, double time, double tot, MSContext& ctx) const;
 
    double CalculateTime(uint32_t epoch, uint32_t coarse, uint32_t fine) const;
 
    int32_t GetPixelUID(int32_t fpgaID, int32_t ch) const;
 
    bool CheckMaskedDiRICH(int32_t subSubEventId) const;
 
   private:
    UnpackPar fParams = {};  
 
    std::vector<int32_t> fMaskedDiRICHes;
 
    bool fbDoToTCorr = true;  //activates ToT correction from parameter file
 
    // uint64_t fCbmTimeMS;
    // uint64_t fCbmTimePacket;
 
    // double fMbsCorr = 0.;
    // double fPrevLastCh0ReTime[13];  // 12 DiRICHes chnl0 + 1 CTS chnl0
    // uint16_t fCurrentSubSubEvent = 0;
 
    double fToTMin = -20.;
    double fToTMax = 100.;
  };
 
 
  class MicrosliceReader {
   private:
    const uint8_t* fData = nullptr;
    size_t fSize         = 0;
    size_t fOffset       = 0;  // offset in bytes
    size_t fWordCounter  = 0;
    uint32_t fCurWord    = 0;
 
   public:
    void SetData(const uint8_t* data, size_t size)
    {
      fData        = data;
      fSize        = size;
      fOffset      = 0;
      fWordCounter = 0;
      fCurWord     = 0;
    }
 
    const uint8_t* GetData() { return fData; }
    size_t GetSize() { return fSize; }
    size_t GetOffset() { return fOffset; }
    size_t GetWordCounter() { return fWordCounter; }
    uint32_t GetCurWord() { return fCurWord; }
 
    std::string GetWordAsHexString(uint32_t word)
    {
      std::stringstream stream;
      stream << "0x" << std::setfill('0') << std::setw(sizeof(uint32_t) * 2) << std::hex << word;
      return stream.str();
    }
 
    uint32_t NextWord()
    {
      uint32_t i = ((uint32_t*) (fData + fOffset))[0];
      //swap bytes
      i = (i >> 24) | ((i << 8) & 0x00FF0000) | ((i >> 8) & 0x0000FF00) | (i << 24);
      fOffset += 4;
      fWordCounter++;
      fCurWord = i;
      return i;
    }
 
    bool IsNextPadding()
    {
      uint32_t nextWord = ((uint32_t*) (fData + fOffset))[0];
      if (nextWord == 0xffffffff) return true;
      return false;
    }
 
    bool IsLastSubSubEvent(uint32_t subSubEventSize)
    {
      uint32_t i = ((uint32_t*) (fData + fOffset + 4 * subSubEventSize))[0];
      i          = (i >> 24) | ((i << 8) & 0x00ff0000) | ((i >> 8) & 0x0000ff00) | (i << 24);
      if (i == 0x00015555) return true;
      return false;
    }
  };
 
}  // namespace cbm::algo::rich