sts/UnpackMS.h

Go to the documentation of this file.

/* Copyright (C) 2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau, Volker Friese [committer] */
#pragma once
 
#include "CbmStsDigi.h"
#include "Definitions.h"
#include "MicrosliceDescriptor.hpp"
#include "StsXyterMessage.h"
#include "UnpackMSBase.h"
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <vector>
 
namespace cbm::algo::sts
{
 
  struct UnpackElinkPar {
    int32_t fAddress     = 0;     
    uint32_t fAsicNr     = 0;     
    uint64_t fTimeOffset = 0.;    
    double fAdcOffset    = 0.;    
    double fAdcGain      = 0.;    
    uint32_t fAdcMinCut  = 0.;    
    std::vector<double> fWalk;    
    std::vector<bool> fChanMask;  
  };
 
 
  struct UnpackPar {
    uint32_t fNumChansPerAsic                = 0;      
    uint32_t fNumAsicsPerModule              = 0;      
    std::vector<UnpackElinkPar> fElinkParams = {};     
    bool fWriteAux                           = false;  
  };
 
 
  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()
    {
      std::stringstream ss;
      ss << "errors " << fNumNonHitOrTsbMessage << " | " << fNumErrElinkOutOfRange << " | "
         << fNumErrInvalidFirstMessage << " | " << fNumErrInvalidMsSize << " | " << fNumErrTimestampOverflow << " | ";
      return ss.str();
    }
  };
 
  struct QaDigi {
 
    QaDigi(bool missed, int32_t addr, int32_t chan, uint32_t t, uint16_t c, uint16_t e)
      : missedEvent(missed)
      , address(addr)
      , channel(chan)
      , time(t)
      , charge(c)
      , elink(e)
    {
    }
 
    bool missedEvent;
    int32_t address;
    int32_t channel;
    uint32_t time;
    uint16_t charge;
    uint16_t elink;
  };
 
  struct UnpackAuxData {
    std::vector<QaDigi> fQaDigis;
  };
 
  class UnpackMS : public UnpackMSBase<CbmStsDigi, 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:  // types
    struct TimeSpec {
      u64 currentTsTime    = 0;  
      u64 currentCycle     = 0;  
      u32 currentEpoch     = 0;  
      u64 currentEpochTime = 0;  
    };
 
   private:  // methods
    void ProcessHitMessage(const stsxyter::Message& message, const TimeSpec& time, std::vector<CbmStsDigi>& digiVec,
                           UnpackMonitorData& monitor, UnpackAuxData& aux) const;
 
    void ProcessTsmsbMessage(const stsxyter::Message& message, TimeSpec& time) const;
 
 
   private:                  // members
    UnpackPar fParams = {};  
 
    static constexpr uint64_t fkEpochsPerCycle = stsxyter::kuTsMsbNbTsBinsBinning;
 
    static constexpr uint64_t fkEpochLength = stsxyter::kuHitNbTsBinsBinning;
 
    static constexpr uint32_t fkClockCycleNom = stsxyter::kulClockCycleNom;
    static constexpr uint32_t fkClockCycleDen = stsxyter::kulClockCycleDen;
 
    static constexpr uint64_t fkCycleLength = (fkEpochsPerCycle * fkEpochLength * fkClockCycleNom) / fkClockCycleDen;
  };
 
} /* namespace cbm::algo::sts */