KfpV0Finder.h

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */
 
 
#pragma once
 
#include "CbmEventTriggers.h"
#include "KFParticleTopoReconstructor.h"
#include "global/RecoResults.h"
#include "kfp/KfpV0FinderMonitor.h"
 
#include <limits>
#include <memory>
 
 
namespace cbm::algo::kfp
{
  class V0Finder {
   public:
    struct ParticleInfo {
      double fMass{std::numeric_limits<double>::quiet_NaN()};  //< Estimated mass of the particle [GeV/c2]
      double fDca{std::numeric_limits<double>::quiet_NaN()};   //< DCA to the origin [cm]
      double fBeta{std::numeric_limits<double>::quiet_NaN()};  //< Speed of the particle [c]
      double fQp{std::numeric_limits<double>::quiet_NaN()};    //< q/p of the particle [GeV^-1]
      int32_t fPdg{V0Finder::kUndefPdg};                       //< PDG code
      int32_t fCharge{0};                                      //< Charge of the particle
      bool fbSelected{false};                                  //< The track was selected
    };
 
    //* Framework and physical constants (public)
    static constexpr double kPionMass{0.13957039};      
    static constexpr double kProtonMass{0.938272088};   
    static constexpr double kSpeedOfLight{29.9792458};  
    static constexpr int32_t kUndefPdg{-2};             
 
    V0Finder() = default;
 
    V0Finder(const V0Finder&) = delete;
 
    V0Finder(V0Finder&&) = delete;
 
    ~V0Finder() = default;
 
    V0Finder& operator=(const V0Finder&) = delete;
 
    V0Finder& operator=(V0Finder&&) = delete;
 
    void AddDecayToReconstructionList(int pdg) { GetKFParticleFinder()->AddDecayToReconstructionList(pdg); }
 
    const V0FinderMonitorData_t& GetEventMonitor() const { return fEventMonitor; }
 
    const std::array<float, 3>& GetOrigin() const { return fOrigin; }
 
    KFParticleFinder* GetKFParticleFinder() { return fpTopoReconstructor->GetKFParticleFinder(); }
 
    const KFParticleFinder* GetKFParticleFinder() const { return fpTopoReconstructor->GetKFParticleFinder(); }
 
    const std::vector<ParticleInfo>& GetParticleInfo() const { return fvParticleInfo; }
 
    double GetSelectedT0() const { return fSelectedT0; }
 
    const std::vector<uint32_t>& GetSelectedTrackIds() const { return fvSelectedTrackIds; }
 
    const std::vector<double>& GetT0s() const { return fvT0s; }
 
    const std::unique_ptr<KFParticleTopoReconstructor>& GetTopoReconstructor() const { return fpTopoReconstructor; }
 
    const auto& GetTrackAssignedParams() const { return fvTrackParam; }
 
    void Init();
 
    CbmEventTriggers Process(const RecoResults& recoEvent);
 
    void SetBmonPartitionIndex(int iPartition) { fBmonPartitionIndex = iPartition; }
 
    void SetMinPionDca(double dca) { fMinPionDca = dca; }
 
    void SetMinProtonDca(double dca) { fMinProtonDca = dca; }
 
    // FIXME: for now origin is defined as the target center, later it can be changed
    void SetOrigin(double x, double y, double z) { fOrigin = {float(x), float(y), float(z)}; }
 
    void SetPionVelocityRange(double vMin, double vMax)
    {
      fMinBetaPion = vMin / kSpeedOfLight;
      fMaxBetaPion = vMax / kSpeedOfLight;
    }
 
    void SetProtonVelocityRange(double vMin, double vMax)
    {
      fMinBetaProton = vMin / kSpeedOfLight;
      fMaxBetaProton = vMax / kSpeedOfLight;
    }
 
    void SetPrimaryAssignedPdg(int pdg) { fPrimaryAssignedPdg = pdg; }
 
    void SetQpAssignedUncertainty(double uncertainty) { fQpAssignedUncertainty = uncertainty; }
 
    void SetTzeroOffset(double offset) { fTzeroOffset = offset; }
 
    void SetLCut(float cut) { GetKFParticleFinder()->SetLCut(cut); }
 
    void SetChiPrimaryCut2D(float cut) { GetKFParticleFinder()->SetChiPrimaryCut2D(cut); }
 
    void SetChi2Cut2D(float cut) { GetKFParticleFinder()->SetChi2Cut2D(cut); }
 
    void SetLdLCut2D(float cut) { GetKFParticleFinder()->SetLdLCut2D(cut); }
 
   private:
    /* clang-format off */
    bool AssignMomentum(const PartitionedVector<tof::Hit>& tofHits, 
                        const std::vector<RecoResults::HitId_t>& tofHitIds,
                        double t0, 
                        ParticleInfo& pidInfo);
    /* clang-format on */
 
    void AssignPid(ParticleInfo& info);
 
    void CollectDca(const RecoResults& recoEvent);
 
    void CollectT0(gsl::span<const bmon::Hit> bmonHits);
 
    double EstimateBeta(const tof::Hit& tofHit, double t0) const;
 
    double EstimateDca(const sts::Hit& fst, const sts::Hit& snd) const;
 
    bool FindV0Candidates(const RecoResults& recoEvent, double t0);
 
    void InitTrackParamVectors(const ca::Vector<ca::Track>& tracks);
 
    static KFVertex MakeKfpPrimaryVertex(const std::array<float, 3>& r);
 
    bool SelectTrack(const ParticleInfo& particleInfo) const;
 
    void SetKfpTrackParameters(KFPTrackVector& kfpTrkVector, uint32_t iKfpTrk, uint32_t iCaTrk,
                               const ca::Track::TrackParam_t& trkParam, const ParticleInfo& particleInfo) const;
 
 
    //* Framework and physical constants (private)
    static constexpr bool kUseAverageSpeed{false};  
 
    V0FinderMonitorData_t fEventMonitor;  
 
    //* Different run-time cuts and flags (TODO: define in a config)
    double fTzeroOffset{0.};             
    double fMinPionDca{1.5};             
    double fMinProtonDca{0.5};           
    double fQpAssignedUncertainty{0.1};  
    double fMinBetaProton{0.};           
    double fMaxBetaProton{1.};           
    double fMinBetaPion{0.};             
    double fMaxBetaPion{1.};             
    int fPrimaryAssignedPdg{321};        
 
    //* Run-time variables, provided by framework
    int fBmonPartitionIndex{-1};  
 
    //* Temporary data arrays (NOTE: keep them here for QA)
    std::array<float, 3> fOrigin{0.f, 0.f, 0.f};                   
    std::vector<double> fvT0s;                                     
    std::vector<ParticleInfo> fvParticleInfo;                      
    std::vector<uint32_t> fvSelectedTrackIds;                      
    double fSelectedT0{std::numeric_limits<double>::quiet_NaN()};  
 
    std::vector<std::pair<ca::Track::TrackParam_t, ca::Track::TrackParam_t>> fvTrackParam;
 
    //* Auxilary variables
 
    std::unique_ptr<KFParticleTopoReconstructor> fpTopoReconstructor{std::make_unique<KFParticleTopoReconstructor>()};
  };
}  // namespace cbm::algo::kfp