From 2b3d257ae6702111e8958e3fccd796facbe64953 Mon Sep 17 00:00:00 2001 From: Rafael Manhart <56776511+RafRaf11@users.noreply.github.com> Date: Thu, 21 Mar 2024 15:47:05 +0100 Subject: [PATCH 1/4] Update QAHistTask.cxx Added ability to enable/disable the centrality histogram. --- PWGLF/Tasks/Nuspex/QAHistTask.cxx | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/QAHistTask.cxx b/PWGLF/Tasks/Nuspex/QAHistTask.cxx index d532059f414..a963631846b 100644 --- a/PWGLF/Tasks/Nuspex/QAHistTask.cxx +++ b/PWGLF/Tasks/Nuspex/QAHistTask.cxx @@ -191,9 +191,9 @@ struct QAHistTask { MC_truth_reg.add("histEta", "#eta", HistType::kTH2F, {{102, -2.01, 2.01}, PDGBINNING}); MC_truth_reg.add("histPt", "p_{t}", HistType::kTH2F, {ptAxis, PDGBINNING}); MC_truth_reg.add("histRecVtxMC", "MC collision z position", HistType::kTH1F, {{400, -40., +40., "z position (cm)"}}); + MC_truth_reg.add("histCentrality", "Centrality", HistType::kTH1F, {centralityAxis_extended}); // MC reconstructed - MC_recon_reg.add("histCentrality", "Centrality", HistType::kTH1F, {centralityAxis_extended}); MC_recon_reg.add("histPhi", "#phi", HistType::kTH2F, {{100, 0., 2. * TMath::Pi()}, PDGBINNING}); MC_recon_reg.add("histEta", "#eta", HistType::kTH2F, {{102, -2.01, 2.01}, PDGBINNING}); MC_recon_reg.add("histPt", "p_{t}", HistType::kTH2F, {ptAxis, PDGBINNING}); @@ -562,12 +562,11 @@ struct QAHistTask { } PROCESS_SWITCH(QAHistTask, processDataCent, "process data containing centralities", false); - void processMC(soa::Join::iterator const& collisions, soa::Filtered> const& tracks, + void processMC(soa::Join::iterator const& collisions, soa::Filtered> const& tracks, aod::McParticles& mcParticles, aod::McCollisions const& mcCollisions) { MC_truth_reg.fill(HIST("histRecVtxMC"), collisions.posZ()); - MC_recon_reg.fill(HIST("histCentrality"), collisions.centFT0C()); for (auto& track : tracks) { const auto particle = track.mcParticle(); @@ -635,6 +634,14 @@ struct QAHistTask { } } PROCESS_SWITCH(QAHistTask, processMC, "process MC", false); + + void processMCCent(soa::Join::iterator const& collisions) + { + + MC_truth_reg.fill(HIST("histCentrality"), collisions.centFT0C()); + + } + PROCESS_SWITCH(QAHistTask, processMCCent, "process MC with centrality", false); }; //**************************************************************************************************** From edd3d853717b65d8b915501212afb19aa6e6c26a Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 21 Mar 2024 14:47:57 +0000 Subject: [PATCH 2/4] Please consider the following formatting changes --- PWGLF/Tasks/Nuspex/QAHistTask.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGLF/Tasks/Nuspex/QAHistTask.cxx b/PWGLF/Tasks/Nuspex/QAHistTask.cxx index a963631846b..239e8554ec5 100644 --- a/PWGLF/Tasks/Nuspex/QAHistTask.cxx +++ b/PWGLF/Tasks/Nuspex/QAHistTask.cxx @@ -639,7 +639,6 @@ struct QAHistTask { { MC_truth_reg.fill(HIST("histCentrality"), collisions.centFT0C()); - } PROCESS_SWITCH(QAHistTask, processMCCent, "process MC with centrality", false); }; From d1e97b51890feb31aaf5644e6ed798d8cc321ed4 Mon Sep 17 00:00:00 2001 From: Rafael Manhart <56776511+RafRaf11@users.noreply.github.com> Date: Thu, 21 Mar 2024 22:45:01 +0100 Subject: [PATCH 3/4] Update NucleiHistTask.cxx Added efficency analysis, Changed names of histograms to something more accurate, Fixed some bugs --- PWGLF/Tasks/Nuspex/NucleiHistTask.cxx | 715 +++++++++++++++++++------- 1 file changed, 532 insertions(+), 183 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx b/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx index 751ecd413ca..53f7429d632 100644 --- a/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx +++ b/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx @@ -42,6 +42,8 @@ struct NucleiHistTask { // Data HistogramRegistry spectra_reg{"spectra", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry pion_reg{"pion", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry apion_reg{"apion", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry proton_reg{"proton", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry aproton_reg{"aproton", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry deuteron_reg{"deuteron", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; @@ -57,7 +59,9 @@ struct NucleiHistTask { HistogramRegistry MC_truth_reg{"MC_particles", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry MC_recon_reg{"MC_particles_reconstructed", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry MC_recon_diff_reg{"MC_reconstructed_diff", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry MC_eff{"MC_efficiency", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; OutputObj histPDG{TH1F("PDG", "PDG;PDG code", 100, 0.0, 100.0)}; + OutputObj histPDG_eff{TH1F("PDG_eff", "PDG;PDG code", 100, 0.0, 100.0)}; void init(o2::framework::InitContext&) { @@ -102,6 +106,48 @@ struct NucleiHistTask { spectra_reg.add("histEta", "Pseudorapidity with centrality cut", HistType::kTH1F, {etaAxis}); spectra_reg.add("histEta_cent", "Pseudorapidity vs Centrality", HistType::kTH2F, {centralityAxis_extended, etaAxis}); + // histograms for pi⁺ + pion_reg.add("histKeepEventData", "skimming histogram (#pi^{+})", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + pion_reg.add("histTpcSignalData", "Specific energy loss (#pi^{+})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + pion_reg.add("histTofSignalData", "TOF signal (#pi^{+})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + pion_reg.add("histDcaVsPtData", "dcaXY vs Pt (#pi^{+})", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + pion_reg.add("histDcaZVsPtData", "dcaZ vs Pt (#pi^{+})", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + pion_reg.add("histTOFm2", "TOF m^2 vs Pt (#pi^{+})", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + pion_reg.add("histTpcNsigmaData", "n-sigma TPC (#pi^{+})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}}); + pion_reg.add("histTofNsigmaData", "n-sigma TOF (#pi^{+})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}}); + pion_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (#pi^{+})", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + pion_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (#pi^{+})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + pion_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (#pi^{+})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + pion_reg.add("histChi2TPC", "chi^2 TPC vs Pt (#pi^{+})", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + pion_reg.add("histChi2ITS", "chi^2 ITS vs Pt (#pi^{+})", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + pion_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (#pi^{+}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}, centralityAxis}); + pion_reg.add("histTofNsigmaData_cent", "n-sigma TOF (#pi^{+}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}, centralityAxis}); + pion_reg.add("histTofm2_cent", "mass^2 TOF (#pi^{+}) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#pi^{+}}"}, centralityAxis}); + pion_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (#pi^{+}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}, etaAxis}); + pion_reg.add("histTofNsigmaData_eta", "n-sigma TOF (#pi^{+}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}, etaAxis}); + pion_reg.add("histTofm2_eta", "mass^2 TOF (#pi^{+}) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#pi^{+}}"}, etaAxis}); + + // histograms for pi⁻ + apion_reg.add("histKeepEventData", "skimming histogram (#pi^{-})", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + apion_reg.add("histTpcSignalData", "Specific energy loss (#pi^{-})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + apion_reg.add("histTofSignalData", "TOF signal (#pi^{-})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + apion_reg.add("histDcaVsPtData", "dcaXY vs Pt (#pi^{-})", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + apion_reg.add("histDcaZVsPtData", "dcaZ vs Pt (#pi^{-})", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + apion_reg.add("histTOFm2", "TOF m^2 vs Pt (#pi^{-})", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + apion_reg.add("histTpcNsigmaData", "n-sigma TPC (#pi^{-})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}}); + apion_reg.add("histTofNsigmaData", "n-sigma TOF (#pi^{-})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}}); + apion_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (#pi^{-})", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + apion_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (#pi^{-})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + apion_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (#pi^{-})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + apion_reg.add("histChi2TPC", "chi^2 TPC vs Pt (#pi^{-})", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + apion_reg.add("histChi2ITS", "chi^2 ITS vs Pt (#pi^{-})", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + apion_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (#pi^{-}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}, centralityAxis}); + apion_reg.add("histTofNsigmaData_cent", "n-sigma TOF (#pi^{-}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}, centralityAxis}); + apion_reg.add("histTofm2_cent", "mass^2 TOF (#pi^{-}) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#pi^{+}}"}, centralityAxis}); + apion_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (#pi^{-}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}, etaAxis}); + apion_reg.add("histTofNsigmaData_eta", "n-sigma TOF (#pi^{-}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}, etaAxis}); + apion_reg.add("histTofm2_eta", "mass^2 TOF (#pi^{-}) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#pi^{+}}"}, etaAxis}); + // histograms for Proton proton_reg.add("histKeepEventData", "skimming histogram (p)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); proton_reg.add("histTpcSignalData", "Specific energy loss (p)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); @@ -124,25 +170,25 @@ struct NucleiHistTask { proton_reg.add("histTofm2_eta", "mass^2 TOF (p) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); // histograms for antiProton - aproton_reg.add("histKeepEventData", "skimming histogram (antip)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); - aproton_reg.add("histTpcSignalData", "Specific energy loss (antip)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); - aproton_reg.add("histTofSignalData", "TOF signal (antip)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); - aproton_reg.add("histDcaVsPtData", "dcaXY vs Pt (antip)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); - aproton_reg.add("histDcaZVsPtData", "dcaZ vs Pt (antip)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); - aproton_reg.add("histTOFm2", "TOF m^2 vs Pt (antip)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); - aproton_reg.add("histTpcNsigmaData", "n-sigma TPC (antip)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antip}"}}); - aproton_reg.add("histTofNsigmaData", "n-sigma TOF (antip)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antip}"}}); - aproton_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (antip)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); - aproton_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (antip)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - aproton_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (antip)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - aproton_reg.add("histChi2TPC", "chi^2 TPC vs Pt (antip)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); - aproton_reg.add("histChi2ITS", "chi^2 ITS vs Pt (antip)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); - aproton_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (antip) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antip}"}, centralityAxis}); - aproton_reg.add("histTofNsigmaData_cent", "n-sigma TOF (antip) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antip}"}, centralityAxis}); - aproton_reg.add("histTofm2_cent", "mass^2 TOF (antip) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{antip}"}, centralityAxis}); - aproton_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (antip) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - aproton_reg.add("histTofNsigmaData_eta", "n-sigma TOF (antip) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - aproton_reg.add("histTofm2_eta", "mass^2 TOF (antip) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + aproton_reg.add("histKeepEventData", "skimming histogram (#bar{p})", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + aproton_reg.add("histTpcSignalData", "Specific energy loss (#bar{p})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + aproton_reg.add("histTofSignalData", "TOF signal (#bar{p})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + aproton_reg.add("histDcaVsPtData", "dcaXY vs Pt (#bar{p})", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + aproton_reg.add("histDcaZVsPtData", "dcaZ vs Pt (#bar{p})", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + aproton_reg.add("histTOFm2", "TOF m^2 vs Pt (#bar{p})", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + aproton_reg.add("histTpcNsigmaData", "n-sigma TPC (#bar{p})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{p}}"}}); + aproton_reg.add("histTofNsigmaData", "n-sigma TOF (#bar{p})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{p}}"}}); + aproton_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (#bar{p})", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + aproton_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (#bar{p})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + aproton_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (#bar{p})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + aproton_reg.add("histChi2TPC", "chi^2 TPC vs Pt (#bar{p})", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + aproton_reg.add("histChi2ITS", "chi^2 ITS vs Pt (#bar{p})", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + aproton_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (#bar{p}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{p}}"}, centralityAxis}); + aproton_reg.add("histTofNsigmaData_cent", "n-sigma TOF (#bar{p}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{p}}"}, centralityAxis}); + aproton_reg.add("histTofm2_cent", "mass^2 TOF (#bar{p}) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#bar{p}}"}, centralityAxis}); + aproton_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (#bar{p}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{p}}"}, etaAxis}); + aproton_reg.add("histTofNsigmaData_eta", "n-sigma TOF (#bar{p}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{p}}"}, etaAxis}); + aproton_reg.add("histTofm2_eta", "mass^2 TOF (#bar{p}) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#bar{p}}"}, etaAxis}); // histograms for Deuterons deuteron_reg.add("histKeepEventData", "skimming histogram (d)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); @@ -161,30 +207,30 @@ struct NucleiHistTask { deuteron_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (d) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{d}"}, centralityAxis}); deuteron_reg.add("histTofNsigmaData_cent", "n-sigma TOF (d) centrality", HistType::kTH3F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{d}"}, centralityAxis}); deuteron_reg.add("histTofm2_cent", "mass^2 TOF (d) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{d}"}, centralityAxis}); - deuteron_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (d) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - deuteron_reg.add("histTofNsigmaData_eta", "n-sigma TOF (d) vs eta", HistType::kTH3F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - deuteron_reg.add("histTofm2_eta", "mass^2 TOF (d) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + deuteron_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (d) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{d}"}, etaAxis}); + deuteron_reg.add("histTofNsigmaData_eta", "n-sigma TOF (d) vs eta", HistType::kTH3F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{d}"}, etaAxis}); + deuteron_reg.add("histTofm2_eta", "mass^2 TOF (d) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{d}"}, etaAxis}); // histograms for antiDeuterons - adeuteron_reg.add("histKeepEventData", "skimming histogram (antid)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); - adeuteron_reg.add("histTpcSignalData", "Specific energy loss (antid)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); - adeuteron_reg.add("histTofSignalData", "TOF signal (antid)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); - adeuteron_reg.add("histDcaVsPtData", "dcaXY vs Pt (antid)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); - adeuteron_reg.add("histDcaZVsPtData", "dcaZ vs Pt (antid)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); - adeuteron_reg.add("histTOFm2", "TOF m^2 vs Pt (antid)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); - adeuteron_reg.add("histTpcNsigmaData", "n-sigma TPC (antid)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antid}"}}); - adeuteron_reg.add("histTofNsigmaData", "n-sigma TOF (antid)", HistType::kTH2F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{antid}"}}); - adeuteron_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (antid)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); - adeuteron_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (antid)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - adeuteron_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (antid)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - adeuteron_reg.add("histChi2TPC", "chi^2 TPC vs Pt (antid)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); - adeuteron_reg.add("histChi2ITS", "chi^2 ITS vs Pt (antid)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); - adeuteron_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (antid) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antid}"}, centralityAxis}); - adeuteron_reg.add("histTofNsigmaData_cent", "n-sigma TOF (antid) centrality", HistType::kTH3F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{antid}"}, centralityAxis}); - adeuteron_reg.add("histTofm2_cent", "mass^2 TOF (antid) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{antid}"}, centralityAxis}); - adeuteron_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (antid) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - adeuteron_reg.add("histTofNsigmaData_eta", "n-sigma TOF (antid) vs eta", HistType::kTH3F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - adeuteron_reg.add("histTofm2_eta", "mass^2 TOF (antid) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + adeuteron_reg.add("histKeepEventData", "skimming histogram (#bar{d})", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + adeuteron_reg.add("histTpcSignalData", "Specific energy loss (#bar{d})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + adeuteron_reg.add("histTofSignalData", "TOF signal (#bar{d})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + adeuteron_reg.add("histDcaVsPtData", "dcaXY vs Pt (#bar{d})", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + adeuteron_reg.add("histDcaZVsPtData", "dcaZ vs Pt (#bar{d})", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + adeuteron_reg.add("histTOFm2", "TOF m^2 vs Pt (#bar{d})", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + adeuteron_reg.add("histTpcNsigmaData", "n-sigma TPC (#bar{d})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{d}}"}}); + adeuteron_reg.add("histTofNsigmaData", "n-sigma TOF (#bar{d})", HistType::kTH2F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{#bar{d}}"}}); + adeuteron_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (#bar{d})", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + adeuteron_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (#bar{d})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + adeuteron_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (#bar{d})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + adeuteron_reg.add("histChi2TPC", "chi^2 TPC vs Pt (#bar{d})", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + adeuteron_reg.add("histChi2ITS", "chi^2 ITS vs Pt (#bar{d})", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + adeuteron_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (#bar{d}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{d}}"}, centralityAxis}); + adeuteron_reg.add("histTofNsigmaData_cent", "n-sigma TOF (#bar{d}) centrality", HistType::kTH3F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{#bar{d}}"}, centralityAxis}); + adeuteron_reg.add("histTofm2_cent", "mass^2 TOF (#bar{d}) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#bar{d}}"}, centralityAxis}); + adeuteron_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (#bar{d}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{d}}"}, etaAxis}); + adeuteron_reg.add("histTofNsigmaData_eta", "n-sigma TOF (#bar{d}) vs eta", HistType::kTH3F, {ptAxis_reduced, {160, -20., +20., "n#sigma_{#bar{d}}"}, etaAxis}); + adeuteron_reg.add("histTofm2_eta", "mass^2 TOF (#bar{d}) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#bar{d}}"}, etaAxis}); // histograms for Triton triton_reg.add("histKeepEventData", "skimming histogram (t)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); @@ -203,114 +249,114 @@ struct NucleiHistTask { triton_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (t) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}, centralityAxis}); triton_reg.add("histTofNsigmaData_cent", "n-sigma TOF (t) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}, centralityAxis}); triton_reg.add("histTofm2_cent", "mass^2 TOF (t) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{t}"}, centralityAxis}); - triton_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (t) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - triton_reg.add("histTofNsigmaData_eta", "n-sigma TOF (t) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - triton_reg.add("histTofm2_eta", "mass^2 TOF (t) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + triton_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (t) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}, etaAxis}); + triton_reg.add("histTofNsigmaData_eta", "n-sigma TOF (t) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}, etaAxis}); + triton_reg.add("histTofm2_eta", "mass^2 TOF (t) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{t}"}, etaAxis}); // histograms for antiTriton - atriton_reg.add("histKeepEventData", "skimming histogram (antit)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); - atriton_reg.add("histTpcSignalData", "Specific energy loss (antit)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); - atriton_reg.add("histTofSignalData", "TOF signal (antit)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); - atriton_reg.add("histDcaVsPtData", "dcaXY vs Pt (antit)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); - atriton_reg.add("histDcaZVsPtData", "dcaZ vs Pt (antit)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); - atriton_reg.add("histTOFm2", "TOF m^2 vs Pt (antit)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); - atriton_reg.add("histTpcNsigmaData", "n-sigma TPC (antit)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antit}"}}); - atriton_reg.add("histTofNsigmaData", "n-sigma TOF (antit)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antit}"}}); - atriton_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (antit)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); - atriton_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (antit)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - atriton_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (antit)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - atriton_reg.add("histChi2TPC", "chi^2 TPC vs Pt (antit)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); - atriton_reg.add("histChi2ITS", "chi^2 ITS vs Pt (antit)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); - atriton_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (antit) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antit}"}, centralityAxis}); - atriton_reg.add("histTofNsigmaData_cent", "n-sigma TOF (antit) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antit}"}, centralityAxis}); - atriton_reg.add("histTofm2_cent", "mass^2 TOF (antit) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{antit}"}, centralityAxis}); - atriton_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (antit) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - atriton_reg.add("histTofNsigmaData_eta", "n-sigma TOF (antit) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - atriton_reg.add("histTofm2_eta", "mass^2 TOF (antit) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + atriton_reg.add("histKeepEventData", "skimming histogram (#bar{t})", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + atriton_reg.add("histTpcSignalData", "Specific energy loss (#bar{t})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + atriton_reg.add("histTofSignalData", "TOF signal (#bar{t})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + atriton_reg.add("histDcaVsPtData", "dcaXY vs Pt (#bar{t})", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + atriton_reg.add("histDcaZVsPtData", "dcaZ vs Pt (#bar{t})", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + atriton_reg.add("histTOFm2", "TOF m^2 vs Pt (#bar{t})", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + atriton_reg.add("histTpcNsigmaData", "n-sigma TPC (#bar{t})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{t}}"}}); + atriton_reg.add("histTofNsigmaData", "n-sigma TOF (#bar{t})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{t}}"}}); + atriton_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (#bar{t})", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + atriton_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (#bar{t})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + atriton_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (#bar{t})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + atriton_reg.add("histChi2TPC", "chi^2 TPC vs Pt (#bar{t})", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + atriton_reg.add("histChi2ITS", "chi^2 ITS vs Pt (#bar{t})", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + atriton_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (#bar{t}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{t}}"}, centralityAxis}); + atriton_reg.add("histTofNsigmaData_cent", "n-sigma TOF (#bar{t}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{t}}"}, centralityAxis}); + atriton_reg.add("histTofm2_cent", "mass^2 TOF (#bar{t}) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#bar{t}}"}, centralityAxis}); + atriton_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (#bar{t}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{t}}"}, etaAxis}); + atriton_reg.add("histTofNsigmaData_eta", "n-sigma TOF (#bar{t}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{#bar{t}}"}, etaAxis}); + atriton_reg.add("histTofm2_eta", "mass^2 TOF (#bar{t}) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{#bar{t}}"}, etaAxis}); // histograms for Helium-3 - Helium3_reg.add("histKeepEventData", "skimming histogram (He-3)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); - Helium3_reg.add("histTpcSignalData", "Specific energy loss (He-3)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); - Helium3_reg.add("histTofSignalData", "TOF signal (He-3)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); - Helium3_reg.add("histDcaVsPtData", "dcaXY vs Pt (He-3)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); - Helium3_reg.add("histDcaZVsPtData", "dcaZ vs Pt (He-3)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); - Helium3_reg.add("histTOFm2", "TOF m^2 vs Pt (He-3)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); - Helium3_reg.add("histTpcNsigmaData", "n-sigma TPC (He-3)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}}); - Helium3_reg.add("histTofNsigmaData", "n-sigma TOF (He-3)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}}); - Helium3_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (He-3)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); - Helium3_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (He-3)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - Helium3_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (He-3)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - Helium3_reg.add("histChi2TPC", "chi^2 TPC vs Pt (He-3)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); - Helium3_reg.add("histChi2ITS", "chi^2 ITS vs Pt (He-3)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); - Helium3_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (He-3) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}, centralityAxis}); - Helium3_reg.add("histTofNsigmaData_cent", "n-sigma TOF (He-3) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}, centralityAxis}); - Helium3_reg.add("histTofm2_cent", "mass^2 TOF (He-3) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{He-3}"}, centralityAxis}); - Helium3_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (He-3) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - Helium3_reg.add("histTofNsigmaData_eta", "n-sigma TOF (He-3) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - Helium3_reg.add("histTofm2_eta", "mass^2 TOF (He-3) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + Helium3_reg.add("histKeepEventData", "skimming histogram (^{3}He)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + Helium3_reg.add("histTpcSignalData", "Specific energy loss (^{3}He)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + Helium3_reg.add("histTofSignalData", "TOF signal (^{3}He)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + Helium3_reg.add("histDcaVsPtData", "dcaXY vs Pt (^{3}He)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + Helium3_reg.add("histDcaZVsPtData", "dcaZ vs Pt (^{3}He)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + Helium3_reg.add("histTOFm2", "TOF m^2 vs Pt (^{3}He)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + Helium3_reg.add("histTpcNsigmaData", "n-sigma TPC (^{3}He)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}}); + Helium3_reg.add("histTofNsigmaData", "n-sigma TOF (^{3}He)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}}); + Helium3_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (^{3}He)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + Helium3_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (^{3}He)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + Helium3_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (^{3}He)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + Helium3_reg.add("histChi2TPC", "chi^2 TPC vs Pt (^{3}He)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + Helium3_reg.add("histChi2ITS", "chi^2 ITS vs Pt (^{3}He)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + Helium3_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (^{3}He) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}, centralityAxis}); + Helium3_reg.add("histTofNsigmaData_cent", "n-sigma TOF (^{3}He) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}, centralityAxis}); + Helium3_reg.add("histTofm2_cent", "mass^2 TOF (^{3}He) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{^{3}He}"}, centralityAxis}); + Helium3_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (^{3}He) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}, etaAxis}); + Helium3_reg.add("histTofNsigmaData_eta", "n-sigma TOF (^{3}He) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}, etaAxis}); + Helium3_reg.add("histTofm2_eta", "mass^2 TOF (^{3}He) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{^{3}He}"}, etaAxis}); // histograms for antiHelium-3 - aHelium3_reg.add("histKeepEventData", "skimming histogram (antiHe-3)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); - aHelium3_reg.add("histTpcSignalData", "Specific energy loss (antiHe-3)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); - aHelium3_reg.add("histTofSignalData", "TOF signal (antiHe-3)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); - aHelium3_reg.add("histDcaVsPtData", "dcaXY vs Pt (antiHe-3)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); - aHelium3_reg.add("histDcaZVsPtData", "dcaZ vs Pt (antiHe-3)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); - aHelium3_reg.add("histTOFm2", "TOF m^2 vs Pt (antiHe-3)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); - aHelium3_reg.add("histTpcNsigmaData", "n-sigma TPC (antiHe-3)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-3}"}}); - aHelium3_reg.add("histTofNsigmaData", "n-sigma TOF (antiHe-3)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-3}"}}); - aHelium3_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (antiHe-3)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); - aHelium3_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (antiHe-3)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - aHelium3_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (antiHe-3)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - aHelium3_reg.add("histChi2TPC", "chi^2 TPC vs Pt (antiHe-3)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); - aHelium3_reg.add("histChi2ITS", "chi^2 ITS vs Pt (antiHe-3)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); - aHelium3_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (antiHe-3) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-3}"}, centralityAxis}); - aHelium3_reg.add("histTofNsigmaData_cent", "n-sigma TOF (antiHe-3) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-3}"}, centralityAxis}); - aHelium3_reg.add("histTofm2_cent", "mass^2 TOF (antiHe-3) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{antiHe-3}"}, centralityAxis}); - aHelium3_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (antiHe-3) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - aHelium3_reg.add("histTofNsigmaData_eta", "n-sigma TOF (antiHe-3) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - aHelium3_reg.add("histTofm2_eta", "mass^2 TOF (antiHe-3) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + aHelium3_reg.add("histKeepEventData", "skimming histogram (^{3}#bar{He})", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + aHelium3_reg.add("histTpcSignalData", "Specific energy loss (^{3}#bar{He})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + aHelium3_reg.add("histTofSignalData", "TOF signal (^{3}#bar{He})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + aHelium3_reg.add("histDcaVsPtData", "dcaXY vs Pt (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + aHelium3_reg.add("histDcaZVsPtData", "dcaZ vs Pt (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + aHelium3_reg.add("histTOFm2", "TOF m^2 vs Pt (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + aHelium3_reg.add("histTpcNsigmaData", "n-sigma TPC (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}}); + aHelium3_reg.add("histTofNsigmaData", "n-sigma TOF (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}}); + aHelium3_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + aHelium3_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + aHelium3_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + aHelium3_reg.add("histChi2TPC", "chi^2 TPC vs Pt (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + aHelium3_reg.add("histChi2ITS", "chi^2 ITS vs Pt (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + aHelium3_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (^{3}#bar{He}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}, centralityAxis}); + aHelium3_reg.add("histTofNsigmaData_cent", "n-sigma TOF (^{3}#bar{He}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}, centralityAxis}); + aHelium3_reg.add("histTofm2_cent", "mass^2 TOF (^{3}#bar{He}) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{^{3}He}"}, centralityAxis}); + aHelium3_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (^{3}#bar{He}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}, etaAxis}); + aHelium3_reg.add("histTofNsigmaData_eta", "n-sigma TOF (^{3}#bar{He}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}, etaAxis}); + aHelium3_reg.add("histTofm2_eta", "mass^2 TOF (^{3}#bar{He}) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{^{3}He}"}, etaAxis}); // histograms for Helium-4 (alpha) - Helium4_reg.add("histKeepEventData", "skimming histogram (He-4)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); - Helium4_reg.add("histTpcSignalData", "Specific energy loss (He-4)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); - Helium4_reg.add("histTofSignalData", "TOF signal (He-4)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); - Helium4_reg.add("histDcaVsPtData", "dcaXY vs Pt (He-4)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); - Helium4_reg.add("histDcaZVsPtData", "dcaZ vs Pt (He-4)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); - Helium4_reg.add("histTOFm2", "TOF m^2 vs Pt (He-4)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); - Helium4_reg.add("histTpcNsigmaData", "n-sigma TPC (He-4)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}}); - Helium4_reg.add("histTofNsigmaData", "n-sigma TOF (He-4)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}}); - Helium4_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (He-4)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); - Helium4_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (He-4)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - Helium4_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (He-4)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - Helium4_reg.add("histChi2TPC", "chi^2 TPC vs Pt (He-4)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); - Helium4_reg.add("histChi2ITS", "chi^2 ITS vs Pt (He-4)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); - Helium4_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (He-4) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}, centralityAxis}); - Helium4_reg.add("histTofNsigmaData_cent", "n-sigma TOF (He-4) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}, centralityAxis}); - Helium4_reg.add("histTofm2_cent", "mass^2 TOF (He-4) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{He-4}"}, centralityAxis}); - Helium4_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (He-4) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - Helium4_reg.add("histTofNsigmaData_eta", "n-sigma TOF (He-4) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - Helium4_reg.add("histTofm2_eta", "mass^2 TOF (He-4) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + Helium4_reg.add("histKeepEventData", "skimming histogram (^{4}He)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + Helium4_reg.add("histTpcSignalData", "Specific energy loss (^{4}He)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + Helium4_reg.add("histTofSignalData", "TOF signal (^{4}He)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + Helium4_reg.add("histDcaVsPtData", "dcaXY vs Pt (^{4}He)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + Helium4_reg.add("histDcaZVsPtData", "dcaZ vs Pt (^{4}He)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + Helium4_reg.add("histTOFm2", "TOF m^2 vs Pt (^{4}He)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + Helium4_reg.add("histTpcNsigmaData", "n-sigma TPC (^{4}He)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{4}He}"}}); + Helium4_reg.add("histTofNsigmaData", "n-sigma TOF (^{4}He)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{4}He}"}}); + Helium4_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (^{4}He)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + Helium4_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (^{4}He)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + Helium4_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (^{4}He)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + Helium4_reg.add("histChi2TPC", "chi^2 TPC vs Pt (^{4}He)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + Helium4_reg.add("histChi2ITS", "chi^2 ITS vs Pt (^{4}He)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + Helium4_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (^{4}He) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{4}He}"}, centralityAxis}); + Helium4_reg.add("histTofNsigmaData_cent", "n-sigma TOF (^{4}He) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{4}He}"}, centralityAxis}); + Helium4_reg.add("histTofm2_cent", "mass^2 TOF (^{4}He) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{^{4}He}"}, centralityAxis}); + Helium4_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (^{4}He) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{4}He}"}, etaAxis}); + Helium4_reg.add("histTofNsigmaData_eta", "n-sigma TOF (^{4}He) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{^{4}He}"}, etaAxis}); + Helium4_reg.add("histTofm2_eta", "mass^2 TOF (^{4}He) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{^{4}He}"}, etaAxis}); // histograms for antiHelium-4 (alpha) - aHelium4_reg.add("histKeepEventData", "skimming histogram (antiHe-4)", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); - aHelium4_reg.add("histTpcSignalData", "Specific energy loss (antiHe-4)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); - aHelium4_reg.add("histTofSignalData", "TOF signal (antiHe-4)", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); - aHelium4_reg.add("histDcaVsPtData", "dcaXY vs Pt (antiHe-4)", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); - aHelium4_reg.add("histDcaZVsPtData", "dcaZ vs Pt (antiHe-4)", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); - aHelium4_reg.add("histTOFm2", "TOF m^2 vs Pt (antiHe-4)", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); - aHelium4_reg.add("histTpcNsigmaData", "n-sigma TPC (antiHe-4)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-4}"}}); - aHelium4_reg.add("histTofNsigmaData", "n-sigma TOF (antiHe-4)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-4}"}}); - aHelium4_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (antiHe-4)", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); - aHelium4_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (antiHe-4)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - aHelium4_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (antiHe-4)", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); - aHelium4_reg.add("histChi2TPC", "chi^2 TPC vs Pt (antiHe-4)", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); - aHelium4_reg.add("histChi2ITS", "chi^2 ITS vs Pt (antiHe-4)", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); - aHelium4_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (antiHe-4) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-4}"}, centralityAxis}); - aHelium4_reg.add("histTofNsigmaData_cent", "n-sigma TOF (antiHe-4) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-4}"}, centralityAxis}); - aHelium4_reg.add("histTofm2_cent", "mass^2 TOF (antiHe-4) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{antiHe-4}"}, centralityAxis}); - aHelium4_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (antiHe-4) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - aHelium4_reg.add("histTofNsigmaData_eta", "n-sigma TOF (antiHe-4) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); - aHelium4_reg.add("histTofm2_eta", "mass^2 TOF (antiHe-4) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); + aHelium4_reg.add("histKeepEventData", "skimming histogram (^{4}#bar{He})", HistType::kTH1F, {{2, -0.5, +1.5, "true: keep event, false: reject event"}}); + aHelium4_reg.add("histTpcSignalData", "Specific energy loss (^{4}#bar{He})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {5000, 0, 5000, "d#it{E} / d#it{X} (a. u.)"}}); + aHelium4_reg.add("histTofSignalData", "TOF signal (^{4}#bar{He})", HistType::kTH2F, {{600, 0., 6., "#it{p} (GeV/#it{c})"}, {550, 0.0, 1.1, "#beta (TOF)"}}); + aHelium4_reg.add("histDcaVsPtData", "dcaXY vs Pt (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {250, -0.5, 0.5, "dca"}}); + aHelium4_reg.add("histDcaZVsPtData", "dcaZ vs Pt (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {1000, -2.0, 2.0, "dca"}}); + aHelium4_reg.add("histTOFm2", "TOF m^2 vs Pt (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {400, 0.0, 10.0, "m^2"}}); + aHelium4_reg.add("histTpcNsigmaData", "n-sigma TPC (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-4}"}}); + aHelium4_reg.add("histTofNsigmaData", "n-sigma TOF (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-4}"}}); + aHelium4_reg.add("histNClusterTPC", "Number of Clusters in TPC vs Pt (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {160, 0.0, 160.0, "nCluster"}}); + aHelium4_reg.add("histNClusterITS", "Number of Clusters in ITS vs Pt (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + aHelium4_reg.add("histNClusterITSib", "Number of Clusters in ib of ITS vs Pt (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {10, 0.0, 10.0, "nCluster"}}); + aHelium4_reg.add("histChi2TPC", "chi^2 TPC vs Pt (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {100, 0.0, 5.0, "chi^2"}}); + aHelium4_reg.add("histChi2ITS", "chi^2 ITS vs Pt (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {500, 0.0, 50.0, "chi^2"}}); + aHelium4_reg.add("histTpcNsigmaData_cent", "n-sigma TPC (^{4}#bar{He}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-4}"}, centralityAxis}); + aHelium4_reg.add("histTofNsigmaData_cent", "n-sigma TOF (^{4}#bar{He}) centrality", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{antiHe-4}"}, centralityAxis}); + aHelium4_reg.add("histTofm2_cent", "mass^2 TOF (^{4}#bar{He}) centrality", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{antiHe-4}"}, centralityAxis}); + aHelium4_reg.add("histTpcNsigmaData_eta", "n-sigma TPC (^{4}#bar{He}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); + aHelium4_reg.add("histTofNsigmaData_eta", "n-sigma TOF (^{4}#bar{He}) vs eta", HistType::kTH3F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}, etaAxis}); + aHelium4_reg.add("histTofm2_eta", "mass^2 TOF (^{4}#bar{He}) vs eta", HistType::kTH3F, {ptAxis, {400, 0.0, 10.0, "m^2_{p}"}, etaAxis}); // +++++++++++++++++++++ MC ++++++++++++++++++++++++++ @@ -319,6 +365,7 @@ struct NucleiHistTask { MC_truth_reg.add("histEta", "#eta", HistType::kTH2F, {{102, -2.01, 2.01}, PDGBINNING}); MC_truth_reg.add("histPt", "p_{t}", HistType::kTH2F, {ptAxis, PDGBINNING}); MC_truth_reg.add("histRecVtxMC", "MC collision z position", HistType::kTH1F, {{400, -40., +40., "z position (cm)"}}); + MC_truth_reg.add("histCentrality", "Centrality", HistType::kTH1F, {centralityAxis_extended}); // MC reconstructed MC_recon_reg.add("histPhi", "#phi", HistType::kTH2F, {{100, 0., 2. * TMath::Pi()}, PDGBINNING}); @@ -346,31 +393,68 @@ struct NucleiHistTask { MC_recon_reg.add("histChi2TOF", "chi^2 TOF vs Pt", HistType::kTH3F, {ptAxis, {75, 0.0, 15.0, "chi^2"}, PDGBINNING}); MC_recon_reg.add("histTrackLength", "Track length", HistType::kTH2F, {{350, 0., 700., "length (cm)"}, PDGBINNING}); MC_recon_reg.add("histTPCFractionSharedCls", "Fraction of shared TPC clusters", HistType::kTH2F, {{100, -2.0, 2.0, "Shared Cls"}, PDGBINNING}); + MC_recon_reg.add("histTpcNsigmaDataPi", "TPC nSigma (#pi^{+})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}}); + MC_recon_reg.add("histTpcNsigmaDataaPi", "TPC nSigma (#pi^{-})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}}); MC_recon_reg.add("histTpcNsigmaDataPr", "TPC nSigma (p)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}}); - MC_recon_reg.add("histTpcNsigmaDataaPr", "TPC nSigma (antip)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}}); + MC_recon_reg.add("histTpcNsigmaDataaPr", "TPC nSigma (#bar{p})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}}); MC_recon_reg.add("histTpcNsigmaDataDe", "TPC nSigma (d)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{d}"}}); - MC_recon_reg.add("histTpcNsigmaDataaDe", "TPC nSigma (antid)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{d}"}}); + MC_recon_reg.add("histTpcNsigmaDataaDe", "TPC nSigma (#bar{d})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{d}"}}); MC_recon_reg.add("histTpcNsigmaDataTr", "TPC nSigma (t)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}}); - MC_recon_reg.add("histTpcNsigmaDataaTr", "TPC nSigma (antit)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}}); - MC_recon_reg.add("histTpcNsigmaDataHe", "TPC nSigma (He-3)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}}); - MC_recon_reg.add("histTpcNsigmaDataaHe", "TPC nSigma (antiHe-3)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}}); - MC_recon_reg.add("histTpcNsigmaDataAl", "TPC nSigma (He-4)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}}); - MC_recon_reg.add("histTpcNsigmaDataaAl", "TPC nSigma (antiHe-4)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}}); + MC_recon_reg.add("histTpcNsigmaDataaTr", "TPC nSigma (#bar{t})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}}); + MC_recon_reg.add("histTpcNsigmaDataHe", "TPC nSigma (^{3}He)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}}); + MC_recon_reg.add("histTpcNsigmaDataaHe", "TPC nSigma (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}}); + MC_recon_reg.add("histTpcNsigmaDataAl", "TPC nSigma (^{4}He)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}}); + MC_recon_reg.add("histTpcNsigmaDataaAl", "TPC nSigma (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}}); + MC_recon_reg.add("histTofNsigmaDataPi", "TOF nSigma (#pi^{+})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}}); + MC_recon_reg.add("histTofNsigmaDataaPi", "TOF nSigma (#pi^{-})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{#pi^{+}}"}}); MC_recon_reg.add("histTofNsigmaDataPr", "TOF nSigma (p)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}}); - MC_recon_reg.add("histTofNsigmaDataaPr", "TOF nSigma (antip)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}}); + MC_recon_reg.add("histTofNsigmaDataaPr", "TOF nSigma (#bar{p})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{p}"}}); MC_recon_reg.add("histTofNsigmaDataDe", "TOF nSigma (d)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{d}"}}); - MC_recon_reg.add("histTofNsigmaDataaDe", "TOF nSigma (antid)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{d}"}}); + MC_recon_reg.add("histTofNsigmaDataaDe", "TOF nSigma (#bar{d})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{d}"}}); MC_recon_reg.add("histTofNsigmaDataTr", "TOF nSigma (t)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}}); - MC_recon_reg.add("histTofNsigmaDataaTr", "TOF nSigma (antit)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}}); - MC_recon_reg.add("histTofNsigmaDataHe", "TOF nSigma (He-3)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}}); - MC_recon_reg.add("histTofNsigmaDataaHe", "TOF nSigma (antiHe-3)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-3}"}}); - MC_recon_reg.add("histTofNsigmaDataAl", "TOF nSigma (He-4)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}}); - MC_recon_reg.add("histTofNsigmaDataaAl", "TOF nSigma (antiHe-4)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{He-4}"}}); + MC_recon_reg.add("histTofNsigmaDataaTr", "TOF nSigma (#bar{t})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{t}"}}); + MC_recon_reg.add("histTofNsigmaDataHe", "TOF nSigma (^{3}He)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}}); + MC_recon_reg.add("histTofNsigmaDataaHe", "TOF nSigma (^{3}#bar{He})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{3}He}"}}); + MC_recon_reg.add("histTofNsigmaDataAl", "TOF nSigma (^{4}He)", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{4}He}"}}); + MC_recon_reg.add("histTofNsigmaDataaAl", "TOF nSigma (^{4}#bar{He})", HistType::kTH2F, {ptAxis, {160, -20., +20., "n#sigma_{^{4}He}"}}); // MC diff (truth - reconstructed) MC_recon_diff_reg.add("histPhiDiff", "MC t", HistType::kTH2F, {ptAxis_diff, PDGBINNING}); MC_recon_diff_reg.add("histEtaDiff", "MC t", HistType::kTH2F, {ptAxis_diff, PDGBINNING}); MC_recon_diff_reg.add("histPtDiff", "MC t", HistType::kTH2F, {ptAxis_diff, PDGBINNING}); + + // MC efficencies + MC_eff.add("histEffSkimming", "Efficiency skimming", HistType::kTH2F, {{10, 0.0, 10.0}, PDGBINNING}); + MC_eff.add("histITS_vs_pT", "ITS pT distribution", HistType::kTH2F, {ptAxis, PDGBINNING}); + MC_eff.add("histITS_TPC_vs_pT", "ITS_TPC pT distribution", HistType::kTH2F, {ptAxis, PDGBINNING}); + MC_eff.add("histITS_TPC_TOFvs_pT", "ITS_TPC_TOF pT distribution", HistType::kTH2F, {ptAxis, PDGBINNING}); + + MC_eff.add("histPt_TPC_Pi", "#pi^{+} reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_aPi", "#pi^{-} reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_Pr", "p reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_aPr", "#bar{p} reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_De", "d reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_aDe", "#bar{d} reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_Tr", "t reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_aTr", "#bar{t} reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_He3", "^{3}He reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_aHe3", "^{3}#bar{He} reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_He4", "^{4}He reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TPC_aHe4", "^{4}#bar{He} reconstructed p_{T} TPC", HistType::kTH1F, {ptAxis}); + + MC_eff.add("histPt_TOF_Pi", "#pi^{+} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_aPi", "#pi^{-} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_Pr", "p reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_aPr", "#bar{p} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_De", "d reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_aDe", "#bar{d} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_Tr", "t reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_aTr", "#bar{t} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_He3", "^{3}He reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_aHe3", "^{3}#bar{He} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_He4", "^{4}He reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + MC_eff.add("histPt_TOF_aHe4", "^{4}#bar{He} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); + } // Configurables @@ -403,6 +487,8 @@ struct NucleiHistTask { Configurable event_selection_sel8{"event_selection_sel8", true, "Enable sel8 event selection"}; Configurable enable_PVcontributor_global{"enable_PVcontributor_global", true, "is PV contributor (global)"}; + Configurable enable_PVcontributor_pion{"enable_PVcontributor_pion", true, "is PV contributor (global)"}; + Configurable enable_PVcontributor_antipion{"enable_PVcontributor_antipion", true, "is PV contributor (global)"}; Configurable enable_PVcontributor_proton{"enable_PVcontributor_proton", true, "is PV contributor (global)"}; Configurable enable_PVcontributor_antiproton{"enable_PVcontributor_antiproton", true, "is PV contributor (global)"}; Configurable enable_PVcontributor_deuteron{"enable_PVcontributor_deuteron", true, "is PV contributor (global)"}; @@ -419,12 +505,14 @@ struct NucleiHistTask { { // collision process loop + bool keepEvent_pi = kFALSE; bool keepEvent_p = kFALSE; bool keepEvent_d = kFALSE; bool keepEvent_t = kFALSE; bool keepEvent_He3 = kFALSE; bool keepEvent_He4 = kFALSE; + bool keepEvent_antipi = kFALSE; bool keepEvent_antip = kFALSE; bool keepEvent_antid = kFALSE; bool keepEvent_antit = kFALSE; @@ -468,27 +556,28 @@ struct NucleiHistTask { if (TPCnumberClsFound < minTPCnClsFound || TPC_nCls_Crossed_Rows < minNCrossedRowsTPC || RatioCrossedRowsOverFindableTPC < minRatioCrossedRowsTPC || RatioCrossedRowsOverFindableTPC > maxRatioCrossedRowsTPC || Chi2perClusterTPC > maxChi2TPC || Chi2perClusterITS > maxChi2ITS || !(track.passedTPCRefit()) || !(track.passedITSRefit()) || (track.itsNClsInnerBarrel()) < minReqClusterITSib || (track.itsNCls()) < minReqClusterITS) { continue; } + if (enable_PVcontributor_global && !(track.isPVContributor())) { continue; } - if (TMath::Abs(track.dcaXY()) > maxDCA_XY || TMath::Abs(track.dcaZ()) > maxDCA_Z) { - continue; - } // cut on rapidity + TLorentzVector lorentzVector_pion{}; TLorentzVector lorentzVector_proton{}; TLorentzVector lorentzVector_deuteron{}; TLorentzVector lorentzVector_triton{}; TLorentzVector lorentzVector_He3{}; TLorentzVector lorentzVector_He4{}; + lorentzVector_pion.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassPiPlus); lorentzVector_proton.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassProton); lorentzVector_deuteron.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassDeuteron); lorentzVector_triton.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassTriton); lorentzVector_He3.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassHelium3); lorentzVector_He4.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassAlpha); - if (lorentzVector_proton.Rapidity() < yMin || lorentzVector_proton.Rapidity() > yMax || + if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || + lorentzVector_proton.Rapidity() < yMin || lorentzVector_proton.Rapidity() > yMax || lorentzVector_deuteron.Rapidity() < yMin || lorentzVector_deuteron.Rapidity() > yMax || lorentzVector_triton.Rapidity() < yMin || lorentzVector_triton.Rapidity() > yMax || lorentzVector_He3.Rapidity() < yMin || lorentzVector_He3.Rapidity() > yMax || @@ -497,6 +586,7 @@ struct NucleiHistTask { } // fill QA histograms + float nSigmaPion = track.tpcNSigmaPi(); float nSigmaProton = track.tpcNSigmaPr(); float nSigmaDeut = track.tpcNSigmaDe(); float nSigmaTriton = track.tpcNSigmaTr(); @@ -511,6 +601,7 @@ struct NucleiHistTask { spectra_reg.fill(HIST("histChi2ITS"), track.pt(), track.itsChi2NCl()); if (track.sign() > 0) { + pion_reg.fill(HIST("histTpcNsigmaData"), track.pt(), nSigmaPion); proton_reg.fill(HIST("histTpcNsigmaData"), track.pt(), nSigmaProton); deuteron_reg.fill(HIST("histTpcNsigmaData"), track.pt(), nSigmaDeut); triton_reg.fill(HIST("histTpcNsigmaData"), track.pt(), nSigmaTriton); @@ -540,6 +631,7 @@ struct NucleiHistTask { } if (track.sign() < 0) { + apion_reg.fill(HIST("histTpcNsigmaData"), track.pt(), nSigmaPion); aproton_reg.fill(HIST("histTpcNsigmaData"), track.pt(), nSigmaProton); adeuteron_reg.fill(HIST("histTpcNsigmaData"), track.pt(), nSigmaDeut); atriton_reg.fill(HIST("histTpcNsigmaData"), track.pt(), nSigmaTriton); @@ -568,6 +660,109 @@ struct NucleiHistTask { } } + //************** check offline-trigger (skimming) condidition Pion ******************* + + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) { + + if (enable_PVcontributor_pion && !(track.isPVContributor())) { + continue; + } + + if (track.sign() > 0) { + keepEvent_pi = kTRUE; + + pion_reg.fill(HIST("histDcaVsPtData"), track.pt(), track.dcaXY()); + pion_reg.fill(HIST("histDcaZVsPtData"), track.pt(), track.dcaZ()); + pion_reg.fill(HIST("histTpcSignalData"), track.pt(), track.tpcSignal()); + pion_reg.fill(HIST("histNClusterTPC"), track.pt(), track.tpcNClsFound()); + pion_reg.fill(HIST("histNClusterITS"), track.pt(), track.itsNCls()); + pion_reg.fill(HIST("histNClusterITSib"), track.pt(), track.itsNClsInnerBarrel()); + pion_reg.fill(HIST("histChi2TPC"), track.pt(), track.tpcChi2NCl()); + pion_reg.fill(HIST("histChi2ITS"), track.pt(), track.itsChi2NCl()); + + if (track.hasTOF()) { + + if (track.hasTRD() && (lastRequiredTrdCluster > 0)) { + int lastLayer = 0; + for (int l = 7; l >= 0; l--) { + if (track.trdPattern() & (1 << l)) { + lastLayer = l; + break; + } + } + if (lastLayer < lastRequiredTrdCluster) { + continue; + } + } + + Float_t TOFmass2 = ((track.mass()) * (track.mass())); + Float_t beta = track.beta(); + + pion_reg.fill(HIST("histTOFm2"), track.pt(), TOFmass2); + pion_reg.fill(HIST("histTofSignalData"), track.pt(), beta); + pion_reg.fill(HIST("histTofNsigmaData"), track.pt(), track.tofNSigmaPi()); + } + } + + if (enable_PVcontributor_antipion && !(track.isPVContributor())) { + continue; + } + + if (track.sign() < 0) { + keepEvent_antipi = kTRUE; + + apion_reg.fill(HIST("histDcaVsPtData"), track.pt(), track.dcaXY()); + apion_reg.fill(HIST("histDcaZVsPtData"), track.pt(), track.dcaZ()); + apion_reg.fill(HIST("histTpcSignalData"), track.pt(), track.tpcSignal()); + apion_reg.fill(HIST("histNClusterTPC"), track.pt(), track.tpcNClsFound()); + apion_reg.fill(HIST("histNClusterITS"), track.pt(), track.itsNCls()); + apion_reg.fill(HIST("histNClusterITSib"), track.pt(), track.itsNClsInnerBarrel()); + apion_reg.fill(HIST("histChi2TPC"), track.pt(), track.tpcChi2NCl()); + apion_reg.fill(HIST("histChi2ITS"), track.pt(), track.itsChi2NCl()); + + if (track.hasTOF()) { + + if (track.hasTRD() && (lastRequiredTrdCluster > 0)) { + int lastLayer = 0; + for (int l = 7; l >= 0; l--) { + if (track.trdPattern() & (1 << l)) { + lastLayer = l; + break; + } + } + if (lastLayer < lastRequiredTrdCluster) { + continue; + } + } + + Float_t TOFmass2 = ((track.mass()) * (track.mass())); + Float_t beta = track.beta(); + + apion_reg.fill(HIST("histTOFm2"), track.pt(), TOFmass2); + apion_reg.fill(HIST("histTofSignalData"), track.pt(), beta); + apion_reg.fill(HIST("histTofNsigmaData"), track.pt(), track.tofNSigmaPi()); + } + } + + if (track.hasTOF()) { + + if (track.hasTRD() && (lastRequiredTrdCluster > 0)) { + int lastLayer = 0; + for (int l = 7; l >= 0; l--) { + if (track.trdPattern() & (1 << l)) { + lastLayer = l; + break; + } + } + if (lastLayer < lastRequiredTrdCluster) { + continue; + } + } + + spectra_reg.fill(HIST("histTofSignalData"), track.pt() * track.sign(), track.beta()); + } + } + //************** check offline-trigger (skimming) condidition Proton ******************* if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) { @@ -1084,6 +1279,8 @@ struct NucleiHistTask { } // end loop over tracks // fill trigger (skimming) results + pion_reg.fill(HIST("histKeepEventData"), keepEvent_pi); + apion_reg.fill(HIST("histKeepEventData"), keepEvent_antipi); proton_reg.fill(HIST("histKeepEventData"), keepEvent_p); aproton_reg.fill(HIST("histKeepEventData"), keepEvent_antip); deuteron_reg.fill(HIST("histKeepEventData"), keepEvent_d); @@ -1142,20 +1339,23 @@ struct NucleiHistTask { continue; } - // cut on rapidity +// cut on rapidity + TLorentzVector lorentzVector_pion{}; TLorentzVector lorentzVector_proton{}; TLorentzVector lorentzVector_deuteron{}; TLorentzVector lorentzVector_triton{}; TLorentzVector lorentzVector_He3{}; TLorentzVector lorentzVector_He4{}; + lorentzVector_pion.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassPiPlus); lorentzVector_proton.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassProton); lorentzVector_deuteron.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassDeuteron); lorentzVector_triton.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassTriton); lorentzVector_He3.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassHelium3); lorentzVector_He4.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassAlpha); - if (lorentzVector_proton.Rapidity() < yMin || lorentzVector_proton.Rapidity() > yMax || + if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || + lorentzVector_proton.Rapidity() < yMin || lorentzVector_proton.Rapidity() > yMax || lorentzVector_deuteron.Rapidity() < yMin || lorentzVector_deuteron.Rapidity() > yMax || lorentzVector_triton.Rapidity() < yMin || lorentzVector_triton.Rapidity() > yMax || lorentzVector_He3.Rapidity() < yMin || lorentzVector_He3.Rapidity() > yMax || @@ -1166,6 +1366,7 @@ struct NucleiHistTask { // fill 3D centrality histograms if (track.sign() > 0) { + pion_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt(), track.tpcNSigmaPi(), event.centFT0C()); proton_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt(), track.tpcNSigmaPr(), event.centFT0C()); deuteron_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt(), track.tpcNSigmaDe(), event.centFT0C()); triton_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt(), track.tpcNSigmaTr(), event.centFT0C()); @@ -1173,6 +1374,7 @@ struct NucleiHistTask { Helium4_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt() * 2.0, track.tpcNSigmaAl(), event.centFT0C()); if ((event.centFT0C() > minCentrality) && (event.centFT0C() < maxCentrality)) { + pion_reg.fill(HIST("histTpcNsigmaData_eta"), track.pt(), track.tpcNSigmaPi(), track.eta()); proton_reg.fill(HIST("histTpcNsigmaData_eta"), track.pt(), track.tpcNSigmaPr(), track.eta()); deuteron_reg.fill(HIST("histTpcNsigmaData_eta"), track.pt(), track.tpcNSigmaDe(), track.eta()); triton_reg.fill(HIST("histTpcNsigmaData_eta"), track.pt(), track.tpcNSigmaTr(), track.eta()); @@ -1194,12 +1396,14 @@ struct NucleiHistTask { } } + pion_reg.fill(HIST("histTofNsigmaData_cent"), track.pt(), track.tofNSigmaPi(), event.centFT0C()); proton_reg.fill(HIST("histTofNsigmaData_cent"), track.pt(), track.tofNSigmaPr(), event.centFT0C()); deuteron_reg.fill(HIST("histTofNsigmaData_cent"), track.pt(), track.tofNSigmaDe(), event.centFT0C()); triton_reg.fill(HIST("histTofNsigmaData_cent"), track.pt(), track.tofNSigmaTr(), event.centFT0C()); Helium3_reg.fill(HIST("histTofNsigmaData_cent"), track.pt() * 2.0, track.tofNSigmaHe(), event.centFT0C()); Helium4_reg.fill(HIST("histTofNsigmaData_cent"), track.pt() * 2.0, track.tofNSigmaAl(), event.centFT0C()); + pion_reg.fill(HIST("histTofm2_cent"), track.pt(), track.mass() * track.mass(), event.centFT0C()); proton_reg.fill(HIST("histTofm2_cent"), track.pt(), track.mass() * track.mass(), event.centFT0C()); deuteron_reg.fill(HIST("histTofm2_cent"), track.pt(), track.mass() * track.mass(), event.centFT0C()); triton_reg.fill(HIST("histTofm2_cent"), track.pt(), track.mass() * track.mass(), event.centFT0C()); @@ -1207,6 +1411,8 @@ struct NucleiHistTask { Helium4_reg.fill(HIST("histTofm2_cent"), track.pt() * 2.0, track.mass() * track.mass(), event.centFT0C()); if ((event.centFT0C() > minCentrality) && (event.centFT0C() < maxCentrality)) { + pion_reg.fill(HIST("histTofm2_eta"), track.pt(), track.mass() * track.mass(), track.eta()); + pion_reg.fill(HIST("histTofNsigmaData_eta"), track.pt(), track.tofNSigmaPi(), track.eta()); proton_reg.fill(HIST("histTofm2_eta"), track.pt(), track.mass() * track.mass(), track.eta()); proton_reg.fill(HIST("histTofNsigmaData_eta"), track.pt(), track.tofNSigmaPr(), track.eta()); deuteron_reg.fill(HIST("histTofm2_eta"), track.pt(), track.mass() * track.mass(), track.eta()); @@ -1223,6 +1429,7 @@ struct NucleiHistTask { if (track.sign() < 0) { + apion_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt(), track.tpcNSigmaPi(), event.centFT0C()); aproton_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt(), track.tpcNSigmaPr(), event.centFT0C()); adeuteron_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt(), track.tpcNSigmaDe(), event.centFT0C()); atriton_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt(), track.tpcNSigmaTr(), event.centFT0C()); @@ -1230,6 +1437,7 @@ struct NucleiHistTask { aHelium4_reg.fill(HIST("histTpcNsigmaData_cent"), track.pt() * 2.0, track.tpcNSigmaAl(), event.centFT0C()); if ((event.centFT0C() > minCentrality) && (event.centFT0C() < maxCentrality)) { + apion_reg.fill(HIST("histTpcNsigmaData_eta"), track.pt(), track.tpcNSigmaPi(), track.eta()); aproton_reg.fill(HIST("histTpcNsigmaData_eta"), track.pt(), track.tpcNSigmaPr(), track.eta()); adeuteron_reg.fill(HIST("histTpcNsigmaData_eta"), track.pt(), track.tpcNSigmaDe(), track.eta()); atriton_reg.fill(HIST("histTpcNsigmaData_eta"), track.pt(), track.tpcNSigmaTr(), track.eta()); @@ -1251,12 +1459,14 @@ struct NucleiHistTask { } } + apion_reg.fill(HIST("histTofNsigmaData_cent"), track.pt(), track.tofNSigmaPi(), event.centFT0C()); aproton_reg.fill(HIST("histTofNsigmaData_cent"), track.pt(), track.tofNSigmaPr(), event.centFT0C()); adeuteron_reg.fill(HIST("histTofNsigmaData_cent"), track.pt(), track.tofNSigmaDe(), event.centFT0C()); atriton_reg.fill(HIST("histTofNsigmaData_cent"), track.pt(), track.tofNSigmaTr(), event.centFT0C()); aHelium3_reg.fill(HIST("histTofNsigmaData_cent"), track.pt() * 2.0, track.tofNSigmaHe(), event.centFT0C()); aHelium4_reg.fill(HIST("histTofNsigmaData_cent"), track.pt() * 2.0, track.tofNSigmaAl(), event.centFT0C()); + apion_reg.fill(HIST("histTofm2_cent"), track.pt(), track.mass() * track.mass(), event.centFT0C()); aproton_reg.fill(HIST("histTofm2_cent"), track.pt(), track.mass() * track.mass(), event.centFT0C()); adeuteron_reg.fill(HIST("histTofm2_cent"), track.pt(), track.mass() * track.mass(), event.centFT0C()); atriton_reg.fill(HIST("histTofm2_cent"), track.pt(), track.mass() * track.mass(), event.centFT0C()); @@ -1264,6 +1474,8 @@ struct NucleiHistTask { aHelium4_reg.fill(HIST("histTofm2_cent"), track.pt() * 2.0, track.mass() * track.mass(), event.centFT0C()); if ((event.centFT0C() > minCentrality) && (event.centFT0C() < maxCentrality)) { + apion_reg.fill(HIST("histTofm2_eta"), track.pt(), track.mass() * track.mass(), track.eta()); + apion_reg.fill(HIST("histTofNsigmaData_eta"), track.pt(), track.tofNSigmaPi(), track.eta()); aproton_reg.fill(HIST("histTofm2_eta"), track.pt(), track.mass() * track.mass(), track.eta()); aproton_reg.fill(HIST("histTofNsigmaData_eta"), track.pt(), track.tofNSigmaPr(), track.eta()); adeuteron_reg.fill(HIST("histTofm2_eta"), track.pt(), track.mass() * track.mass(), track.eta()); @@ -1289,7 +1501,7 @@ struct NucleiHistTask { using EventCandidatesCent = soa::Filtered>; - using TrackCandidates = soa::Filtered>; + using TrackCandidates = soa::Filtered>; void processData(EventCandidates::iterator const& event, TrackCandidates const& tracks) { @@ -1304,18 +1516,18 @@ struct NucleiHistTask { } PROCESS_SWITCH(NucleiHistTask, processDataCent, "process data with centralities", false); - void processMC(soa::Join::iterator const& collisions, soa::Filtered> const& tracks, + void processMC(soa::Join::iterator const& collisions, soa::Filtered> const& tracks, aod::McParticles& mcParticles, aod::McCollisions const& mcCollisions) { MC_truth_reg.fill(HIST("histRecVtxMC"), collisions.posZ()); + MC_truth_reg.fill(HIST("histCentrality"), collisions.centFT0C()); for (auto& track : tracks) { const auto particle = track.mcParticle(); const auto pdg = Form("%i", particle.pdgCode()); - if (!particle.isPhysicalPrimary()) - continue; + if (!particle.isPhysicalPrimary()) continue; histPDG->Fill(pdg, 1); const float pdgbin = histPDG->GetXaxis()->GetBinCenter(histPDG->GetXaxis()->FindBin(pdg)); @@ -1349,19 +1561,28 @@ struct NucleiHistTask { MC_recon_reg.fill(HIST("histTrackLength"), track.length(), pdgbin); MC_recon_reg.fill(HIST("histTPCFractionSharedCls"), track.tpcFractionSharedCls(), pdgbin); + float nSigmaPion = track.tpcNSigmaPi(); + float nSigmaProton = track.tpcNSigmaPr(); + float nSigmaDeuteron = track.tpcNSigmaDe(); + float nSigmaTriton = track.tpcNSigmaTr(); + float nSigmaHe3 = track.tpcNSigmaHe(); + float nSigmaHe4 = track.tpcNSigmaAl(); + if (track.sign() > 0) { - MC_recon_reg.fill(HIST("histTpcNsigmaDataPr"), track.pt(), track.tpcNSigmaPr()); - MC_recon_reg.fill(HIST("histTpcNsigmaDataDe"), track.pt(), track.tpcNSigmaDe()); - MC_recon_reg.fill(HIST("histTpcNsigmaDataTr"), track.pt(), track.tpcNSigmaTr()); - MC_recon_reg.fill(HIST("histTpcNsigmaDataHe"), track.pt(), track.tpcNSigmaHe()); - MC_recon_reg.fill(HIST("histTpcNsigmaDataAl"), track.pt(), track.tpcNSigmaAl()); + MC_recon_reg.fill(HIST("histTpcNsigmaDataPi"), track.pt(), nSigmaPion); + MC_recon_reg.fill(HIST("histTpcNsigmaDataPr"), track.pt(), nSigmaProton); + MC_recon_reg.fill(HIST("histTpcNsigmaDataDe"), track.pt(), nSigmaDeuteron); + MC_recon_reg.fill(HIST("histTpcNsigmaDataTr"), track.pt(), nSigmaTriton); + MC_recon_reg.fill(HIST("histTpcNsigmaDataHe"), track.pt(), nSigmaHe3); + MC_recon_reg.fill(HIST("histTpcNsigmaDataAl"), track.pt(), nSigmaHe4); } if (track.sign() < 0) { - MC_recon_reg.fill(HIST("histTpcNsigmaDataaPr"), track.pt(), track.tpcNSigmaPr()); - MC_recon_reg.fill(HIST("histTpcNsigmaDataaDe"), track.pt(), track.tpcNSigmaDe()); - MC_recon_reg.fill(HIST("histTpcNsigmaDataaTr"), track.pt(), track.tpcNSigmaTr()); - MC_recon_reg.fill(HIST("histTpcNsigmaDataaHe"), track.pt(), track.tpcNSigmaHe()); - MC_recon_reg.fill(HIST("histTpcNsigmaDataaAl"), track.pt(), track.tpcNSigmaAl()); + MC_recon_reg.fill(HIST("histTpcNsigmaDataaPi"), track.pt(), nSigmaPion); + MC_recon_reg.fill(HIST("histTpcNsigmaDataaPr"), track.pt(), nSigmaProton); + MC_recon_reg.fill(HIST("histTpcNsigmaDataaDe"), track.pt(), nSigmaDeuteron); + MC_recon_reg.fill(HIST("histTpcNsigmaDataaTr"), track.pt(), nSigmaTriton); + MC_recon_reg.fill(HIST("histTpcNsigmaDataaHe"), track.pt(), nSigmaHe3); + MC_recon_reg.fill(HIST("histTpcNsigmaDataaAl"), track.pt(), nSigmaHe4); } if (track.hasTOF()) { @@ -1371,18 +1592,20 @@ struct NucleiHistTask { MC_recon_reg.fill(HIST("histTofSignalData"), track.pt() * track.sign(), track.beta(), pdgbin); if (track.sign() > 0) { - MC_recon_reg.fill(HIST("histTofNsigmaDataPr"), track.pt(), track.tofNSigmaPr()); - MC_recon_reg.fill(HIST("histTofNsigmaDataDe"), track.pt(), track.tofNSigmaDe()); - MC_recon_reg.fill(HIST("histTofNsigmaDataTr"), track.pt(), track.tofNSigmaTr()); - MC_recon_reg.fill(HIST("histTofNsigmaDataHe"), track.pt(), track.tofNSigmaHe()); - MC_recon_reg.fill(HIST("histTofNsigmaDataAl"), track.pt(), track.tofNSigmaAl()); + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataPi"), track.pt(), track.tofNSigmaPi()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataPr"), track.pt(), track.tofNSigmaPr()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataDe"), track.pt(), track.tofNSigmaDe()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataTr"), track.pt(), track.tofNSigmaTr()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataHe"), track.pt(), track.tofNSigmaHe()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataAl"), track.pt(), track.tofNSigmaAl()); } if (track.sign() < 0) { - MC_recon_reg.fill(HIST("histTofNsigmaDataaPr"), track.pt(), track.tofNSigmaPr()); - MC_recon_reg.fill(HIST("histTofNsigmaDataaDe"), track.pt(), track.tofNSigmaDe()); - MC_recon_reg.fill(HIST("histTofNsigmaDataaTr"), track.pt(), track.tofNSigmaTr()); - MC_recon_reg.fill(HIST("histTofNsigmaDataaHe"), track.pt(), track.tofNSigmaHe()); - MC_recon_reg.fill(HIST("histTofNsigmaDataaAl"), track.pt(), track.tofNSigmaAl()); + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaPi"), track.pt(), track.tofNSigmaPi()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaPr"), track.pt(), track.tofNSigmaPr()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaDe"), track.pt(), track.tofNSigmaDe()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaTr"), track.pt(), track.tofNSigmaTr()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaHe"), track.pt(), track.tofNSigmaHe()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaAl"), track.pt(), track.tofNSigmaAl()); } } @@ -1400,6 +1623,132 @@ struct NucleiHistTask { } } PROCESS_SWITCH(NucleiHistTask, processMC, "process MC", false); + + + void processMCefficiency(soa::Join::iterator const& collisions, + soa::Filtered> const& tracks, + aod::McParticles& mcParticles, aod::McCollisions const& mcCollisions) + { + + for (auto& track : tracks) { + const auto particle = track.mcParticle(); + const auto pdg = Form("%i", particle.pdgCode()); + + if (!particle.isPhysicalPrimary()) continue; + + histPDG_eff->Fill(pdg, 1); + const float pdgbin = histPDG_eff->GetXaxis()->GetBinCenter(histPDG_eff->GetXaxis()->FindBin(pdg)); + MC_eff.fill(HIST("histEffSkimming"), 0, pdgbin); + + TLorentzVector lorentzVector_pion{}; + TLorentzVector lorentzVector_proton{}; + TLorentzVector lorentzVector_deuteron{}; + TLorentzVector lorentzVector_triton{}; + TLorentzVector lorentzVector_He3{}; + TLorentzVector lorentzVector_He4{}; + + lorentzVector_pion.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassPiPlus); + lorentzVector_proton.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassProton); + lorentzVector_deuteron.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassDeuteron); + lorentzVector_triton.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), constants::physics::MassTriton); + lorentzVector_He3.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassHelium3); + lorentzVector_He4.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassAlpha); + + if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || + lorentzVector_proton.Rapidity() < yMin || lorentzVector_proton.Rapidity() > yMax || + lorentzVector_deuteron.Rapidity() < yMin || lorentzVector_deuteron.Rapidity() > yMax || + lorentzVector_triton.Rapidity() < yMin || lorentzVector_triton.Rapidity() > yMax || + lorentzVector_He3.Rapidity() < yMin || lorentzVector_He3.Rapidity() > yMax || + lorentzVector_He4.Rapidity() < yMin || lorentzVector_He4.Rapidity() > yMax) { + continue; + } + + bool passedITS = track.hasITS(); + bool passedTPC = track.hasTPC(); + bool passedTOF = track.hasTOF(); + + if (passedITS) { + MC_eff.fill(HIST("histITS_vs_pT"), particle.pt(), pdgbin); + MC_eff.fill(HIST("histEffSkimming"), 1, pdgbin); + + if (passedTPC) { + MC_eff.fill(HIST("histITS_TPC_vs_pT"), particle.pt(), pdgbin); + MC_eff.fill(HIST("histEffSkimming"), 2, pdgbin); + + if (passedTOF) { + MC_eff.fill(HIST("histITS_TPC_TOFvs_pT"), particle.pt(), pdgbin); + MC_eff.fill(HIST("histEffSkimming"), 3, pdgbin); + } + } + } + + float TPCnumberClsFound = track.tpcNClsFound(); + float TPC_nCls_Crossed_Rows = track.tpcNClsCrossedRows(); + float RatioCrossedRowsOverFindableTPC = track.tpcCrossedRowsOverFindableCls(); + float Chi2perClusterTPC = track.tpcChi2NCl(); + float Chi2perClusterITS = track.itsChi2NCl(); + + if (TPCnumberClsFound < minTPCnClsFound || TPC_nCls_Crossed_Rows < minNCrossedRowsTPC || RatioCrossedRowsOverFindableTPC < minRatioCrossedRowsTPC || RatioCrossedRowsOverFindableTPC > maxRatioCrossedRowsTPC || Chi2perClusterTPC > maxChi2TPC || Chi2perClusterITS > maxChi2ITS || !(track.passedTPCRefit()) || !(track.passedITSRefit()) || (track.itsNClsInnerBarrel()) < minReqClusterITSib || (track.itsNCls()) < minReqClusterITS || TMath::Abs(track.dcaXY()) > maxDCA_XY || TMath::Abs(track.dcaZ()) > maxDCA_Z) { + continue; + } + + MC_eff.fill(HIST("histEffSkimming"), 4, pdgbin); + + float nSigmaPion = track.tpcNSigmaPi(); + float nSigmaProton = track.tpcNSigmaPr(); + float nSigmaDeuteron = track.tpcNSigmaDe(); + float nSigmaTriton = track.tpcNSigmaTr(); + float nSigmaHe3 = track.tpcNSigmaHe(); + float nSigmaHe4 = track.tpcNSigmaAl(); + + float TOFnSigmaPion = track.tofNSigmaPi(); + float TOFnSigmaProton = track.tofNSigmaPr(); + float TOFnSigmaDeuteron = track.tofNSigmaDe(); + float TOFnSigmaTriton = track.tofNSigmaTr(); + float TOFnSigmaHe3 = track.tofNSigmaHe(); + float TOFnSigmaHe4 = track.tofNSigmaAl(); + + if (track.sign() > 0) { + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_Pi"), track.pt()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_Pr"), track.pt()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_De"), track.pt()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_Tr"), track.pt()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_He3"), track.pt()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_He4"), track.pt()); + } + if (track.sign() < 0) { + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aPi"), track.pt()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aPr"), track.pt()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aDe"), track.pt()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aTr"), track.pt()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aHe3"), track.pt()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aHe4"), track.pt()); + } + + if (track.hasTOF()) { + + if (track.sign() > 0) { + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh && TOFnSigmaPion > nsigmacutLow && TOFnSigmaPion < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_Pi"), track.pt()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh && TOFnSigmaProton > nsigmacutLow && TOFnSigmaProton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_Pr"), track.pt()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh && TOFnSigmaDeuteron > nsigmacutLow && TOFnSigmaDeuteron < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_De"), track.pt()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh && TOFnSigmaTriton > nsigmacutLow && TOFnSigmaTriton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_Tr"), track.pt()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh && TOFnSigmaHe3 > nsigmacutLow && TOFnSigmaHe3 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_He3"), track.pt()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh && TOFnSigmaHe4 > nsigmacutLow && TOFnSigmaHe4 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_He4"), track.pt()); + } + if (track.sign() < 0) { + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh && TOFnSigmaPion > nsigmacutLow && TOFnSigmaPion < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aPi"), track.pt()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh && TOFnSigmaProton > nsigmacutLow && TOFnSigmaProton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aPr"), track.pt()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh && TOFnSigmaDeuteron > nsigmacutLow && TOFnSigmaDeuteron < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aDe"), track.pt()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh && TOFnSigmaTriton > nsigmacutLow && TOFnSigmaTriton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aTr"), track.pt()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh && TOFnSigmaHe3 > nsigmacutLow && TOFnSigmaHe3 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aHe3"), track.pt()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh && TOFnSigmaHe4 > nsigmacutLow && TOFnSigmaHe4 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aHe4"), track.pt()); + } + } + + } + } + PROCESS_SWITCH(NucleiHistTask, processMCefficiency, "process MC efficencies", false); + }; //**************************************************************************************************** From 4c1162ed1660cb4b2b14e0f35ec38df1839ad06e Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 21 Mar 2024 21:48:31 +0000 Subject: [PATCH 4/4] Please consider the following formatting changes --- PWGLF/Tasks/Nuspex/NucleiHistTask.cxx | 128 ++++++++++++++++---------- 1 file changed, 81 insertions(+), 47 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx b/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx index 53f7429d632..7d6736644e1 100644 --- a/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx +++ b/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx @@ -454,7 +454,6 @@ struct NucleiHistTask { MC_eff.add("histPt_TOF_aHe3", "^{3}#bar{He} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); MC_eff.add("histPt_TOF_He4", "^{4}He reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); MC_eff.add("histPt_TOF_aHe4", "^{4}#bar{He} reconstructed p_{T} TOF", HistType::kTH1F, {ptAxis}); - } // Configurables @@ -576,7 +575,7 @@ struct NucleiHistTask { lorentzVector_He3.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassHelium3); lorentzVector_He4.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassAlpha); - if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || + if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || lorentzVector_proton.Rapidity() < yMin || lorentzVector_proton.Rapidity() > yMax || lorentzVector_deuteron.Rapidity() < yMin || lorentzVector_deuteron.Rapidity() > yMax || lorentzVector_triton.Rapidity() < yMin || lorentzVector_triton.Rapidity() > yMax || @@ -1339,7 +1338,7 @@ struct NucleiHistTask { continue; } -// cut on rapidity + // cut on rapidity TLorentzVector lorentzVector_pion{}; TLorentzVector lorentzVector_proton{}; TLorentzVector lorentzVector_deuteron{}; @@ -1354,7 +1353,7 @@ struct NucleiHistTask { lorentzVector_He3.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassHelium3); lorentzVector_He4.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassAlpha); - if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || + if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || lorentzVector_proton.Rapidity() < yMin || lorentzVector_proton.Rapidity() > yMax || lorentzVector_deuteron.Rapidity() < yMin || lorentzVector_deuteron.Rapidity() > yMax || lorentzVector_triton.Rapidity() < yMin || lorentzVector_triton.Rapidity() > yMax || @@ -1527,7 +1526,8 @@ struct NucleiHistTask { const auto particle = track.mcParticle(); const auto pdg = Form("%i", particle.pdgCode()); - if (!particle.isPhysicalPrimary()) continue; + if (!particle.isPhysicalPrimary()) + continue; histPDG->Fill(pdg, 1); const float pdgbin = histPDG->GetXaxis()->GetBinCenter(histPDG->GetXaxis()->FindBin(pdg)); @@ -1592,20 +1592,32 @@ struct NucleiHistTask { MC_recon_reg.fill(HIST("histTofSignalData"), track.pt() * track.sign(), track.beta(), pdgbin); if (track.sign() > 0) { - if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataPi"), track.pt(), track.tofNSigmaPi()); - if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataPr"), track.pt(), track.tofNSigmaPr()); - if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataDe"), track.pt(), track.tofNSigmaDe()); - if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataTr"), track.pt(), track.tofNSigmaTr()); - if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataHe"), track.pt(), track.tofNSigmaHe()); - if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataAl"), track.pt(), track.tofNSigmaAl()); + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataPi"), track.pt(), track.tofNSigmaPi()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataPr"), track.pt(), track.tofNSigmaPr()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataDe"), track.pt(), track.tofNSigmaDe()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataTr"), track.pt(), track.tofNSigmaTr()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataHe"), track.pt(), track.tofNSigmaHe()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataAl"), track.pt(), track.tofNSigmaAl()); } if (track.sign() < 0) { - if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaPi"), track.pt(), track.tofNSigmaPi()); - if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaPr"), track.pt(), track.tofNSigmaPr()); - if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaDe"), track.pt(), track.tofNSigmaDe()); - if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaTr"), track.pt(), track.tofNSigmaTr()); - if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaHe"), track.pt(), track.tofNSigmaHe()); - if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) MC_recon_reg.fill(HIST("histTofNsigmaDataaAl"), track.pt(), track.tofNSigmaAl()); + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataaPi"), track.pt(), track.tofNSigmaPi()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataaPr"), track.pt(), track.tofNSigmaPr()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataaDe"), track.pt(), track.tofNSigmaDe()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataaTr"), track.pt(), track.tofNSigmaTr()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataaHe"), track.pt(), track.tofNSigmaHe()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) + MC_recon_reg.fill(HIST("histTofNsigmaDataaAl"), track.pt(), track.tofNSigmaAl()); } } @@ -1624,8 +1636,7 @@ struct NucleiHistTask { } PROCESS_SWITCH(NucleiHistTask, processMC, "process MC", false); - - void processMCefficiency(soa::Join::iterator const& collisions, + void processMCefficiency(soa::Join::iterator const& collisions, soa::Filtered> const& tracks, aod::McParticles& mcParticles, aod::McCollisions const& mcCollisions) { @@ -1634,7 +1645,8 @@ struct NucleiHistTask { const auto particle = track.mcParticle(); const auto pdg = Form("%i", particle.pdgCode()); - if (!particle.isPhysicalPrimary()) continue; + if (!particle.isPhysicalPrimary()) + continue; histPDG_eff->Fill(pdg, 1); const float pdgbin = histPDG_eff->GetXaxis()->GetBinCenter(histPDG_eff->GetXaxis()->FindBin(pdg)); @@ -1654,7 +1666,7 @@ struct NucleiHistTask { lorentzVector_He3.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassHelium3); lorentzVector_He4.SetPtEtaPhiM(track.pt() * 2.0, track.eta(), track.phi(), constants::physics::MassAlpha); - if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || + if (lorentzVector_pion.Rapidity() < yMin || lorentzVector_pion.Rapidity() > yMax || lorentzVector_proton.Rapidity() < yMin || lorentzVector_proton.Rapidity() > yMax || lorentzVector_deuteron.Rapidity() < yMin || lorentzVector_deuteron.Rapidity() > yMax || lorentzVector_triton.Rapidity() < yMin || lorentzVector_triton.Rapidity() > yMax || @@ -1709,46 +1721,68 @@ struct NucleiHistTask { float TOFnSigmaHe4 = track.tofNSigmaAl(); if (track.sign() > 0) { - if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_Pi"), track.pt()); - if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_Pr"), track.pt()); - if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_De"), track.pt()); - if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_Tr"), track.pt()); - if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_He3"), track.pt()); - if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_He4"), track.pt()); + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_Pi"), track.pt()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_Pr"), track.pt()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_De"), track.pt()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_Tr"), track.pt()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_He3"), track.pt()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_He4"), track.pt()); } if (track.sign() < 0) { - if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aPi"), track.pt()); - if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aPr"), track.pt()); - if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aDe"), track.pt()); - if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aTr"), track.pt()); - if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aHe3"), track.pt()); - if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TPC_aHe4"), track.pt()); + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_aPi"), track.pt()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_aPr"), track.pt()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_aDe"), track.pt()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_aTr"), track.pt()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_aHe3"), track.pt()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TPC_aHe4"), track.pt()); } if (track.hasTOF()) { if (track.sign() > 0) { - if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh && TOFnSigmaPion > nsigmacutLow && TOFnSigmaPion < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_Pi"), track.pt()); - if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh && TOFnSigmaProton > nsigmacutLow && TOFnSigmaProton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_Pr"), track.pt()); - if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh && TOFnSigmaDeuteron > nsigmacutLow && TOFnSigmaDeuteron < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_De"), track.pt()); - if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh && TOFnSigmaTriton > nsigmacutLow && TOFnSigmaTriton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_Tr"), track.pt()); - if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh && TOFnSigmaHe3 > nsigmacutLow && TOFnSigmaHe3 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_He3"), track.pt()); - if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh && TOFnSigmaHe4 > nsigmacutLow && TOFnSigmaHe4 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_He4"), track.pt()); + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh && TOFnSigmaPion > nsigmacutLow && TOFnSigmaPion < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_Pi"), track.pt()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh && TOFnSigmaProton > nsigmacutLow && TOFnSigmaProton < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_Pr"), track.pt()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh && TOFnSigmaDeuteron > nsigmacutLow && TOFnSigmaDeuteron < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_De"), track.pt()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh && TOFnSigmaTriton > nsigmacutLow && TOFnSigmaTriton < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_Tr"), track.pt()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh && TOFnSigmaHe3 > nsigmacutLow && TOFnSigmaHe3 < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_He3"), track.pt()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh && TOFnSigmaHe4 > nsigmacutLow && TOFnSigmaHe4 < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_He4"), track.pt()); } if (track.sign() < 0) { - if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh && TOFnSigmaPion > nsigmacutLow && TOFnSigmaPion < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aPi"), track.pt()); - if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh && TOFnSigmaProton > nsigmacutLow && TOFnSigmaProton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aPr"), track.pt()); - if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh && TOFnSigmaDeuteron > nsigmacutLow && TOFnSigmaDeuteron < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aDe"), track.pt()); - if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh && TOFnSigmaTriton > nsigmacutLow && TOFnSigmaTriton < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aTr"), track.pt()); - if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh && TOFnSigmaHe3 > nsigmacutLow && TOFnSigmaHe3 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aHe3"), track.pt()); - if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh && TOFnSigmaHe4 > nsigmacutLow && TOFnSigmaHe4 < nsigmacutHigh) MC_eff.fill(HIST("histPt_TOF_aHe4"), track.pt()); + if (nSigmaPion > nsigmacutLow && nSigmaPion < nsigmacutHigh && TOFnSigmaPion > nsigmacutLow && TOFnSigmaPion < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_aPi"), track.pt()); + if (nSigmaProton > nsigmacutLow && nSigmaProton < nsigmacutHigh && TOFnSigmaProton > nsigmacutLow && TOFnSigmaProton < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_aPr"), track.pt()); + if (nSigmaDeuteron > nsigmacutLow && nSigmaDeuteron < nsigmacutHigh && TOFnSigmaDeuteron > nsigmacutLow && TOFnSigmaDeuteron < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_aDe"), track.pt()); + if (nSigmaTriton > nsigmacutLow && nSigmaTriton < nsigmacutHigh && TOFnSigmaTriton > nsigmacutLow && TOFnSigmaTriton < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_aTr"), track.pt()); + if (nSigmaHe3 > nsigmacutLow && nSigmaHe3 < nsigmacutHigh && TOFnSigmaHe3 > nsigmacutLow && TOFnSigmaHe3 < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_aHe3"), track.pt()); + if (nSigmaHe4 > nsigmacutLow && nSigmaHe4 < nsigmacutHigh && TOFnSigmaHe4 > nsigmacutLow && TOFnSigmaHe4 < nsigmacutHigh) + MC_eff.fill(HIST("histPt_TOF_aHe4"), track.pt()); } } - } } PROCESS_SWITCH(NucleiHistTask, processMCefficiency, "process MC efficencies", false); - }; //****************************************************************************************************