CbmCaTrackTypeQa.h

Go to the documentation of this file.

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

 
 
#pragma once
 
#include "CaDebugger.h"
#include "CaMcData.h"
#include "CaParameters.h"
#include "CbmCaTrackFitQa.h"
#include "CbmL1DetectorID.h"
#include "CbmQaIO.h"
 
#include <map>
#include <string>
 
namespace cbm::algo::ca
{
  class McHitInfo;
}  // namespace cbm::algo::ca
 
class CbmL1Track;
 
class TH1F;
class TH2F;
class TProfile;
class TProfile2D;
 
namespace cbm::ca
{
  class TrackTypeQa : virtual public CbmQaIO {
   public:
    TrackTypeQa(const char* typeName, const char* prefixName, bool bUseMC, std::shared_ptr<ObjList_t> pObjList);

    ~TrackTypeQa() = default;

    TrackTypeQa(const TrackTypeQa&) = delete;

    TrackTypeQa(TrackTypeQa&&) = delete;

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

    TrackTypeQa& operator=(TrackTypeQa&&) = delete;
 
    void SetDebugger(cbm::algo::ca::utils::Debugger* pDebugger) { fpDebugger = pDebugger; }
 
    struct FitQaPoint {
      cbm::algo::ca::McPoint mcPoint;
      cbm::algo::kf::TrackParamD trackParam;
      bool isFilled{false};
    };
 
    struct FitQaPointSet {
      FitQaPoint firstHit;       
      FitQaPoint lastHit;        
      FitQaPoint vertex;         
      FitQaPoint trd;            
      bool isTimeFitted{false};  
    };

    double GetAverageRecoLength() const { return fRecoLength / (GetNofRecoTracksMatched() + fCounterClones); }

    double GetAverageNofStationsWithHit() const
    {
      assert(fph_stations_hit);
      return fph_stations_hit->GetBinContent(1);
    }

    double GetAverageNofStationsWithPoint() const
    {
      assert(fph_stations_point);
      return fph_stations_point->GetBinContent(1);
    }

    double GetAverageFakeLength() const { return fFakeLength / (GetNofRecoTracksMatched() + fCounterClones); }

    double GetIntegratedEff() const
    {
      assert(fph_rate_reco);
      return fph_rate_reco->GetBinContent(1);
    }

    double GetClonesRate() const
    {
      assert(fph_rate_clones);
      return fph_rate_clones->GetBinContent(1);
    }

    double GetKilledRate() const
    {
      assert(fbUseMC);
      return fph_rate_killed->GetBinContent(1);
    }

    double GetNofMCTracks() const { return fCounterMC; }

    double GetNofRecoTracksTotal() const
    {
      //return fCounterMC * GetIntegratedEff();
      return fCounterRecoTotal;
    }

    double GetNofRecoTracksMatched() const { return GetIntegratedEff() * fCounterMC; }

    double GetNofClones() const { return GetClonesRate() * fCounterMC; }

    const char* GetTitle() const { return fsTitle.Data(); }

    void Init();

    bool IsMCUsed() const { return fbUseMC; }

    void FillRecoTrack(int iTrkReco, const FitQaPointSet& fitPoints, double weight = 1);

    void FillMCTrack(int iTrkMC, double weight = 1);

    void RegisterRecoTracks(ca::Vector<CbmL1Track>& vTracks) { fpvRecoTracks = &vTracks; }

    void RegisterRecoHits(ca::Vector<cbm::algo::ca::McHitInfo>& vHits) { fpvHits = &vHits; }

    void RegisterMCData(cbm::algo::ca::McData& mcData) { fpMCData = &mcData; }

    void RegisterParameters(std::shared_ptr<const ca::Parameters<double>>& pParameters) { fpParameters = pParameters; }

    void SetDrawAtt(Color_t markerCol = 1, Style_t markerSty = 20, Color_t lineCol = -1, Style_t lineSty = 1);

    void SetTitle(const char* title) { fsTitle = title; }

    void SetMCTrackCut(std::function<bool(const cbm::algo::ca::McTrack&)> cut) { fMCTrackCut = cut; }

    void SetRecoTrackCut(std::function<bool(const CbmL1Track&)> cut) { fRecoTrackCut = cut; }

    void FillPerEvent();

    cbm::algo::ca::utils::Debugger* fpDebugger{nullptr};
 
    // ************************
    // ** List of histograms **
    // ************************
 
