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 "CaParameters.h"
#include "CbmCaTrackFitQa.h"
#include "CbmL1DetectorID.h"
#include "CbmL1Hit.h"
#include "CbmQaIO.h"
#include "KfFieldRegion.h"
#include "KfTrackKalmanFilter.h"
 
#include <map>
#include <string>
 
// Forward declarations
namespace cbm::ca::tools
{
  class MCData;
  class MCTrack;
}  // namespace cbm::ca::tools
class CbmL1Track;
class CbmL1HitDebugInfo;
 
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;
 
    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, double weight = 1);
 
    void FillMCTrack(int iTrkMC, double weight = 1);
 
    void RegisterRecoTracks(ca::Vector<CbmL1Track>& vTracks) { fpvRecoTracks = &vTracks; }
 
    void RegisterRecoHits(ca::Vector<CbmL1HitDebugInfo>& vHits) { fpvHits = &vHits; }
 
    void RegisterMCData(tools::MCData& mcData) { fpMCData = &mcData; }
 
    void RegisterParameters(std::shared_ptr<ca::Parameters<float>>& 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 tools::MCTrack&)> cut) { fMCTrackCut = cut; }
 
    void SetRecoTrackCut(std::function<bool(const CbmL1Track&)> cut) { fRecoTrackCut = cut; }
 
    void FillPerEvent();
 
 
    // ************************
    // ** 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> fpFitQaFirstMCpoint = nullptr;
    std::unique_ptr<TrackFitQa> fpFitQaFirstHit     = nullptr;
    std::unique_ptr<TrackFitQa> fpFitQaLastHit      = nullptr;
    std::unique_ptr<TrackFitQa> fpFitQaVertex       = 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;  
 
    cbm::algo::kf::TrackKalmanFilter<double> fTrackFit;  
    cbm::algo::kf::FieldRegion<double> fFieldRegion;     
 
    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<CbmL1HitDebugInfo>* fpvHits              = nullptr;  
    tools::MCData* fpMCData                             = nullptr;  
    std::shared_ptr<ca::Parameters<float>> fpParameters = nullptr;  
 
 
    // ** Cuts on tracks for a given track class **
 
    std::function<bool(const tools::MCTrack&)> fMCTrackCut = [](const tools::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