diff --git a/reco/L1/qa/CbmCaOutputQa.cxx b/reco/L1/qa/CbmCaOutputQa.cxx index 4c39ab72c0451bab603654e985bcbb7884f7c3b5..bd946878538cd0f48c9dc14f373e7387b107e86d 100644 --- a/reco/L1/qa/CbmCaOutputQa.cxx +++ b/reco/L1/qa/CbmCaOutputQa.cxx @@ -714,8 +714,8 @@ InitStatus OutputQa::InitCanvases() // MC rapidity vs. MC momentum // auto* pc_mc_pMC_yMC = - MakeQaObject<CbmQaCanvas>("mc_pMC_yMC", "MC track MC mom. vs. rapidity ", kCXSIZEPX * 3, kCYSIZEPX * 2); - DrawSetOf<TH2F>(vCmpTypesGeneral, [&](ETrackType t) -> TH2F* { return fvpTrackHistograms[t]->fph_reco_pMC_yMC; }); + MakeQaObject<CbmQaCanvas>("mc_ptMC_yMC", "MC track MC transverse mom. vs. rapidity ", kCXSIZEPX * 3, kCYSIZEPX * 2); + DrawSetOf<TH2F>(vCmpTypesGeneral, [&](ETrackType t) -> TH2F* { return fvpTrackHistograms[t]->fph_reco_ptMC_yMC; }); // ** Efficiencies ** diff --git a/reco/L1/qa/CbmCaTrackTypeQa.cxx b/reco/L1/qa/CbmCaTrackTypeQa.cxx index db6156bfcbb0a73ca04a33e8a1830461766eb208..f5497a8dd10fbdbbc5df9ffc3e89767541d9d05a 100644 --- a/reco/L1/qa/CbmCaTrackTypeQa.cxx +++ b/reco/L1/qa/CbmCaTrackTypeQa.cxx @@ -43,28 +43,37 @@ void TrackTypeQa::Init() // fph_reco_p = MakeQaObject<TH1F>("reco_p", "", kBinsP, kLoP, kUpP); fph_reco_pt = MakeQaObject<TH1F>("reco_pt", "", kBinsPT, kLoPT, kUpPT); - fph_reco_eta = MakeQaObject<TH1F>("reco_eta", "", kBinsETA, kLoETA, kUpETA); fph_reco_phi = MakeQaObject<TH1F>("reco_phi", "", kBinsPHI, kLoPHI, kUpPHI); fph_reco_theta = MakeQaObject<TH1F>("reco_theta", "", kBinsTHETA, kLoTHETA, kUpTHETA); fph_reco_theta_phi = MakeQaObject<TH2F>("reco_theta_phi", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA); - fph_reco_tx = MakeQaObject<TH1F>("reco_tx", "", kBinsTX, kLoTX, kUpTX); - fph_reco_ty = MakeQaObject<TH1F>("reco_ty", "", kBinsTY, kLoTY, kUpTY); - fph_reco_ty_tx = MakeQaObject<TH2F>("reco_ty_tx", "", kBinsTX, kLoTX, kUpTX, kBinsTY, kLoTY, kUpTY); - fph_reco_fhitR = MakeQaObject<TH1F>("reco_fhitR", "", kBinsFHITR, kLoFHITR, kUpFHITR); - // TODO: ... + fph_reco_tx = MakeQaObject<TH1F>("reco_tx", "", kBinsTX, kLoTX, kUpTX); + fph_reco_ty = MakeQaObject<TH1F>("reco_ty", "", kBinsTY, kLoTY, kUpTY); + fph_reco_ty_tx = MakeQaObject<TH2F>("reco_ty_tx", "", kBinsTX, kLoTX, kUpTX, kBinsTY, kLoTY, kUpTY); + fph_reco_eta = MakeQaObject<TH1F>("reco_eta", "", kBinsETA, kLoETA, kUpETA); + fph_reco_fhitR = MakeQaObject<TH1F>("reco_fhitR", "", kBinsFHITR, kLoFHITR, kUpFHITR); + fph_reco_nhits = MakeQaObject<TH1F>("reco_nhits", "", kBinsNHITS, kLoNHITS, kUpNHITS); + fph_reco_fsta = MakeQaObject<TH1F>("reco_fsta", "", kBinsNSTA, kLoNSTA, kUpNSTA); + fph_reco_lsta = MakeQaObject<TH1F>("reco_lsta", "", kBinsNSTA, kLoNSTA, kUpNSTA); + fph_reco_chi2_ndf = MakeQaObject<TH1F>("reco_chi2_ndf", "", kBinsCHI2NDF, kLoCHI2NDF, kUpCHI2NDF); + fph_reco_chi2_ndf_time = MakeQaObject<TH1F>("reco_chi2_ndf_time", "", kBinsCHI2NDF, kLoCHI2NDF, kUpCHI2NDF); fph_reco_p->SetTitle("Total momentum of reconstructed track;p^{reco} [GeV/c];Counts"); fph_reco_pt->SetTitle("Transverse momentum of reconstructed track;p_{T}^{reco} [GeV/c];Counts"); fph_reco_phi->SetTitle("Azimuthal angle of reconstructed track;#phi^{reco} [rad];Counts"); - fph_reco_eta->SetTitle("Pseudorapidity of reconstructed track;#eta^{reco};Counts"); fph_reco_theta->SetTitle("Polar angle of reconstructed track;#theta^{reco} [rad];Counts"); fph_reco_theta_phi->SetTitle( "Polar angle vs. azimuthal angle of reconstructed track;#phi^{reco} [rad];#theta^{reco} [rad];Counts"); fph_reco_tx->SetTitle("Slope along x-axis of reconstructed tracks;t_{x}^{reco};Counts"); fph_reco_ty->SetTitle("Slope along y-axis of reconstructed tracks;t_{y}^{reco};Counts"); fph_reco_ty_tx->SetTitle("Slope along y-axis vs. x-axis of reconstructed tracks;t_{x}^{reco};t_{y}^{reco};"); + fph_reco_eta->SetTitle("Pseudorapidity of reconstructed track;#eta^{reco};Counts"); fph_reco_fhitR->SetTitle("Distance of the first hit from z-axis for reconstructed tracks;R^{reco} [cm];Counts"); + fph_reco_nhits->SetTitle("Number of hits of reconstructed tracks;N_{hits};Counts"); + fph_reco_fsta->SetTitle("First station index of reconstructed tracks;ID_{station};Counts"); + fph_reco_lsta->SetTitle("Last station index of reconstructed tracks;ID_{station};Counts"); + fph_reco_chi2_ndf->SetTitle("#chi^{2}/NDF of reconstructed tracks;#chi^{2}/NDF;Counts"); + fph_reco_chi2_ndf_time->SetTitle("Time #chi^{2}/NDF of reconstructed tracks;#chi^{2}/NDF;Counts"); fCounterRecoTotal = 0; @@ -72,41 +81,58 @@ void TrackTypeQa::Init() // // ** Distributions of reconstructed tracks vs. MC quantities ** // - fph_reco_pMC = MakeQaObject<TH1F>("reco_pMC", "", kBinsP, kLoP, kUpP); - fph_reco_etaMC = MakeQaObject<TH1F>("reco_etaMC", "", kBinsETA, kLoETA, kUpETA); - fph_reco_yMC = MakeQaObject<TH1F>("reco_yMC", "", kBinsY, kLoY, kUpY); - fph_reco_pMC_yMC = MakeQaObject<TH2F>("reco_pMC_yMC", "", kBinsY, kLoY, kUpY, kBinsP, kLoP, kUpP); - fph_reco_phiMC = MakeQaObject<TH1F>("reco_phiMC", "", kBinsPHI, kLoPHI, kUpPHI); - fph_reco_thetaMC = MakeQaObject<TH1F>("reco_thetaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA); - fph_reco_nhits = MakeQaObject<TH1F>("reco_nhits", "", kBinsNHITS, kLoNHITS, kUpNHITS); + fph_reco_pMC = MakeQaObject<TH1F>("reco_pMC", "", kBinsP, kLoP, kUpP); + fph_reco_ptMC = MakeQaObject<TH1F>("reco_ptMC", "", kBinsPT, kLoPT, kUpPT); + fph_reco_yMC = MakeQaObject<TH1F>("reco_yMC", "", kBinsY, kLoY, kUpY); + fph_reco_etaMC = MakeQaObject<TH1F>("reco_etaMC", "", kBinsETA, kLoETA, kUpETA); + fph_reco_ptMC_yMC = MakeQaObject<TH2F>("reco_ptMC_yMC", "", kBinsY, kLoY, kUpY, kBinsPT, kLoPT, kUpPT); + fph_reco_phiMC = MakeQaObject<TH1F>("reco_phiMC", "", kBinsPHI, kLoPHI, kUpPHI); + fph_reco_thetaMC = MakeQaObject<TH1F>("reco_thetaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA); + fph_reco_thetaMC_phiMC = + MakeQaObject<TH2F>("reco_thetaMC_phiMC", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA); + fph_reco_txMC = MakeQaObject<TH1F>("reco_txMC", "", kBinsTX, kLoTX, kUpTX); + fph_reco_tyMC = MakeQaObject<TH1F>("reco_tyMC", "", kBinsTY, kLoTY, kUpTY); fph_reco_pMC->SetTitle("MC total momentum of reconstructed track;p^{MC} [GeV/c];Counts"); + fph_reco_ptMC->SetTitle("MC transverse momentum of reconstructed track;p_{T}^{MC} [GeV/c];Counts"); fph_reco_yMC->SetTitle("MC rapidity of reconstructed track;y^{MC};Counts"); fph_reco_etaMC->SetTitle("MC pseudorapidity of reconstructed track;#eta^{MC};Counts"); - fph_reco_pMC_yMC->SetTitle("Transverse momentum of reconstructed track;y^{MC};p_{T}^{MC} [GeV/c];Counts"); - fph_reco_phiMC->SetTitle("Azimuthal angle of reconstructed track;#phi^{MC} [rad];Counts"); - fph_reco_thetaMC->SetTitle("Polar angle of reconstructed track;#theta^{MC} [rad];Counts"); - fph_reco_nhits->SetTitle("Hit number of reconstructed tracks;N^{MC}_{hits};Counts"); + fph_reco_ptMC_yMC->SetTitle("MC Transverse momentum of reconstructed track;y^{MC};p_{T}^{MC} [GeV/c];Counts"); + fph_reco_phiMC->SetTitle("MC Azimuthal angle of reconstructed track;#phi^{MC} [rad];Counts"); + fph_reco_thetaMC->SetTitle("MC Polar angle of reconstructed track;#theta^{MC} [rad];Counts"); + fph_reco_thetaMC_phiMC->SetTitle( + "MC Polar angle vs. MC azimuthal angle of reconstructed track;#phi^{MC} [rad];#theta^{MC} [rad];Counts"); + fph_reco_txMC->SetTitle("MC Slope along x-axis of reconstructed tracks;t_{x}^{MC};Counts"); + fph_reco_tyMC->SetTitle("MC Slope along y-axis of reconstructed tracks;t_{y}^{MC};Counts"); + // + // ** Distributions of MC tracks ** + // fph_mc_pMC = MakeQaObject<TH1F>("mc_pMC", "", kBinsP, kLoP, kUpP); fph_mc_etaMC = MakeQaObject<TH1F>("mc_etaMC", "", kBinsETA, kLoETA, kUpETA); fph_mc_yMC = MakeQaObject<TH1F>("mc_yMC", "", kBinsY, kLoY, kUpY); - fph_mc_pMC_yMC = MakeQaObject<TH2F>("mc_pMC_yMC", "", kBinsY, kLoY, kUpY, kBinsP, kLoP, kUpP); + fph_mc_ptMC_yMC = MakeQaObject<TH2F>("mc_ptMC_yMC", "", kBinsY, kLoY, kUpY, kBinsPT, kLoPT, kUpPT); + fph_mc_ptMC = MakeQaObject<TH1F>("mc_ptMC", "", kBinsPT, kLoPT, kUpPT); + fph_mc_phiMC = MakeQaObject<TH1F>("mc_phiMC", "", kBinsPHI, kLoPHI, kUpPHI); + fph_mc_thetaMC = MakeQaObject<TH1F>("mc_thetaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA); + fph_mc_thetaMC_phiMC = + MakeQaObject<TH2F>("mc_thetaMC_phiMC", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA); fph_mc_txMC = MakeQaObject<TH1F>("mc_txMC", "", kBinsTX, kLoTX, kUpTX); fph_mc_tyMC = MakeQaObject<TH1F>("mc_tyMC", "", kBinsTY, kLoTY, kUpTY); fph_mc_tyMC_txMC = MakeQaObject<TH2F>("mc_tyMC_txMC", "", kBinsTX, kLoTX, kUpTX, kBinsTY, kLoTY, kUpTY); - fph_mc_thetaMC_phiMC = - MakeQaObject<TH2F>("mc_thetaMC_phiMC", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA); - fph_mc_pMC->SetTitle("MC total momentum of MC tracks;p^{MC} [GeV/c];Counts"); - fph_mc_yMC->SetTitle("MC rapidity of MC tracks;y^{MC};Counts"); - fph_mc_etaMC->SetTitle("MC pseudorapidity of MC track;#eta^{MC};Counts"); - fph_mc_pMC_yMC->SetTitle("MC total momentum vs. MC rapidity of MC tracks;y^{MC};p^{MC} [GeV/c];Counts"); + fph_mc_pMC->SetTitle("Total momentum of MC tracks;p^{MC} [GeV/c];Counts"); + fph_mc_etaMC->SetTitle("Pseudorapidity of MC tracks;#eta^{MC};Counts"); + fph_mc_yMC->SetTitle("Rapidity of MC tracks;y^{MC};Counts"); + fph_mc_ptMC_yMC->SetTitle("Transverse momentum vs. rapidity of MC tracks;y^{MC};p_{T}^{MC} [GeV/c];Counts"); + fph_mc_ptMC->SetTitle("Transverse momentum of MC track;p_{T}^{MC} [GeV/c];Counts"); + fph_mc_phiMC->SetTitle("Azimuthal angle of MC track;#phi^{MC} [rad];Counts"); + fph_mc_thetaMC->SetTitle("Polar angle of MC track;#theta^{MC} [rad];Counts"); + fph_mc_thetaMC_phiMC->SetTitle("Polar angle vs. azimuthal angle of MC track;#phi^{MC} [rad];#theta^{MC} [rad]"); fph_mc_txMC->SetTitle("Slope along x-axis of MC tracks;t_{x}^{MC};Counts"); fph_mc_tyMC->SetTitle("Slope along y-axis of MC tracks;t_{y}^{MC};Counts"); fph_mc_tyMC_txMC->SetTitle("Slope along y-axis vs. x-axis of MC tracks;t_{x}^{MC};t_{y}^{MC};"); - fph_mc_thetaMC_phiMC->SetTitle("Polar angle vs. azimuthal angle of MC track;#phi^{MC} [rad];#theta^{MC} [rad]"); // // ** Efficiencies ** @@ -118,7 +144,7 @@ void TrackTypeQa::Init() fph_eff_thetaMC = MakeQaObject<TProfile>("eff_thetaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA, 0., 1.); fph_eff_etaMC = MakeQaObject<TProfile>("eff_etaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA, 0., 1.); fph_eff_phiMC = MakeQaObject<TProfile>("eff_phiMC", "", kBinsPHI, kLoPHI, kUpPHI, 0., 1.); - fph_eff_nhitsMC = MakeQaObject<TProfile>("eff_nhitsMC", "", kBinsNHITS, kLoNHITS, kUpNHITS, 0., 1.); + fph_eff_nhitsMC = MakeQaObject<TProfile>("eff_nhitsMC", "", kBinsNSTA, kLoNSTA, kUpNSTA, 0., 1.); fph_eff_txMC = MakeQaObject<TProfile>("eff_txMC", "", kBinsTX, kLoTX, kUpTX, 0., 1.); fph_eff_tyMC = MakeQaObject<TProfile>("eff_tyMC", "", kBinsTY, kLoTY, kUpTX, 0., 1.); @@ -138,21 +164,22 @@ void TrackTypeQa::Init() fph_eff_int->SetTitle("Integrated efficiency;;#epsilon_{CA}"); fph_eff_pMC->SetTitle("Efficiency vs. MC total momentum;p_{MC} [GeV/c];#epsilon_{CA}"); fph_eff_yMC->SetTitle("Efficiency vs. MC rapidity;y_{MC};#epsilon"); - fph_eff_ptMC->SetTitle("Efficiency vs. MC total momentum;p_{T}^{MC} [GeV/c];#epsilon_{CA}"); + fph_eff_ptMC->SetTitle("Efficiency vs. MC transverse momentum;p_{T}^{MC} [GeV/c];#epsilon_{CA}"); fph_eff_thetaMC->SetTitle("Efficiency vs. MC polar angle;#theta^{MC};#epsilon_{CA}"); fph_eff_etaMC->SetTitle("Efficiency vs. MC pseudorapidity;#eta^{MC};#epsilon_{CA}"); fph_eff_phiMC->SetTitle("Efficiency vs. MC azimuthal angle;#phi^{MC};#epsilon_{CA}"); - fph_eff_nhitsMC->SetTitle("Efficiency vs. MC number of stations with hits;N_{hit}^{MC};#epsilon_{CA}"); + fph_eff_nhitsMC->SetTitle("Efficiency vs. number of hits;N_{hit}^{MC};#epsilon_{CA}"); fph_eff_txMC->SetTitle("Efficiency vs. MC slope along x-axis;t_{x}^{MC};#epsilon_{CA}"); fph_eff_tyMC->SetTitle("Efficiency vs. MC slope along y-axis;t_{y}^{MC};#epsilon_{CA}"); - fph_eff_pMC_yMC = MakeQaObject<TProfile2D>("eff_pMC_yMC", "", kBinsY, kLoY, kUpY, kBinsP, kLoP, kUpP, 0., 1.); + fph_eff_ptMC_yMC = MakeQaObject<TProfile2D>("eff_ptMC_yMC", "", kBinsY, kLoY, kUpY, kBinsPT, kLoPT, kUpPT, 0., 1.); fph_eff_thetaMC_phiMC = MakeQaObject<TProfile2D>("eff_theta_phi", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA, 0., 1.); - fph_eff_pMC_yMC->SetTitle("Efficiency vs. MC total momentum and MC rapidity;y^{MC};#epsilon_{CA};p^{MC} [GeV/c]"); + fph_eff_ptMC_yMC->SetTitle( + "Efficiency vs. MC transverse momentum and MC rapidity;y^{MC};#epsilon_{CA};p_{T}^{MC} [GeV/c]"); fph_eff_thetaMC_phiMC->SetTitle( - "Efficiency vs. MC polar and azimuthal angles;#phi^{MC} [rad];#theta^{MC} [rad];#epsilon_{CA}"); + "Efficiency vs. MC polar and MC azimuthal angles;#phi^{MC} [rad];#theta^{MC} [rad];#epsilon_{CA}"); // // ** Track fit parameter properties (residuals and pulls) ** // @@ -185,15 +212,25 @@ void TrackTypeQa::Init() void TrackTypeQa::FillRecoTrack(int iTrkReco, double weight) { const auto& recoTrack = (*fpvRecoTracks)[iTrkReco]; + const auto& fstHit = (*fpvHits)[recoTrack.GetFirstHitIndex()]; + const auto& lstHit = (*fpvHits)[recoTrack.GetLastHitIndex()]; + fph_reco_p->Fill(recoTrack.GetP(), weight); fph_reco_pt->Fill(recoTrack.GetPt(), weight); fph_reco_eta->Fill(recoTrack.GetEta(), weight); fph_reco_phi->Fill(recoTrack.GetPhi(), weight); fph_reco_theta->Fill(recoTrack.GetTheta(), weight); + fph_reco_theta_phi->Fill(recoTrack.GetPhi(), recoTrack.GetTheta(), weight); fph_reco_tx->Fill(recoTrack.GetTx(), weight); fph_reco_ty->Fill(recoTrack.GetTy(), weight); fph_reco_ty_tx->Fill(recoTrack.GetTx(), recoTrack.GetTy(), weight); - fph_reco_theta_phi->Fill(recoTrack.GetPhi(), recoTrack.GetTheta(), weight); + fph_reco_nhits->Fill(recoTrack.GetNofHits(), weight); + fph_reco_fhitR->Fill(fstHit.GetR()); + fph_reco_fsta->Fill(fstHit.GetStationId(), weight); + fph_reco_lsta->Fill(lstHit.GetStationId(), weight); + fph_reco_chi2_ndf->Fill(recoTrack.GetChiSq() / recoTrack.GetNdf()); + fph_reco_chi2_ndf_time->Fill(recoTrack.GetChiSqTime() / recoTrack.GetNdfTime()); + ++fCounterRecoTotal; if (fbUseMC) { int iTrkMC = recoTrack.GetMatchedMCTrackIndex(); @@ -201,9 +238,15 @@ void TrackTypeQa::FillRecoTrack(int iTrkReco, double weight) /// TODO: fill mass hypothesis into CbmL1Track const auto& mcTrack = fpMCData->GetTrack(iTrkMC); fph_reco_pMC->Fill(mcTrack.GetP(), weight); - fph_reco_etaMC->Fill(mcTrack.GetEta(), weight); + fph_reco_ptMC->Fill(mcTrack.GetPt(), weight); fph_reco_yMC->Fill(mcTrack.GetRapidity(), weight); - fph_reco_pMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetP(), weight); + fph_reco_etaMC->Fill(mcTrack.GetEta(), weight); + fph_reco_ptMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetPt(), weight); + fph_reco_phiMC->Fill(mcTrack.GetPhi(), weight); + fph_reco_thetaMC->Fill(mcTrack.GetTheta(), weight); + fph_reco_thetaMC_phiMC->Fill(mcTrack.GetPhi(), mcTrack.GetTheta(), weight); + fph_reco_txMC->Fill(mcTrack.GetTx(), weight); + fph_reco_tyMC->Fill(mcTrack.GetTy(), weight); // ***************************** // ** Track fit parameters QA ** @@ -285,11 +328,14 @@ void TrackTypeQa::FillMCTrack(int iTrkMC, double weight) fph_mc_pMC->Fill(mcTrack.GetP(), weight); fph_mc_etaMC->Fill(mcTrack.GetEta(), weight); fph_mc_yMC->Fill(mcTrack.GetRapidity(), weight); - fph_mc_pMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetP(), weight); + fph_mc_ptMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetPt(), weight); + fph_mc_ptMC->Fill(mcTrack.GetPt(), weight); + fph_mc_phiMC->Fill(mcTrack.GetPhi(), weight); + fph_mc_thetaMC->Fill(mcTrack.GetTheta(), weight); + fph_mc_thetaMC_phiMC->Fill(mcTrack.GetPhi(), mcTrack.GetTheta(), weight); fph_mc_txMC->Fill(mcTrack.GetTx(), weight); fph_mc_tyMC->Fill(mcTrack.GetTy(), weight); fph_mc_tyMC_txMC->Fill(mcTrack.GetTx(), mcTrack.GetTy(), weight); - fph_mc_thetaMC_phiMC->Fill(mcTrack.GetPhi(), mcTrack.GetTheta(), weight); // ** Efficiencies ** bool bReco = mcTrack.IsReconstructed(); @@ -325,7 +371,7 @@ void TrackTypeQa::FillMCTrack(int iTrkMC, double weight) fph_eff_txMC->Fill(mcTrack.GetTx(), bReco); fph_eff_tyMC->Fill(mcTrack.GetTy(), bReco); - fph_eff_pMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetP(), bReco); + fph_eff_ptMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetPt(), bReco); fph_eff_thetaMC_phiMC->Fill(mcTrack.GetPhi(), mcTrack.GetTheta(), bReco); } diff --git a/reco/L1/qa/CbmCaTrackTypeQa.h b/reco/L1/qa/CbmCaTrackTypeQa.h index 551ed0b3def18f75ca6aae7cb85845f43f227e8d..38171e3a8db4d8c5dcffc9af3a971b630e88d57f 100644 --- a/reco/L1/qa/CbmCaTrackTypeQa.h +++ b/reco/L1/qa/CbmCaTrackTypeQa.h @@ -200,37 +200,39 @@ namespace cbm::ca // to be separated with "_" (example: "p_yMC" -- reconstructed momentum vs MC rapidity) // ** Histograms from reconstructed information only ** - TH1F* fph_reco_p = nullptr; ///< Total momentum over charge of reconstructed tracks - TH1F* fph_reco_pt = nullptr; ///< Transverse momentum over charge of reconstructed tracks - TH1F* fph_reco_phi = nullptr; ///< Azimuthal angle of reconstructed tracks - TH1F* fph_reco_theta = nullptr; ///< Polar angle of reconstructed tracks - TH2F* fph_reco_theta_phi = nullptr; ///< Polar angle vs. azimuthal angle of reconstructed tracks - TH1F* fph_reco_tx = nullptr; ///< Slope along x-axis of reconstructed tracks - TH1F* fph_reco_ty = nullptr; ///< Slope along y-axis of reconstructed tracks - TH2F* fph_reco_ty_tx = nullptr; ///< Slope along x-axis vs y-axis of reconstructed tracks - TH1F* fph_reco_eta = nullptr; ///< Pseudo-rapidity of reconstructed tracks - TH1F* fph_reco_fhitR = nullptr; ///< Distance of the first hit from z-axis for reconstructed tracks - TH1F* fph_reco_nhits = nullptr; ///< Hit number of reconstructed tracks - TH1F* fph_reco_fsta = nullptr; ///< First station index of reconstructed tracks - TH1F* fph_reco_chi2_ndf = nullptr; ///< Fit chi2 over NDF of reconstructed tracks + TH1F* fph_reco_p = nullptr; ///< Total momentum over charge of reconstructed tracks + TH1F* fph_reco_pt = nullptr; ///< Transverse momentum over charge of reconstructed tracks + TH1F* fph_reco_phi = nullptr; ///< Azimuthal angle of reconstructed tracks + TH1F* fph_reco_theta = nullptr; ///< Polar angle of reconstructed tracks + TH2F* fph_reco_theta_phi = nullptr; ///< Polar angle vs. azimuthal angle of reconstructed tracks + TH1F* fph_reco_tx = nullptr; ///< Slope along x-axis of reconstructed tracks + TH1F* fph_reco_ty = nullptr; ///< Slope along y-axis of reconstructed tracks + TH2F* fph_reco_ty_tx = nullptr; ///< Slope along x-axis vs y-axis of reconstructed tracks + TH1F* fph_reco_eta = nullptr; ///< Pseudo-rapidity of reconstructed tracks + TH1F* fph_reco_nhits = nullptr; ///< Hit number of reconstructed tracks + TH1F* fph_reco_fhitR = nullptr; ///< Distance of the first hit from z-axis for reconstructed tracks + TH1F* fph_reco_fsta = nullptr; ///< First station index of reconstructed tracks + TH1F* fph_reco_lsta = nullptr; ///< Last station index of reconstructed tracks + TH1F* fph_reco_chi2_ndf = nullptr; ///< Fit chi2 over NDF of reconstructed tracks + TH1F* fph_reco_chi2_ndf_time = nullptr; ///< Fit chi2 over NDF of reconstructed tracks for time // ** Reconstructed track distributions, requiring MC information ** - TH1F* fph_reco_pMC = nullptr; ///< MC total momentum over charge of reconstructed tracks - TH1F* fph_reco_yMC = nullptr; ///< MC rapidity of reconstructed tracks - TH1F* fph_reco_etaMC = nullptr; ///< MC pseudo-rapidity of reconstructed tracks - TH2F* fph_reco_p_yMC = nullptr; ///< Total momentum vs MC rapidity of reconstructed tracks - TH2F* fph_reco_pMC_yMC = nullptr; ///< MC total momentum vs MC rapidity of reconstructed tracks - TH1F* fph_reco_ptMC = nullptr; ///< Transverse momentum over charge of reconstructed tracks - TH1F* fph_reco_phiMC = nullptr; ///< Azimuthal angle of reconstructed tracks - TH1F* fph_reco_thetaMC = nullptr; ///< Polar angle of reconstructed tracks - TH1F* fph_reco_txMC = nullptr; ///< Slope along x-axis of reconstructed tracks - TH1F* fph_reco_tyMC = nullptr; ///< Slope along y-axis of reconstructed tracks + TH1F* fph_reco_pMC = nullptr; ///< MC total momentum over charge of reconstructed tracks + TH1F* fph_reco_ptMC = nullptr; ///< MC transverse momentum over charge of reconstructed tracks + TH1F* fph_reco_yMC = nullptr; ///< MC rapidity of reconstructed tracks + TH1F* fph_reco_etaMC = nullptr; ///< MC pseudo-rapidity of reconstructed tracks + TH2F* fph_reco_ptMC_yMC = nullptr; ///< MC transverse momentum vs MC rapidity of reconstructed tracks + TH1F* fph_reco_phiMC = nullptr; ///< MC Azimuthal angle of reconstructed tracks + TH1F* fph_reco_thetaMC = nullptr; ///< MC Polar angle of reconstructed tracks + TH2F* fph_reco_thetaMC_phiMC = nullptr; ///< MC Polar angle vs. azimuthal angle of reconstructed tracks + TH1F* fph_reco_txMC = nullptr; ///< MC Slope along x-axis of reconstructed tracks + TH1F* fph_reco_tyMC = nullptr; ///< MC Slope along y-axis of reconstructed tracks // ** MC track distributions ** TH1F* fph_mc_pMC = nullptr; ///< MC total momentum over charge of MC tracks TH1F* fph_mc_yMC = nullptr; ///< MC rapidity of MC tracks TH1F* fph_mc_etaMC = nullptr; ///< MC pseudo-rapidity of MC tracks - TH2F* fph_mc_pMC_yMC = nullptr; ///< MC total momentum vs. MC rapidity of MC tracks + TH2F* fph_mc_ptMC_yMC = nullptr; ///< MC transverse momentum vs. MC rapidity of MC tracks TH1F* fph_mc_ptMC = nullptr; ///< Transverse momentum over charge of MC tracks TH1F* fph_mc_phiMC = nullptr; ///< Azimuthal angle of MC tracks TH1F* fph_mc_thetaMC = nullptr; ///< Polar angle of MC tracks @@ -247,13 +249,13 @@ namespace cbm::ca TProfile* fph_eff_thetaMC = nullptr; ///< Efficiency vs. MC polar angle TProfile* fph_eff_etaMC = nullptr; ///< Efficiency vs. MC pseudorapidity TProfile* fph_eff_phiMC = nullptr; ///< Efficiency vs. MC azimuthal angle - TProfile* fph_eff_nhitsMC = nullptr; ///< Efficiency vs. MC number of hits + TProfile* fph_eff_nhitsMC = nullptr; ///< Efficiency vs. MC number of hits (total number of stations with a) TProfile* fph_eff_txMC = nullptr; ///< Efficiency vs. MC slope along x-axis TProfile* fph_eff_tyMC = nullptr; ///< Efficiency vs. MC slope along y-axis TProfile2D* fph_eff_thetaMC_phiMC = nullptr; ///< Efficiency vs. MC theta and MC phi - TProfile2D* fph_eff_pMC_yMC = nullptr; ///< Efficiency vs. MC momentum and MC rapidity + TProfile2D* fph_eff_ptMC_yMC = nullptr; ///< Efficiency vs. MC transverse momentum and MC rapidity TProfile2D* fph_eff_tyMC_txMC = nullptr; ///< Efficiency vs. MC slopes // ** Fit QA ** @@ -290,6 +292,7 @@ namespace cbm::ca bool fbUseMC = false; ///< Flag: true - MC information is used TString fsTitle = ""; ///< Title of the track category + // TODO: SZh 20.03.2024: Maybe replace CbmL1Track with CaTrack? ca::Vector<CbmL1Track>* fpvRecoTracks = nullptr; ///< Pointer to vector of reconstructed tracks ca::Vector<CbmL1HitDebugInfo>* fpvHits = nullptr; ///< Pointer to vector of reconstructed hits tools::MCData* fpMCData = nullptr; ///< Pointer to MC data object @@ -310,36 +313,43 @@ namespace cbm::ca // ************************** // ** Binning ** - static constexpr int kBinsP = 100; ///< Number of bins, total momentum - static constexpr double kLoP = 0.; ///< Lower boundary, total momentum [GeV/c] - static constexpr double kUpP = 10.; ///< Upper boundary, total momentum [GeV/c] - static constexpr int kBinsPT = 100; ///< Number of bins, transverse momentum - static constexpr double kLoPT = 0.; ///< Lower boundary, transverse momentum [GeV/c] - static constexpr double kUpPT = 10.; ///< Upper boundary, transverse momentum [GeV/c] - static constexpr int kBinsETA = 40; ///< Number of bins, pseudo-rapidity - static constexpr double kLoETA = 0.; ///< Lower boundary, pseudo-rapidity - static constexpr double kUpETA = 4.; ///< Upper boundary, pseudo-rapidity - static constexpr int kBinsY = 40; ///< Number of bins, rapidity - static constexpr double kLoY = 0.; ///< Lower boundary, rapidity - static constexpr double kUpY = 4.; ///< Upper boundary, rapidity - static constexpr int kBinsPHI = 68; ///< Number of bins, azimuthal angle - static constexpr double kLoPHI = -3.2; ///< Lower boundary, azimuthal angle [rad] - static constexpr double kUpPHI = +3.2; ///< Upper boundary, azimuthal angle [rad] - static constexpr int kBinsTHETA = 68; ///< Number of bins, polar angle - static constexpr double kLoTHETA = 0.; ///< Lower boundary, polar angle [rad] - static constexpr double kUpTHETA = 3.2; ///< Upper boundary, polar angle [rad] - static constexpr int kBinsTX = 80; ///< Number of bins, slope along x - static constexpr double kLoTX = -2.; ///< Lower boundary, slope along x - static constexpr double kUpTX = +2.; ///< Upper boundary, slope along x - static constexpr int kBinsTY = 80; ///< Number of bins, slope along y - static constexpr double kLoTY = -2.; ///< Lower boundary, slope along y - static constexpr double kUpTY = +2.; ///< Upper boundary, slope along y - static constexpr int kBinsNHITS = 15; ///< Number of bins, number of hits - static constexpr double kLoNHITS = -0.5; ///< Lower boundary, number of hits - static constexpr double kUpNHITS = 14.5; ///< Upper boundary, number of hits - static constexpr int kBinsFHITR = 50; ///< Number of bins, transverse distance of the 1st hit from z-axis - static constexpr double kLoFHITR = 0.; ///< Lower boundary, transverse distance of the 1st hit from z-axis [cm] - static constexpr double kUpFHITR = 150.; ///< Upper boundary, transverse distance of the 1st hit from z-axis [cm] + // TODO: SZh 20.03.2024: Make yaml-configurable + static constexpr int kBinsP = 120; ///< Number of bins, total momentum + static constexpr double kLoP = 0.; ///< Lower boundary, total momentum [GeV/c] + static constexpr double kUpP = 12.; ///< Upper boundary, total momentum [GeV/c] + static constexpr int kBinsPT = 100; ///< Number of bins, transverse momentum + static constexpr double kLoPT = 0.; ///< Lower boundary, transverse momentum [GeV/c] + static constexpr double kUpPT = 4.; ///< Upper boundary, transverse momentum [GeV/c] + static constexpr int kBinsETA = 40; ///< Number of bins, pseudo-rapidity + static constexpr double kLoETA = 0.; ///< Lower boundary, pseudo-rapidity + static constexpr double kUpETA = 4.; ///< Upper boundary, pseudo-rapidity + static constexpr int kBinsY = 40; ///< Number of bins, rapidity + static constexpr double kLoY = 0.; ///< Lower boundary, rapidity + static constexpr double kUpY = 4.; ///< Upper boundary, rapidity + static constexpr int kBinsPHI = 68; ///< Number of bins, azimuthal angle + static constexpr double kLoPHI = -3.2; ///< Lower boundary, azimuthal angle [rad] + static constexpr double kUpPHI = +3.2; ///< Upper boundary, azimuthal angle [rad] + static constexpr int kBinsTHETA = 68; ///< Number of bins, polar angle + static constexpr double kLoTHETA = 0.; ///< Lower boundary, polar angle [rad] + static constexpr double kUpTHETA = 3.2; ///< Upper boundary, polar angle [rad] + static constexpr int kBinsTX = 80; ///< Number of bins, slope along x + static constexpr double kLoTX = -2.; ///< Lower boundary, slope along x + static constexpr double kUpTX = +2.; ///< Upper boundary, slope along x + static constexpr int kBinsTY = 80; ///< Number of bins, slope along y + static constexpr double kLoTY = -2.; ///< Lower boundary, slope along y + static constexpr double kUpTY = +2.; ///< Upper boundary, slope along y + static constexpr int kBinsNHITS = 15; ///< Number of bins, number of hits + static constexpr double kLoNHITS = -0.5; ///< Lower boundary, number of hits + static constexpr double kUpNHITS = 14.5; ///< Upper boundary, number of hits + static constexpr int kBinsFHITR = 50; ///< Number of bins, transverse dist. of the 1st hit from z-axis + static constexpr double kLoFHITR = 0.; ///< Lower boundary, transverse dist. of the 1st hit from z-axis [cm] + static constexpr double kUpFHITR = 150.; ///< Upper boundary, transverse dist. of the 1st hit from z-axis [cm] + static constexpr int kBinsNSTA = 12; ///< Number of bins, number of stations + static constexpr double kLoNSTA = -0.5; ///< Lower boundary, number of stations + static constexpr double kUpNSTA = 11.5; ///< Upper boundary, number of stations + static constexpr int kBinsCHI2NDF = 200; ///< Number of bins, chi2 over NDF + static constexpr double kLoCHI2NDF = 0.; ///< Lower boundary, chi2 over NDF + static constexpr double kUpCHI2NDF = 20.; ///< Upper boundary, chi2 over NDF // ** Drawing attributes ** Color_t fMarkerColor = 1; ///< Marker color