much/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 "CbmMuchDigi.h"
#include "MicrosliceDescriptor.hpp"
#include "StsXyterMessage.h"
#include "Timeslice.hpp"
#include "algo/unpack/UnpackMSBase.h"
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <sstream>
#include <vector>
 
namespace cbm::algo::much
{
 

  struct UnpackElinkPar {
    std::vector<uint32_t> fAddress;  
    std::vector<bool> fChanMask;     
    int64_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;  
    uint32_t fNumErrTimestampUnderflow  = 0;  
    bool HasErrors()
    {
      uint32_t numErrors = fNumNonHitOrTsbMessage + fNumErrElinkOutOfRange + fNumErrInvalidFirstMessage
                           + fNumErrInvalidMsSize + fNumErrTimestampOverflow + fNumErrTimestampUnderflow;
      return (numErrors > 0 ? true : false);
    }
    std::string print() const
    {
      std::stringstream ss;
      ss << "errors " << fNumNonHitOrTsbMessage << " | " << fNumErrElinkOutOfRange << " | "
         << fNumErrInvalidFirstMessage << " | " << fNumErrInvalidMsSize << " | " << fNumErrTimestampOverflow << " | "
         << fNumErrTimestampUnderflow << " | ";
      return ss.str();
    }
    void add(const UnpackMonitorData& rhs)
    {
      fNumNonHitOrTsbMessage += rhs.fNumNonHitOrTsbMessage;
      fNumErrElinkOutOfRange += rhs.fNumErrElinkOutOfRange;
      fNumErrInvalidFirstMessage += rhs.fNumErrInvalidFirstMessage;
      fNumErrInvalidMsSize += rhs.fNumErrInvalidMsSize;
      fNumErrTimestampOverflow += rhs.fNumErrTimestampOverflow;
      fNumErrTimestampUnderflow += rhs.fNumErrTimestampUnderflow;
    }
  };

  struct UnpackAuxData {
  };

  class UnpackMS : public UnpackMSBase<CbmMuchDigi, 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;
 
   private:  // datatypes
    struct TimeSpec {
      uint64_t currentTsTime    = 0;  
      uint64_t currentCycle     = 0;  
      uint32_t currentEpoch     = 0;  
      uint64_t currentEpochTime = 0;  
    };
 
 
   private:  // methods
    void ProcessHitMessage(const stsxyter::Message& message, const TimeSpec& time, std::vector<CbmMuchDigi>& digiVec,
                           UnpackMonitorData& monitor) 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::much