CbmCaIdealHitProducerDet.h

Go to the documentation of this file.

/* Copyright (C) 2023-2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#pragma once
 
#include "CaAlgoRandom.h"
#include "CaDefs.h"
#include "CaUvConverter.h"
#include "CbmEvent.h"
#include "CbmL1DetectorID.h"
#include "CbmMCDataArray.h"
#include "CbmMCDataManager.h"
#include "CbmMCDataObject.h"
#include "CbmMCEventList.h"
#include "CbmMatch.h"
#include "CbmMuchAddress.h"
#include "CbmMuchPixelHit.h"
#include "CbmMuchPoint.h"
#include "CbmMvdHit.h"
#include "CbmMvdPoint.h"
#include "CbmRecoSetupManager.h"
#include "CbmStsHit.h"
#include "CbmStsPoint.h"
#include "CbmTimeSlice.h"
#include "CbmTofAddress.h"
#include "CbmTofHit.h"
#include "CbmTofPoint.h"
#include "CbmTrdHit.h"
#include "CbmTrdPoint.h"
 
#include <FairRootManager.h>
#include <FairTask.h>
#include <Logger.h>
 
#include <TClonesArray.h>
#include <TVector3.h>
 
#include <array>
#include <optional>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
 
#include <yaml-cpp/yaml.h>
 
// TODO: Refactor the class
 
namespace cbm::ca
{
  namespace constants = cbm::algo::ca::constants;

  // TODO: Replace ca::EDetectorID -> ECbmModuleId
  template<ca::EDetectorID DetID>
  class IdealHitProducerDet {
   public:
    using Hit_t   = HitTypes_t::at<DetID>;
    using Point_t = PointTypes_t::at<DetID>;

    IdealHitProducerDet();

    ~IdealHitProducerDet();

    IdealHitProducerDet(const IdealHitProducerDet&) = delete;

    IdealHitProducerDet(IdealHitProducerDet&&) = delete;

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

    IdealHitProducerDet& operator=(IdealHitProducerDet&&) = delete;

    InitStatus Init();

    InitStatus ReInit() { return Init(); }

    void Exec(Option_t* option);

    void SetRandomSeed(int seed) { fRandom.SetSeed(seed); }

    void SetConfigName(const char* name) { fsConfigName = name; }
 
   private:
    static constexpr double kHitWSize = 3.5;  

    std::optional<CbmLink> GetMatchedPointLink(int iH);

    void ParseConfig();

    void PushBackHit(const Hit_t* pHit);

    void SmearValue(double& value, double sigma, int opt);

    void FillPointIsLegit(int iEvGlob);

    struct HitParameters {
 
      double fPhiU{constants::Undef<double>};  
      double fPhiV{constants::Undef<double>};  
 
      double fDu{constants::Undef<double>};  
      double fDv{constants::Undef<double>};  
      double fDt{constants::Undef<double>};  

      short fPdfU = -1;
      short fPdfV = -1;
      short fPdfT = -1;

      short fMode = 0;

      bool fbSmear = false;
    };
 
    const cbm::algo::RecoSetupUnit_t<ToCbmModuleId(DetID)>* fpDetInterface = nullptr;  
 
    // ----- Input branches:
    CbmTimeSlice* fpTimeSlice        = nullptr;  
    TClonesArray* fpRecoEvents       = nullptr;  
    CbmMCEventList* fpMCEventList    = nullptr;  
    CbmMCDataObject* fpMCEventHeader = nullptr;  
    CbmMCDataArray* fpBrPoints       = nullptr;  
    CbmMCDataArray* fpBrMCTracks     = nullptr;  
 
    TClonesArray* fpBrHits       = nullptr;  
    TClonesArray* fpBrHitMatches = nullptr;  
 
    TClonesArray* fpBrHitsTmp       = nullptr;  
    TClonesArray* fpBrHitMatchesTmp = nullptr;  
 
    ECbmDataType fHitDataType = ECbmDataType::kUnknown;  
 
    std::string fsConfigName = "";  
 
    std::vector<HitParameters> fvStationPars;  
 
    std::vector<unsigned char> fvbPointIsLegit;  
 
    std::unordered_map<uint32_t, double> fTofRpcZpos;  
 
    ca::Random fRandom{1};  

    bool fbRunTheRoutine = true;
 
 
    int fHitCounter = 0;  
  };
 
 
  // **********************************************************
  // **     Template and inline function implementations     **
  // **********************************************************
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<ca::EDetectorID DetID>
  inline void IdealHitProducerDet<DetID>::PushBackHit(const HitTypes_t::at<DetID>* pHit)
  {
    // Common fields for all the subsystems
    auto pos     = TVector3{};
    auto dpos    = TVector3{};
    auto address = pHit->GetAddress();
    pHit->Position(pos);
    pHit->PositionError(dpos);
 
    // Fields specific to each detector type
    if constexpr (ca::EDetectorID::kMvd == DetID) {
      auto statNr  = pHit->GetStationNr();
      auto iCentrX = pHit->GetIndexCentralX();
      auto iCentrY = pHit->GetIndexCentralY();
      auto iClust  = pHit->GetClusterIndex();
      auto flag    = pHit->GetFlag();
      new ((*fpBrHits)[fHitCounter]) CbmMvdHit(address, statNr, pos, dpos, iCentrX, iCentrY, iClust, flag);
    }
    else {
      auto time  = pHit->GetTime();
      auto dtime = pHit->GetTimeError();
      if constexpr (ca::EDetectorID::kSts == DetID) {
        auto dxy     = pHit->GetDxy();
        auto iClustF = pHit->GetFrontClusterId();
        auto iClustB = pHit->GetBackClusterId();
        auto du      = pHit->GetDu();
        auto dv      = pHit->GetDv();
        new ((*fpBrHits)[fHitCounter]) CbmStsHit(address, pos, dpos, dxy, iClustF, iClustB, time, dtime, du, dv);
      }
      else if constexpr (ca::EDetectorID::kMuch == DetID) {
        auto dxy     = pHit->GetDxy();
        auto refId   = pHit->GetRefId();
        auto planeId = pHit->GetPlaneId();
        LOG(info) << "MUCH: " << pHit->GetRefId() << ' ' << pHit->GetPlaneId();
        new ((*fpBrHits)[fHitCounter]) CbmMuchPixelHit(address, pos, dpos, dxy, refId, planeId, time, dtime);
      }
      else if constexpr (ca::EDetectorID::kTrd == DetID) {
        auto dxy   = pHit->GetDxy();
        auto refId = pHit->GetRefId();
        auto eLoss = pHit->GetELoss();
        new ((*fpBrHits)[fHitCounter]) CbmTrdHit(address, pos, dpos, dxy, refId, eLoss, time, dtime);
      }
      else if constexpr (ca::EDetectorID::kTof == DetID) {
        auto refId   = -1;  // pHit->GetRefId(); // -> deprecated
        auto flag    = pHit->GetFlag();
        auto channel = pHit->GetCh();
        new ((*fpBrHits)[fHitCounter]) CbmTofHit(address, pos, dpos, refId, time, dtime, flag, channel);
      }
    }
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<ca::EDetectorID DetID>
  inline std::optional<CbmLink> IdealHitProducerDet<DetID>::GetMatchedPointLink(int iH)
  {
    const auto* pHitMatch = dynamic_cast<CbmMatch*>(fpBrHitMatchesTmp->At(iH));
    assert(pHitMatch);
    if (pHitMatch->GetNofLinks() > 0) {
      const auto& link = pHitMatch->GetMatchedLink();
      if (link.GetIndex() > -1) {
        return std::make_optional(link);
      }
    }
    return std::nullopt;
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<ca::EDetectorID DetID>
  inline void IdealHitProducerDet<DetID>::SmearValue(double& value, double sigma, int opt)
  {
    switch (opt) {
      case 0: value += fRandom.BoundedGaus<double>(0., sigma, kHitWSize); break;
      case 1: value += fRandom.Uniform<double>(0., sigma); break;
      default: LOG(fatal) << "IdealHitProducerDet::SmearValue: illegal option: opt = " << opt;
    }
  }
 
 
}  // namespace cbm::ca