    // NOTE: Naming convention:
    //  "fph_" + <"reco"/"mc"> + <quantity> + <""/"MC">. Here <"reco"/"mc"> stands for reconstructed track or true MC
    //  track, <quantity> is a name of a quantity, versus which one wants to build the dependency, <""/"MC"> stands
    //  for an origin of the quantity - reconstructed or true Monte-Carlo. If there are several quantities, they are
    //  to be separated with "_" (example: "p_yMC" -- reconstructed momentum vs MC rapidity)
 
    // ** Histograms from reconstructed information only **
    TH1F* fph_reco_p             = nullptr;  
    TH1F* fph_reco_pt            = nullptr;  
    TH1F* fph_reco_phi           = nullptr;  
    TH1F* fph_reco_theta         = nullptr;  
    TH2F* fph_reco_theta_phi     = nullptr;  
    TH1F* fph_reco_tx            = nullptr;  
    TH1F* fph_reco_ty            = nullptr;  
    TH2F* fph_reco_ty_tx         = nullptr;  
    TH1F* fph_reco_eta           = nullptr;  
    TH1F* fph_reco_nhits         = nullptr;  
    TH1F* fph_reco_fhitR         = nullptr;  
    TH1F* fph_reco_fsta          = nullptr;  
    TH1F* fph_reco_lsta          = nullptr;  
    TH1F* fph_reco_chi2_ndf      = nullptr;  
    TH1F* fph_reco_chi2_ndf_time = nullptr;  
 
    // ** Reconstructed track distributions, requiring MC information **
    TH1F* fph_reco_pMC           = nullptr;  
    TH1F* fph_reco_ptMC          = nullptr;  
    TH1F* fph_reco_yMC           = nullptr;  
    TH1F* fph_reco_etaMC         = nullptr;  
    TH2F* fph_reco_ptMC_yMC      = nullptr;  
    TH1F* fph_reco_phiMC         = nullptr;  
    TH1F* fph_reco_thetaMC       = nullptr;  
    TH2F* fph_reco_thetaMC_phiMC = nullptr;  
    TH1F* fph_reco_txMC          = nullptr;  
    TH1F* fph_reco_tyMC          = nullptr;  
 
    // ** MC track distributions **
    TH1F* fph_mc_pMC           = nullptr;  
    TH1F* fph_mc_yMC           = nullptr;  
    TH1F* fph_mc_etaMC         = nullptr;  
    TH2F* fph_mc_ptMC_yMC      = nullptr;  
    TH1F* fph_mc_ptMC          = nullptr;  
    TH1F* fph_mc_phiMC         = nullptr;  
    TH1F* fph_mc_thetaMC       = nullptr;  
    TH2F* fph_mc_thetaMC_phiMC = nullptr;  
    TH1F* fph_mc_txMC          = nullptr;  
    TH1F* fph_mc_tyMC          = nullptr;  
    TH2F* fph_mc_tyMC_txMC     = nullptr;  
 
    // ** Efficiencies **
    TProfile* fph_eff_int     = nullptr;  
    TProfile* fph_eff_pMC     = nullptr;  
    TProfile* fph_eff_yMC     = nullptr;  
    TProfile* fph_eff_ptMC    = nullptr;  
    TProfile* fph_eff_thetaMC = nullptr;  
    TProfile* fph_eff_etaMC   = nullptr;  
    TProfile* fph_eff_phiMC   = nullptr;  
    TProfile* fph_eff_nhitsMC = nullptr;  
    TProfile* fph_eff_txMC    = nullptr;  
    TProfile* fph_eff_tyMC    = nullptr;  
 
    TProfile2D* fph_eff_thetaMC_phiMC = nullptr;  
    TProfile2D* fph_eff_ptMC_yMC      = nullptr;  
    TProfile2D* fph_eff_tyMC_txMC     = nullptr;  
 
    // ** Clone rate **
 
    TProfile* fph_clone_pMC     = nullptr;  
    TProfile* fph_clone_yMC     = nullptr;  
    TProfile* fph_clone_ptMC    = nullptr;  
    TProfile* fph_clone_thetaMC = nullptr;  
    TProfile* fph_clone_etaMC   = nullptr;  
    TProfile* fph_clone_phiMC   = nullptr;  
    TProfile* fph_clone_nhitsMC = nullptr;  
    TProfile* fph_clone_txMC    = nullptr;  
    TProfile* fph_clone_tyMC    = nullptr;  
 
    TProfile2D* fph_clone_thetaMC_phiMC = nullptr;  
    TProfile2D* fph_clone_ptMC_yMC      = nullptr;  
    TProfile2D* fph_clone_tyMC_txMC     = nullptr;  
 
