CbmKFV0FinderTask.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] */
 
 
// TODO: Provide a configurator to the class
 
#pragma once
 
#include "CbmEnumArray.h"
#include "CbmKFParticleFinder.h"  // for the CbmKFParticleFinder::InverseChi2Prob()
#include "CbmKFV0FinderQa.h"
#include "CbmKFVertex.h"
#include "CbmVertex.h"
#include "FairTask.h"
#include "KFParticleTopoReconstructor.h"
 
#include <memory>
 
class CbmEvent;
class CbmGlobalTrack;
class CbmStsTrack;
class CbmTofHit;
class TClonesArray;
class FairTrackParam;
class KFPTrackVector;
class KFVertex;
class KFParticleFinder;
class CbmEventTriggers;
 
namespace cbm::kfp
{
  class V0FinderTask : public FairTask {
   public:
    struct QpAndBeta {
      double fQp{std::numeric_limits<double>::signaling_NaN()};
      double fQpVar{std::numeric_limits<double>::signaling_NaN()};
      double fBeta{std::numeric_limits<double>::signaling_NaN()};
      double fBetaVar{std::numeric_limits<double>::signaling_NaN()};
    };
 
    struct DcaVector {
      double fAbs{std::numeric_limits<double>::signaling_NaN()};  
      double fX{std::numeric_limits<double>::signaling_NaN()};    
      double fY{std::numeric_limits<double>::signaling_NaN()};    
    };
 
    enum class ECounter : uint8_t
    {
      TracksTotal,                //< Total number of tracks
      TracksSelected,             //< Tracks, which satisfy topology PID applicability
      TracksInfiniteParam,        //< Tracks, which have infinite parameters
      TracksWoTofHits,            //< Tracks, which have no TOF hits
      TracksWNegativeTofHitTime,  //< Tracks, the last TOF hit of which has a negative time (it's time is less then the t0)
      TracksWoStsHits,            //< Tracks, which have no STS hits
      TracksWoPid,                //< Tracks, which has undefined PID
      TracksWoMomentum,           //< Tracks, which has undefined PID
      TracksWAtLeastOneTofHit,   //< Tracks with at least one tof hit
      TracksWAtLeastTwoTofHits,  //< Tracks with at least two tof hits
      TracksWithUnphysicalBeta,  //< Tracks with beta > 1
      TracksW2Sts2Tof,           //< Tracks with at least two STS hits and two TOF hits
      Pions,                     //< Number of pion-candidates
      Protons,                   //< Number of proton-candidates
      EventsTotal,               //< Total number of events
      EventsWoTzero,             //< Number of events with undefined t-zero
      EventsLambdaCand,          //< Events with at least one pion and one proton candidate
      KfpEventsLambdaCand,       //< Events with lambda-candidates in KF-particle
      KfpLambdaCandidates,       //< Number of lambda-candidates
      END
    };
 
    enum class EPidApproach : uint8_t
    {
      Topo,  //< Topological PID (DCA calculation for a track)
      Mc     //< MC-truth PID
    };
 
    enum class EProcessingMode : uint8_t
    {
      TimeBased,  //< Time based simulation or real data
      EventBased  //< Event based simulation
    };
 
    enum class EPvUsageMode : uint8_t
    {
      Target,               //< Use target center as a primary vertex
      Reconstructed,        //< Use reconstructed primary vertex
      ReconstructSingle,    //< Reconstruct a single PV from given track vectors
      ReconstructMultiple,  //< Reconstruct multiple PVs (in case of pile-up)
      Mc                    //< Use MC-true primary vertex
    };
 
    explicit V0FinderTask(int verbose = 1) : FairTask("V0FinderTask", verbose){};
 
    ~V0FinderTask() = default;
 
    // Eliminate copy and move
    V0FinderTask(const V0FinderTask&) = delete;
    V0FinderTask(V0FinderTask&&)      = delete;
    V0FinderTask& operator=(const V0FinderTask&) = delete;
    V0FinderTask& operator=(V0FinderTask&&) = delete;
 
 
    //* FairTask overriden methods
 
    void Exec(Option_t*) override;
 
    void Finish() override;
 
    InitStatus Init() override;
 
 
    //* Accessors
 
    KFParticleFinder* GetKFParticleFinder() { return fpTopoReconstructorRun->GetKFParticleFinder(); }
 
    const KFParticleFinder* GetKFParticleFinder() const { return fpTopoReconstructorRun->GetKFParticleFinder(); }
 
