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 "UnpackMSBase.h"
 
#include <cmath>
#include <memory>
#include <sstream>
 
namespace cbm::algo::trd
{
  struct UnpackElinkPar {
    std::vector<uint32_t> fChanAddress;  
    uint32_t fAddress;                   
    uint64_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;  
 
    bool HasErrors()
    {
      uint32_t numErrors = fNumElinkMis + fNumCorruptEom + fNumWildRda + fNumWildEom + fNumUnknownWords + fNumMissingEom
                           + fNumWildNul + fNumCrcValidFlags + fNumOverflowFlimFlags + fNumOverflowUserFlags
                           + fNumDataErrorFlags;
      return (numErrors > 0 ? true : false);
    }
    std::string print()
    {
      std::stringstream ss;
      ss << " stats " << fNumNonMajorTsMsb << " | " << fNumCreatedRawMsgs << " | " << fNumEpochMsgs << " | "
         << fNumCreatedInfoMsgs << " errors " << fNumElinkMis << " | " << fNumCorruptEom << " | " << fNumWildRda
         << " | " << fNumWildEom << " | " << fNumUnknownWords << " | " << fNumMissingEom << " | " << fNumWildNul
         << " | " << fNumCrcValidFlags << " | " << fNumOverflowFlimFlags << " | " << fNumOverflowUserFlags << " | "
         << fNumDataErrorFlags << " | ";
      return ss.str();
    }
  };
 
  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<std::uint8_t> fNrTsMsbVec = {};
    };
 
   private:                  // members
    UnpackPar fParams = {};  
 
    void digestOutput(std::unique_ptr<CbmTrdDigi> digi, CbmTrdRawMessageSpadic raw);
 
    Spadic::MsInfoType digestBufInfoFlags(const std::uint32_t frame) const;
 
    void digestMsFlags(const std::uint16_t flags, UnpackMonitorData& monitor) const;
 
    void digestInfoMsg(const std::uint32_t frame) const;
 
    std::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 std::uint32_t frame) const;
 
    std::uint8_t getTsMsb(const std::uint32_t frame, UnpackMonitorData& monitor) const;
 
    CbmTrdRawMessageSpadic makeRaw(const std::uint32_t frame, std::uint16_t criId, std::uint8_t crobId,
                                   std::uint16_t elinkId, std::uint8_t istream, MsContext& ctx) const;
 
    static CbmTrdDigi::eTriggerType GetDigiTriggerType(Spadic::eTriggerType tt);
 
    CbmTrdDigi makeDigi(CbmTrdRawMessageSpadic raw, MsContext& ctx) const;
 
    CbmTrdDigi makeDigi(Spadic::FexWord<sys_ver> fw, size_t fMsStartTimeRel) const;
 
    uint64_t GetBinTimeShift(const std::vector<std::int16_t>* /*samples*/) const { return 0.; };
 
    std::float_t GetMaxAdcValue(const std::vector<std::int16_t>* samples) const;
 
    float_t GetBaseline(const std::vector<std::int16_t>* samples) const;
 
    Spadic::MsMessageType getMessageType(const std::uint32_t frame) const;
 
    static constexpr std::uint8_t fBytesPerWord = 8;
 
    static constexpr std::uint8_t fStreamsPerWord = 2;
 
    static constexpr size_t fNrOfPresamples = 1;
 
    static constexpr float_t fAsicClockCycle = 62.5;
 
    static constexpr std::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