    // ** Fit QA **
    std::unique_ptr<TrackFitQa> fpFitQaFirstHit = nullptr;
    std::unique_ptr<TrackFitQa> fpFitQaLastHit  = nullptr;
    std::unique_ptr<TrackFitQa> fpFitQaVertex   = nullptr;
    std::unique_ptr<TrackFitQa> fpFitQaTrd      = nullptr;
 
    // TODO: Provide integrated efficiencies
 
   private:
    virtual void SetTH1Properties(TH1* pHist) const override;
 
    // ** Technical profiles and histograms (counters) **
    TProfile* fph_rate_reco      = nullptr;  
    TProfile* fph_rate_killed    = nullptr;  
    TProfile* fph_rate_clones    = nullptr;  
    TProfile* fph_stations_point = nullptr;  
    TProfile* fph_stations_hit   = nullptr;  
 
    int fCounterMC        = 0;   
    int fCounterClones    = 0;   
    int fCounterRecoTotal = 0;   
    double fRecoLength    = 0.;  
    double fMCLength      = 0.;  
    double fFakeLength    = 0.;  
 
 
    bool fbUseMC    = false;  
    TString fsTitle = "";     
 
    // TODO: SZh 20.03.2024: Maybe replace CbmL1Track with CaTrack?
    ca::Vector<CbmL1Track>* fpvRecoTracks               = nullptr;  
    ca::Vector<cbm::algo::ca::McHitInfo>* fpvHits       = nullptr;  
    cbm::algo::ca::McData* fpMCData                     = nullptr;  
    std::shared_ptr<const ca::Parameters<double>> fpParameters = nullptr;  
 
 
    // ** Cuts on tracks for a given track class **

    std::function<bool(const cbm::algo::ca::McTrack&)> fMCTrackCut = [](const cbm::algo::ca::McTrack&) { return true; };

    std::function<bool(const CbmL1Track&)> fRecoTrackCut = [](const CbmL1Track&) { return true; };
 
 
    // **************************
    // ** Histogram properties **
    // **************************
 
    // ** Binning **
    // TODO: SZh 20.03.2024: Make yaml-configurable
    static constexpr int kBinsP        = 120;   
    static constexpr double kLoP       = 0.;    
    static constexpr double kUpP       = 12.;   
    static constexpr int kBinsPT       = 100;   
    static constexpr double kLoPT      = 0.;    
    static constexpr double kUpPT      = 4.;    
    static constexpr int kBinsETA      = 40;    
    static constexpr double kLoETA     = 0.;    
    static constexpr double kUpETA     = 4.;    
    static constexpr int kBinsY        = 40;    
    static constexpr double kLoY       = 0.;    
    static constexpr double kUpY       = 4.;    
    static constexpr int kBinsPHI      = 68;    
    static constexpr double kLoPHI     = -3.2;  
    static constexpr double kUpPHI     = +3.2;  
    static constexpr int kBinsTHETA    = 68;    
    static constexpr double kLoTHETA   = 0.;    
    static constexpr double kUpTHETA   = 3.2;   
    static constexpr int kBinsTX       = 80;    
    static constexpr double kLoTX      = -2.;   
    static constexpr double kUpTX      = +2.;   
    static constexpr int kBinsTY       = 80;    
    static constexpr double kLoTY      = -2.;   
    static constexpr double kUpTY      = +2.;   
    static constexpr int kBinsNHITS    = 15;    
    static constexpr double kLoNHITS   = -0.5;  
    static constexpr double kUpNHITS   = 14.5;  
    static constexpr int kBinsFHITR    = 50;    
    static constexpr double kLoFHITR   = 0.;    
    static constexpr double kUpFHITR   = 150.;  
    static constexpr int kBinsNSTA     = 12;    
    static constexpr double kLoNSTA    = -0.5;  
    static constexpr double kUpNSTA    = 11.5;  
    static constexpr int kBinsCHI2NDF  = 200;   
    static constexpr double kLoCHI2NDF = 0.;    
    static constexpr double kUpCHI2NDF = 20.;   
 
    // ** Drawing attributes **
    Color_t fMarkerColor = 1;   
    Style_t fMarkerStyle = 20;  
    Color_t fLineColor   = 1;   
    Style_t fLineStyle   = 1;   
 
    ClassDefNV(TrackTypeQa, 0);
  };  // namespace cbm::ca
 
}  // namespace cbm::ca