    const auto& GetTrackDcaToOrigin() const { return fvTrackDca; }
 
    const std::shared_ptr<const KFParticleTopoReconstructor> GetTopoReconstructor() const
    {
      return fpTopoReconstructorRun;
    }
 
    //const
 
    //* Task logic and preliminary selection cut setters
 
    void SetProcessingMode(EProcessingMode mode) { fProcessingMode = mode; }
 
    void SetPidApproach(EPidApproach pid) { fPidApproach = pid; }
 
    void SetPvFindingMode(EPvUsageMode mode) { fPvUsageMode = mode; }
 
    void SetUseMc(bool bUseMc) { fbUseMc = bUseMc; }
 
    void SetRunQa(bool bRunQa) { fbRunQa = bRunQa; }
 
    void SetMinPionDca(double dca) { fMinPionDca = dca; }
 
    void SetMinProtonDca(double dca) { fMinProtonDca = dca; }
 
    void SetQaOutputFileName(const TString& fileName) { fsQaOutputName = fileName; }
 
    void SetQpAssignedUncertainty(double uncertainty) { fQpAssignedUncertainty = uncertainty; }
 
    void SetTzeroOffset(double offset) { fTzeroOffset = offset; }
 
    // NOTE: The KFParticleFinder has its internal mixed-event analysis mode, but was not used in mCBM Lambda-analysis
    //       the internal mixed-event mode can be selected using the following method:
    //          fpTopoReconstructorRun->SetMixedEventAnalysis()
    void SetMixedEventMode(bool bMixedEvent) { fbMixedEventMode = bMixedEvent; }
 
 
    //* KFParticleFinder setters
 
    void AddDecayToReconstructionList(int pdg) { GetKFParticleFinder()->AddDecayToReconstructionList(pdg); }
 
    void SetPrimaryProbCut(double pVal)
    {
      constexpr int Ndf{2};
      fpTopoReconstructorRun->SetChi2PrimaryCut(CbmKFParticleFinder::InversedChi2Prob(pVal, Ndf));
    }
 
