mvd/UnpackMS.h

Go to the documentation of this file.

/* Copyright (C) 2025 IKF Frankfurt University, Frankfurt am Main
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Ajit Kumar [committer], Bartosz Sobol, Benedikt Gutsche */
 
#pragma once
 
#include "CbmMvdAddress.h"
#include "CbmMvdRawDigi.h"
#include "MicrosliceDescriptor.hpp"
#include "MimosisMessage.h"
#include "Timeslice.hpp"
#include "algo/unpack/UnpackMSBase.h"
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <sstream>
#include <vector>
 
namespace cbm::algo::mvd
{
 

  struct UnpackElinkPar {
    std::vector<uint32_t> fStation;  
    std::vector<uint8_t> fPixX;      
    std::vector<uint8_t> fPixY;      
    uint64_t fTimeOffset = 0.;       
  };
 

  struct UnpackPar {
    std::vector<UnpackElinkPar> fElinkParams = {};  
  };
 

  struct UnpackMonitorData {
    uint32_t fNumNonHitOrTsbMessage     = 0;
    uint32_t fNumErrElinkOutOfRange     = 0;  
    uint32_t fNumErrInvalidFirstMessage = 0;  
    uint32_t fNumErrInvalidMsSize       = 0;  
    uint32_t fNumErrTimestampOverflow   = 0;  
    bool HasErrors()
    {
      uint32_t numErrors = fNumNonHitOrTsbMessage + fNumErrElinkOutOfRange + fNumErrInvalidFirstMessage
                           + fNumErrInvalidMsSize + fNumErrTimestampOverflow;
      return (numErrors > 0 ? true : false);
    }
    std::string print() const
    {
      std::stringstream ss;
      ss << "errors " << fNumNonHitOrTsbMessage << " | " << fNumErrElinkOutOfRange << " | "
         << fNumErrInvalidFirstMessage << " | " << fNumErrInvalidMsSize << " | " << fNumErrTimestampOverflow << " | ";
      return ss.str();
    }
    void add(const UnpackMonitorData& rhs)
    {
      fNumNonHitOrTsbMessage += rhs.fNumNonHitOrTsbMessage;
      fNumErrElinkOutOfRange += rhs.fNumErrElinkOutOfRange;
      fNumErrInvalidFirstMessage += rhs.fNumErrInvalidFirstMessage;
      fNumErrInvalidMsSize += rhs.fNumErrInvalidMsSize;
      fNumErrTimestampOverflow += rhs.fNumErrTimestampOverflow;
    }
  };

  struct UnpackAuxData {
  };

  class UnpackMS : public UnpackMSBase<CbmMvdRawDigi, UnpackMonitorData, UnpackAuxData> {
 
   public:
    UnpackMS(const UnpackPar& pars, const uint64_t& frameLengthNs);
    // UnpackMS(const UnpackPar& pars, std::vector<CbmMvdRawDigi>& vec);

    ~UnpackMS() override;
 

    Result_t operator()(const uint8_t* msContent, const fles::MicrosliceDescriptor& msDescr,
                        const uint64_t tTimeslice) const override;
 
    void dcd_pxl(const uint16_t& regionIn, const uint16_t& word, uint32_t& column, uint32_t& row) const;
 
   private:  // methods
    void ProcessData(const uint32_t& data, const uint64_t& time, std::vector<CbmMvdRawDigi>& digiVec,
                     UnpackMonitorData& monitor, UnpackAuxData& aux, uint16_t& eq_idx) const;
 
    void printMsContent(const uint8_t* msContent, size_t size) const;
 
   private:                  // members
    UnpackPar fParams = {};  

    uint64_t fFrameLengthNs = 5000;  
 
    // static constexpr uint64_t fTimeStamp = mimosis::Time;
    static constexpr uint64_t fTimeStamp = 0;
 
    mutable unsigned int frameNumber = 0;
    mutable uint64_t frameTime       = 0;
    mutable unsigned int region      = 0;
    mutable unsigned int headersnow  = 0;
  };
 
}  // namespace cbm::algo::mvd