trd/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, Dominik Smith [committer], David Schledt */
 
#pragma once
 
#include "CbmTrdDigi.h"
#include "CbmTrdFexMessageSpadic.h"
#include "CbmTrdRawMessageSpadic.h"
#include "MicrosliceDescriptor.hpp"
#include "Timeslice.hpp"
#include "algo/unpack/UnpackMSBase.h"
 
#include <cmath>
#include <memory>
#include <sstream>
 
namespace cbm::algo::trd
{
  struct UnpackElinkPar {
    std::vector<uint32_t> fChanAddress;  
    uint32_t fAddress;                   
    int64_t fTimeOffset = 0;             
  };

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

  struct UnpackPar {
    bool fUseBaselineAvg                   = true;  
    float_t fMaxAdcToEnergyCal             = 1.0;   
    uint32_t fNumChansPerAsic              = 0;     
    uint32_t fNumAsicsPerModule            = 0;     
    std::vector<UnpackCrobPar> fCrobParams = {};    
  };
 

  struct UnpackMonitorData {
    size_t fNumNonMajorTsMsb     = 0;  
    size_t fNumCreatedRawMsgs    = 0;  
    size_t fNumEpochMsgs         = 0;  
    size_t fNumCreatedInfoMsgs   = 0;  
    size_t fNumElinkMis          = 0;  
    size_t fNumCorruptEom        = 0;  
    size_t fNumWildRda           = 0;  
    size_t fNumWildEom           = 0;  
    size_t fNumUnknownWords      = 0;  
    size_t fNumMissingEom        = 0;  
    size_t fNumWildNul           = 0;  
    size_t fNumCrcValidFlags     = 0;  
    size_t fNumOverflowFlimFlags = 0;  
    size_t fNumOverflowUserFlags = 0;  
    size_t fNumDataErrorFlags    = 0;  
    size_t fNumErrTimestampUnderflow = 0;  
 
    bool HasErrors()
    {
      uint32_t numErrors = fNumElinkMis + fNumCorruptEom + fNumWildRda + fNumWildEom + fNumUnknownWords + fNumMissingEom
                           + fNumWildNul + fNumCrcValidFlags + fNumOverflowFlimFlags + fNumOverflowUserFlags
                           + fNumDataErrorFlags + fNumErrTimestampUnderflow;
      return (numErrors > 0 ? true : false);
    }
    std::string print() const
    {
      std::stringstream ss;
      ss << " stats " << fNumNonMajorTsMsb << " | " << fNumCreatedRawMsgs << " | " << fNumEpochMsgs << " | "
         << fNumCreatedInfoMsgs << " errors " << fNumElinkMis << " | " << fNumCorruptEom << " | " << fNumWildRda
         << " | " << fNumWildEom << " | " << fNumUnknownWords << " | " << fNumMissingEom << " | " << fNumWildNul
         << " | " << fNumCrcValidFlags << " | " << fNumOverflowFlimFlags << " | " << fNumOverflowUserFlags << " | "
         << fNumDataErrorFlags << " | " << fNumErrTimestampUnderflow << " | ";
      return ss.str();
    }
    void add(const UnpackMonitorData& rhs)
    {
      fNumNonMajorTsMsb += rhs.fNumNonMajorTsMsb;
      fNumCreatedRawMsgs += rhs.fNumCreatedRawMsgs;
      fNumEpochMsgs += rhs.fNumEpochMsgs;
      fNumCreatedInfoMsgs += rhs.fNumCreatedInfoMsgs;
      fNumElinkMis += rhs.fNumElinkMis;
      fNumCorruptEom += rhs.fNumCorruptEom;
      fNumWildRda += rhs.fNumWildRda;
      fNumWildEom += rhs.fNumWildEom;
      fNumUnknownWords += rhs.fNumUnknownWords;
      fNumWildNul += rhs.fNumWildNul;
      fNumCrcValidFlags += rhs.fNumCrcValidFlags;
      fNumOverflowFlimFlags += rhs.fNumOverflowFlimFlags;
      fNumOverflowUserFlags += rhs.fNumOverflowUserFlags;
      fNumDataErrorFlags += rhs.fNumDataErrorFlags;
      fNumErrTimestampUnderflow += rhs.fNumErrTimestampUnderflow;
    }
  };

  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 {
      size_t fMsStartTimeRelCC = 0;

      size_t fLastFulltime = 0;

      std::vector<uint8_t> fNrTsMsbVec = {};
    };
 
   private:                  // members
    UnpackPar fParams = {};  

    void digestOutput(std::unique_ptr<CbmTrdDigi> digi, CbmTrdRawMessageSpadic raw);

    Spadic::MsInfoType digestBufInfoFlags(const uint32_t frame) const;

    void digestMsFlags(const uint16_t flags, UnpackMonitorData& monitor) const;

    void digestInfoMsg(const uint32_t frame) const;

    int16_t extractSample(size_t* adcbuffer, size_t* nadcbits) const;

    std::float_t extractAvgSample(size_t* adcbuffer, size_t* nadcbits) const;

    Spadic::MsInfoType getInfoType(const uint32_t frame) const;

    uint8_t getTsMsb(const uint32_t frame, UnpackMonitorData& monitor) const;

    CbmTrdRawMessageSpadic makeRaw(const uint32_t frame, uint16_t criId, uint8_t crobId, uint16_t elinkId,
                                   uint8_t istream, MsContext& ctx) const;

    static CbmTrdDigi::eTriggerType GetDigiTriggerType(Spadic::eTriggerType tt);

    CbmTrdDigi makeDigi(CbmTrdRawMessageSpadic raw, MsContext& ctx, UnpackMonitorData& monitor) const;

    CbmTrdDigi makeDigi(Spadic::FexWord<sys_ver> fw, size_t fMsStartTimeRel, UnpackMonitorData& monitor) const;

    uint64_t GetBinTimeShift(const std::vector<int16_t>* /*samples*/) const { return 0.; };

    std::float_t GetMaxAdcValue(const std::vector<int16_t>* samples) const;

    float_t GetBaseline(const std::vector<int16_t>* samples) const;

    Spadic::MsMessageType getMessageType(const uint32_t frame) const;

    static constexpr uint8_t fBytesPerWord = 8;

    static constexpr uint8_t fStreamsPerWord = 2;

    static constexpr size_t fNrOfPresamples = 1;

    static constexpr float_t fAsicClockCycle = 62.5;

    static constexpr uint16_t fTsMsbLength = 16000;

    static constexpr size_t fTsMsbLengthCC = fTsMsbLength / fAsicClockCycle;

    static constexpr size_t fPeakingBinMin = fNrOfPresamples;

    static constexpr size_t fPeakingBinMax = static_cast<size_t>(120.0 / fAsicClockCycle + fNrOfPresamples + 5);
  };
 
}  // namespace cbm::algo::trd