CbmMvdMcQaTask.h

Go to the documentation of this file.

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

 
#ifndef CbmMvdMcQaTask_h
#define CbmMvdMcQaTask_h 1
 
#include "CbmQaTask.h"
 
class TClonesArray;
class CbmMCEventList;
class CbmMCDataArray;
class CbmMCDataManager;
class FairRootManager;
namespace cbm::mvd
{
  class CbmMvdMcQaTask : public CbmQaTask {
   public:
    CbmMvdMcQaTask(int verbose, bool isMcUsed);
 
    void Check() override;
 
    void CreateSummary() override;
 
    void ExecQa() override;
 
    InitStatus InitQa() override;

    void SetKeVRange(int maxKeV, int binKeV = 1)
    {
      fKeVMax = maxKeV;
      fKeVBin = (binKeV > 0 ? binKeV : 1);
    }

    enum class Origin
    {
      All       = 0,
      Primary   = 1,
      Secondary = 2,
      DeltaSec  = 3,
      Other     = 4
    };
    int MapPdgToSpeciesBin_(int pdg) const;
    int GetStationIdFromZ_(double z) const;
    // static std::string PdgToName_(int pdg);
    void SetNumberOfStations(int nstation) { fNStations = nstation; }
 
   private:
    void ProcessMcTracks(const int& fileId, const int& eventId);
    void ProcessMvdPoints(const int& fileId, const int& eventId);

    FairRootManager* fManager    = nullptr;
    CbmMCDataManager* fMcManager = nullptr;

    CbmMCEventList* fMcEventList = nullptr;
    CbmMCDataArray* fMvdPoints   = nullptr;
    CbmMCDataArray* fMcTracks    = nullptr;

    std::vector<int> fPdgBuf;        
    std::vector<Origin> fOriginBuf;  
 
    Int_t fNStations = 4;  

    Long64_t fAllNPrim = 0;
    Long64_t fAllNSec  = 0;
    std::unordered_map<int, uint64_t> fAllCountsPrim;  
    std::unordered_map<int, uint64_t> fAllCountsSec;   
 
    static constexpr int kNumOrigins = 5;
    std::array<std::unordered_map<int, TH1F*>, kNumOrigins> fHistsElossKeVByPDG;
    std::array<TList*, kNumOrigins> fLists{};
    static constexpr const char* kOriginName[kNumOrigins] = {"all", "primary", "secondary", "deltaSec", "other"};
    TH1F* GetOrBookElossHist(int pdg, Origin origin);

    int fKeVMax = 2000;  
    int fKeVBin = 1;     

    double fZMinStation0 = -38, fZMaxStation0 = -34;
    double fZMinStation1 = -34, fZMaxStation1 = -30;
    double fZMinStation2 = -30, fZMaxStation2 = -26;
    double fZMinStation3 = -26, fZMaxStation3 = -22;

    TH1D* fh_nTracksAll    = nullptr;  
    TH1D* fh_nMvdPointsEvt = nullptr;  
    TH1D* fh_nHitTracksEvt = nullptr;  
    TH1D* fh_nDeltaEvt     = nullptr;  

    TH1D* fh_mc_pdg_all     = nullptr;  
    TH1D* fh_mc_pdg_prim    = nullptr;  
    TH1D* fh_mc_pdg_sec     = nullptr;  
    TH1D* fh_mc_p_prim      = nullptr;  
    TH1D* fh_mc_p_sec       = nullptr;  
    TH1D* fh_mc_startZ      = nullptr;  
    TH2D* fh_mc_startX_vs_Z = nullptr;  
    TH2D* fh_mc_startY_vs_Z = nullptr;  
    TH2D* fh_mc_startY_vs_X = nullptr;  

    // per-event per-station
    std::vector<TH1D*> fh_mvd_nPointsEvt_station;  
 
    // XY maps per station, split by origin
    std::vector<TH2D*> fh_mvd_xy_prim_station;  
    std::vector<TH2D*> fh_mvd_xy_sec_station;   
 
    // species-labelled PDG histos at MVD point level
    TH1D* fh_mvd_pdg_all  = nullptr;  
    TH1D* fh_mvd_pdg_prim = nullptr;  
    TH1D* fh_mvd_pdg_sec  = nullptr;  
 
    // momentum distributions (p from parent MCTrack)
    TH1D* fh_mvd_p_prim = nullptr;
    TH1D* fh_mvd_p_sec  = nullptr;
 
    // energy loss correlations
    TH2D* fh_mvd_dEkeV_vs_p   = nullptr;  
    TH2D* fh_mvd_dEkeV_vs_pdg = nullptr;  
 
    TH1D* fh_sec_count_bySpecies = nullptr;  
    TH2D* fh_dEkeV_vs_pidClass   = nullptr;  
    TH2D* fh_xy_points_nonprim   = nullptr;  
    std::vector<TH2D*> fh_xy_points;         
    std::vector<TH1D*> fhCountMvdPoint;      
 
    TH1D* fhZdistMvd    = nullptr;
    TH2D* fh_dEkeV_vs_p = nullptr;  

    void BookHists_();
    static bool DecodeIonPDG_(int pdg, int& Z, int& A);
 
    int PidClass_(int pdg) const;
    Origin ClassifyTrack_(const int& fileId, const int& eventId, Int_t trackindex) const;
    double PointELossGeV_(const void* vp) const;
 
    ClassDefOverride(CbmMvdMcQaTask, 1);
  };
 
}  // namespace cbm::mvd
 
#endif  // CbmMvdCbmMvdMcQaTask_h