Unpack.h

/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese, Dominik Smith [committer] */


#ifndef UNPACK_H
#define UNPACK_H 1

#include "CbmDigiTimeslice.h"

#include "tof/TofReadoutConfig.h"
#include "tof/UnpackTof.h"
#include "trd/TrdReadoutConfig.h"
#include "trd/UnpackTrd.h"
#include "trd2d/Trd2dReadoutConfig.h"
#include "trd2d/UnpackTrd2d.h"

#include <optional>
#include <sstream>
#include <vector>

#include "bmon/BmonReadoutConfig.h"
#include "bmon/UnpackBmon.h"
#include "much/MuchReadoutConfig.h"
#include "much/UnpackMuch.h"
#include "rich/RichReadoutConfig.h"
#include "rich/UnpackRich.h"
#include "sts/StsReadoutConfigLegacy.h"
#include "sts/UnpackSts.h"

namespace cbm::algo
{

  /** @struct UnpackMonitorData
   ** @author Dominik Smith <d.smith@gsi.de>
   ** @since 2 Jun 2023
   ** @brief Monitoring data for unpacking
   **/
  struct UnpackMonitorData {
    std::vector<UnpackStsMonitorData> fSts;      ///< Monitoring data for STS
    std::vector<UnpackMuchMonitorData> fMuch;    ///< Monitoring data for MUCH
    std::vector<UnpackTofMonitorData> fTof;      ///< Monitoring data for TOF
    std::vector<UnpackBmonMonitorData> fBmon;    ///< Monitoring data for T0
    std::vector<UnpackTrdMonitorData> fTrd;      ///< Monitoring data for TRD
    std::vector<UnpackTrd2dMonitorData> fTrd2d;  ///< Monitoring data for TRD2D
    std::vector<UnpackRichMonitorData> fRich;    ///< Monitoring data for RICH
    size_t fNumMs       = 0;
    size_t fNumBytes    = 0;
    size_t fNumDigis    = 0;
    size_t fNumCompUsed = 0;
    std::string print()
    {
      std::stringstream ss;
      ss << "TS stats: num MS " << fNumMs << ", bytes " << fNumBytes << ", digis " << fNumDigis << ", components "
         << fNumCompUsed << std::endl;
      return ss.str();
    }
  };

  /** @class Unpack
 ** @brief Algo class for unpacking digi timeslicess
 ** @author Dominik Smith <d.smith@gsi.de>
 ** @since 02.06.2023
 **
 **/
  class Unpack {

  public:
    typedef std::pair<CbmDigiTimeslice, UnpackMonitorData> resultType;

    /** @brief Algorithm execution
     ** @param fles timeslice to unpack
     ** @return pair: digi timeslice, monitoring data
     **/
    resultType operator()(const fles::Timeslice* timeslice);

    /** @brief Default constructor **/
    Unpack() {};

    /** @brief Destructor **/
    ~Unpack() {};

    /** @brief Parameters for STS unpackers **/
    StsReadoutConfigLegacy fStsConfig {};

    /** @brief Parameters for MUCH unpackers **/
    MuchReadoutConfig fMuchConfig {};

    /** @brief Parameters for TOF unpackers **/
    TofReadoutConfig fTofConfig {};

    /** @brief Parameters for T0 unpackers **/
    BmonReadoutConfig fBmonConfig {};

    /** @brief Parameters for TRD unpackers **/
    TrdReadoutConfig fTrdConfig {};

    /** @brief Parameters for TRD2D unpackers **/
    Trd2dReadoutConfig fTrd2dConfig {};

    /** @brief Parameters for RICH unpackers **/
    RichReadoutConfig fRichConfig {};

    /** @brief Initialize unpackers and fill parameters from config objects
     * @param subIds: vector of subsystem identifiers to unpack, default: all
     * @see Init()
     **/
    bool Init(std::optional<std::vector<fles::SubsystemIdentifier>> subIds = {});

    bool DetectorEnabled(fles::SubsystemIdentifier subId)
    {
      return std::find(fSubIds.begin(), fSubIds.end(), subId) != fSubIds.end();
    }

  private:  // methods
    /** @brief Microslice loop **/
    template<class Digi, class UnpackAlgo, class MonitorData>
    void MsLoop(const fles::Timeslice* timeslice, std::map<uint16_t, UnpackAlgo>& algoMap, const uint64_t comp,
                const uint16_t eqId, std::vector<Digi>* digis, UnpackMonitorData& monitor,
                std::vector<MonitorData>* monitorMs, uint8_t sys_ver);


  private:                                                // members
    std::vector<fles::SubsystemIdentifier> fSubIds = {};  ///< Detector identifiers to unpack

    /** @brief STS unpackers **/
    std::map<uint16_t, UnpackSts> fAlgoSts = {};

    /** @brief MUCH unpackers **/
    std::map<uint16_t, UnpackMuch> fAlgoMuch = {};

    /** @brief TOF unpackers **/
    std::map<uint16_t, UnpackTof> fAlgoTof = {};

    /** @brief T0 unpackers **/
    std::map<uint16_t, UnpackBmon> fAlgoBmon = {};

    /** @brief TRD unpackers **/
    std::map<uint16_t, UnpackTrd> fAlgoTrd = {};

    /** @brief TRD2D unpackers **/
    std::map<uint16_t, UnpackTrd2d> fAlgoTrd2d = {};

    /** @brief RICH unpackers **/
    std::map<uint16_t, UnpackRich> fAlgoRich = {};

    /** @brief System time offsets **/
    std::map<fles::SubsystemIdentifier, int32_t> fSystemTimeOffset = {
      {fles::SubsystemIdentifier::STS, -970},  {fles::SubsystemIdentifier::MUCH, -980},
      {fles::SubsystemIdentifier::RICH, 100},  {fles::SubsystemIdentifier::RPC, 40},
      {fles::SubsystemIdentifier::T0, 0},      {fles::SubsystemIdentifier::TRD, 1300},
      {fles::SubsystemIdentifier::TRD2D, -510}};
  };
}  // namespace cbm::algo

#endif /* UNPACK_H */