From 6fa3e584b2a4baaa8c90806efdc80fe5772efb52 Mon Sep 17 00:00:00 2001 From: nidamalikk Date: Sun, 28 Sep 2025 18:02:10 +0530 Subject: [PATCH 1/2] added histograms for multiplicity correlation plots --- .../Tasks/netchargeFluctuations.cxx | 288 ++++++++++++++---- 1 file changed, 229 insertions(+), 59 deletions(-) diff --git a/PWGCF/EbyEFluctuations/Tasks/netchargeFluctuations.cxx b/PWGCF/EbyEFluctuations/Tasks/netchargeFluctuations.cxx index 8ce63ab6cf8..a2d95bd72df 100644 --- a/PWGCF/EbyEFluctuations/Tasks/netchargeFluctuations.cxx +++ b/PWGCF/EbyEFluctuations/Tasks/netchargeFluctuations.cxx @@ -40,12 +40,13 @@ #include "Framework/RunningWorkflowInfo.h" #include "Framework/runDataProcessing.h" +#include "TF1.h" #include "TProfile.h" #include "TProfile2D.h" #include "TRandom3.h" #include -#include // Include for std::vector +#include using namespace o2; using namespace o2::framework; @@ -53,34 +54,14 @@ using namespace o2::framework::expressions; using namespace std; using namespace o2::constants::physics; -namespace o2 -{ -namespace aod -{ -using MyCollisionsRun2 = soa::Join; -using MyCollisionRun2 = MyCollisionsRun2::iterator; -using MyCollisionsRun3 = soa::Join; -using MyCollisionRun3 = MyCollisionsRun3::iterator; -using MyTracks = soa::Join; -using MyTrack = MyTracks::iterator; - -using MyMCCollisionsRun2 = soa::Join; -using MyMCCollisionRun2 = MyMCCollisionsRun2::iterator; - -using MyMCCollisionsRun3 = soa::Join; -using MyMCCollisionRun3 = MyMCCollisionsRun3::iterator; - -using MyMCTracks = soa::Join; -using MyMCTrack = MyMCTracks::iterator; -} // namespace aod -} // namespace o2 - enum RunType { kRun3 = 0, kRun2 }; struct NetchargeFluctuations { +#define O2_DEFINE_CONFIGURABLE(NAME, TYPE, DEFAULT, HELP) Configurable NAME{#NAME, DEFAULT, HELP}; + Service pdgService; Service ccdb; TRandom3* fRndm = new TRandom3(0); @@ -96,11 +77,11 @@ struct NetchargeFluctuations { Configurable etaCut{"etaCut", 0.8f, "Eta cut"}; Configurable ptMinCut{"ptMinCut", 0.2, "Pt min cut"}; Configurable ptMaxCut{"ptMaxCut", 5.0, "Pt max cut"}; - Configurable dcaXYCut{"dcaXYCut", 0.12, "DCA XY cut"}; - Configurable dcaZCut{"dcaZCut", 0.3, "DCA Z cut"}; - Configurable tpcCrossCut{"tpcCrossCut", 70, "TPC crossrows cut"}; - Configurable itsChiCut{"itsChiCut", 70, "ITS chi2 cluster cut"}; - Configurable tpcChiCut{"tpcChiCut", 70, "TPC chi2 cluster cut"}; + Configurable dcaXYCut{"dcaXYCut", 0.2, "DCA XY cut"}; + Configurable dcaZCut{"dcaZCut", 2.0, "DCA Z cut"}; + Configurable tpcCrossCut{"tpcCrossCut", 70., "TPC crossrows cut"}; + Configurable itsChiCut{"itsChiCut", 36., "ITS chi2 cluster cut"}; + Configurable tpcChiCut{"tpcChiCut", 4., "TPC chi2 cluster cut"}; Configurable centMin{"centMin", 0.0f, "cenrality min for delta eta"}; Configurable centMax{"centMax", 10.0f, "cenrality max for delta eta"}; Configurable cfgNSubsample{"cfgNSubsample", 30, "Number of subsamples for Error"}; @@ -108,33 +89,87 @@ struct NetchargeFluctuations { Configurable threshold{"threshold", 1e-6, "Delta eta bin count"}; // Event selections - Configurable cSel8Trig{"cSel8Trig", true, "Sel8 (T0A + T0C) Selection Run3"}; // sel8 - Configurable cInt7Trig{"cInt7Trig", true, "kINT7 MB Trigger"}; // kINT7 - Configurable cSel7Trig{"cSel7Trig", true, "Sel7 (V0A + V0C) Selection Run2"}; // sel7 - Configurable cPileupReject{"cPileupReject", false, "Pileup rejection"}; // pileup - Configurable cfgUseGoodItsLayerAllCut{"cfgUseGoodItsLayerAllCut", false, "Good ITS Layers All"}; // pileup - Configurable cDcaXy{"cDcaXy", false, "Dca XY cut"}; - Configurable cDcaZ{"cDcaZ", false, "Dca Z cut"}; - Configurable cTpcCr{"cTpcCr", false, "tpc crossrows"}; - Configurable cItsChi{"cItsChi", false, "ITS chi"}; - Configurable cTpcChi{"cTpcChi", false, "TPC chi"}; + Configurable cSel8Trig{"cSel8Trig", true, "Sel8 (T0A + T0C) Selection Run3"}; // sel8 + Configurable cInt7Trig{"cInt7Trig", true, "kINT7 MB Trigger"}; // kINT7 + Configurable cSel7Trig{"cSel7Trig", true, "Sel7 (V0A + V0C) Selection Run2"}; // sel7 + Configurable cDcaXy{"cDcaXy", true, "Dca XY cut"}; + Configurable cDcaZ{"cDcaZ", true, "Dca Z cut"}; + Configurable cTpcCr{"cTpcCr", true, "tpc crossrows"}; + Configurable cItsChi{"cItsChi", true, "ITS chi"}; + Configurable cTpcChi{"cTpcChi", true, "TPC chi"}; Configurable cFT0C{"cFT0C", true, "cent FT0C"}; Configurable cFT0M{"cFT0M", false, "cent FT0M"}; ConfigurableAxis centBining{"centBining", {0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, "Centrality/Multiplicity percentile bining"}; - Configurable cTFBorder{"cTFBorder", false, "Timeframe Border Selection"}; // pileup - Configurable cNoItsROBorder{"cNoItsROBorder", false, "No ITSRO Border Cut"}; // pileup - Configurable cItsTpcVtx{"cItsTpcVtx", false, "ITS+TPC Vertex Selection"}; // pileup - Configurable cZVtxTimeDiff{"cZVtxTimeDiff", false, "z-vtx time diff selection"}; // pileup + Configurable cPileupReject{"cPileupReject", true, "Pileup rejection"}; // pileup + Configurable cfgUseGoodItsLayerAllCut{"cfgUseGoodItsLayerAllCut", true, "Good ITS Layers All"}; // pileup + Configurable cTFBorder{"cTFBorder", false, "Timeframe Border Selection"}; // pileup + Configurable cNoItsROBorder{"cNoItsROBorder", false, "No ITSRO Border Cut"}; // pileup + Configurable cItsTpcVtx{"cItsTpcVtx", true, "ITS+TPC Vertex Selection"}; // pileup + Configurable cZVtxTimeDiff{"cZVtxTimeDiff", false, "z-vtx time diff selection"}; // pileup + Configurable cPVcont{"cPVcont", true, "primary vertex contributor"}; + + O2_DEFINE_CONFIGURABLE(cfgEvSelMultCorrelation, bool, true, "Multiplicity correlation cut") + struct : ConfigurableGroup { + + O2_DEFINE_CONFIGURABLE(cfgMultPVT0CCutEnabled, bool, true, "Enable PV multiplicity vs T0C centrality cut") + O2_DEFINE_CONFIGURABLE(cfgMultGlobalFT0CCutEnabled, bool, true, "Enable globalTracks vs FT0C multiplicity cut") + O2_DEFINE_CONFIGURABLE(cfgMultGlobalPVCutEnabled, bool, false, "Enable globalTracks vs PV multiplicity cut") + + Configurable> cfgMultPVT0CCutPars{"cfgMultPVT0CCutPars", + std::vector{187.621, -5.14575, 0.0716601, -0.000586642, 2.02818e-06, 51.2929, -1.66644, 0.0354762, -0.000389809, 1.55365e-06}, + "PV multiplicity vs T0C centrality cut parameter values"}; + + Configurable> cfgMultGlobalFT0CCutPars{"cfgMultGlobalFT0CCutPars", + std::vector{135.561, -3.7818, 0.0536562, -0.000445155, 1.55429e-06, 38.2336, -1.2568, 0.0270932, -0.000301034, 1.21234e-06}, + "globalTracks vs FT0C cut parameter values"}; + + Configurable> cfgMultGlobalPVCutPars{"cfgMultGlobalPVCutPars", + std::vector{100., -2., 0.05, -0.0003, 1e-06, 30., -1.0, 0.02, -0.0002, 8e-07}, + "globalTracks vs PV cut parameter values"}; + + std::vector multPVT0CCutPars; + std::vector multGlobalFT0CPars; + std::vector multGlobalPVCutPars; + + TF1* fMultPVT0CCutLow = nullptr; + TF1* fMultPVT0CCutHigh = nullptr; + TF1* fMultGlobalFT0CCutLow = nullptr; + TF1* fMultGlobalFT0CCutHigh = nullptr; + TF1* fMultGlobalPVCutLow = nullptr; + TF1* fMultGlobalPVCutHigh = nullptr; + + } cfgFunCoeff; // CCDB efficiency histograms TH1D* efficiency = nullptr; - // Initialization + Filter collisionFilter = nabs(aod::collision::posZ) <= vertexZcut; + Filter trackFilter = (nabs(aod::track::eta) < etaCut) && (aod::track::pt > ptMinCut) && (aod::track::pt < ptMaxCut) && (requireGlobalTrackInFilter()); + + using MyCollisionsRun2 = soa::Filtered>; + using MyCollisionRun2 = MyCollisionsRun2::iterator; + + using MyCollisionsRun3 = soa::Filtered>; + using MyCollisionRun3 = MyCollisionsRun3::iterator; + + using MyTracks = soa::Filtered>; + using MyTrack = MyTracks::iterator; + + using MyMCCollisionsRun2 = soa::Filtered>; + using MyMCCollisionRun2 = MyMCCollisionsRun2::iterator; + + using MyMCCollisionsRun3 = soa::Filtered>; + using MyMCCollisionRun3 = MyMCCollisionsRun3::iterator; + + using MyMCTracks = soa::Filtered>; + using MyMCTrack = MyMCTracks::iterator; + void init(o2::framework::InitContext&) { const AxisSpec vtxzAxis = {800, -20, 20, "V_{Z} (cm)"}; const AxisSpec dcaAxis = {1000, -0.5, 0.5, "DCA_{xy} (cm)"}; const AxisSpec dcazAxis = {600, -3, 3, "DCA_{z} (cm)"}; + const AxisSpec phiAxis = {70, 0, 7, "#phi "}; const AxisSpec ptAxis = {70, 0.0, 7.0, "#it{p}_{T} (GeV/#it{c})"}; const AxisSpec etaAxis = {20, -1., 1., "#eta"}; const AxisSpec deltaEtaAxis = {9, 0, 1.8, "#eta"}; @@ -156,6 +191,7 @@ struct NetchargeFluctuations { histogramRegistry.add("QA/hVtxZ_before", "", kTH1F, {vtxzAxis}); histogramRegistry.add("QA/hDcaXY_before", "", kTH1F, {dcaAxis}); + histogramRegistry.add("QA/hphi", "", kTH1F, {phiAxis}); histogramRegistry.add("QA/hDcaZ_before", "", kTH1F, {dcazAxis}); histogramRegistry.add("QA/hTPCchi2perCluster_before", "", kTH1D, {tpcChiAxis}); histogramRegistry.add("QA/hITSchi2perCluster_before", "", kTH1D, {itsChiAxis}); @@ -276,6 +312,58 @@ struct NetchargeFluctuations { histogramRegistry.add("subsample/delta_eta/gen/neg_sq", "", kTProfile2D, {deltaEtaAxis, subsampleAxis}); histogramRegistry.add("subsample/delta_eta/gen/posneg", "", kTProfile2D, {deltaEtaAxis, subsampleAxis}); + histogramRegistry.add("QA/hCentFT0C", "", kTH1F, {centAxis}); + histogramRegistry.add("QA/hNchGlobal", "", kTH1F, {nchAxis}); + histogramRegistry.add("QA/hNchPV", "", kTH1F, {nchAxis}); + + histogramRegistry.add("MultCorrelationPlots/globalTracks_PV_bef", "", {HistType::kTH2D, {nchAxis, nchAxis}}); + histogramRegistry.add("MultCorrelationPlots/globalTracks_FT0C_bef", "", {HistType::kTH2D, {centAxis, nchAxis}}); + histogramRegistry.add("MultCorrelationPlots/PV_FT0C_bef", "", {HistType::kTH2D, {centAxis, nchAxis}}); + + histogramRegistry.add("MultCorrelationPlots/globalTracks_PV_aft", "", {HistType::kTH2D, {nchAxis, nchAxis}}); + histogramRegistry.add("MultCorrelationPlots/globalTracks_FT0C_aft", "", {HistType::kTH2D, {centAxis, nchAxis}}); + histogramRegistry.add("MultCorrelationPlots/PV_FT0C_aft", "", {HistType::kTH2D, {centAxis, nchAxis}}); + + cfgFunCoeff.multPVT0CCutPars = cfgFunCoeff.cfgMultPVT0CCutPars; + cfgFunCoeff.multGlobalFT0CPars = cfgFunCoeff.cfgMultGlobalFT0CCutPars; + cfgFunCoeff.multGlobalPVCutPars = cfgFunCoeff.cfgMultGlobalPVCutPars; + + cfgFunCoeff.fMultPVT0CCutLow = + new TF1("fMultPVT0CCutLow", + "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x - 2.0*([5]+[6]*x+[7]*x*x+[8]*x*x*x+[9]*x*x*x*x)", + 0, 100); + cfgFunCoeff.fMultPVT0CCutLow->SetParameters(&(cfgFunCoeff.multPVT0CCutPars[0])); + + cfgFunCoeff.fMultPVT0CCutHigh = + new TF1("fMultPVT0CCutHigh", + "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x + 2.*([5]+[6]*x+[7]*x*x+[8]*x*x*x+[9]*x*x*x*x)", + 0, 100); + cfgFunCoeff.fMultPVT0CCutHigh->SetParameters(&(cfgFunCoeff.multPVT0CCutPars[0])); + + cfgFunCoeff.fMultGlobalFT0CCutLow = + new TF1("fMultGlobalFT0CCutLow", + "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x - 2.*([5]+[6]*x+[7]*x*x+[8]*x*x*x+[9]*x*x*x*x)", + 0, 100); + cfgFunCoeff.fMultGlobalFT0CCutLow->SetParameters(&(cfgFunCoeff.multGlobalFT0CPars[0])); + + cfgFunCoeff.fMultGlobalFT0CCutHigh = + new TF1("fMultGlobalFT0CCutHigh", + "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x + 2.*([5]+[6]*x+[7]*x*x+[8]*x*x*x+[9]*x*x*x*x)", + 0, 100); + cfgFunCoeff.fMultGlobalFT0CCutHigh->SetParameters(&(cfgFunCoeff.multGlobalFT0CPars[0])); + + cfgFunCoeff.fMultGlobalPVCutLow = + new TF1("fMultGlobalPVCutLow", + "[0] + [1]*x - 5.*([2] + [3]*x)", + 0, 100); + cfgFunCoeff.fMultGlobalPVCutLow->SetParameters(&(cfgFunCoeff.multGlobalPVCutPars[0])); + + cfgFunCoeff.fMultGlobalPVCutHigh = + new TF1("fMultGlobalPVCutHigh", + "[0] + [1]*x + 5.*([2] + [3]*x)", + 0, 100); + cfgFunCoeff.fMultGlobalPVCutHigh->SetParameters(&(cfgFunCoeff.multGlobalPVCutPars[0])); + if (cfgLoadEff) { ccdb->setURL(cfgUrlCCDB.value); ccdb->setCaching(true); @@ -289,16 +377,45 @@ struct NetchargeFluctuations { } } + bool eventSelected(const float& globalNch, const float& pvTrack, const float& centrality) + { + if (cfgFunCoeff.cfgMultPVT0CCutEnabled) { + + if (pvTrack < cfgFunCoeff.fMultPVT0CCutLow->Eval(centrality)) + return false; + if (pvTrack > cfgFunCoeff.fMultPVT0CCutHigh->Eval(centrality)) + return false; + } + + if (cfgFunCoeff.cfgMultGlobalFT0CCutEnabled) { + + if (globalNch < cfgFunCoeff.fMultGlobalFT0CCutLow->Eval(centrality)) + return false; + if (globalNch > cfgFunCoeff.fMultGlobalFT0CCutHigh->Eval(centrality)) + return false; + } + + if (cfgFunCoeff.cfgMultGlobalPVCutEnabled) { + + if (globalNch < cfgFunCoeff.fMultGlobalPVCutLow->Eval(pvTrack)) + return false; + if (globalNch > cfgFunCoeff.fMultGlobalPVCutHigh->Eval(pvTrack)) + return false; + } + + return true; + } + template bool selCollision(C const& coll, float& cent, float& mult) { - if (std::abs(coll.posZ()) > vertexZcut) + if (std::abs(coll.posZ()) >= vertexZcut) return false; if constexpr (run == kRun3) { if (cSel8Trig && !coll.sel8()) { return false; - } // require min bias trigger + } if (cFT0M) { cent = coll.centFT0M(); // centrality for run3 using FT0M mult = coll.multFT0M(); @@ -349,6 +466,7 @@ struct NetchargeFluctuations { template void fillAfterQA(T const& track) { + histogramRegistry.fill(HIST("QA/hphi"), track.phi()); histogramRegistry.fill(HIST("QA/hDcaXY_after"), track.dcaXY()); histogramRegistry.fill(HIST("QA/hDcaZ_after"), track.dcaZ()); histogramRegistry.fill(HIST("QA/hPt"), track.pt()); @@ -366,21 +484,23 @@ struct NetchargeFluctuations { { if (!track.isGlobalTrack()) return false; + if (cPVcont && !track.isPVContributor()) + return false; if (std::fabs(track.eta()) >= etaCut) return false; if (track.pt() <= ptMinCut || track.pt() >= ptMaxCut) return false; if (track.sign() == 0) return false; - if (cDcaXy && std::fabs(track.dcaXY()) > dcaXYCut) + if (cDcaXy && std::fabs(track.dcaXY()) >= dcaXYCut) return false; - if (cDcaZ && std::fabs(track.dcaZ()) > dcaZCut) + if (cDcaZ && std::fabs(track.dcaZ()) >= dcaZCut) return false; - if (cTpcCr && track.tpcNClsCrossedRows() < tpcCrossCut) + if (cTpcCr && track.tpcNClsCrossedRows() <= tpcCrossCut) return false; - if (cItsChi && track.itsChi2NCl() > itsChiCut) + if (cItsChi && track.itsChi2NCl() >= itsChiCut) return false; - if (cTpcChi && track.tpcChi2NCl() > tpcChiCut) + if (cTpcChi && track.tpcChi2NCl() >= tpcChiCut) return false; return true; @@ -438,6 +558,24 @@ struct NetchargeFluctuations { if (!selCollision(coll, cent, mult)) { return; } + + float globalNch = tracks.size(); + float pvTrack = coll.multNTracksPV(); + + histogramRegistry.fill(HIST("QA/hCentFT0C"), cent); + histogramRegistry.fill(HIST("QA/hNchGlobal"), globalNch); + histogramRegistry.fill(HIST("QA/hNchPV"), pvTrack); + + histogramRegistry.fill(HIST("MultCorrelationPlots/globalTracks_PV_bef"), pvTrack, globalNch); + histogramRegistry.fill(HIST("MultCorrelationPlots/globalTracks_FT0C_bef"), cent, globalNch); + histogramRegistry.fill(HIST("MultCorrelationPlots/PV_FT0C_bef"), cent, pvTrack); + + if (cfgEvSelMultCorrelation && !eventSelected(globalNch, pvTrack, cent)) { + return; + } + histogramRegistry.fill(HIST("MultCorrelationPlots/globalTracks_PV_aft"), pvTrack, globalNch); + histogramRegistry.fill(HIST("MultCorrelationPlots/globalTracks_FT0C_aft"), cent, globalNch); + histogramRegistry.fill(HIST("MultCorrelationPlots/PV_FT0C_aft"), cent, pvTrack); histogramRegistry.fill(HIST("QA/hVtxZ_after"), coll.posZ()); histogramRegistry.fill(HIST("QA/hCentrality"), cent); histogramRegistry.fill(HIST("QA/hMultiplicity"), mult); @@ -477,6 +615,7 @@ struct NetchargeFluctuations { termp = fpos * (fpos - 1); termn = fneg * (fneg - 1); posneg = fpos * fneg; + histogramRegistry.fill(HIST("data/cent_nchTotal"), cent, nchTotal); histogramRegistry.fill(HIST("data/cent_nchTotalCor"), cent, nchTotalCor); histogramRegistry.fill(HIST("data/nch_nchCor"), nch, nchCor); @@ -500,6 +639,25 @@ struct NetchargeFluctuations { if (!selCollision(coll, cent, mult)) { return; } + + int globalNch = inputTracks.size(); + int pvTrack = coll.multNTracksPV(); + + histogramRegistry.fill(HIST("QA/hCentFT0C"), cent); + histogramRegistry.fill(HIST("QA/hNchGlobal"), globalNch); + histogramRegistry.fill(HIST("QA/hNchPV"), pvTrack); + + histogramRegistry.fill(HIST("MultCorrelationPlots/globalTracks_PV_bef"), pvTrack, globalNch); + histogramRegistry.fill(HIST("MultCorrelationPlots/globalTracks_FT0C_bef"), cent, globalNch); + histogramRegistry.fill(HIST("MultCorrelationPlots/PV_FT0C_bef"), cent, pvTrack); + + if (cfgEvSelMultCorrelation && !eventSelected(globalNch, pvTrack, cent)) { + return; + } + histogramRegistry.fill(HIST("MultCorrelationPlots/globalTracks_PV_aft"), pvTrack, globalNch); + histogramRegistry.fill(HIST("MultCorrelationPlots/globalTracks_FT0C_aft"), cent, globalNch); + histogramRegistry.fill(HIST("MultCorrelationPlots/PV_FT0C_aft"), cent, pvTrack); + histogramRegistry.fill(HIST("QA/hVtxZ_after"), coll.posZ()); histogramRegistry.fill(HIST("QA/hCentrality"), cent); histogramRegistry.fill(HIST("QA/hMultiplicity"), mult); @@ -547,7 +705,7 @@ struct NetchargeFluctuations { int posGen = 0, negGen = 0, posNegGen = 0, termNGen = 0, termPGen = 0, nchGen = 0; const auto& mccolgen = coll.template mcCollision_as(); - if (std::abs(mccolgen.posZ()) > vertexZcut) + if (std::abs(mccolgen.posZ()) >= vertexZcut) return; const auto& mcpartgen = mcParticles.sliceByCached(aod::mcparticle::mcCollisionId, mccolgen.globalIndex(), cache); histogramRegistry.fill(HIST("gen/hVtxZ_after"), mccolgen.posZ()); @@ -620,6 +778,12 @@ struct NetchargeFluctuations { float cent = -1, mult = -1; if (!selCollision(coll, cent, mult)) return; + + int globalNch = tracks.size(); + int pvTrack = coll.multNTracksPV(); + if (cfgEvSelMultCorrelation && !eventSelected(globalNch, pvTrack, cent)) + return; + if (!(cent >= centMin && cent < centMax)) return; histogramRegistry.fill(HIST("data/delta_eta_cent"), cent); @@ -692,6 +856,12 @@ struct NetchargeFluctuations { float cent = -1, mult = -1; if (!selCollision(coll, cent, mult)) return; + + int globalNch = inputTracks.size(); + int pvTrack = coll.multNTracksPV(); + if (cfgEvSelMultCorrelation && !eventSelected(globalNch, pvTrack, cent)) + return; + if (!(cent >= centMin && cent < centMax)) return; histogramRegistry.fill(HIST("data/delta_eta_cent"), cent); @@ -745,7 +915,7 @@ struct NetchargeFluctuations { const auto& mccolgen = coll.template mcCollision_as(); - if (std::abs(mccolgen.posZ()) > vertexZcut) + if (std::abs(mccolgen.posZ()) >= vertexZcut) return; const auto& mcpartgen = mcParticles.sliceByCached(aod::mcparticle::mcCollisionId, mccolgen.globalIndex(), cache); @@ -817,10 +987,10 @@ struct NetchargeFluctuations { } // void SliceCache cache; - Preslice mcTrack = o2::aod::mcparticle::mcCollisionId; + Preslice mcTrack = aod::mcparticle::mcCollisionId; // process function for Data Run3 - void processDataRun3(aod::MyCollisionRun3 const& coll, aod::MyTracks const& tracks) + void processDataRun3(MyCollisionRun3 const& coll, MyTracks const& tracks) { calculationData(coll, tracks); for (int ii = 0; ii < deltaEta; ii++) { @@ -831,10 +1001,10 @@ struct NetchargeFluctuations { } } - PROCESS_SWITCH(NetchargeFluctuations, processDataRun3, "Process for Run3 DATA", false); + PROCESS_SWITCH(NetchargeFluctuations, processDataRun3, "Process for Run3 DATA", true); // process function for Data Run2 - void processDataRun2(aod::MyCollisionRun2 const& coll, aod::MyTracks const& tracks) + void processDataRun2(MyCollisionRun2 const& coll, MyTracks const& tracks) { calculationData(coll, tracks); for (int ii = 0; ii < deltaEta; ii++) { @@ -849,7 +1019,7 @@ struct NetchargeFluctuations { // process function for MC Run3 - void processMcRun3(aod::MyMCCollisionRun3 const& coll, aod::MyMCTracks const& inputTracks, + void processMcRun3(MyMCCollisionRun3 const& coll, MyMCTracks const& inputTracks, aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles) { calculationMc(coll, inputTracks, mcCollisions, mcParticles); @@ -859,11 +1029,11 @@ struct NetchargeFluctuations { calculationMcDeltaEta(coll, inputTracks, mcCollisions, mcParticles, etaMin, etaMax); } } - PROCESS_SWITCH(NetchargeFluctuations, processMcRun3, "Process reconstructed", true); + PROCESS_SWITCH(NetchargeFluctuations, processMcRun3, "Process reconstructed", false); // process function for MC Run2 - void processMcRun2(aod::MyMCCollisionRun2 const& coll, aod::MyMCTracks const& inputTracks, + void processMcRun2(MyMCCollisionRun2 const& coll, MyMCTracks const& inputTracks, aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles) { calculationMc(coll, inputTracks, mcCollisions, mcParticles); From 4fda1aa1c00039d1952d358968bfad363e968d4a Mon Sep 17 00:00:00 2001 From: nidamalikk Date: Wed, 1 Oct 2025 15:15:30 +0530 Subject: [PATCH 2/2] use different polynomial for fitting multiplicity correlation plots --- .../EbyEFluctuations/Tasks/netchargeFluctuations.cxx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/PWGCF/EbyEFluctuations/Tasks/netchargeFluctuations.cxx b/PWGCF/EbyEFluctuations/Tasks/netchargeFluctuations.cxx index a2d95bd72df..6414df12727 100644 --- a/PWGCF/EbyEFluctuations/Tasks/netchargeFluctuations.cxx +++ b/PWGCF/EbyEFluctuations/Tasks/netchargeFluctuations.cxx @@ -113,18 +113,18 @@ struct NetchargeFluctuations { O2_DEFINE_CONFIGURABLE(cfgMultPVT0CCutEnabled, bool, true, "Enable PV multiplicity vs T0C centrality cut") O2_DEFINE_CONFIGURABLE(cfgMultGlobalFT0CCutEnabled, bool, true, "Enable globalTracks vs FT0C multiplicity cut") - O2_DEFINE_CONFIGURABLE(cfgMultGlobalPVCutEnabled, bool, false, "Enable globalTracks vs PV multiplicity cut") + O2_DEFINE_CONFIGURABLE(cfgMultGlobalPVCutEnabled, bool, true, "Enable globalTracks vs PV multiplicity cut") Configurable> cfgMultPVT0CCutPars{"cfgMultPVT0CCutPars", - std::vector{187.621, -5.14575, 0.0716601, -0.000586642, 2.02818e-06, 51.2929, -1.66644, 0.0354762, -0.000389809, 1.55365e-06}, + std::vector{30.434, -0.917137, 0.0185032, -0.000198425, 7.94381e-07, 13.7406, -0.282656, 0.00556147, -6.32766e-05, 2.51648e-07}, "PV multiplicity vs T0C centrality cut parameter values"}; Configurable> cfgMultGlobalFT0CCutPars{"cfgMultGlobalFT0CCutPars", - std::vector{135.561, -3.7818, 0.0536562, -0.000445155, 1.55429e-06, 38.2336, -1.2568, 0.0270932, -0.000301034, 1.21234e-06}, + std::vector{18.9628, -0.576466, 0.0117324, -0.000126086, 5.05365e-07, 8.99921, -0.188022, 0.0037089, -4.20275e-05, 1.68234e-07}, "globalTracks vs FT0C cut parameter values"}; Configurable> cfgMultGlobalPVCutPars{"cfgMultGlobalPVCutPars", - std::vector{100., -2., 0.05, -0.0003, 1e-06, 30., -1.0, 0.02, -0.0002, 8e-07}, + std::vector{0.148031, 0.616699, 0.603083, 0.112751, -0.0013846, 8.38211e-06}, "globalTracks vs PV cut parameter values"}; std::vector multPVT0CCutPars; @@ -354,13 +354,13 @@ struct NetchargeFluctuations { cfgFunCoeff.fMultGlobalPVCutLow = new TF1("fMultGlobalPVCutLow", - "[0] + [1]*x - 5.*([2] + [3]*x)", + "[0]+[1]*x - 3.5*([2]+[3]*x+[4]*x*x+[5]*x*x*x)", 0, 100); cfgFunCoeff.fMultGlobalPVCutLow->SetParameters(&(cfgFunCoeff.multGlobalPVCutPars[0])); cfgFunCoeff.fMultGlobalPVCutHigh = new TF1("fMultGlobalPVCutHigh", - "[0] + [1]*x + 5.*([2] + [3]*x)", + "[0]+[1]*x + 3.5*([2]+[3]*x+[4]*x*x+[5]*x*x*x)", 0, 100); cfgFunCoeff.fMultGlobalPVCutHigh->SetParameters(&(cfgFunCoeff.multGlobalPVCutPars[0]));