From 2f570ebccf92eeabd4ac20b2676348a31a2f9b68 Mon Sep 17 00:00:00 2001 From: pravatp98 <158029188+pravatp98@users.noreply.github.com> Date: Mon, 30 Mar 2026 01:00:50 +0530 Subject: [PATCH 1/4] Efficiency Correction added --- .../EbyEFluctuations/Tasks/nchCumulantsId.cxx | 1144 +++++++++++++++-- 1 file changed, 1059 insertions(+), 85 deletions(-) diff --git a/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx b/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx index 3f683b99589..ab0db618cb1 100644 --- a/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx +++ b/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx @@ -20,6 +20,7 @@ #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/TrackSelectionTables.h" +#include "CCDB/BasicCCDBManager.h" #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" @@ -28,6 +29,8 @@ #include "Framework/O2DatabasePDGPlugin.h" #include "Framework/runDataProcessing.h" +#include + #include #include @@ -37,9 +40,59 @@ using namespace o2::framework::expressions; using namespace o2::constants::physics; // for constants using namespace std; +#define ID_BIT_PI 0 // Identificationi bits for PID checks +#define ID_BIT_KA 1 +#define ID_BIT_PR 2 +#define ID_BIT_EL 3 +#define ID_BIT_DE 4 + +#define BITSET(mask, ithBit) ((mask) |= (1 << (ithBit))) // avoid name bitset as std::bitset is already there +#define BITCHECK(mask, ithBit) ((mask) & (1 << (ithBit))) // bit check will return int value, not bool, use BITCHECK != 0 in Analysi + +enum PidEnum { + kCh = 0, + kPi, // dont use kPion, kKaon, as these enumeration + kKa, // are already defined in $ROOTSYS/root/include/TPDGCode.h + kPr, + kEl, + kDe +}; + +enum ChargeEnum { + kPos = 0, + kNeg = 1 +}; + +static constexpr std::string_view PidDire[] = { + "Ch/", + "Pi/", + "Ka/", + "Pr/", + "El/", + "De/"}; + +static constexpr std::string_view ChargeDire[] = { + "Pos/", + "Neg/"}; + +std::string getModifiedStr(const std::string& myString) +{ + size_t pos = myString.rfind('/'); + if (pos != std::string::npos) { + std::string subString = myString.substr(0, pos); // remove "/" from end of the string + return subString; + } else { + return myString; + } +} + struct NchCumulantsId { HistogramRegistry hist{"hist", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry recoTracks{"recoTracks", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry genAnalysis{"genAnalysis", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry recoAnalysis{"recoAnalysis", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry purityAnalysis{"purityAnalysis", {}, OutputObjHandlingPolicy::AnalysisObject}; // PDG data base Service pdgDB; @@ -51,6 +104,9 @@ struct NchCumulantsId { Configurable cfgCutPtMax{"cfgCutPtMax", 3.0, "max cut for pT"}; Configurable cfgCutPtMin{"cfgCutPtMin", 0.15, "min cut for pT"}; + Configurable checkCollPosZMc{"checkCollPosZMc", false, "checkCollPosZMc"}; + Configurable flagUnusedVariableError{"flagUnusedVariableError", false, "flagUnusedVariableError"}; + // Configurables for particle Identification Configurable cfgId01CheckVetoCut{"cfgId01CheckVetoCut", false, "cfgId01CheckVetoCut"}; Configurable cfgId02DoElRejection{"cfgId02DoElRejection", true, "cfgId02DoElRejection"}; @@ -101,12 +157,60 @@ struct NchCumulantsId { Configurable cfgVetoId10DeTOF{"cfgVetoId10DeTOF", 3.0, "cfgVetoId10DeTOF"}; } cfgVetoIdCut; + struct : ConfigurableGroup { + Configurable cfgCCDB01URL{"cfgCCDB01URL", "http://ccdb-test.cern.ch:8080", "cfgCCDB01URL"}; + Configurable cfgCCDB02Path{"cfgCCDB02Path", "Users/p/ppanigra/NchCumulants/correctionWeights/", "cfgCCDB02Path"}; + Configurable cfgCCDB03SOR{"cfgCCDB03SOR", 1, "cfgCCDB03SOR"}; + Configurable cfgCCDB04StrHistP{"cfgCCDB04StrHistP", "h01_p", "cfgCCDB04StrHistP"}; + Configurable cfgCCDB05StrHistPt{"cfgCCDB05StrHistPt", "h02_pt", "cfgCCDB05StrHistPt"}; + Configurable cfgCCDB06StrHistPtEta{"cfgCCDB06StrHistPtEta", "h20_pt_eta", "cfgCCDB06StrHistPtEta"}; + } cfgCCDB; + + struct : ConfigurableGroup { + Configurable printDebugMessages{"printDebugMessages", false, "printDebugMessages"}; + Configurable resetHistograms{"resetHistograms", false, "resetHistograms"}; + } cfgDebug; + + // Efficieny containing Histograms. + TH2F* hPtEtaForBinSearch = nullptr; + std::vector> hPtEtaForEffCorrection{kDe + 1, std::array{}}; + void init(InitContext const&) { + auto& mgr = o2::ccdb::BasicCCDBManager::instance(); + mgr.setURL(cfgCCDB.cfgCCDB01URL); + mgr.setCaching(true); + auto ccdbObj = mgr.getForTimeStamp(cfgCCDB.cfgCCDB02Path, cfgCCDB.cfgCCDB03SOR); + if (!ccdbObj) { + if (cfgDebug.printDebugMessages) + LOG(info) << "DEBUG :: CCDB OBJECT NOT FOUND"; + } else { + if (cfgDebug.printDebugMessages) + LOG(info) << "DEBUG :: CCDB OBJECT FOUND"; + } + + ccdbObj->Print(); + + hPtEtaForBinSearch = reinterpret_cast(ccdbObj->FindObject("hPtEta")); + if (cfgDebug.printDebugMessages) + LOG(info) << "DEBUG :: Obj Name = " << hPtEtaForBinSearch->GetName() << " :: entries = " << hPtEtaForBinSearch->GetEntries(); + std::string name = ""; + for (int i = 0; i <= kDe; i++) { + for (int j = 0; j < (kNeg + 1); j++) { + name = "hPtEta" + getModifiedStr(static_cast(PidDire[i])) + getModifiedStr(static_cast(ChargeDire[j])); + hPtEtaForEffCorrection[i][j] = reinterpret_cast(ccdbObj->FindObject(name.c_str())); + if (cfgDebug.printDebugMessages) + LOG(info) << "DEBUG :: Obj Name = " << hPtEtaForEffCorrection[i][j]->GetName() << " :: entries = " << hPtEtaForBinSearch->GetEntries(); + } + } + + mgr.setURL("http://alice-ccdb.cern.ch"); // RESET the URL otherwise the other process functions which contains ccdb lookups will fail + // QA check axes const AxisSpec axisEvents{1, 0, 1, "Counts"}; const AxisSpec axisEta{100, -1., +1., "#eta"}; - const AxisSpec axisPt{100, 0., 3., "p_{T} (GeV/c)"}; + const AxisSpec axisRapidity{200, -5, 5, "Rapidity (y)"}; + const AxisSpec axisPt{100, 0., 5., "p_{T} (GeV/c)"}; const AxisSpec axisP{100, 0., 5., "p (GeV/c)"}; const AxisSpec axisTPCInnerParam{100, 0, 3, "P_innerParam_Gev"}; const AxisSpec axisdEdx(100, 20, 500, {"#frac{dE}{dx}"}); @@ -124,15 +228,15 @@ struct NchCumulantsId { const AxisSpec axisTOFExpMom = {200, 0.0f, 10.0f, "#it{p}_{tofExpMom} (GeV/#it{c})"}; const AxisSpec axisNch(100, -50, 50, "Net_charge_dN"); - const AxisSpec axisPosCh(1001, -1, 1000, "Pos_charge"); - const AxisSpec axisNegCh(1001, -1, 1000, "Neg_charge"); - const AxisSpec axisNt(5001, -1, 5000, "Mult_midRap_Nch"); + const AxisSpec axisPosCh(101, -1, 100, "Pos_charge"); + const AxisSpec axisNegCh(101, -1, 100, "Neg_charge"); + const AxisSpec axisNt(201, -1, 200, "Mult_midRap_Nch"); const AxisSpec axisPrCh(101, -1, 100, "Pr_charge"); const AxisSpec axisAPrCh(101, -1, 100, "APr_charge"); const AxisSpec axisKaCh(101, -1, 100, "Ka_charge"); const AxisSpec axisAKaCh(101, -1, 100, "AKa_charge"); - const AxisSpec axisPiCh(1001, -1, 1000, "Pion_Positive"); - const AxisSpec axisAPiCh(1001, -1, 1000, "Pion_Negative"); + const AxisSpec axisPiCh(101, -1, 100, "Pion_Positive"); + const AxisSpec axisAPiCh(101, -1, 100, "Pion_Negative"); HistogramConfigSpec qnHist1({HistType::kTHnSparseD, {axisNch, axisPosCh, axisNegCh, axisPrCh, axisAPrCh, axisKaCh, axisAKaCh, axisNt, axisCent}}); HistogramConfigSpec qnHist2({HistType::kTHnSparseD, {axisNch, axisPosCh, axisNegCh, axisPiCh, axisAPiCh, axisKaCh, axisAKaCh, axisNt, axisCent}}); @@ -153,6 +257,8 @@ struct NchCumulantsId { HistogramConfigSpec histTofExpMomTofNSigma({HistType::kTH2F, {axisTOFExpMom, axisTOFNSigma}}); HistogramConfigSpec histTpcNSigmaTofNSigma({HistType::kTH2F, {axisTPCNSigma, axisTOFNSigma}}); + HistogramConfigSpec histPtMc({HistType::kTH1F, {axisPt}}); + // QA check histos hist.add("QA/events/preSel/h_VtxZ", "V_{Z}", kTH1D, {axisVtxZ}); @@ -222,8 +328,137 @@ struct NchCumulantsId { hist.add("sparse1", "sparse1", qnHist1); hist.add("sparse2", "sparse2", qnHist2); + + hist.add("sim/gen/sparse1", "sparse1", qnHist1); + hist.add("sim/gen/sparse2", "sparse2", qnHist2); + + hist.add("sim/reco/sparse1", "sparse1", qnHist1); + hist.add("sim/reco/sparse2", "sparse2", qnHist2); + + hist.add("sim/purity/sparse1", "sparse1", qnHist1); + hist.add("sim/purity/sparse2", "sparse2", qnHist2); + + recoAnalysis.add("recoAnalysis/Pi/Pos/h12_p", "p", kTH1F, {axisP}); + recoAnalysis.add("recoAnalysis/Pi/Pos/h13_pt", "pt", kTH1F, {axisPt}); + recoAnalysis.add("recoAnalysis/Pi/Pos/h14_eta", "eta", kTH1F, {axisEta}); + recoAnalysis.add("recoAnalysis/Pi/Pos/h15_phi", "phi", kTH1F, {axisPhi}); + recoAnalysis.add("recoAnalysis/Pi/Pos/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + recoAnalysis.add("recoAnalysis/Pi/Pos/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + recoAnalysis.add("recoAnalysis/Pi/Neg/h12_p", "p", kTH1F, {axisP}); + recoAnalysis.add("recoAnalysis/Pi/Neg/h13_pt", "pt", kTH1F, {axisPt}); + recoAnalysis.add("recoAnalysis/Pi/Neg/h14_eta", "eta", kTH1F, {axisEta}); + recoAnalysis.add("recoAnalysis/Pi/Neg/h15_phi", "phi", kTH1F, {axisPhi}); + recoAnalysis.add("recoAnalysis/Pi/Neg/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + recoAnalysis.add("recoAnalysis/Pi/Neg/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + + recoAnalysis.addClone("recoAnalysis/Pi/", "recoAnalysis/Ka/"); + recoAnalysis.addClone("recoAnalysis/Pi/", "recoAnalysis/Pr/"); + // recoAnalysis.addClone("recoAnalysis/Pi/", "recoAnalysis/El/"); + // recoAnalysis.addClone("recoAnalysis/Pi/", "recoAnalysis/De/"); + recoAnalysis.add("recoAnalysis/Charge/Pos/h12_p", "p", kTH1F, {axisP}); + recoAnalysis.add("recoAnalysis/Charge/Pos/h13_pt", "pt", kTH1F, {axisPt}); + recoAnalysis.add("recoAnalysis/Charge/Pos/h14_eta", "eta", kTH1F, {axisEta}); + recoAnalysis.add("recoAnalysis/Charge/Pos/h15_phi", "phi", kTH1F, {axisPhi}); + recoAnalysis.add("recoAnalysis/Charge/Pos/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + recoAnalysis.add("recoAnalysis/Charge/Pos/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + recoAnalysis.add("recoAnalysis/Charge/Neg/h12_p", "p", kTH1F, {axisP}); + recoAnalysis.add("recoAnalysis/Charge/Neg/h13_pt", "pt", kTH1F, {axisPt}); + recoAnalysis.add("recoAnalysis/Charge/Neg/h14_eta", "eta", kTH1F, {axisEta}); + recoAnalysis.add("recoAnalysis/Charge/Neg/h15_phi", "phi", kTH1F, {axisPhi}); + recoAnalysis.add("recoAnalysis/Charge/Neg/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + recoAnalysis.add("recoAnalysis/Charge/Neg/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + + genAnalysis.add("genAnalysis/Pi/Pos/h12_p", "p", kTH1F, {axisP}); + genAnalysis.add("genAnalysis/Pi/Pos/h13_pt", "pt", kTH1F, {axisPt}); + genAnalysis.add("genAnalysis/Pi/Pos/h14_eta", "eta", kTH1F, {axisEta}); + genAnalysis.add("genAnalysis/Pi/Pos/h15_phi", "phi", kTH1F, {axisPhi}); + genAnalysis.add("genAnalysis/Pi/Pos/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + genAnalysis.add("genAnalysis/Pi/Pos/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + genAnalysis.add("genAnalysis/Pi/Neg/h12_p", "p", kTH1F, {axisP}); + genAnalysis.add("genAnalysis/Pi/Neg/h13_pt", "pt", kTH1F, {axisPt}); + genAnalysis.add("genAnalysis/Pi/Neg/h14_eta", "eta", kTH1F, {axisEta}); + genAnalysis.add("genAnalysis/Pi/Neg/h15_phi", "phi", kTH1F, {axisPhi}); + genAnalysis.add("genAnalysis/Pi/Neg/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + genAnalysis.add("genAnalysis/Pi/Neg/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + + genAnalysis.addClone("genAnalysis/Pi/", "genAnalysis/Ka/"); + genAnalysis.addClone("genAnalysis/Pi/", "genAnalysis/Pr/"); + // genAnalysis.addClone("genAnalysis/Pi/", "genAnalysis/El/"); + // genAnalysis.addClone("genAnalysis/Pi/", "genAnalysis/De/"); + + genAnalysis.add("genAnalysis/Charge/Pos/h12_p", "p", kTH1F, {axisP}); + genAnalysis.add("genAnalysis/Charge/Pos/h13_pt", "pt", kTH1F, {axisPt}); + genAnalysis.add("genAnalysis/Charge/Pos/h14_eta", "eta", kTH1F, {axisEta}); + genAnalysis.add("genAnalysis/Charge/Pos/h15_phi", "phi", kTH1F, {axisPhi}); + genAnalysis.add("genAnalysis/Charge/Pos/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + genAnalysis.add("genAnalysis/Charge/Pos/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + genAnalysis.add("genAnalysis/Charge/Neg/h12_p", "p", kTH1F, {axisP}); + genAnalysis.add("genAnalysis/Charge/Neg/h13_pt", "pt", kTH1F, {axisPt}); + genAnalysis.add("genAnalysis/Charge/Neg/h14_eta", "eta", kTH1F, {axisEta}); + genAnalysis.add("genAnalysis/Charge/Neg/h15_phi", "phi", kTH1F, {axisPhi}); + genAnalysis.add("genAnalysis/Charge/Neg/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + genAnalysis.add("genAnalysis/Charge/Neg/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + + purityAnalysis.add("purityAnalysis/Charge/Pos/h12_p", "p", kTH1F, {axisP}); + purityAnalysis.add("purityAnalysis/Charge/Pos/h13_pt", "pt", kTH1F, {axisPt}); + purityAnalysis.add("purityAnalysis/Charge/Pos/h14_eta", "eta", kTH1F, {axisEta}); + purityAnalysis.add("purityAnalysis/Charge/Pos/h15_phi", "phi", kTH1F, {axisPhi}); + purityAnalysis.add("purityAnalysis/Charge/Pos/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + purityAnalysis.add("purityAnalysis/Charge/Pos/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + purityAnalysis.add("purityAnalysis/Charge/Neg/h12_p", "p", kTH1F, {axisP}); + purityAnalysis.add("purityAnalysis/Charge/Neg/h13_pt", "pt", kTH1F, {axisPt}); + purityAnalysis.add("purityAnalysis/Charge/Neg/h14_eta", "eta", kTH1F, {axisEta}); + purityAnalysis.add("purityAnalysis/Charge/Neg/h15_phi", "phi", kTH1F, {axisPhi}); + purityAnalysis.add("purityAnalysis/Charge/Neg/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + purityAnalysis.add("purityAnalysis/Charge/Neg/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + + purityAnalysis.add("purityAnalysis/Pi/Pos/h12_p", "p", kTH1F, {axisP}); + purityAnalysis.add("purityAnalysis/Pi/Pos/h13_pt", "pt", kTH1F, {axisPt}); + purityAnalysis.add("purityAnalysis/Pi/Pos/h14_eta", "eta", kTH1F, {axisEta}); + purityAnalysis.add("purityAnalysis/Pi/Pos/h15_phi", "phi", kTH1F, {axisPhi}); + purityAnalysis.add("purityAnalysis/Pi/Pos/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + purityAnalysis.add("purityAnalysis/Pi/Pos/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + purityAnalysis.add("purityAnalysis/Pi/Neg/h12_p", "p", kTH1F, {axisP}); + purityAnalysis.add("purityAnalysis/Pi/Neg/h13_pt", "pt", kTH1F, {axisPt}); + purityAnalysis.add("purityAnalysis/Pi/Neg/h14_eta", "eta", kTH1F, {axisEta}); + purityAnalysis.add("purityAnalysis/Pi/Neg/h15_phi", "phi", kTH1F, {axisPhi}); + purityAnalysis.add("purityAnalysis/Pi/Neg/h16_rapidity", "rapidity", kTH1F, {axisRapidity}); + purityAnalysis.add("purityAnalysis/Pi/Neg/h20_pt_eta", "pt_eta", kTH2F, {axisPt, axisEta}); + + purityAnalysis.addClone("purityAnalysis/Pi/", "purityAnalysis/Ka/"); + purityAnalysis.addClone("purityAnalysis/Pi/", "purityAnalysis/Pr/"); + // purityAnalysis.addClone("purityAnalysis/Pi/", "purityAnalysis/El/"); + // purityAnalysis.addClone("purityAnalysis/Pi/", "purityAnalysis/De/"); + } // init ends + static constexpr std::string_view HistRegDire2[] = { + "v0Table/Full/", + "v0Table/postK0sCheck/", + "v0Table/postMassCut/", + "v0Table/postSelectionCut/", + "recoK0s/PreSel/", + "recoK0s/PostSel/", + "recoTracks/PreSel/", + "recoTracks/PostSel/", + "recoAnalysis/", + "genAnalysis/", + "purityAnalysis/"}; + + enum HistRegEnum2 { + v0Full = 0, + v0PostK0sCheck, + v0PostMassCut, + v0PostSelectionCut, + recoK0sPreSel, + recoK0sPostSel, + recoTracksPreSel, + recoTracksPostSel, + recoAnalysisDir, + genAnalysisDir, + purityAnalysisDir + }; + enum IdentificationType { kTPCidentified = 0, kTOFidentified, @@ -255,7 +490,7 @@ struct NchCumulantsId { qaEventPostSel, qaTracksPreSel, qaTracksPostSel, - qaTracksIdfd + qaTracksIdfd, }; static constexpr std::string_view HistRegDire[] = { @@ -265,21 +500,14 @@ struct NchCumulantsId { "QA/tracks/postSel/", "QA/tracks/Idfd/"}; - enum PidEnum { - kPi = 0, // dont use kPion, kKaon, as these enumeration - kKa, // are already defined in $ROOTSYS/root/include/TPDGCode.h - kPr, - kEl, - kDe + enum ProcessTypeEnum { + doDataProcessing = 0, + doRecoProcessing, + doPurityProcessing, + doGenProcessing, + doSimProcessing }; - static constexpr std::string_view PidDire[] = { - "Pi/", - "Ka/", - "Pr/", - "El/", - "De/"}; - // particle identifications // tpc Selections @@ -648,10 +876,167 @@ struct NchCumulantsId { fillIdentificationQA(hist, track); // Look at Proton } - using MyAllTracks = soa::Join; + // template + // void fillGenTrackQA(H& histReg, const T& mcTrack) + // { + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h12_p"), mcTrack.p()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h13_pt"), mcTrack.pt()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h14_eta"), mcTrack.eta()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h15_phi"), mcTrack.phi()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h16_rapidity"), mcTrack.y()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); + // } + // + // template + // void fillRecoTrackQA(H& histReg, const T& track) + // { + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h12_p"), track.p()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h13_pt"), track.pt()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h14_eta"), track.eta()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h15_phi"), track.phi()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h16_rapidity"), track.y()); + // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h20_pt_eta"), track.pt(), track.eta()); + // } + + template + void fillGenTrackQA(HistogramRegistry& r, const TrackType& t) + { + auto base = + HIST(HistRegDire2[DIR]) + + HIST(PidDire[P]) + + HIST(ChargeDire[C]); + r.fill(base + HIST("h12_p"), t.p()); + r.fill(base + HIST("h13_pt"), t.pt()); + r.fill(base + HIST("h14_eta"), t.eta()); + r.fill(base + HIST("h15_phi"), t.phi()); + r.fill(base + HIST("h16_rapidity"), t.y()); + r.fill(base + HIST("h20_pt_eta"), t.pt(), t.eta()); + } + + template + void fillRecoTrackQA(HistogramRegistry& r, const TrackType& t) + { + auto base = + HIST(HistRegDire2[DIR]) + + HIST(PidDire[P]) + + HIST(ChargeDire[C]); + r.fill(base + HIST("h12_p"), t.p()); + r.fill(base + HIST("h13_pt"), t.pt()); + r.fill(base + HIST("h14_eta"), t.eta()); + r.fill(base + HIST("h15_phi"), t.phi()); + r.fill(base + HIST("h16_rapidity"), t.y()); + r.fill(base + HIST("h20_pt_eta"), t.pt(), t.eta()); + } + + template + void fillPurityTrackQA(HistogramRegistry& r, const TrackType& t) + { + auto base = + HIST(HistRegDire2[DIR]) + + HIST(PidDire[P]) + + HIST(ChargeDire[C]); + r.fill(base + HIST("h12_p"), t.p()); + r.fill(base + HIST("h13_pt"), t.pt()); + r.fill(base + HIST("h14_eta"), t.eta()); + r.fill(base + HIST("h15_phi"), t.phi()); + r.fill(base + HIST("h16_rapidity"), t.y()); + r.fill(base + HIST("h20_pt_eta"), t.pt(), t.eta()); + } + + template + void executeTrackAnalysisPart(const T& track, const int& trackIdTag, float& nP, float& nM, + const int& idMethodPi, const bool& trackIsPion, float& nAPi, float& nPi, + const int& idMethodKa, const bool& trackIsKaon, float& nAKa, float& nKa, + const int& idMethodPr, const bool& trackIsProton, float& nPr, float& nAPr, H& recoAnalysis) + { + if (flagUnusedVariableError) + LOG(info) << trackIdTag << idMethodPi << ":" << idMethodKa << ":" << idMethodPr; + if (track.sign() > 0) { + // fillRecoTrackQA(recoAnalysis, track); + nP++; + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h12_p"), track.p()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h13_pt"), track.pt()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h14_eta"), track.eta()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h15_phi"), track.phi()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h16_rapidity"), track.y()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h20_pt_eta"), track.pt(), track.eta()); + } + if (track.sign() < 0) { + // fillRecoTrackQA(recoAnalysis, track); + nM++; + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h12_p"), track.p()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h13_pt"), track.pt()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h14_eta"), track.eta()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h15_phi"), track.phi()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h16_rapidity"), track.y()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h20_pt_eta"), track.pt(), track.eta()); + } + + if (trackIsPion) { + // if (idMethodPi == kTPCidentified) { + // fillIdentificationQA(hist, track); // set hist as recoAnalysis after tpcId etc add true + // } else if (idMethodPi == kTPCTOFidentified) { + // fillIdentificationQA(hist, track); + // } else if (idMethodPi == kUnidentified) { + // fillIdentificationQA(hist, track); + // } + if (track.sign() > 0) { + nPi++; + fillRecoTrackQA(recoAnalysis, track); + } else if (track.sign() < 0) { + nAPi++; + fillRecoTrackQA(recoAnalysis, track); + } + // fillRecoTrackQA(recoAnalysis, track); + } + if (trackIsKaon) { + // if (idMethodKa == kTPCidentified) { + // fillIdentificationQA(hist, track); + // } else if (idMethodKa == kTPCTOFidentified) { + // fillIdentificationQA(hist, track); + // } else if (idMethodKa == kUnidentified) { + // fillIdentificationQA(hist, track); + // } + if (track.sign() > 0) { + nKa++; + fillRecoTrackQA(recoAnalysis, track); + } else if (track.sign() < 0) { + nAKa++; + fillRecoTrackQA(recoAnalysis, track); + } + // fillRecoTrackQA(recoAnalysis, track); + } + if (trackIsProton) { + // if (idMethodPr == kTPCidentified) { + // fillIdentificationQA(hist, track); + // } else if (idMethodPr == kTPCTOFidentified) { + // fillIdentificationQA(hist, track); + // } else if (idMethodPr == kUnidentified) { + // fillIdentificationQA(hist, track); + // } + if (track.sign() > 0) { + nPr++; + fillRecoTrackQA(recoAnalysis, track); + } else if (track.sign() < 0) { + nAPr++; + fillRecoTrackQA(recoAnalysis, track); + } + // fillRecoTrackQA(recoAnalysis, track); + } + + // recoAnalysis.fill(HIST("recoAnalysis/SelectedTrack_IdentificationTag"), trackIdTag); + } + + using MyAllTracks = soa::Join; using MyCollisions = soa::Join; + + using MyTracksWithMclabels = soa::Join; + using MyCollisionsWithMcLabels = soa::Join; + // tracks and collision filters Filter col = aod::evsel::sel8 == true; Filter colFilter = nabs(aod::collision::posZ) < cfgCutPosZ; @@ -664,94 +1049,683 @@ struct NchCumulantsId { using MyFilteredCol = soa::Filtered; using MyFilteredTracks = soa::Filtered; + using MyFilteredColsWithMcLabels = soa::Filtered; + using MyFilteredTracksWithMcLabels = soa::Filtered; + // manual sliceby SliceCache cache; + Preslice tracksPerCollisionPreslice = o2::aod::track::collisionId; + Preslice mctracksPerCollisionPreslice = o2::aod::track::collisionId; - void process(MyFilteredCol const& collisions, MyFilteredTracks const& tracks) + template + void executeAnalysis(const C& collisions, const T& tracks) { - for (const auto& col : collisions) { - - int nP = 0; - int nM = 0; - int nCh = 0; - int nT = 0; - int nPr = 0; - int nAPr = 0; - int nKa = 0; - int nAKa = 0; - int nPi = 0; - int nAPi = 0; - // group tracks manually with corresponding collision using col id; - const uint64_t collIdx = col.globalIndex(); - const auto tracksTablePerColl = tracks.sliceBy(tracksPerCollisionPreslice, collIdx); + float nP = 0; + float nM = 0; + float nCh = 0; + float nT = 0; + float nPr = 0; + float nAPr = 0; + float nKa = 0; + float nAKa = 0; + float nPi = 0; + float nAPi = 0; + + bool trackIsPion = false; + bool trackIsKaon = false; + bool trackIsProton = false; + bool trackIsElectron = false; + bool trackIsDeuteron = false; + + int trackIdTag = 0; + int idMethodPi = kUnidentified; + int idMethodKa = kUnidentified; + int idMethodPr = kUnidentified; + int idMethodEl = kUnidentified; + int idMethodDe = kUnidentified; + + int ptEtaBin = -1; + + if constexpr (analysisType == doDataProcessing) { + for (const auto& col : collisions) { + nP = 0; + nM = 0; + nCh = 0; + nT = 0; + nPr = 0; + nAPr = 0; + nKa = 0; + nAKa = 0; + nPi = 0; + nAPi = 0; + + // group tracks manually with corresponding collision using col id; + const uint64_t collIdx = col.globalIndex(); + const auto tracksTablePerColl = tracks.sliceBy(tracksPerCollisionPreslice, collIdx); + + for (const auto& track : tracksTablePerColl) { + + ptEtaBin = hPtEtaForBinSearch->FindBin(track.pt(), track.eta()); // Find Track Bin for efficiency correction + + fillTrackQA(track); - for (const auto& track : tracksTablePerColl) { - - fillTrackQA(track); - - if (track.sign() == 1) { - nP++; - } - if (track.sign() == -1) { - nM++; - } - - int idMethod; - // pion - if (selPion(track, idMethod)) { if (track.sign() == 1) { - nPi++; + // nP++; + nP += hPtEtaForEffCorrection[kCh][kPos]->GetBinContent(ptEtaBin); } if (track.sign() == -1) { - nAPi++; + nM += hPtEtaForEffCorrection[kCh][kNeg]->GetBinContent(ptEtaBin); } - if (idMethod == kTPCidentified) - fillIdentificationQA(hist, track); - if (idMethod == kTPCTOFidentified) - fillIdentificationQA(hist, track); - } - // kaon - if (selKaon(track, idMethod)) { - if (track.sign() == 1) { - nKa++; + int idMethod; + // pion + if (selPion(track, idMethod)) { + if (track.sign() == 1) { + nPi += hPtEtaForEffCorrection[kPi][kPos]->GetBinContent(ptEtaBin); + } + if (track.sign() == -1) { + nAPi += hPtEtaForEffCorrection[kPi][kNeg]->GetBinContent(ptEtaBin); + } + + if (idMethod == kTPCidentified) + fillIdentificationQA(hist, track); + if (idMethod == kTPCTOFidentified) + fillIdentificationQA(hist, track); } - if (track.sign() == -1) { - nAKa++; + // kaon + if (selKaon(track, idMethod)) { + if (track.sign() == 1) { + nKa += hPtEtaForEffCorrection[kKa][kPos]->GetBinContent(ptEtaBin); + } + if (track.sign() == -1) { + nAKa += hPtEtaForEffCorrection[kKa][kNeg]->GetBinContent(ptEtaBin); + } + + if (idMethod == kTPCidentified) + fillIdentificationQA(hist, track); + if (idMethod == kTPCTOFidentified) + fillIdentificationQA(hist, track); + } + // proton + if (selProton(track, idMethod)) { + if (track.sign() == 1) { + nPr += hPtEtaForEffCorrection[kPr][kPos]->GetBinContent(ptEtaBin); + } + if (track.sign() == -1) { + nAPr += hPtEtaForEffCorrection[kPr][kNeg]->GetBinContent(ptEtaBin); + } + + if (idMethod == kTPCidentified) + fillIdentificationQA(hist, track); + if (idMethod == kTPCTOFidentified) + fillIdentificationQA(hist, track); } + } // track loop ends + nCh = nP - nM; + nT = nP + nM; + + fillCollQA(col, nCh, nT); + + hist.fill(HIST("sparse1"), nCh, nP, nM, nPr, nAPr, nKa, nAKa, nT, col.centFT0M()); + hist.fill(HIST("sparse2"), nCh, nP, nM, nPi, nAPi, nKa, nAKa, nT, col.centFT0M()); + + } // collision loop ends + } else if constexpr (analysisType == doRecoProcessing || analysisType == doPurityProcessing) { - if (idMethod == kTPCidentified) - fillIdentificationQA(hist, track); - if (idMethod == kTPCTOFidentified) - fillIdentificationQA(hist, track); + for (const auto& col : collisions) { + + if (!col.has_mcCollision()) { + LOG(warning) << "No MC collision for this collision, skip..."; + continue; } - // proton - if (selProton(track, idMethod)) { - if (track.sign() == 1) { - nPr++; + float nP = 0; + float nM = 0; + float nCh = 0; + float nT = 0; + float nPr = 0; + float nAPr = 0; + float nKa = 0; + float nAKa = 0; + float nPi = 0; + float nAPi = 0; + // group tracks manually with corresponding collision using col id; + const uint64_t collIdx = col.globalIndex(); + const auto tracksTablePerColl = tracks.sliceBy(mctracksPerCollisionPreslice, collIdx); + + for (const auto& track : tracksTablePerColl) { + + if (!track.has_mcParticle()) { + LOG(warning) << "No MC Particle for this track, skip..."; + continue; } - if (track.sign() == -1) { - nAPr++; + + auto mcPart = track.mcParticle(); + + fillTrackQA(track); + + // Do Proper Track Identification + trackIsPion = false; + trackIsKaon = false; + trackIsProton = false; + trackIsElectron = false; + trackIsDeuteron = false; + + trackIdTag = 0; + idMethodPi = kUnidentified; + idMethodKa = kUnidentified; + idMethodPr = kUnidentified; + idMethodEl = kUnidentified; + idMethodDe = kUnidentified; + + if (selPion(track, idMethodPi)) { + trackIsPion = true; + BITSET(trackIdTag, ID_BIT_PI); + } + if (selKaon(track, idMethodKa)) { + trackIsKaon = true; + BITSET(trackIdTag, ID_BIT_KA); + } + if (selProton(track, idMethodPr)) { + trackIsProton = true; + BITSET(trackIdTag, ID_BIT_PR); } + // if (selElectron(track, idMethodEl)) { + // trackIsElectron = true; + // BITSET(trackIdTag, ID_BIT_EL); + // } + // if (selDeuteron(track, idMethodDe)) { + // trackIsDeuteron = true; + // BITSET(trackIdTag, ID_BIT_DE); + // } + + if constexpr (analysisType == doPurityProcessing) { + if (trackIsPion) { + if (track.sign() > 0 && mcPart.pdgCode() != kPiPlus) { + trackIsPion = false; + } + if (track.sign() < 0 && mcPart.pdgCode() != kPiMinus) { + trackIsPion = false; + } + } + if (trackIsKaon) { + if (track.sign() > 0 && mcPart.pdgCode() != kKPlus) { + trackIsKaon = false; + } + if (track.sign() < 0 && mcPart.pdgCode() != kKMinus) { + trackIsKaon = false; + } + } + if (trackIsProton) { + if (track.sign() > 0 && mcPart.pdgCode() != kProton) { + trackIsProton = false; + } + if (track.sign() < 0 && mcPart.pdgCode() != kProtonBar) { + trackIsProton = false; + } + } + } + + executeTrackAnalysisPart(track, trackIdTag, nP, nM, + idMethodPi, trackIsPion, nAPi, nPi, + idMethodKa, trackIsKaon, nAKa, nKa, + idMethodPr, trackIsProton, nPr, nAPr, recoAnalysis); + + } // track itteration ends + + nCh = nP - nM; + nT = nP + nM; + + fillCollQA(col, nCh, nT); - if (idMethod == kTPCidentified) - fillIdentificationQA(hist, track); - if (idMethod == kTPCTOFidentified) - fillIdentificationQA(hist, track); + hist.fill(HIST("sparse1"), nCh, nP, nM, nPr, nAPr, nKa, nAKa, nT, col.centFT0M()); + hist.fill(HIST("sparse2"), nCh, nP, nM, nPi, nAPi, nKa, nAKa, nT, col.centFT0M()); + + } // collision ends + } + } + + void processRun3(MyFilteredCol const& collisions, MyFilteredTracks const& tracks) + { + executeAnalysis(collisions, tracks); + } + PROCESS_SWITCH(NchCumulantsId, processRun3, "Process for Run-3", false); + + void processMcRecco(MyFilteredColsWithMcLabels const& collisions, MyFilteredTracksWithMcLabels const& tracks, aod::McParticles const&) + { + executeAnalysis(collisions, tracks); + } + PROCESS_SWITCH(NchCumulantsId, processMcRecco, "Process for MC Recco", false); + + void processPurity(MyFilteredColsWithMcLabels const& collisions, MyFilteredTracksWithMcLabels const& tracks, aod::McParticles const&) + { + executeAnalysis(collisions, tracks); + } + PROCESS_SWITCH(NchCumulantsId, processPurity, "Process for MC generated purity", false); + // process fun is over + + // process for truth and response matrix starts now + + Preslice mcTracksPerMcCollisionPreslice = o2::aod::mcparticle::mcCollisionId; + + using MyMcCollisions = aod::McCollisions; + + void processGen(MyMcCollisions const&, MyFilteredColsWithMcLabels const& collisions, aod::McParticles const& mcParticles) + { + for (const auto& col : collisions) { + if (!col.has_mcCollision()) { + LOG(warning) << "No MC collision for this event, skip..."; + continue; + } + const auto& mcColl = col.mcCollision(); + + // ---- apply same Vz cut as data/reco ---- + if (std::abs(mcColl.posZ()) > cfgCutPosZ) { + continue; // reject GEN events outside acceptance + } + // slice MCParticles for this MC collision + const auto mcTracksTablePerMcColl = mcParticles.sliceBy(mcTracksPerMcCollisionPreslice, mcColl.globalIndex()); + + float nP = 0; + float nM = 0; + float nCh = 0; + float nT = 0; + float nPr = 0; + float nAPr = 0; + float nKa = 0; + float nAKa = 0; + float nPi = 0; + float nAPi = 0; + for (const auto& mcTrack : mcTracksTablePerMcColl) { + if (!mcTrack.isPhysicalPrimary()) { + continue; + } + // pt / eta acceptance (same as RECO acceptance) + if (mcTrack.pt() <= cfgCutPtMin || + mcTrack.pt() >= cfgCutPtMax || + std::abs(mcTrack.eta()) >= cfgCutEta) { + continue; + } + + int pdg = mcTrack.pdgCode(); + + if (pdg == kPiPlus || pdg == kKPlus || pdg == kProton || pdg == kPositron || pdg == kMuonPlus || pdg == kDeuteron) { + // fillGenTrackQA(genAnalysis, mcTrack); + nP++; + + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h12_p"), mcTrack.p()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h13_pt"), mcTrack.pt()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h14_eta"), mcTrack.eta()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h15_phi"), mcTrack.phi()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h16_rapidity"), mcTrack.y()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); + } else if (pdg == kPiMinus || pdg == kKMinus || pdg == kProtonBar || pdg == kElectron || pdg == kMuonMinus || pdg == -kDeuteron) { + // fillGenTrackQA(genAnalysis, mcTrack); + nM++; + + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h12_p"), mcTrack.p()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h13_pt"), mcTrack.pt()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h14_eta"), mcTrack.eta()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h15_phi"), mcTrack.phi()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h16_rapidity"), mcTrack.y()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); + } + // ----- Pions ----- + if (pdg == kPiPlus) { + // fillGenTrackQA(genAnalysis, mcTrack); + nPi++; + fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kPiMinus) { + // fillGenTrackQA(genAnalysis, mcTrack); + nAPi++; + fillGenTrackQA(genAnalysis, mcTrack); + } + + // ----- Kaons ----- + else if (pdg == kKPlus) { + // fillGenTrackQA(genAnalysis, mcTrack); + nKa++; + fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kKMinus) { + // fillGenTrackQA(genAnalysis, mcTrack); + nAKa++; + fillGenTrackQA(genAnalysis, mcTrack); } - } // track itteration ends + // ----- Protons ----- + else if (pdg == kProton) { + // fillGenTrackQA(genAnalysis, mcTrack); + nPr++; + fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kProtonBar) { + // fillGenTrackQA(genAnalysis, mcTrack); + nAPr++; + fillGenTrackQA(genAnalysis, mcTrack); + } + } nCh = nP - nM; nT = nP + nM; - fillCollQA(col, nCh, nT); - hist.fill(HIST("sparse1"), nCh, nP, nM, nPr, nAPr, nKa, nAKa, nT, col.centFT0M()); hist.fill(HIST("sparse2"), nCh, nP, nM, nPi, nAPi, nKa, nAKa, nT, col.centFT0M()); - } // collision ends - } // process ends + } + PROCESS_SWITCH(NchCumulantsId, processGen, "Process for MC generated or truth", false); + + void processSim(MyFilteredColsWithMcLabels const& collisions, MyFilteredTracksWithMcLabels const& tracks, aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles) + { + if (flagUnusedVariableError) + LOG(info) << mcCollisions.size(); + bool trackIsPion = false; + bool trackIsKaon = false; + bool trackIsProton = false; + + int trackIdTag = 0; + int idMethodPi = kUnidentified; + int idMethodKa = kUnidentified; + int idMethodPr = kUnidentified; + + int ptEtaBin = -1; + + for (auto const& col : collisions) { + + if (!col.has_mcCollision()) { + LOG(warning) << "No MC collision for this collision, skip..."; + continue; + } + auto mcCollision = col.mcCollision(); + + if (checkCollPosZMc && std::abs(mcCollision.posZ()) > cfgCutPosZ) + continue; + + // slice reco tracks to this collision + const uint64_t collIdx = col.globalIndex(); + const auto tracksTablePerColl = tracks.sliceBy(mctracksPerCollisionPreslice, collIdx); + + // slice mc particles to mc collisions + const auto mcTracksTablePerMcColl = mcParticles.sliceBy(mcTracksPerMcCollisionPreslice, mcCollision.globalIndex()); + + // Denominator -- Generator level(truth) + + float nPGen = 0, nMGen = 0, nChGen = 0, nTGen = 0; + float nPrGen = 0, nAPrGen = 0; + float nKaGen = 0, nAKaGen = 0; + float nPiGen = 0, nAPiGen = 0; + + for (const auto& mcTrack : mcTracksTablePerMcColl) { + if (!mcTrack.isPhysicalPrimary()) + continue; + if (mcTrack.pt() <= cfgCutPtMin || + mcTrack.pt() >= cfgCutPtMax || + std::abs(mcTrack.eta()) >= cfgCutEta) + continue; + + int pdg = mcTrack.pdgCode(); + + if (pdg == kPiPlus || pdg == kKPlus || pdg == kProton || pdg == kPositron || pdg == kMuonPlus || pdg == kDeuteron) { + // fillGenTrackQA(genAnalysis, mcTrack); + nPGen++; + + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h12_p"), mcTrack.p()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h13_pt"), mcTrack.pt()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h14_eta"), mcTrack.eta()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h15_phi"), mcTrack.phi()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h16_rapidity"), mcTrack.y()); + genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); + } else if (pdg == kPiMinus || pdg == kKMinus || pdg == kProtonBar || pdg == kElectron || pdg == kMuonMinus || pdg == -kDeuteron) { + // fillGenTrackQA(genAnalysis, mcTrack); + nMGen++; + + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h12_p"), mcTrack.p()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h13_pt"), mcTrack.pt()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h14_eta"), mcTrack.eta()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h15_phi"), mcTrack.phi()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h16_rapidity"), mcTrack.y()); + genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); + } + // ----- Pions ----- + if (pdg == kPiPlus) { + // fillGenTrackQA(genAnalysis, mcTrack); + nPiGen++; + fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kPiMinus) { + // fillGenTrackQA(genAnalysis, mcTrack); + nAPiGen++; + fillGenTrackQA(genAnalysis, mcTrack); + } + + // ----- Kaons ----- + else if (pdg == kKPlus) { + // fillGenTrackQA(genAnalysis, mcTrack); + nKaGen++; + fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kKMinus) { + // fillGenTrackQA(genAnalysis, mcTrack); + nAKaGen++; + fillGenTrackQA(genAnalysis, mcTrack); + } + + // ----- Protons ----- + else if (pdg == kProton) { + // fillGenTrackQA(genAnalysis, mcTrack); + nPrGen++; + fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kProtonBar) { + // fillGenTrackQA(genAnalysis, mcTrack); + nAPrGen++; + fillGenTrackQA(genAnalysis, mcTrack); + } + + } // particle/track loop for gen ends + nChGen = nPGen - nMGen; + nTGen = nPGen + nMGen; + + // ── Fill GEN sparse (denominator) ──────────────────────── + hist.fill(HIST("sim/gen/sparse1"), nChGen, nPGen, nMGen, + nPrGen, nAPrGen, nKaGen, nAKaGen, nTGen, + col.centFT0M()); + hist.fill(HIST("sim/gen/sparse2"), nChGen, nPGen, nMGen, + nPiGen, nAPiGen, nKaGen, nAKaGen, nTGen, + col.centFT0M()); + // + // Numerator - Reconstructed + truth matched + // reco->selFunc passed, no pdg + // purity -> selFunc matched with pdg matched + // + float nPRec = 0, nMRec = 0, nChRec = 0, nTRec = 0; + float nPrRec = 0, nAPrRec = 0; + float nKaRec = 0, nAKaRec = 0; + float nPiRec = 0, nAPiRec = 0; + + // purity counters — separate from reco + float nPPur = 0, nMPur = 0, nChPur = 0, nTPur = 0; + float nPrPur = 0, nAPrPur = 0; + float nKaPur = 0, nAKaPur = 0; + float nPiPur = 0, nAPiPur = 0; + + for (const auto& track : tracksTablePerColl) { + + if (!track.has_mcParticle()) { + LOG(warning) << "No MC Particle for this track, skip..."; + continue; + } + auto mcPart = track.mcParticle(); + if (!mcPart.isPhysicalPrimary()) + continue; + int pdg = mcPart.pdgCode(); + + fillTrackQA(track); + + trackIsPion = false; + trackIsKaon = false; + trackIsProton = false; + trackIdTag = 0; + idMethodPi = kUnidentified; + idMethodKa = kUnidentified; + idMethodPr = kUnidentified; + + if (selPion(track, idMethodPi)) { + trackIsPion = true; + BITSET(trackIdTag, ID_BIT_PI); + } + if (selKaon(track, idMethodKa)) { + trackIsKaon = true; + BITSET(trackIdTag, ID_BIT_KA); + } + if (selProton(track, idMethodPr)) { + trackIsProton = true; + BITSET(trackIdTag, ID_BIT_PR); + } + + // bool isKnownCharged = (std::abs(pdg) == kPiPlus || + // std::abs(pdg) == kKPlus || + // std::abs(pdg) == kProton || + // std::abs(pdg) == kElectron || + // std::abs(pdg) == kMuonMinus || + // std::abs(pdg) == kDeuteron); + + ptEtaBin = hPtEtaForBinSearch->FindBin(track.pt(), track.eta()); // Find Track Bin for efficiency correction + + if (track.sign() > 0) { + nPRec += hPtEtaForEffCorrection[kCh][kPos]->GetBinContent(ptEtaBin); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h12_p"), track.p()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h13_pt"), track.pt()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h14_eta"), track.eta()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h15_phi"), track.phi()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h16_rapidity"), track.y()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Pos/h20_pt_eta"), track.pt(), track.eta()); + } else if (track.sign() < 0) { + nMRec += hPtEtaForEffCorrection[kCh][kNeg]->GetBinContent(ptEtaBin); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h12_p"), track.p()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h13_pt"), track.pt()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h14_eta"), track.eta()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h15_phi"), track.phi()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h16_rapidity"), track.y()); + recoAnalysis.fill(HIST("recoAnalysis/Charge/Neg/h20_pt_eta"), track.pt(), track.eta()); + } + + // species reco — sel passes, PDG not checked (raw reco) + if (trackIsPion) { + if (track.sign() > 0) { + nPiRec += hPtEtaForEffCorrection[kPi][kPos]->GetBinContent(ptEtaBin); + fillRecoTrackQA(recoAnalysis, track); + } else if (track.sign() < 0) { + nAPiRec += hPtEtaForEffCorrection[kPi][kNeg]->GetBinContent(ptEtaBin); + fillRecoTrackQA(recoAnalysis, track); + } + } else if (trackIsKaon) { + if (track.sign() > 0) { + nKaRec += hPtEtaForEffCorrection[kKa][kPos]->GetBinContent(ptEtaBin); + fillRecoTrackQA(recoAnalysis, track); + } else if (track.sign() < 0) { + nAKaRec += hPtEtaForEffCorrection[kKa][kNeg]->GetBinContent(ptEtaBin); + fillRecoTrackQA(recoAnalysis, track); + } + } else if (trackIsProton) { + if (track.sign() > 0) { + nPrRec += hPtEtaForEffCorrection[kPr][kPos]->GetBinContent(ptEtaBin); + fillRecoTrackQA(recoAnalysis, track); + } else if (track.sign() < 0) { + nAPrRec += hPtEtaForEffCorrection[kPr][kNeg]->GetBinContent(ptEtaBin); + fillRecoTrackQA(recoAnalysis, track); + } + } + // purity check - check pdg aginst sign + bool purityPion = false; + if (trackIsPion) { + if (track.sign() > 0 && pdg == kPiPlus) + purityPion = true; + if (track.sign() < 0 && pdg == kPiMinus) + purityPion = true; + } + + bool purityKaon = false; + if (trackIsKaon) { + if (track.sign() > 0 && pdg == kKPlus) + purityKaon = true; + if (track.sign() < 0 && pdg == kKMinus) + purityKaon = true; + } + + bool purityProton = false; + if (trackIsProton) { + if (track.sign() > 0 && pdg == kProton) + purityProton = true; + if (track.sign() < 0 && pdg == kProtonBar) + purityProton = true; + } + + // charge purity — track.sign() + isKnownCharged + PDG sign consistency + bool pdgPositive = (pdg == kPiPlus || pdg == kKPlus || pdg == kProton || + pdg == kPositron || pdg == kMuonPlus || pdg == kDeuteron); + bool pdgNegative = (pdg == kPiMinus || pdg == kKMinus || pdg == kProtonBar || + pdg == kElectron || pdg == kMuonMinus || pdg == -kDeuteron); + + if (track.sign() > 0 && pdgPositive) { + nPPur++; + purityAnalysis.fill(HIST("purityAnalysis/Charge/Pos/h12_p"), track.p()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Pos/h13_pt"), track.pt()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Pos/h14_eta"), track.eta()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Pos/h15_phi"), track.phi()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Pos/h16_rapidity"), track.y()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Pos/h20_pt_eta"), track.pt(), track.eta()); + } else if (track.sign() < 0 && pdgNegative) { + nMPur++; + purityAnalysis.fill(HIST("purityAnalysis/Charge/Neg/h12_p"), track.p()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Neg/h13_pt"), track.pt()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Neg/h14_eta"), track.eta()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Neg/h15_phi"), track.phi()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Neg/h16_rapidity"), track.y()); + purityAnalysis.fill(HIST("purityAnalysis/Charge/Neg/h20_pt_eta"), track.pt(), track.eta()); + } + + // species purity fill + if (purityPion) { + if (track.sign() > 0) { + nPiPur++; + fillPurityTrackQA(purityAnalysis, track); + } else { + nAPiPur++; + fillPurityTrackQA(purityAnalysis, track); + } + } else if (purityKaon) { + if (track.sign() > 0) { + nKaPur++; + fillPurityTrackQA(purityAnalysis, track); + } else { + nAKaPur++; + fillPurityTrackQA(purityAnalysis, track); + } + } else if (purityProton) { + if (track.sign() > 0) { + nPrPur++; + fillPurityTrackQA(purityAnalysis, track); + } else { + nAPrPur++; + fillPurityTrackQA(purityAnalysis, track); + } + } + } + nChRec = nPRec - nMRec; + nTRec = nPRec + nMRec; + nChPur = nPPur - nMPur; + nTPur = nPPur + nMPur; + + // ── fill reco histos ───────────────────────────────────── + hist.fill(HIST("sim/reco/sparse1"), nChRec, nPRec, nMRec, + nPrRec, nAPrRec, nKaRec, nAKaRec, nTRec, col.centFT0M()); + hist.fill(HIST("sim/reco/sparse2"), nChRec, nPRec, nMRec, + nPiRec, nAPiRec, nKaRec, nAKaRec, nTRec, col.centFT0M()); + + // ── fill purity histos ─────────────────────────────────── + hist.fill(HIST("sim/purity/sparse1"), nChPur, nPPur, nMPur, + nPrPur, nAPrPur, nKaPur, nAKaPur, nTPur, col.centFT0M()); + hist.fill(HIST("sim/purity/sparse2"), nChPur, nPPur, nMPur, + nPiPur, nAPiPur, nKaPur, nAKaPur, nTPur, col.centFT0M()); + + } // common collision loop ends + } // process sim ends + PROCESS_SWITCH(NchCumulantsId, processSim, "Process Sim: Gen + Reco + Purity", true); }; // structure ends WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 2bd91c1464d3d36ac6af0e95048ef8c8ba12f405 Mon Sep 17 00:00:00 2001 From: pravatp98 <158029188+pravatp98@users.noreply.github.com> Date: Mon, 30 Mar 2026 01:17:01 +0530 Subject: [PATCH 2/4] Remove commented-out track QA functions Removed commented-out code for various track quality assessment functions and their calls, streamlining the nchCumulantsId.cxx file. --- .../EbyEFluctuations/Tasks/nchCumulantsId.cxx | 68 ++----------------- 1 file changed, 5 insertions(+), 63 deletions(-) diff --git a/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx b/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx index ab0db618cb1..32f003c1c09 100644 --- a/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx +++ b/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx @@ -876,28 +876,6 @@ struct NchCumulantsId { fillIdentificationQA(hist, track); // Look at Proton } - // template - // void fillGenTrackQA(H& histReg, const T& mcTrack) - // { - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h12_p"), mcTrack.p()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h13_pt"), mcTrack.pt()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h14_eta"), mcTrack.eta()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h15_phi"), mcTrack.phi()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h16_rapidity"), mcTrack.y()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); - // } - // - // template - // void fillRecoTrackQA(H& histReg, const T& track) - // { - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h12_p"), track.p()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h13_pt"), track.pt()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h14_eta"), track.eta()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h15_phi"), track.phi()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h16_rapidity"), track.y()); - // histReg.fill(HIST(HistRegDire2[Mode]) + HIST(PidDire[pidMode]) + HIST("h20_pt_eta"), track.pt(), track.eta()); - // } - template void fillGenTrackQA(HistogramRegistry& r, const TrackType& t) { @@ -1230,14 +1208,6 @@ struct NchCumulantsId { trackIsProton = true; BITSET(trackIdTag, ID_BIT_PR); } - // if (selElectron(track, idMethodEl)) { - // trackIsElectron = true; - // BITSET(trackIdTag, ID_BIT_EL); - // } - // if (selDeuteron(track, idMethodDe)) { - // trackIsDeuteron = true; - // BITSET(trackIdTag, ID_BIT_DE); - // } if constexpr (analysisType == doPurityProcessing) { if (trackIsPion) { @@ -1350,7 +1320,6 @@ struct NchCumulantsId { int pdg = mcTrack.pdgCode(); if (pdg == kPiPlus || pdg == kKPlus || pdg == kProton || pdg == kPositron || pdg == kMuonPlus || pdg == kDeuteron) { - // fillGenTrackQA(genAnalysis, mcTrack); nP++; genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h12_p"), mcTrack.p()); @@ -1360,7 +1329,6 @@ struct NchCumulantsId { genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h16_rapidity"), mcTrack.y()); genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); } else if (pdg == kPiMinus || pdg == kKMinus || pdg == kProtonBar || pdg == kElectron || pdg == kMuonMinus || pdg == -kDeuteron) { - // fillGenTrackQA(genAnalysis, mcTrack); nM++; genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h12_p"), mcTrack.p()); @@ -1372,33 +1340,21 @@ struct NchCumulantsId { } // ----- Pions ----- if (pdg == kPiPlus) { - // fillGenTrackQA(genAnalysis, mcTrack); nPi++; fillGenTrackQA(genAnalysis, mcTrack); } else if (pdg == kPiMinus) { - // fillGenTrackQA(genAnalysis, mcTrack); nAPi++; fillGenTrackQA(genAnalysis, mcTrack); - } - - // ----- Kaons ----- - else if (pdg == kKPlus) { - // fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kKPlus) { nKa++; fillGenTrackQA(genAnalysis, mcTrack); } else if (pdg == kKMinus) { - // fillGenTrackQA(genAnalysis, mcTrack); nAKa++; fillGenTrackQA(genAnalysis, mcTrack); - } - - // ----- Protons ----- - else if (pdg == kProton) { - // fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kProton) { nPr++; fillGenTrackQA(genAnalysis, mcTrack); } else if (pdg == kProtonBar) { - // fillGenTrackQA(genAnalysis, mcTrack); nAPr++; fillGenTrackQA(genAnalysis, mcTrack); } @@ -1463,7 +1419,6 @@ struct NchCumulantsId { int pdg = mcTrack.pdgCode(); if (pdg == kPiPlus || pdg == kKPlus || pdg == kProton || pdg == kPositron || pdg == kMuonPlus || pdg == kDeuteron) { - // fillGenTrackQA(genAnalysis, mcTrack); nPGen++; genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h12_p"), mcTrack.p()); @@ -1473,7 +1428,6 @@ struct NchCumulantsId { genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h16_rapidity"), mcTrack.y()); genAnalysis.fill(HIST("genAnalysis/Charge/Pos/h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); } else if (pdg == kPiMinus || pdg == kKMinus || pdg == kProtonBar || pdg == kElectron || pdg == kMuonMinus || pdg == -kDeuteron) { - // fillGenTrackQA(genAnalysis, mcTrack); nMGen++; genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h12_p"), mcTrack.p()); @@ -1483,35 +1437,23 @@ struct NchCumulantsId { genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h16_rapidity"), mcTrack.y()); genAnalysis.fill(HIST("genAnalysis/Charge/Neg/h20_pt_eta"), mcTrack.pt(), mcTrack.eta()); } - // ----- Pions ----- + if (pdg == kPiPlus) { - // fillGenTrackQA(genAnalysis, mcTrack); nPiGen++; fillGenTrackQA(genAnalysis, mcTrack); } else if (pdg == kPiMinus) { - // fillGenTrackQA(genAnalysis, mcTrack); nAPiGen++; fillGenTrackQA(genAnalysis, mcTrack); - } - - // ----- Kaons ----- - else if (pdg == kKPlus) { - // fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kKPlus) { nKaGen++; fillGenTrackQA(genAnalysis, mcTrack); } else if (pdg == kKMinus) { - // fillGenTrackQA(genAnalysis, mcTrack); nAKaGen++; fillGenTrackQA(genAnalysis, mcTrack); - } - - // ----- Protons ----- - else if (pdg == kProton) { - // fillGenTrackQA(genAnalysis, mcTrack); + } else if (pdg == kProton) { nPrGen++; fillGenTrackQA(genAnalysis, mcTrack); } else if (pdg == kProtonBar) { - // fillGenTrackQA(genAnalysis, mcTrack); nAPrGen++; fillGenTrackQA(genAnalysis, mcTrack); } From bd2b742556fbc108fe1491594bdbea4e9f248d30 Mon Sep 17 00:00:00 2001 From: pravatp98 <158029188+pravatp98@users.noreply.github.com> Date: Mon, 30 Mar 2026 01:27:59 +0530 Subject: [PATCH 3/4] Remove unused track identification variables Removed unused variables related to electron and deuteron track identification. --- PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx b/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx index 32f003c1c09..bc721310ab9 100644 --- a/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx +++ b/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx @@ -32,6 +32,7 @@ #include #include +#include #include using namespace o2; @@ -1053,15 +1054,11 @@ struct NchCumulantsId { bool trackIsPion = false; bool trackIsKaon = false; bool trackIsProton = false; - bool trackIsElectron = false; - bool trackIsDeuteron = false; int trackIdTag = 0; int idMethodPi = kUnidentified; int idMethodKa = kUnidentified; int idMethodPr = kUnidentified; - int idMethodEl = kUnidentified; - int idMethodDe = kUnidentified; int ptEtaBin = -1; @@ -1186,15 +1183,11 @@ struct NchCumulantsId { trackIsPion = false; trackIsKaon = false; trackIsProton = false; - trackIsElectron = false; - trackIsDeuteron = false; trackIdTag = 0; idMethodPi = kUnidentified; idMethodKa = kUnidentified; idMethodPr = kUnidentified; - idMethodEl = kUnidentified; - idMethodDe = kUnidentified; if (selPion(track, idMethodPi)) { trackIsPion = true; From 42b9c743bcdad8bda698ad016573e6e498a3ada9 Mon Sep 17 00:00:00 2001 From: pravatp98 <158029188+pravatp98@users.noreply.github.com> Date: Mon, 30 Mar 2026 21:52:33 +0530 Subject: [PATCH 4/4] Add configurable parameters for charge histograms --- .../EbyEFluctuations/Tasks/nchCumulantsId.cxx | 28 ++++++++++++------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx b/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx index bc721310ab9..3cfea59e573 100644 --- a/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx +++ b/PWGCF/EbyEFluctuations/Tasks/nchCumulantsId.cxx @@ -104,6 +104,14 @@ struct NchCumulantsId { Configurable cfgCutEta{"cfgCutEta", 0.8, "cut for eta"}; Configurable cfgCutPtMax{"cfgCutPtMax", 3.0, "max cut for pT"}; Configurable cfgCutPtMin{"cfgCutPtMin", 0.15, "min cut for pT"}; + Configurable netChBin{"netChBin", 160, "bins for netch"}; + Configurable netChMax{"netChMax", 80.0, "max for netch"}; + Configurable netChMin{"netChMin", -80.0, "min for netch"}; + Configurable chBins{"chBins", 501, "bins for ch"}; + Configurable chMax{"chMax", 500.0, "max for ch"}; + Configurable chMin{"chMin", -1.0, "min for ch"}; + Configurable midRapMax{"midRapMax", 1000.0, "max for midrapmult"}; + Configurable midRapBins{"midRapBins", 1001, "bins for midrapmult"}; Configurable checkCollPosZMc{"checkCollPosZMc", false, "checkCollPosZMc"}; Configurable flagUnusedVariableError{"flagUnusedVariableError", false, "flagUnusedVariableError"}; @@ -228,16 +236,16 @@ struct NchCumulantsId { const AxisSpec axisTOFNSigma = {200, -10.0, 10.0, "n#sigma_{TOF}"}; const AxisSpec axisTOFExpMom = {200, 0.0f, 10.0f, "#it{p}_{tofExpMom} (GeV/#it{c})"}; - const AxisSpec axisNch(100, -50, 50, "Net_charge_dN"); - const AxisSpec axisPosCh(101, -1, 100, "Pos_charge"); - const AxisSpec axisNegCh(101, -1, 100, "Neg_charge"); - const AxisSpec axisNt(201, -1, 200, "Mult_midRap_Nch"); - const AxisSpec axisPrCh(101, -1, 100, "Pr_charge"); - const AxisSpec axisAPrCh(101, -1, 100, "APr_charge"); - const AxisSpec axisKaCh(101, -1, 100, "Ka_charge"); - const AxisSpec axisAKaCh(101, -1, 100, "AKa_charge"); - const AxisSpec axisPiCh(101, -1, 100, "Pion_Positive"); - const AxisSpec axisAPiCh(101, -1, 100, "Pion_Negative"); + const AxisSpec axisNch(netChBin, netChMin, netChMax, "Net_charge_dN"); + const AxisSpec axisPosCh(chBins, chMin, chMax, "Pos_charge"); + const AxisSpec axisNegCh(chBins, chMin, chMax, "Neg_charge"); + const AxisSpec axisNt(midRapBins, chMin, midRapMax, "Mult_midRap_Nch"); + const AxisSpec axisPrCh(chBins, chMin, chMax, "Pr_charge"); + const AxisSpec axisAPrCh(chBins, chMin, chMax, "APr_charge"); + const AxisSpec axisKaCh(chBins, chMin, chMax, "Ka_charge"); + const AxisSpec axisAKaCh(chBins, chMin, chMax, "AKa_charge"); + const AxisSpec axisPiCh(chBins, chMin, chMax, "Pion_Positive"); + const AxisSpec axisAPiCh(chBins, chMin, chMax, "Pion_Negative"); HistogramConfigSpec qnHist1({HistType::kTHnSparseD, {axisNch, axisPosCh, axisNegCh, axisPrCh, axisAPrCh, axisKaCh, axisAKaCh, axisNt, axisCent}}); HistogramConfigSpec qnHist2({HistType::kTHnSparseD, {axisNch, axisPosCh, axisNegCh, axisPiCh, axisAPiCh, axisKaCh, axisAKaCh, axisNt, axisCent}});