trd2d/UnpackMS.h

Go to the documentation of this file.

/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pascal Raisig, Alexandru Bercuci, Dominik Smith [committer] */
#pragma once
 
#include "CbmTrdDigi.h"
#include "MicrosliceDescriptor.hpp"
#include "algo/unpack/UnpackMSBase.h"
 
#include <array>
#include <memory>
#include <sstream>
 
#define NFASPMOD 180
#define NROBMOD 5
#define NFASPROB NFASPMOD / NROBMOD
#define NFASPCH 16
#define NFASPPAD NFASPCH / 2
 
#define FASP_EPOCH_LENGTH 128  // the length in clks of FASP epoch [1600ns @ 40MHz]
 
namespace cbm::algo::trd2d
{
  enum class eMessageLength : int
  {
    kMessCh    = 4,
    kMessType  = 1,
    kMessTlab  = 7,
    kMessData  = 14,
    kMessFasp  = 6,
    kMessEpoch = 21
  };
 
  enum class eMessageVersion : uint8_t
  {
    kMessLegacy = 2,  
    kMess24     = 3,  
  };
 
  enum class eMessageType : int
  {
    kData  = 0,
    kEpoch = 1,
    kNone
  };

  static constexpr uint fAsicClockPeriod = 25;

  // Constants
  struct FaspMessage {
    FaspMessage()                   = default;
    FaspMessage(const FaspMessage&) = default;
    FaspMessage(uint8_t c, uint8_t typ, uint8_t t, uint16_t d, uint8_t asic);

    template<uint8_t mess_ver>
    static eMessageType getType(uint32_t w);
 
    std::string print() const;

    template<uint8_t mess_ver>
    void readDW(uint32_t w);

    template<uint8_t mess_ver>
    void readEW(uint32_t w);
 
    uint8_t ch        = 0;                    
    eMessageType type = eMessageType::kNone;  
    uint8_t tlab      = 0;                    
    uint16_t data     = 0;                    
    uint32_t epoch    = 0;                    
    uint8_t fasp      = 0;                    
  };

  struct UnpackChannelPar {
    int32_t fPadAddress;      
    bool fMask;               
    int8_t fDaqOffset     = 0;  
    uint16_t fSignalThres = 0;  
  };

  struct UnpackAsicPar {
    std::vector<UnpackChannelPar> fChanParams;  
  };

  struct NoiseChannelPar {
    uint16_t tDelay       = 0;  
    uint16_t tWindow      = 0;  
    uint16_t lThreshold   = 0;  
    uint16_t fSignalThres = 0;  
  };

  struct CalibChannelPar {
    bool fMask            = false;  
    int8_t fDaqOffset     = 0;      
    float fBaseline       = 0.;     
    float fGainFee        = -1.;    
    NoiseChannelPar noise = {};     
  };

  struct UnpackPar {
    int32_t fSystemTimeOffset                    = 0;     
    uint16_t fModId                              = 0;     
    uint16_t fEqAdd                              = 0;     
    uint8_t fEqId                                = 0xff;  
    float fRefSignal                             = 900;   
    std::map<uint8_t, UnpackAsicPar> fAsicParams = {};    
    std::array<CalibChannelPar, NFASPMOD* NFASPCH> fCalibParams =
      {};  
    int toff[NFASPMOD * NFASPPAD];

    void dump() const;

    template<uint8_t ver>
    uint8_t mapFaspId2Mod(uint8_t fasp_id) const;
  };
 

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

  struct UnpackAuxData {
  };

  template<uint8_t sys_ver>
  class UnpackMS : public UnpackMSBase<CbmTrdDigi, UnpackMonitorData, UnpackAuxData> {
 
   public:
    UnpackMS(const UnpackPar& pars) : fParams(pars) {}

    ~UnpackMS() override = default;

    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:  // Types
    struct MsContext {
      UnpackMonitorData fMonitor;  
 
      std::array<std::vector<CbmTrdDigi>, NFASPMOD* NFASPCH> fDigiBuffer = {
        {}};  
    };
 
   private:                  // members
    UnpackPar fParams = {};  
 
    bool pushDigis(std::vector<FaspMessage> messages, const uint64_t time, MsContext& ctx) const;

    std::vector<CbmTrdDigi> FinalizeComponent(MsContext& ctx) const;
  };
 

  template<>
  class UnpackMS<uint8_t(eMessageVersion::kMess24)> :
    public UnpackMSBase<CbmTrdDigi, UnpackMonitorData, UnpackAuxData> {
 
   public:
    UnpackMS(const UnpackPar& pars) : fParams(pars) {}

    ~UnpackMS() override = default;
 

    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:  // Types
    struct MsContext {
      UnpackMonitorData fMonitor;  
      std::array<std::vector<CbmTrdDigi>, NFASPMOD* NFASPPAD> fRobDigi = {
        {}};              
      FaspMessage fMess;  
    };
 
   private:  // members
    bool pushDigis(std::vector<FaspMessage> messages, const uint64_t time, MsContext& ctx) const;
 
    UnpackPar fParams = {};  
  };
 
}  // namespace cbm::algo::trd2d