From 87e8f74477cde769caf66505636e3774a8dd9075 Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Wed, 29 Oct 2025 21:32:00 +0100 Subject: [PATCH 01/11] create histograms for MC only when running over MC --- PWGUD/Tasks/upcRhoAnalysis.cxx | 77 ++++++++++++++++++---------------- 1 file changed, 40 insertions(+), 37 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index 247cdc27d2e..ac3b68af32d 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -185,7 +185,7 @@ struct UpcRhoAnalysis { HistogramRegistry rSystem{"rSystem", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry rMC{"rMC", {}, OutputObjHandlingPolicy::AnalysisObject}; - void init(o2::framework::InitContext&) + void init(o2::framework::InitContext& context) { // QA // // collisions @@ -285,42 +285,45 @@ struct UpcRhoAnalysis { rSystem.addClone("system/selected/no-selection/", "system/selected/Xn0n/"); rSystem.addClone("system/selected/no-selection/", "system/selected/0nXn/"); rSystem.addClone("system/selected/no-selection/", "system/selected/XnXn/"); - - // MC - // collisions - rMC.add("MC/collisions/hPosXY", ";vertex #it{x} (cm);vertex #it{y} (cm);counts", kTH2D, {{2000, -0.1, 0.1}, {2000, -0.1, 0.1}}); - rMC.add("MC/collisions/hPosZ", ";vertex #it{z} (cm);counts", kTH1D, {{400, -20.0, 20.0}}); - rMC.add("MC/collisions/hNPions", ";number of pions;counts", kTH1D, {{11, -0.5, 10.5}}); - rMC.add("MC/collisions/hNumOfCollisionRecos", ";number of collision reconstructions;counts", kTH1D, {{6, -0.5, 5.5}}); - // tracks - rMC.add("MC/tracks/all/hPdgCode", ";pdg code;counts", kTH1D, {{2001, -1000.5, 1000.5}}); - rMC.add("MC/tracks/all/hMotherPdgCode", ";mother pdg code;counts", kTH1D, {{2001, -1000.5, 1000.5}}); - rMC.add("MC/tracks/all/hProducedByGenerator", ";produced by generator;counts", kTH1D, {{2, -0.5, 1.5}}); - rMC.add("MC/tracks/all/hIsPhysicalPrimary", ";is physical primary;counts", kTH1D, {{2, -0.5, 1.5}}); - rMC.add("MC/tracks/all/hPt", ";#it{p}_{T} (GeV/#it{c});counts", kTH1D, {ptAxis}); - rMC.add("MC/tracks/all/hEta", ";#it{#eta};counts", kTH1D, {etaAxis}); - rMC.add("MC/tracks/all/hPhi", ";#it{#phi};counts", kTH1D, {phiAxis}); - rMC.addClone("MC/tracks/all/", "MC/tracks/primaries/"); - rMC.addClone("MC/tracks/all/", "MC/tracks/prodByGen/"); - rMC.add("MC/tracks/hPt", ";#it{p}_{T leading} (GeV/#it{c});#it{p}_{T subleading} (GeV/#it{c});counts", kTH2D, {ptAxis, ptAxis}); - rMC.add("MC/tracks/hEta", ";#it{#eta}_{leading};#it{#eta}_{subleading};counts", kTH2D, {etaAxis, etaAxis}); - rMC.add("MC/tracks/hPhi", ";#it{#phi}_{leading};#it{#phi}_{subleading};counts", kTH2D, {phiAxis, phiAxis}); - // resolution - rMC.add("MC/resolution/tracks/hPt", ";#it{p}_{T, reco} - #it{p}_{T, true} (GeV/#it{c});counts", kTH1D, {{200, -1.0, 1.0}}); - rMC.add("MC/resolution/tracks/hEta", ";#it{#eta}_{reco} - #it{#eta}_{true};counts", kTH1D, {{200, -0.2, 0.2}}); - rMC.add("MC/resolution/tracks/hPhi", ";#it{#phi}_{reco} - #it{#phi}_{true} (rad);counts", kTH1D, {{200, -0.2, 0.2}}); - // system - rMC.add("MC/system/hM", ";#it{m} (GeV/#it{c}^{2});counts", kTH1D, {mAxis}); - rMC.add("MC/system/hPt", ";#it{p}_{T} (GeV/#it{c});counts", kTH1D, {ptAxis}); - rMC.add("MC/system/hPt2", ";#it{p}_{T}^{2} (GeV^{2}/#it{c}^{2});counts", kTH1D, {pt2Axis}); - rMC.add("MC/system/hPtVsM", ";#it{m} (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c});counts", kTH2D, {mAxis, ptAxis}); - rMC.add("MC/system/hY", ";#it{y};counts", kTH1D, {yAxis}); - rMC.add("MC/system/hPhi", ";#it{#phi};counts", kTH1D, {phiAxis}); - rMC.add("MC/system/hPhiRandom", ";#Delta#it{#phi}_{random};counts", kTH1D, {deltaPhiAxis}); - rMC.add("MC/system/hPhiCharge", ";#Delta#it{#phi}_{charge};counts", kTH1D, {deltaPhiAxis}); - rMC.add("MC/system/hPhiRandomVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi};counts", kTH2D, {mAxis, deltaPhiAxis}); - rMC.add("MC/system/hPhiChargeVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi};counts", kTH2D, {mAxis, deltaPhiAxis}); - rMC.addClone("MC/system/", "MC/system/selected/"); + + if (context.mOptions.get("processMCdata")) { + // MC + // collisions + rMC.add("MC/collisions/hPosXY", ";vertex #it{x} (cm);vertex #it{y} (cm);counts", kTH2D, {{2000, -0.1, 0.1}, {2000, -0.1, 0.1}}); + rMC.add("MC/collisions/hPosZ", ";vertex #it{z} (cm);counts", kTH1D, {{400, -20.0, 20.0}}); + rMC.add("MC/collisions/hNPions", ";number of pions;counts", kTH1D, {{11, -0.5, 10.5}}); + if (context.mOptions.get("processCollisionRecoCheck")) + rMC.add("MC/collisions/hNumOfCollisionRecos", ";number of collision reconstructions;counts", kTH1D, {{6, -0.5, 5.5}}); + // tracks + rMC.add("MC/tracks/all/hPdgCode", ";pdg code;counts", kTH1D, {{2001, -1000.5, 1000.5}}); + rMC.add("MC/tracks/all/hMotherPdgCode", ";mother pdg code;counts", kTH1D, {{2001, -1000.5, 1000.5}}); + rMC.add("MC/tracks/all/hProducedByGenerator", ";produced by generator;counts", kTH1D, {{2, -0.5, 1.5}}); + rMC.add("MC/tracks/all/hIsPhysicalPrimary", ";is physical primary;counts", kTH1D, {{2, -0.5, 1.5}}); + rMC.add("MC/tracks/all/hPt", ";#it{p}_{T} (GeV/#it{c});counts", kTH1D, {ptAxis}); + rMC.add("MC/tracks/all/hEta", ";#it{#eta};counts", kTH1D, {etaAxis}); + rMC.add("MC/tracks/all/hPhi", ";#it{#phi};counts", kTH1D, {phiAxis}); + rMC.addClone("MC/tracks/all/", "MC/tracks/primaries/"); + rMC.addClone("MC/tracks/all/", "MC/tracks/prodByGen/"); + rMC.add("MC/tracks/hPt", ";#it{p}_{T leading} (GeV/#it{c});#it{p}_{T subleading} (GeV/#it{c});counts", kTH2D, {ptAxis, ptAxis}); + rMC.add("MC/tracks/hEta", ";#it{#eta}_{leading};#it{#eta}_{subleading};counts", kTH2D, {etaAxis, etaAxis}); + rMC.add("MC/tracks/hPhi", ";#it{#phi}_{leading};#it{#phi}_{subleading};counts", kTH2D, {phiAxis, phiAxis}); + // resolution + rMC.add("MC/resolution/tracks/hPt", ";#it{p}_{T, reco} - #it{p}_{T, true} (GeV/#it{c});counts", kTH1D, {{200, -1.0, 1.0}}); + rMC.add("MC/resolution/tracks/hEta", ";#it{#eta}_{reco} - #it{#eta}_{true};counts", kTH1D, {{200, -0.2, 0.2}}); + rMC.add("MC/resolution/tracks/hPhi", ";#it{#phi}_{reco} - #it{#phi}_{true} (rad);counts", kTH1D, {{200, -0.2, 0.2}}); + // system + rMC.add("MC/system/hM", ";#it{m} (GeV/#it{c}^{2});counts", kTH1D, {mAxis}); + rMC.add("MC/system/hPt", ";#it{p}_{T} (GeV/#it{c});counts", kTH1D, {ptAxis}); + rMC.add("MC/system/hPt2", ";#it{p}_{T}^{2} (GeV^{2}/#it{c}^{2});counts", kTH1D, {pt2Axis}); + rMC.add("MC/system/hPtVsM", ";#it{m} (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c});counts", kTH2D, {mAxis, ptAxis}); + rMC.add("MC/system/hY", ";#it{y};counts", kTH1D, {yAxis}); + rMC.add("MC/system/hPhi", ";#it{#phi};counts", kTH1D, {phiAxis}); + rMC.add("MC/system/hPhiRandom", ";#Delta#it{#phi}_{random};counts", kTH1D, {deltaPhiAxis}); + rMC.add("MC/system/hPhiCharge", ";#Delta#it{#phi}_{charge};counts", kTH1D, {deltaPhiAxis}); + rMC.add("MC/system/hPhiRandomVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi};counts", kTH2D, {mAxis, deltaPhiAxis}); + rMC.add("MC/system/hPhiChargeVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi};counts", kTH2D, {mAxis, deltaPhiAxis}); + rMC.addClone("MC/system/", "MC/system/selected/"); + } } static constexpr std::string_view AppliedSelections[3] = {"all/", "trackSelections/", "systemSelections/"}; From f12ea20f164aed261c308f2cc3516954e090053e Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Thu, 30 Oct 2025 11:15:51 +0100 Subject: [PATCH 02/11] introduced 'AnAn' notation --- PWGUD/Tasks/upcRhoAnalysis.cxx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index ac3b68af32d..6239b5f2038 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -279,12 +279,12 @@ struct UpcRhoAnalysis { rSystem.addClone("system/all/unlike-sign/", "system/all/like-sign/positive/"); rSystem.addClone("system/all/unlike-sign/", "system/all/like-sign/negative/"); // selected rhos - rSystem.addClone("system/all/", "system/selected/no-selection/"); + rSystem.addClone("system/all/", "system/selected/AnAn/"); // clones for neutron classes - rSystem.addClone("system/selected/no-selection/", "system/selected/0n0n/"); - rSystem.addClone("system/selected/no-selection/", "system/selected/Xn0n/"); - rSystem.addClone("system/selected/no-selection/", "system/selected/0nXn/"); - rSystem.addClone("system/selected/no-selection/", "system/selected/XnXn/"); + rSystem.addClone("system/selected/AnAn/", "system/selected/0n0n/"); + rSystem.addClone("system/selected/AnAn/", "system/selected/Xn0n/"); + rSystem.addClone("system/selected/AnAn/", "system/selected/0nXn/"); + rSystem.addClone("system/selected/AnAn/", "system/selected/XnXn/"); if (context.mOptions.get("processMCdata")) { // MC @@ -328,7 +328,7 @@ struct UpcRhoAnalysis { static constexpr std::string_view AppliedSelections[3] = {"all/", "trackSelections/", "systemSelections/"}; static constexpr std::string_view ChargeLabel[3] = {"unlike-sign/", "like-sign/positive/", "like-sign/negative/"}; - static constexpr std::string_view NeutronClass[5] = {"no-selection/", "0n0n/", "Xn0n/", "0nXn/", "XnXn/"}; + static constexpr std::string_view NeutronClass[5] = {"AnAn/", "0n0n/", "Xn0n/", "0nXn/", "XnXn/"}; template void fillCollisionQcHistos(const C& collision) // fills collision QC histograms before/after cuts From aa6d2b766d80c5f69177072b4a8b46c28777c36a Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Sun, 2 Nov 2025 22:42:38 +0100 Subject: [PATCH 03/11] explicit writing of rads as units in histogram axes --- PWGUD/Tasks/upcRhoAnalysis.cxx | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index 6239b5f2038..d6185a80135 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -221,7 +221,7 @@ struct UpcRhoAnalysis { rQC.add("QC/tracks/all/hTpcNClsCrossedRowsOverNClsFindable", ";TPC crossed rows/findable #it{N}_{cls};counts", kTH1D, {{300, 0.5, 2.5}}); rQC.add("QC/tracks/all/hPt", ";#it{p}_{T} (GeV/#it{c});counts", kTH1D, {ptAxis}); rQC.add("QC/tracks/all/hEta", ";#it{#eta};counts", kTH1D, {etaAxis}); - rQC.add("QC/tracks/all/hPhi", ";#it{#phi};counts", kTH1D, {phiAxis}); + rQC.add("QC/tracks/all/hPhi", ";#it{#phi} (rad);counts", kTH1D, {phiAxis}); rQC.add("QC/tracks/all/hTpcSignalVsP", ";|#it{p}| (GeV/#it{c});TPC d#it{E}/d#it{x} signal (arb. units);counts", kTH2D, {ptAxis, {500, 0.0, 500.0}}); rQC.add("QC/tracks/all/hTpcSignalVsPt", ";#it{p}_{T} (GeV/#it{c});TPC d#it{E}/d#it{x} signal (arb. units);counts", kTH2D, {ptAxis, {500, 0.0, 500.0}}); // tracks passing selections @@ -258,7 +258,7 @@ struct UpcRhoAnalysis { // TRACKS (2D) rTracks.add("tracks/trackSelections/unlike-sign/hPt", ";#it{p}_{T leading} (GeV/#it{c});#it{p}_{T subleading} (GeV/#it{c});counts", kTH2D, {ptAxis, ptAxis}); rTracks.add("tracks/trackSelections/unlike-sign/hEta", ";#it{#eta}_{leading};#it{#eta}_{subleading};counts", kTH2D, {etaAxis, etaAxis}); - rTracks.add("tracks/trackSelections/unlike-sign/hPhi", ";#it{#phi}_{leading};#it{#phi}_{subleading};counts", kTH2D, {phiAxis, phiAxis}); + rTracks.add("tracks/trackSelections/unlike-sign/hPhi", ";#it{#phi}_{leading} (rad);#it{#phi}_{subleading} (rad);counts", kTH2D, {phiAxis, phiAxis}); rTracks.addClone("tracks/trackSelections/unlike-sign/", "tracks/trackSelections/like-sign/positive/"); rTracks.addClone("tracks/trackSelections/unlike-sign/", "tracks/trackSelections/like-sign/negative/"); rTracks.addClone("tracks/trackSelections/", "tracks/systemSelections/"); @@ -270,11 +270,11 @@ struct UpcRhoAnalysis { rSystem.add("system/all/unlike-sign/hPt2", ";#it{p}_{T}^{2} (GeV^{2}/#it{c}^{2});counts", kTH1D, {pt2Axis}); rSystem.add("system/all/unlike-sign/hPtVsM", ";#it{m} (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c});counts", kTH2D, {mAxis, ptAxis}); rSystem.add("system/all/unlike-sign/hY", ";#it{y};counts", kTH1D, {yAxis}); - rSystem.add("system/all/unlike-sign/hPhi", ";#it{#phi};counts", kTH1D, {phiAxis}); - rSystem.add("system/all/unlike-sign/hPhiRandom", ";#Delta#it{#phi}_{random};counts", kTH1D, {deltaPhiAxis}); - rSystem.add("system/all/unlike-sign/hPhiCharge", ";#Delta#it{#phi}_{charge};counts", kTH1D, {deltaPhiAxis}); - rSystem.add("system/all/unlike-sign/hPhiRandomVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi}_{random};counts", kTH2D, {mAxis, deltaPhiAxis}); - rSystem.add("system/all/unlike-sign/hPhiChargeVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi}_{charge};counts", kTH2D, {mAxis, deltaPhiAxis}); + rSystem.add("system/all/unlike-sign/hPhi", ";#it{#phi} (rad);counts", kTH1D, {phiAxis}); + rSystem.add("system/all/unlike-sign/hPhiRandom", ";#Delta#it{#phi}_{random} (rad);counts", kTH1D, {deltaPhiAxis}); + rSystem.add("system/all/unlike-sign/hPhiCharge", ";#Delta#it{#phi}_{charge} (rad);counts", kTH1D, {deltaPhiAxis}); + rSystem.add("system/all/unlike-sign/hPhiRandomVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi}_{random} (rad);counts", kTH2D, {mAxis, deltaPhiAxis}); + rSystem.add("system/all/unlike-sign/hPhiChargeVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi}_{charge} (rad);counts", kTH2D, {mAxis, deltaPhiAxis}); // clones for like-sign rSystem.addClone("system/all/unlike-sign/", "system/all/like-sign/positive/"); rSystem.addClone("system/all/unlike-sign/", "system/all/like-sign/negative/"); @@ -301,12 +301,12 @@ struct UpcRhoAnalysis { rMC.add("MC/tracks/all/hIsPhysicalPrimary", ";is physical primary;counts", kTH1D, {{2, -0.5, 1.5}}); rMC.add("MC/tracks/all/hPt", ";#it{p}_{T} (GeV/#it{c});counts", kTH1D, {ptAxis}); rMC.add("MC/tracks/all/hEta", ";#it{#eta};counts", kTH1D, {etaAxis}); - rMC.add("MC/tracks/all/hPhi", ";#it{#phi};counts", kTH1D, {phiAxis}); + rMC.add("MC/tracks/all/hPhi", ";#it{#phi} (rad);counts", kTH1D, {phiAxis}); rMC.addClone("MC/tracks/all/", "MC/tracks/primaries/"); rMC.addClone("MC/tracks/all/", "MC/tracks/prodByGen/"); rMC.add("MC/tracks/hPt", ";#it{p}_{T leading} (GeV/#it{c});#it{p}_{T subleading} (GeV/#it{c});counts", kTH2D, {ptAxis, ptAxis}); rMC.add("MC/tracks/hEta", ";#it{#eta}_{leading};#it{#eta}_{subleading};counts", kTH2D, {etaAxis, etaAxis}); - rMC.add("MC/tracks/hPhi", ";#it{#phi}_{leading};#it{#phi}_{subleading};counts", kTH2D, {phiAxis, phiAxis}); + rMC.add("MC/tracks/hPhi", ";#it{#phi}_{leading} (rad);#it{#phi}_{subleading} (rad);counts", kTH2D, {phiAxis, phiAxis}); // resolution rMC.add("MC/resolution/tracks/hPt", ";#it{p}_{T, reco} - #it{p}_{T, true} (GeV/#it{c});counts", kTH1D, {{200, -1.0, 1.0}}); rMC.add("MC/resolution/tracks/hEta", ";#it{#eta}_{reco} - #it{#eta}_{true};counts", kTH1D, {{200, -0.2, 0.2}}); @@ -317,11 +317,11 @@ struct UpcRhoAnalysis { rMC.add("MC/system/hPt2", ";#it{p}_{T}^{2} (GeV^{2}/#it{c}^{2});counts", kTH1D, {pt2Axis}); rMC.add("MC/system/hPtVsM", ";#it{m} (GeV/#it{c}^{2});#it{p}_{T} (GeV/#it{c});counts", kTH2D, {mAxis, ptAxis}); rMC.add("MC/system/hY", ";#it{y};counts", kTH1D, {yAxis}); - rMC.add("MC/system/hPhi", ";#it{#phi};counts", kTH1D, {phiAxis}); - rMC.add("MC/system/hPhiRandom", ";#Delta#it{#phi}_{random};counts", kTH1D, {deltaPhiAxis}); - rMC.add("MC/system/hPhiCharge", ";#Delta#it{#phi}_{charge};counts", kTH1D, {deltaPhiAxis}); - rMC.add("MC/system/hPhiRandomVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi};counts", kTH2D, {mAxis, deltaPhiAxis}); - rMC.add("MC/system/hPhiChargeVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi};counts", kTH2D, {mAxis, deltaPhiAxis}); + rMC.add("MC/system/hPhi", ";#it{#phi} (rad);counts", kTH1D, {phiAxis}); + rMC.add("MC/system/hPhiRandom", ";#Delta#it{#phi}_{random} (rad);counts", kTH1D, {deltaPhiAxis}); + rMC.add("MC/system/hPhiCharge", ";#Delta#it{#phi}_{charge} (rad);counts", kTH1D, {deltaPhiAxis}); + rMC.add("MC/system/hPhiRandomVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi} (rad);counts", kTH2D, {mAxis, deltaPhiAxis}); + rMC.add("MC/system/hPhiChargeVsM", ";#it{m} (GeV/#it{c}^{2});#Delta#it{#phi} (rad);counts", kTH2D, {mAxis, deltaPhiAxis}); rMC.addClone("MC/system/", "MC/system/selected/"); } } From 3897ecbc7c8a36322e6695835d408d8bf7622a12 Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Wed, 5 Nov 2025 15:41:02 +0100 Subject: [PATCH 04/11] removed unused configurable --- PWGUD/Tasks/upcRhoAnalysis.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index 06159a0ef0d..b47c8731f5b 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -135,7 +135,6 @@ struct UpcRhoAnalysis { Configurable cutTrueGapSideZDC{"cutTrueGapSideZDC", 10000., "ZDC threshold for SG selector. 0 is <1n, 4.2 is <2n, 6.7 is <3n, 9.5 is <4n, 12.5 is <5n"}; Configurable requireTof{"requireTof", false, "require TOF signal"}; - Configurable onlyGoldenRuns{"onlyGoldenRuns", false, "process only golden runs"}; Configurable useRecoFlag{"useRecoFlag", false, "use reco flag for event selection"}; Configurable cutRecoFlag{"cutRecoFlag", 1, "0 = std mode, 1 = upc mode"}; Configurable useRctFlag{"useRctFlag", false, "use RCT flags for event selection"}; From a27dea9bb6c3ae0114060fb31a1096ce0b7830b2 Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Wed, 5 Nov 2025 18:21:52 +0100 Subject: [PATCH 05/11] add collision selection histogram --- PWGUD/Tasks/upcRhoAnalysis.cxx | 43 ++++++++++++++++++++++++---------- 1 file changed, 30 insertions(+), 13 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index b47c8731f5b..c36bad8b4ed 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -202,9 +202,16 @@ struct UpcRhoAnalysis { rQC.add("QC/collisions/all/hTimeFDDA", ";FDDA time (ns);counts", kTH1D, {{500, -10.0, 40.0}}); rQC.add("QC/collisions/all/hTimeFDDC", ";FDDC time (ns);counts", kTH1D, {{500, -10.0, 40.0}}); // events with selected rho candidates - rQC.addClone("QC/collisions/all/", "QC/collisions/trackSelections/"); // clone "all" histograms as "selected" + rQC.addClone("QC/collisions/all/", "QC/collisions/trackSelections/"); rQC.addClone("QC/collisions/all/", "QC/collisions/systemSelections/"); + std::vector collisionSelectionCounterLabels = {"all collisions", "vertex selections", "#it{z} position", "number of contributors", "RCT selections", "reco flag selection"}; + rQC.add("QC/collisions/hSelectionCounter", ";;collisions passing selections", kTH1D, {{static_cast(collisionSelectionCounterLabels.size()), -0.5, static_cast(collisionSelectionCounterLabels.size()) - 0.5}}); + rQC.add("QC/collisions/hSelectionCounterPerRun", ";;run number;collisions passing selections", kTH2D, {{static_cast(collisionSelectionCounterLabels.size()), -0.5, static_cast(collisionSelectionCounterLabels.size()) - 0.5}, runNumberAxis}); + for (int i = 0; i < static_cast(collisionSelectionCounterLabels.size()); ++i) { + rQC.get(HIST("QC/collisions/hSelectionCounter"))->GetXaxis()->SetBinLabel(i + 1, collisionSelectionCounterLabels[i].c_str()); + rQC.get(HIST("QC/collisions/hSelectionCounterPerRun"))->GetXaxis()->SetBinLabel(i + 1, collisionSelectionCounterLabels[i].c_str()); + } // tracks rQC.add("QC/tracks/all/hTpcNSigmaPi", ";TPC #it{n#sigma}(#pi);counts", kTH1D, {nSigmaAxis}); rQC.add("QC/tracks/all/hTpcNSigmaEl", ";TPC #it{n#sigma}(e);counts", kTH1D, {nSigmaAxis}); @@ -222,22 +229,22 @@ struct UpcRhoAnalysis { rQC.add("QC/tracks/all/hTpcSignalVsP", ";|#it{p}| (GeV/#it{c});TPC d#it{E}/d#it{x} signal (arb. units);counts", kTH2D, {ptAxis, {500, 0.0, 500.0}}); rQC.add("QC/tracks/all/hTpcSignalVsPt", ";#it{p}_{T} (GeV/#it{c});TPC d#it{E}/d#it{x} signal (arb. units);counts", kTH2D, {ptAxis, {500, 0.0, 500.0}}); // tracks passing selections - rQC.addClone("QC/tracks/all/", "QC/tracks/trackSelections/"); // clone "raw" histograms as "cut" + rQC.addClone("QC/tracks/all/", "QC/tracks/trackSelections/"); rQC.addClone("QC/tracks/all/", "QC/tracks/systemSelections/"); rQC.add("QC/tracks/trackSelections/hRemainingTracks", ";remaining tracks;counts", kTH1D, {{21, -0.5, 20.5}}); rQC.add("QC/tracks/trackSelections/hTpcNSigmaPi2D", ";TPC #it{n#sigma}(#pi)_{leading};TPC #it{n#sigma}(#pi)_{subleading};counts", kTH2D, {nSigmaAxis, nSigmaAxis}); rQC.add("QC/tracks/trackSelections/hTpcNSigmaEl2D", ";TPC #it{n#sigma}(e)_{leading};TPC #it{n#sigma}(e)_{subleading};counts", kTH2D, {nSigmaAxis, nSigmaAxis}); rQC.add("QC/tracks/trackSelections/hTpcNSigmaKa2D", ";TPC #it{n#sigma}(K)_{leading};TPC #it{n#sigma}(K)_{subleading};counts", kTH2D, {nSigmaAxis, nSigmaAxis}); // selection counter - std::vector selectionCounterLabels = {"all tracks", "PV contributor", "ITS hit", "ITS #it{N}_{cls}", "itsClusterMap check", "ITS #it{#chi}^{2}/#it{N}_{cls}", "TPC hit", "found TPC #it{N}_{cls}", "TPC #it{#chi}^{2}/#it{N}_{cls}", "TPC crossed rows", + std::vector trackSelectionCounterLabels = {"all tracks", "PV contributor", "ITS hit", "ITS #it{N}_{cls}", "itsClusterMap check", "ITS #it{#chi}^{2}/#it{N}_{cls}", "TPC hit", "found TPC #it{N}_{cls}", "TPC #it{#chi}^{2}/#it{N}_{cls}", "TPC crossed rows", "TPC crossed rows/#it{N}_{cls}", "TOF requirement", "#it{p}_{T}", "#it{DCA}", "#it{#eta}", "exactly 2 tracks", "PID"}; - rQC.add("QC/tracks/hSelectionCounter", ";;tracks passing selections", kTH1D, {{static_cast(selectionCounterLabels.size()), -0.5, static_cast(selectionCounterLabels.size()) - 0.5}}); - rQC.add("QC/tracks/hSelectionCounterPerRun", ";;run number;tracks passing selections", kTH2D, {{static_cast(selectionCounterLabels.size()), -0.5, static_cast(selectionCounterLabels.size()) - 0.5}, runNumberAxis}); - for (int i = 0; i < static_cast(selectionCounterLabels.size()); ++i) { - rQC.get(HIST("QC/tracks/hSelectionCounter"))->GetXaxis()->SetBinLabel(i + 1, selectionCounterLabels[i].c_str()); - rQC.get(HIST("QC/tracks/hSelectionCounterPerRun"))->GetXaxis()->SetBinLabel(i + 1, selectionCounterLabels[i].c_str()); + rQC.add("QC/tracks/hSelectionCounter", ";;tracks passing selections", kTH1D, {{static_cast(trackSelectionCounterLabels.size()), -0.5, static_cast(trackSelectionCounterLabels.size()) - 0.5}}); + rQC.add("QC/tracks/hSelectionCounterPerRun", ";;run number;tracks passing selections", kTH2D, {{static_cast(trackSelectionCounterLabels.size()), -0.5, static_cast(trackSelectionCounterLabels.size()) - 0.5}, runNumberAxis}); + for (int i = 0; i < static_cast(trackSelectionCounterLabels.size()); ++i) { + rQC.get(HIST("QC/tracks/hSelectionCounter"))->GetXaxis()->SetBinLabel(i + 1, trackSelectionCounterLabels[i].c_str()); + rQC.get(HIST("QC/tracks/hSelectionCounterPerRun"))->GetXaxis()->SetBinLabel(i + 1, trackSelectionCounterLabels[i].c_str()); } for (int i = 0; i < static_cast(runNumbers.size()); ++i) { rQC.get(HIST("QC/tracks/hSelectionCounterPerRun"))->GetYaxis()->SetBinLabel(i + 1, std::to_string(runNumbers[i]).c_str()); @@ -438,21 +445,31 @@ struct UpcRhoAnalysis { } template - bool collisionPassesCuts(const C& collision) // collision cuts + bool collisionPassesCuts(const C& collision, int runIndex) // collision cuts { + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 1); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 1, runIndex); if (!collision.vtxITSTPC() || !collision.sbp() || !collision.itsROFb() || !collision.tfb()) // not applied automatically in 2023 Pb-Pb pass5 return false; - + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 2); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 2, runIndex); if (std::abs(collision.posZ()) > collisionsPosZMaxCut) return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 3); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 3, runIndex); if (cutNumContribs && (collision.numContrib() > collisionsNumContribsMaxCut)) return false; - + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 4); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 4, runIndex); if (useRctFlag && !isGoodRctFlag(collision)) // check RCT flags return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 5); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 5, runIndex); if (useRecoFlag && (collision.flags() != cutRecoFlag)) // check reconstruction mode return false; - + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 6); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 6, runIndex); + // if all selections passed return true; } @@ -646,7 +663,7 @@ struct UpcRhoAnalysis { int runIndex = getRunIndex(collision.runNumber(), runNumbers); fillCollisionQcHistos<0>(collision); // fill QC histograms before cuts - if (!collisionPassesCuts(collision)) + if (!collisionPassesCuts(collision, runIndex)) // apply collision cuts return; int neutronClass = -1; From 3b48393542c189a60886ea5d07b22e07cba5a659 Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Wed, 5 Nov 2025 23:48:10 +0100 Subject: [PATCH 06/11] bugfix + extension of the histogram --- PWGUD/Tasks/upcRhoAnalysis.cxx | 39 +++++++++++++++++++++++++++------- 1 file changed, 31 insertions(+), 8 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index c36bad8b4ed..c8dd7f3a985 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -205,7 +205,7 @@ struct UpcRhoAnalysis { rQC.addClone("QC/collisions/all/", "QC/collisions/trackSelections/"); rQC.addClone("QC/collisions/all/", "QC/collisions/systemSelections/"); - std::vector collisionSelectionCounterLabels = {"all collisions", "vertex selections", "#it{z} position", "number of contributors", "RCT selections", "reco flag selection"}; + std::vector collisionSelectionCounterLabels = {"all collisions", "ITS-TPC vertex", "same bunch pile-up", "ITS ROF border", "TF border", "#it{z} position", "number of contributors", "RCT selections", "reco flag selection"}; rQC.add("QC/collisions/hSelectionCounter", ";;collisions passing selections", kTH1D, {{static_cast(collisionSelectionCounterLabels.size()), -0.5, static_cast(collisionSelectionCounterLabels.size()) - 0.5}}); rQC.add("QC/collisions/hSelectionCounterPerRun", ";;run number;collisions passing selections", kTH2D, {{static_cast(collisionSelectionCounterLabels.size()), -0.5, static_cast(collisionSelectionCounterLabels.size()) - 0.5}, runNumberAxis}); for (int i = 0; i < static_cast(collisionSelectionCounterLabels.size()); ++i) { @@ -447,28 +447,49 @@ struct UpcRhoAnalysis { template bool collisionPassesCuts(const C& collision, int runIndex) // collision cuts { + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 0); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 0, runIndex); + + if (!collision.vtxITSTPC()) + return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 1); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 1, runIndex); - if (!collision.vtxITSTPC() || !collision.sbp() || !collision.itsROFb() || !collision.tfb()) // not applied automatically in 2023 Pb-Pb pass5 + + if (!collision.sbp()) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 2); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 2, runIndex); - if (std::abs(collision.posZ()) > collisionsPosZMaxCut) + + if (!collision.itsROFb()) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 3); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 3, runIndex); - if (cutNumContribs && (collision.numContrib() > collisionsNumContribsMaxCut)) + + if (!collision.tfb()) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 4); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 4, runIndex); - if (useRctFlag && !isGoodRctFlag(collision)) // check RCT flags + + if (std::abs(collision.posZ()) > collisionsPosZMaxCut) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 5); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 5, runIndex); - if (useRecoFlag && (collision.flags() != cutRecoFlag)) // check reconstruction mode + + if (cutNumContribs && (collision.numContrib() > collisionsNumContribsMaxCut)) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 6); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 6, runIndex); + + if (useRctFlag && !isGoodRctFlag(collision)) // check RCT flags + return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 7); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 7, runIndex); + + if (useRecoFlag && (collision.flags() != cutRecoFlag)) // check reconstruction mode + return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 8); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 8, runIndex); + // if all selections passed return true; } @@ -476,6 +497,9 @@ struct UpcRhoAnalysis { template bool trackPassesCuts(const T& track, int runIndex) // track cuts (PID done separately) { + rQC.fill(HIST("QC/tracks/hSelectionCounter"), 0); + rQC.fill(HIST("QC/tracks/hSelectionCounterPerRun"), 0, runIndex); + if (!track.isPVContributor()) return false; rQC.fill(HIST("QC/tracks/hSelectionCounter"), 1); @@ -545,6 +569,7 @@ struct UpcRhoAnalysis { return false; rQC.fill(HIST("QC/tracks/hSelectionCounter"), 14); rQC.fill(HIST("QC/tracks/hSelectionCounterPerRun"), 14, runIndex); + // if all selections passed return true; } @@ -699,8 +724,6 @@ struct UpcRhoAnalysis { std::vector cutTracks; // store selected tracks for (const auto& track : tracks) { - rQC.fill(HIST("QC/tracks/hSelectionCounter"), 0); - rQC.fill(HIST("QC/tracks/hSelectionCounterPerRun"), 0, runIndex); fillTrackQcHistos<0>(track); // fill QC histograms before cuts if (!trackPassesCuts(track, runIndex)) // apply track cuts From 651a59e263a2ccb626a78687240baabbdcbf817e Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Sat, 8 Nov 2025 14:08:15 +0100 Subject: [PATCH 07/11] still extending --- PWGUD/Tasks/upcRhoAnalysis.cxx | 45 ++++++++++++++++++++-------------- 1 file changed, 26 insertions(+), 19 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index c8dd7f3a985..9e4e05993d1 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -205,7 +205,7 @@ struct UpcRhoAnalysis { rQC.addClone("QC/collisions/all/", "QC/collisions/trackSelections/"); rQC.addClone("QC/collisions/all/", "QC/collisions/systemSelections/"); - std::vector collisionSelectionCounterLabels = {"all collisions", "ITS-TPC vertex", "same bunch pile-up", "ITS ROF border", "TF border", "#it{z} position", "number of contributors", "RCT selections", "reco flag selection"}; + std::vector collisionSelectionCounterLabels = {"all collisions", "rapidity gap", "ITS-TPC vertex", "same bunch pile-up", "ITS ROF border", "TF border", "#it{z} position", "number of contributors", "RCT selections", "reco flag selection"}; rQC.add("QC/collisions/hSelectionCounter", ";;collisions passing selections", kTH1D, {{static_cast(collisionSelectionCounterLabels.size()), -0.5, static_cast(collisionSelectionCounterLabels.size()) - 0.5}}); rQC.add("QC/collisions/hSelectionCounterPerRun", ";;run number;collisions passing selections", kTH2D, {{static_cast(collisionSelectionCounterLabels.size()), -0.5, static_cast(collisionSelectionCounterLabels.size()) - 0.5}, runNumberAxis}); for (int i = 0; i < static_cast(collisionSelectionCounterLabels.size()); ++i) { @@ -447,49 +447,46 @@ struct UpcRhoAnalysis { template bool collisionPassesCuts(const C& collision, int runIndex) // collision cuts { - rQC.fill(HIST("QC/collisions/hSelectionCounter"), 0); - rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 0, runIndex); - if (!collision.vtxITSTPC()) return false; - rQC.fill(HIST("QC/collisions/hSelectionCounter"), 1); - rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 1, runIndex); - - if (!collision.sbp()) - return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 2); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 2, runIndex); - if (!collision.itsROFb()) + if (!collision.sbp()) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 3); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 3, runIndex); - if (!collision.tfb()) + if (!collision.itsROFb()) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 4); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 4, runIndex); - if (std::abs(collision.posZ()) > collisionsPosZMaxCut) + if (!collision.tfb()) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 5); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 5, runIndex); - if (cutNumContribs && (collision.numContrib() > collisionsNumContribsMaxCut)) + if (std::abs(collision.posZ()) > collisionsPosZMaxCut) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 6); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 6, runIndex); - if (useRctFlag && !isGoodRctFlag(collision)) // check RCT flags + if (cutNumContribs && (collision.numContrib() > collisionsNumContribsMaxCut)) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 7); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 7, runIndex); - if (useRecoFlag && (collision.flags() != cutRecoFlag)) // check reconstruction mode + if (useRctFlag && !isGoodRctFlag(collision)) // check RCT flags return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 8); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 8, runIndex); + if (useRecoFlag && (collision.flags() != cutRecoFlag)) // check reconstruction mode + return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 9); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 9, runIndex); + // if all selections passed return true; } @@ -680,12 +677,11 @@ struct UpcRhoAnalysis { } template - void processReco(C const& collision, T const& tracks) + void processReco(C const& collision, T const& tracks, const int runIndex) { // check if the collision run number is contained within the selectedRuns vector if (selectRuns && getRunIndex(collision.runNumber(), selectedRuns) == 0) return; - int runIndex = getRunIndex(collision.runNumber(), runNumbers); fillCollisionQcHistos<0>(collision); // fill QC histograms before cuts if (!collisionPassesCuts(collision, runIndex)) // apply collision cuts @@ -989,17 +985,28 @@ struct UpcRhoAnalysis { void processSGdata(FullUdSgCollision const& collision, FullUdTracks const& tracks) { + int runIndex = getRunIndex(collision.runNumber(), runNumbers); + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 0); // all collisions + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 0, runIndex); + if (cutGapSide && collision.gapSide() != gapSide) return; if (useTrueGap && (collision.gapSide() != sgSelector.trueGap(collision, cutTrueGapSideFV0, cutTrueGapSideFT0A, cutTrueGapSideFT0C, cutTrueGapSideZDC))) // check true gap side return; - processReco(collision, tracks); + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 1); // only double-gap collisions + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 1, runIndex); + + processReco(collision, tracks, runIndex); } PROCESS_SWITCH(UpcRhoAnalysis, processSGdata, "analyse SG data", true); void processDGdata(FullUdDgCollision const& collision, FullUdTracks const& tracks) { - processReco(collision, tracks); + int runIndex = getRunIndex(collision.runNumber(), runNumbers); + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 1); // no single-gap collisions in dataset + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 1, runIndex); + + processReco(collision, tracks, runIndex); } PROCESS_SWITCH(UpcRhoAnalysis, processDGdata, "analyse DG data", false); From 346b985206e6d255851bd2775bfe98c45fc6436f Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Mon, 10 Nov 2025 09:26:42 +0100 Subject: [PATCH 08/11] changed-up drawing of selection histos and added a switch for pO --- PWGUD/Tasks/upcRhoAnalysis.cxx | 62 ++++++++++++++++++++-------------- 1 file changed, 37 insertions(+), 25 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index 9e4e05993d1..fe151b216a0 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -126,6 +126,8 @@ struct UpcRhoAnalysis { Configurable numPions{"numPions", 2, "required number of pions in the event"}; + Configurable isPO{"isPO", false, "process proton-oxygen data"}; + Configurable cutGapSide{"cutGapSide", true, "apply gap side cut"}; Configurable gapSide{"gapSide", 2, "required gap side"}; Configurable useTrueGap{"useTrueGap", false, "use true gap"}; @@ -447,15 +449,17 @@ struct UpcRhoAnalysis { template bool collisionPassesCuts(const C& collision, int runIndex) // collision cuts { - if (!collision.vtxITSTPC()) - return false; - rQC.fill(HIST("QC/collisions/hSelectionCounter"), 2); - rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 2, runIndex); - - if (!collision.sbp()) - return false; - rQC.fill(HIST("QC/collisions/hSelectionCounter"), 3); - rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 3, runIndex); + if (!isPO) { + if (!collision.vtxITSTPC()) + return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 2); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 2, runIndex); + + if (!collision.sbp()) + return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 3); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 3, runIndex); + } if (!collision.itsROFb()) return false; @@ -472,20 +476,26 @@ struct UpcRhoAnalysis { rQC.fill(HIST("QC/collisions/hSelectionCounter"), 6); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 6, runIndex); - if (cutNumContribs && (collision.numContrib() > collisionsNumContribsMaxCut)) - return false; - rQC.fill(HIST("QC/collisions/hSelectionCounter"), 7); - rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 7, runIndex); + if (cutNumContribs) { + if (collision.numContrib() > collisionsNumContribsMaxCut) + return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 7); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 7, runIndex); + } - if (useRctFlag && !isGoodRctFlag(collision)) // check RCT flags - return false; - rQC.fill(HIST("QC/collisions/hSelectionCounter"), 8); - rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 8, runIndex); + if (useRctFlag) { + if (!isGoodRctFlag(collision)) // check RCT flags + return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 8); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 8, runIndex); + } - if (useRecoFlag && (collision.flags() != cutRecoFlag)) // check reconstruction mode - return false; - rQC.fill(HIST("QC/collisions/hSelectionCounter"), 9); - rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 9, runIndex); + if (useRecoFlag) { + if (collision.flags() != cutRecoFlag) // check reconstruction mode + return false; + rQC.fill(HIST("QC/collisions/hSelectionCounter"), 9); + rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 9, runIndex); + } // if all selections passed return true; @@ -547,10 +557,12 @@ struct UpcRhoAnalysis { rQC.fill(HIST("QC/tracks/hSelectionCounter"), 10); rQC.fill(HIST("QC/tracks/hSelectionCounterPerRun"), 10, runIndex); - if (requireTof && !track.hasTOF()) - return false; - rQC.fill(HIST("QC/tracks/hSelectionCounter"), 11); - rQC.fill(HIST("QC/tracks/hSelectionCounterPerRun"), 11, runIndex); + if (requireTof) { + if (!track.hasTOF()) + return false; + rQC.fill(HIST("QC/tracks/hSelectionCounter"), 11); + rQC.fill(HIST("QC/tracks/hSelectionCounterPerRun"), 11, runIndex); + } if (track.pt() < tracksMinPtCut) return false; From 0aeca676245cf396083e509eeeb882950175977b Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Tue, 11 Nov 2025 10:58:48 +0100 Subject: [PATCH 09/11] adjusting unnecessarily wide axis ranges in configurable defaults --- PWGUD/Tasks/upcRhoAnalysis.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index fe151b216a0..650f5abd867 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -168,11 +168,11 @@ struct UpcRhoAnalysis { Configurable systemPtCut{"systemPtCut", 0.1, "max pT cut for reco system"}; Configurable systemYCut{"systemYCut", 0.9, "rapiditiy cut for reco system"}; - ConfigurableAxis mAxis{"mAxis", {1000, 0.0, 10.0}, "#it{m} (GeV/#it{c}^{2})"}; - ConfigurableAxis ptAxis{"ptAxis", {1000, 0.0, 10.0}, "#it{p}_{T} (GeV/#it{c})"}; - ConfigurableAxis pt2Axis{"pt2Axis", {1000, 0.0, 0.1}, "#it{p}_{T}^{2} (GeV^{2}/#it{c}^{2})"}; + ConfigurableAxis mAxis{"mAxis", {400, 0.0, 4.0}, "#it{m} (GeV/#it{c}^{2})"}; + ConfigurableAxis ptAxis{"ptAxis", {400, 0.0, 4.0}, "#it{p}_{T} (GeV/#it{c})"}; + ConfigurableAxis pt2Axis{"pt2Axis", {1000, 0.0, 1.0}, "#it{p}_{T}^{2} (GeV^{2}/#it{c}^{2})"}; ConfigurableAxis etaAxis{"etaAxis", {300, -1.5, 1.5}, "#it{#eta}"}; - ConfigurableAxis yAxis{"yAxis", {400, -4.0, 4.0}, "#it{y}"}; + ConfigurableAxis yAxis{"yAxis", {300, -1.5, 1.5}, "#it{y}"}; ConfigurableAxis phiAxis{"phiAxis", {180, 0.0, o2::constants::math::TwoPI}, "#it{#phi} (rad)"}; ConfigurableAxis deltaPhiAxis{"deltaPhiAxis", {182, -o2::constants::math::PI, o2::constants::math::PI}, "#Delta#it{#phi} (rad)"}; ConfigurableAxis znCommonEnergyAxis{"znCommonEnergyAxis", {250, -5.0, 20.0}, "ZN common energy (TeV)"}; From 71870425e1fa034b8a7ce30785466c0ac4e5575e Mon Sep 17 00:00:00 2001 From: Jakub Juracka Date: Thu, 20 Nov 2025 14:44:49 +0100 Subject: [PATCH 10/11] added functionality to include runNumber for MC truth events while running with on-the-fly SGCandProducer --- PWGUD/Tasks/upcRhoAnalysis.cxx | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index 650f5abd867..bafb7671f0e 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -96,6 +96,7 @@ namespace mc_tree { // misc event info DECLARE_SOA_COLUMN(LocalBc, localBc, int); +DECLARE_SOA_COLUMN(RunNumber, runNumber, int); // event vertex DECLARE_SOA_COLUMN(PosX, posX, float); DECLARE_SOA_COLUMN(PosY, posY, float); @@ -109,7 +110,7 @@ DECLARE_SOA_COLUMN(TrackEta, trackEta, float[2]); DECLARE_SOA_COLUMN(TrackPhi, trackPhi, float[2]); } // namespace mc_tree DECLARE_SOA_TABLE(McTree, "AOD", "MCTREE", - mc_tree::LocalBc, + mc_tree::LocalBc, mc_tree::RunNumber, mc_tree::PosX, mc_tree::PosY, mc_tree::PosZ, mc_tree::PhiRandom, mc_tree::PhiCharge, mc_tree::TrackSign, mc_tree::TrackPt, mc_tree::TrackEta, mc_tree::TrackPhi); } // namespace o2::aod @@ -884,7 +885,7 @@ struct UpcRhoAnalysis { } template - void processMC(C const& mcCollision, T const& mcParticles) + void processMC(C const& mcCollision, T const& mcParticles, const int runNumber) { rMC.fill(HIST("MC/collisions/hPosXY"), mcCollision.posX(), mcCollision.posY()); rMC.fill(HIST("MC/collisions/hPosZ"), mcCollision.posZ()); @@ -984,7 +985,7 @@ struct UpcRhoAnalysis { float trackPts[2] = {pt(positivePion.px(), positivePion.py()), pt(negativePion.px(), negativePion.py())}; float trackEtas[2] = {eta(positivePion.px(), positivePion.py(), positivePion.pz()), eta(negativePion.px(), negativePion.py(), negativePion.pz())}; float trackPhis[2] = {phi(positivePion.px(), positivePion.py()), phi(negativePion.px(), negativePion.py())}; - mcTree(localBc, + mcTree(localBc, runNumber, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), phiRandom, phiCharge, trackSigns, trackPts, trackEtas, trackPhis); } @@ -1024,10 +1025,21 @@ struct UpcRhoAnalysis { void processMCdata(aod::UDMcCollision const& mcCollision, aod::UDMcParticles const& mcParticles) { - processMC(mcCollision, mcParticles); + processMC(mcCollision, mcParticles, -1); } PROCESS_SWITCH(UpcRhoAnalysis, processMCdata, "analyse MC data", false); + void processMCdataWithBCs(aod::UDMcCollision const& mcCollision, aod::UDMcParticles const& mcParticles, aod::BCs const& bcs) + { + int runNumber = -1; + if (bcs.size() != 0) { + auto bc = bcs.begin(); + runNumber = bc.runNumber(); + } + processMC(mcCollision, mcParticles, runNumber); + } + PROCESS_SWITCH(UpcRhoAnalysis, processMCdataWithBCs, "analyse MC data with BCs (only with on-the-fly skimming)", false); + void processCollisionRecoCheck(aod::UDMcCollision const& /* mcCollision */, soa::SmallGroups> const& collisions) { checkNumberOfCollisionReconstructions(collisions); From 11b2a10c23174fa197156d74999816f9eb300a19 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 20 Nov 2025 13:49:24 +0000 Subject: [PATCH 11/11] Please consider the following formatting changes --- PWGUD/Tasks/upcRhoAnalysis.cxx | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/PWGUD/Tasks/upcRhoAnalysis.cxx b/PWGUD/Tasks/upcRhoAnalysis.cxx index bafb7671f0e..c13a901c7fc 100644 --- a/PWGUD/Tasks/upcRhoAnalysis.cxx +++ b/PWGUD/Tasks/upcRhoAnalysis.cxx @@ -240,9 +240,9 @@ struct UpcRhoAnalysis { rQC.add("QC/tracks/trackSelections/hTpcNSigmaKa2D", ";TPC #it{n#sigma}(K)_{leading};TPC #it{n#sigma}(K)_{subleading};counts", kTH2D, {nSigmaAxis, nSigmaAxis}); // selection counter std::vector trackSelectionCounterLabels = {"all tracks", "PV contributor", "ITS hit", "ITS #it{N}_{cls}", "itsClusterMap check", "ITS #it{#chi}^{2}/#it{N}_{cls}", "TPC hit", "found TPC #it{N}_{cls}", "TPC #it{#chi}^{2}/#it{N}_{cls}", "TPC crossed rows", - "TPC crossed rows/#it{N}_{cls}", - "TOF requirement", - "#it{p}_{T}", "#it{DCA}", "#it{#eta}", "exactly 2 tracks", "PID"}; + "TPC crossed rows/#it{N}_{cls}", + "TOF requirement", + "#it{p}_{T}", "#it{DCA}", "#it{#eta}", "exactly 2 tracks", "PID"}; rQC.add("QC/tracks/hSelectionCounter", ";;tracks passing selections", kTH1D, {{static_cast(trackSelectionCounterLabels.size()), -0.5, static_cast(trackSelectionCounterLabels.size()) - 0.5}}); rQC.add("QC/tracks/hSelectionCounterPerRun", ";;run number;tracks passing selections", kTH2D, {{static_cast(trackSelectionCounterLabels.size()), -0.5, static_cast(trackSelectionCounterLabels.size()) - 0.5}, runNumberAxis}); for (int i = 0; i < static_cast(trackSelectionCounterLabels.size()); ++i) { @@ -292,7 +292,7 @@ struct UpcRhoAnalysis { rSystem.addClone("system/selected/AnAn/", "system/selected/Xn0n/"); rSystem.addClone("system/selected/AnAn/", "system/selected/0nXn/"); rSystem.addClone("system/selected/AnAn/", "system/selected/XnXn/"); - + if (context.mOptions.get("processMCdata")) { // MC // collisions @@ -472,7 +472,7 @@ struct UpcRhoAnalysis { rQC.fill(HIST("QC/collisions/hSelectionCounter"), 5); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 5, runIndex); - if (std::abs(collision.posZ()) > collisionsPosZMaxCut) + if (std::abs(collision.posZ()) > collisionsPosZMaxCut) return false; rQC.fill(HIST("QC/collisions/hSelectionCounter"), 6); rQC.fill(HIST("QC/collisions/hSelectionCounterPerRun"), 6, runIndex);