Reco.h

/* Copyright (C) 2023 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Felix Weiglhofer [committer] */
#pragma once

#include "AlgoTraits.h"
#include "SubChain.h"
#include "global/RecoResults.h"

#include <xpu/host.h>

// fwd declarations
namespace fles
{
  class Timeslice;
}

namespace cbm::algo
{
  class HistogramSender;
  class Options;
  class TrackingChain;

  template<class M>
  struct UnpackMonitor;

  namespace bmon
  {
    class Unpack;
  }

  namespace much
  {
    class Unpack;
  }

  namespace rich
  {
    class Unpack;
  }

  namespace sts
  {
    class Unpack;
    class DigiQa;
    class HitfinderChain;
    class HitfinderMon;
  }

  namespace tof
  {
    class Unpack;
    class CalibratorChain;
    struct CalibrateMonitorData;
    class HitfinderChain;
    struct HitfindMonitorData;
  }

  namespace trd
  {
    class Unpack;
    class Hitfind;
    struct HitfindMonitorData;
  }

  namespace trd2d
  {
    class Unpack;
  }

  namespace evbuild
  {
    class EventbuildChain;
    struct EventbuildChainMonitorData;
  }  // namespace evbuild

  namespace ca
  {
    template<class C, class T>
    class MonitorData;
    enum class ECounter;
    enum class ETimer;
    using TrackingMonitorData = MonitorData<ECounter, ETimer>;
  }  // namespace ca

}  // namespace cbm::algo

namespace cbm::algo
{
  struct ProcessingMonitor {
    xpu::timings time;           //< total processing time
    xpu::timings timeUnpack;     //< time spent in unpacking
    std::optional<i64> tsDelta;  //< id difference between current and previous timeslice
  };

  class Reco : SubChain {
   public:
    Reco();
    ~Reco();

    Reco(const Reco&) = delete;
    Reco& operator=(const Reco&) = delete;
    Reco(Reco&&)                 = delete;
    Reco& operator=(Reco&&) = delete;

    void Init(const Options&);
    RecoResults Run(const fles::Timeslice&);
    void Finalize();
    void PrintTimings(xpu::timings&);

   private:
    bool fInitialized = false;
    ChainContext fContext;
    xpu::timings fTimesliceTimesAcc;
    std::shared_ptr<HistogramSender> fSender;

    std::optional<u64> prevTsId;

    // BMON
    std::unique_ptr<bmon::Unpack> fBmonUnpack;

    // MUCH
    std::unique_ptr<much::Unpack> fMuchUnpack;

    // RICH
    std::unique_ptr<rich::Unpack> fRichUnpack;

    // STS
    std::unique_ptr<sts::Unpack> fStsUnpack;
    std::unique_ptr<sts::DigiQa> fStsDigiQa;  ///< Raw STS-digis QA
    std::unique_ptr<sts::HitfinderChain> fStsHitFinder;

    // TOF
    std::unique_ptr<tof::Unpack> fTofUnpack;
    std::unique_ptr<tof::HitfinderChain> fTofHitFinder;
    std::unique_ptr<tof::CalibratorChain> fTofCalibrator;

    // TRD
    std::unique_ptr<trd::Unpack> fTrdUnpack;
    std::unique_ptr<trd2d::Unpack> fTrd2dUnpack;
    std::unique_ptr<trd::Hitfind> fTrdHitfind;

    // Eventbuilding
    std::unique_ptr<evbuild::EventbuildChain> fEventBuild;

    // Tracking
    std::unique_ptr<TrackingChain> fTracking;

    void Validate(const Options& opts);

    template<class Unpacker>
    auto RunUnpacker(const std::unique_ptr<Unpacker>&, const fles::Timeslice&) -> algo_traits::Output_t<Unpacker>;

    template<class MSMonitor>
    void QueueUnpackerMetricsDet(const UnpackMonitor<MSMonitor>&);
    void QueueStsRecoMetrics(const sts::HitfinderMon&);
    void QueueTofRecoMetrics(const tof::HitfindMonitorData&);
    void QueueTrdRecoMetrics(const trd::HitfindMonitorData&);
    void QueueTofCalibMetrics(const tof::CalibrateMonitorData&);
    void QueueEvbuildMetrics(const evbuild::EventbuildChainMonitorData&);
    void QueueTrackingMetrics(const ca::TrackingMonitorData&);
    void QueueProcessingMetrics(const ProcessingMonitor&);
  };
}  // namespace cbm::algo