    void SetMaxDistanceBetweenParticlesCut(float cut) { GetKFParticleFinder()->SetMaxDistanceBetweenParticlesCut(cut); }
 
    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); }
 
    void SetSecondaryCuts(float sigmaMass, float chi2Topo, float ldl)
    {
      GetKFParticleFinder()->SetSecondaryCuts(sigmaMass, chi2Topo, ldl);
    }
 
    void SetLdLCutXiOmega(float cut) { GetKFParticleFinder()->SetLdLCutXiOmega(cut); }
 
    void SetChi2TopoCutXiOmega(float cut) { GetKFParticleFinder()->SetChi2TopoCutXiOmega(cut); }
 
    void SetChi2CutXiOmega(float cut) { GetKFParticleFinder()->SetChi2CutXiOmega(cut); }
 
    void SetChi2TopoCutResonances(float cut) { GetKFParticleFinder()->SetChi2TopoCutResonances(cut); }
 
    void SetChi2CutResonances(float cut) { GetKFParticleFinder()->SetChi2CutResonances(cut); }
 
    void SetPtCutLMVM(float cut) { GetKFParticleFinder()->SetPtCutLMVM(cut); }
 
    void SetPCutLMVM(float cut) { GetKFParticleFinder()->SetPCutLMVM(cut); }
 
    void SetPtCutJPsi(float cut) { GetKFParticleFinder()->SetPtCutJPsi(cut); }
 
    void SetPtCutCharm(float cut) { GetKFParticleFinder()->SetPtCutCharm(cut); }
 
    void SetChiPrimaryCutCharm(float cut) { GetKFParticleFinder()->SetChiPrimaryCutCharm(cut); }
 
    void SetLdLCutCharmManybodyDecays(float cut) { GetKFParticleFinder()->SetLdLCutCharmManybodyDecays(cut); }
 
    void SetChi2TopoCutCharmManybodyDecays(float cut) { GetKFParticleFinder()->SetChi2TopoCutCharmManybodyDecays(cut); }
 
    void SetChi2CutCharmManybodyDecays(float cut) { GetKFParticleFinder()->SetChi2CutCharmManybodyDecays(cut); }
 
    void SetLdLCutCharm2D(float cut) { GetKFParticleFinder()->SetLdLCutCharm2D(cut); }
 
    void SetChi2TopoCutCharm2D(float cut) { GetKFParticleFinder()->SetChi2TopoCutCharm2D(cut); }
 
    void SetChi2CutCharm2D(float cut) { GetKFParticleFinder()->SetChi2CutCharm2D(cut); }
 
 
    //* Static helper methods
 
    static std::string ToString(EProcessingMode mode);
 
    static std::string ToString(EPidApproach pid);
 
    static std::string ToString(EPvUsageMode pvMode);
 
    static std::string ToString(const FairTrackParam* pParam);
 
    static bool CheckTrackParam(const FairTrackParam* pParam);
 
   private:
    //* Auxilary internal methods
 
    bool AssignMomentum(CbmGlobalTrack* pTrack, int pdg);
 
    DcaVector EstimateDcaToOrigin(const CbmStsTrack* pTrack) const;
 
    QpAndBeta EstimateQp(const CbmTofHit* pTofHit, int pdg) const;
 
    KFPTrackVector MakeKfpTrackVector(const std::vector<const CbmGlobalTrack*>& vpTracks,
                                      const std::vector<int>& vTrackIds, const std::vector<float>& vChi2ToPv,
                                      bool bAtFirstPoint) const;
 
    KFVertex MakeKfpPrimaryVertex(float x, float y, float z) const;
 
    int InferTrackPidTopo(double dca) const;
 
    template<bool UseEvent>
    bool ProcessEvent(const CbmEvent* pEvent);
 
    // TODO:  Replace with a functor (a function from a separate FairTask)
    bool SelectTrack(CbmGlobalTrack* pTrack, int iTrk);
 
    double ShiftTofHitsToTzero(const CbmEvent* pEvent);
 
    void StoreParticles();
 
 
    //* Task constants (To be moved to a configuration)
    static constexpr int kPrimaryPdg{321};        
    static constexpr int kUndefPdg{-2};           
    static constexpr float kChi2PvPrimThrsh{3.};  
 
    //* Physical constants
    static constexpr double kPionMass{0.13957039};      
    static constexpr double kProtonMass{0.938272088};   
    static constexpr double kSpeedOfLight{29.9792458};  
 
    //* Different run-time flags;
    double fTzeroOffset{0.};             
    double fMinPionDca{1.5};             
    double fMinProtonDca{0.5};           
    double fQpAssignedUncertainty{0.1};  
    int fPrimaryAssignedPdg{321};        
 
    //* Input data branches
    TClonesArray* fpBrRecoEvents{nullptr};
    TClonesArray* fpBrGlobalTracks{nullptr};
    TClonesArray* fpBrStsTracks{nullptr};
    TClonesArray* fpBrTrdTracks{nullptr};
    TClonesArray* fpBrTofTracks{nullptr};
    TClonesArray* fpBrStsHits{nullptr};
    TClonesArray* fpBrTrdHits{nullptr};
    TClonesArray* fpBrTofHits{nullptr};
    CbmVertex* fpBrPrimaryVertex{nullptr};
 
    //* Output data branches
    std::vector<CbmEventTriggers>* fpBrEventTriggers{nullptr};  //< Branch for event triggers
    // TODO: in principle one can store the found KF particles and vertices as well
 
    //* Temporary data and auxilary variables (per FairTask::Exec() call)
    std::vector<DcaVector> fvTrackDca;  
    std::unique_ptr<CbmVertex> fpOrigin{
      std::make_unique<CbmVertex>()};  
 
    //* KFParticleFinder utilities
    // Main topology reconstructor
    std::shared_ptr<KFParticleTopoReconstructor> fpTopoReconstructorRun{
      std::make_shared<KFParticleTopoReconstructor>()};
    std::unique_ptr<KFParticleTopoReconstructor> fpTopoReconstructorEvent{
      std::make_unique<KFParticleTopoReconstructor>()};
 
    //* Control flags
    EProcessingMode fProcessingMode{EProcessingMode::TimeBased};  
    EPidApproach fPidApproach{EPidApproach::Topo};                
    EPvUsageMode fPvUsageMode{EPvUsageMode::Target};              
    bool fbMixedEventMode{false};                                 
    bool fbUseMc{false};                                          
    bool fbRunQa{false};                                          
    bool fbUsePvChi2Selection{false};                             
 
    //* QA and monitoring variables
    cbm::core::EnumArray<ECounter, size_t> fCounters{{0}};  
    std::unique_ptr<V0FinderQa> fpQa{nullptr};              
    TString fsQaOutputName{"./V0FinderQa.root"};            
 
 
    ClassDefOverride(V0FinderTask, 0);
  };
}  // namespace cbm::kfp