From 848d1ca97633470e159da30259fe2ced172030a7 Mon Sep 17 00:00:00 2001 From: abmodak <67369858+abmodak@users.noreply.github.com> Date: Wed, 1 Oct 2025 17:50:54 +0200 Subject: [PATCH 1/5] Add new task to study RAA in light-ion collisions --- PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx | 483 ++++++++++++++++++++++ 1 file changed, 483 insertions(+) create mode 100644 PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx diff --git a/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx b/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx new file mode 100644 index 00000000000..38ffcc00142 --- /dev/null +++ b/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx @@ -0,0 +1,483 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \file chargedparticleRaa.cxx +/// +/// \brief task for analysis of charged-particle RAA at midrapidity in light-ion collisions +/// \author Abhi Modak (abhi.modak@cern.ch) +/// \since October 01, 2025 + +#include +#include +#include +#include + +#include "PWGMM/Mult/DataModel/bestCollisionTable.h" +#include "CCDB/BasicCCDBManager.h" +#include "Common/Core/trackUtilities.h" +#include "Common/CCDB/EventSelectionParams.h" +#include "Common/Core/TrackSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "CommonConstants/MathConstants.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/Configurable.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "Framework/runDataProcessing.h" +#include "ReconstructionDataFormats/GlobalTrackID.h" +#include "ReconstructionDataFormats/Track.h" +#include "PWGMM/Mult/DataModel/Index.h" +#include "Common/DataModel/PIDResponse.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod::track; +using namespace o2::aod::evsel; + +using ColDataTablePbPb = soa::Join; +using ColDataTablepp = soa::Join; +using ColMCRecTablePbPb = soa::SmallGroups>; +using ColMCRecTablepp = soa::SmallGroups>; +using ColMCTrueTable = aod::McCollisions; +using TrackDataTable = soa::Join; +using FilTrackDataTable = soa::Filtered; +using TrackMCRecTable = soa::Join; +using FilTrackMCRecTable = soa::Filtered; +using TrackMCTrueTable = aod::McParticles; + +enum { + kTrackTypebegin = 0, + kGlobalplusITS = 1, + kGlobalonly, + kITSonly, + kTrackTypeend +}; + +static constexpr TrackSelectionFlags::flagtype TrackSelectionIts = + TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | + TrackSelectionFlags::kITSHits; +static constexpr TrackSelectionFlags::flagtype TrackSelectionTpc = + TrackSelectionFlags::kTPCNCls | + TrackSelectionFlags::kTPCCrossedRowsOverNCls | + TrackSelectionFlags::kTPCChi2NDF; +static constexpr TrackSelectionFlags::flagtype TrackSelectionDca = + TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; +static constexpr TrackSelectionFlags::flagtype TrackSelectionDcaxyOnly = + TrackSelectionFlags::kDCAxy; + +AxisSpec axisEvent{15, 0.5, 15.5, "#Event", "EventAxis"}; +AxisSpec axisVtxZ{40, -20, 20, "Vertex Z", "VzAxis"}; +AxisSpec axisEta{40, -2, 2, "#eta", "EtaAxis"}; +AxisSpec axisPhi{629, 0, o2::constants::math::TwoPI, "#phi"}; +AxisSpec axisCent{100, 0, 100, "#Cent"}; +AxisSpec axisTrackType = {kTrackTypeend - 1, +kTrackTypebegin + 0.5, +kTrackTypeend - 0.5, "", "TrackTypeAxis"}; +auto static constexpr kMinCharge = 3.f; + +struct ChargedparticleRaa { + + HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + Service pdg; + Preslice perCollision = aod::track::collisionId; + Configurable etaRange{"etaRange", 1.0f, "Eta range to consider"}; + Configurable vtxRange{"vtxRange", 10.0f, "Vertex Z range to consider"}; + Configurable occuRange{"occuRange", 500.0f, "Occupancy range to consider"}; + Configurable dcaZ{"dcaZ", 0.2f, "Custom DCA Z cut (ignored if negative)"}; + Configurable cfgPtCutMin{"cfgPtCutMin", 0.15f, "minimum accepted track pT"}; + Configurable extraphicut1{"extraphicut1", 3.07666f, "Extra Phi cut 1"}; + Configurable extraphicut2{"extraphicut2", 3.12661f, "Extra Phi cut 2"}; + Configurable extraphicut3{"extraphicut3", 0.03f, "Extra Phi cut 3"}; + Configurable extraphicut4{"extraphicut4", 6.253f, "Extra Phi cut 4"}; + ConfigurableAxis ptHistBin{"ptHistBin", {200, 0., 20.}, ""}; + ConfigurableAxis centralityBinning{"centralityBinning", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, ""}; + ConfigurableAxis binsImpactPar{"binsImpactPar", {VARIABLE_WIDTH, 0.0, 3.00065, 4.28798, 6.14552, 7.6196, 8.90942, 10.0897, 11.2002, 12.2709, 13.3167, 14.4173, 23.2518}, "Binning of the impact parameter axis"}; + + Configurable isApplySameBunchPileup{"isApplySameBunchPileup", false, "Enable SameBunchPileup cut"}; + Configurable isApplyGoodZvtxFT0vsPV{"isApplyGoodZvtxFT0vsPV", false, "Enable GoodZvtxFT0vsPV cut"}; + Configurable isApplyExtraPhiCut{"isApplyExtraPhiCut", false, "Enable extra phi cut"}; + Configurable isApplyNoCollInTimeRangeStandard{"isApplyNoCollInTimeRangeStandard", true, "Enable NoCollInTimeRangeStandard cut"}; + Configurable isApplyNoCollInRofStandard{"isApplyNoCollInRofStandard", false, "Enable NoCollInRofStandard cut"}; + Configurable isApplyNoHighMultCollInPrevRof{"isApplyNoHighMultCollInPrevRof", false, "Enable NoHighMultCollInPrevRof cut"}; + Configurable isApplyFT0CbasedOccupancy{"isApplyFT0CbasedOccupancy", false, "Enable FT0CbasedOccupancy cut"}; + Configurable isApplyInelgt0{"isApplyInelgt0", false, "Enable INEL > 0 condition"}; + Configurable isApplyOccuCut{"isApplyOccuCut", false, "Enable occupancy selection"}; + + void init(InitContext const&) + { + AxisSpec centAxis = {centralityBinning, "Centrality", "CentralityAxis"}; + AxisSpec axisPt = {ptHistBin, "pT", "pTAxis"}; + AxisSpec impactParAxis = {binsImpactPar, "Impact Parameter"}; + + histos.add("EventHist", "EventHist", kTH1D, {axisEvent}, false); + histos.add("VtxZHist", "VtxZHist", kTH1D, {axisVtxZ}, false); + histos.add("CentPercentileHist", "CentPercentileHist", kTH1D, {axisCent}, false); + histos.add("CentPercentileMCRecHist", "CentPercentileMCRecHist", kTH1D, {axisCent}, false); + histos.add("PhiVsEtaHistNoCut", "PhiVsEtaHistNoCut", kTH2D, {axisPhi, axisEta}, false); + histos.add("PhiVsEtaHistWithCut", "PhiVsEtaHistWithCut", kTH2D, {axisPhi, axisEta}, false); + + if (processDataPbPb) { + histos.add("hdatazvtxcent", "hdatazvtxcent", kTH2D, {axisVtxZ, centAxis}, false); + histos.add("hdatahistPbPb", "hdatahistPbPb", kTHnSparseD, {axisVtxZ, centAxis, axisPt, axisTrackType}, false); + } + + if (processDatapp) { + histos.add("hdatahistpp", "hdatahistpp", kTHnSparseD, {axisVtxZ, axisPt, axisTrackType}, false); + } + + if (processMCPbPb) { + histos.add("hmczvtxcent", "hmczvtxcent", kTH2D, {axisVtxZ, centAxis}, false); + histos.add("hmcrechistPbPb", "hmcrechistPbPb", kTHnSparseD, {axisVtxZ, centAxis, axisPt, axisTrackType}, false); + histos.add("hmcgenhistPbPb", "hmcgenhistPbPb", kTHnSparseD, {axisVtxZ, centAxis, axisPt}, false); + } + + if (processMCpp) { + histos.add("hmcrechistpp", "hmcrechistpp", kTHnSparseD, {axisVtxZ, axisPt, axisTrackType}, false); + histos.add("hmcgenhistpp", "hmcgenhistpp", kTHnSparseD, {axisVtxZ, axisPt}, false); + } + + if (doprocessEvtLossSigLossMCpp || doprocessEvtLossSigLossMCPbPb) { + histos.add("MCEventHist", "MCEventHist", kTH1F, {axisEvent}, false); + auto hstat = histos.get(HIST("MCEventHist")); + auto* x = hstat->GetXaxis(); + x->SetBinLabel(1, "All MC events"); + x->SetBinLabel(2, "MC events with atleast one reco event"); + histos.add("hgenptBeforeEvtSel", "hgenptBeforeEvtSel", kTH1F, {axisPt}, false); + histos.add("hgenptAfterEvtSel", "hgenptAfterEvtSel", kTH1F, {axisPt}, false); + histos.add("hgenptBeforeEvtSelPbPb", "hgenptBeforeEvtSelPbPb", kTH2F, {axisPt, impactParAxis}, false); + histos.add("hgenptAfterEvtSelPbPb", "hgenptAfterEvtSelPbPb", kTH2F, {axisPt, impactParAxis}, false); + histos.add("hImpactParameterGen", "Impact parameter of generated MC events", kTH1F, {impactParAxis}); + histos.add("hImpactParameterRec", "Impact parameter of selected MC events", kTH1F, {impactParAxis}); + histos.add("hImpactParvsCentrRec", "Impact parameter of selected MC events vs centrality", kTH2F, {axisCent, impactParAxis}); + } + + auto hstat = histos.get(HIST("EventHist")); + auto* x = hstat->GetXaxis(); + x->SetBinLabel(1, "All events"); + x->SetBinLabel(2, "sel8"); + x->SetBinLabel(3, "kNoSameBunchPileup"); // reject collisions in case of pileup with another collision in the same foundBC + x->SetBinLabel(4, "kIsGoodZvtxFT0vsPV"); // small difference between z-vertex from PV and from FT0 + x->SetBinLabel(5, "ApplyNoCollInTimeRangeStandard"); + x->SetBinLabel(6, "ApplyNoCollInRofStandard"); + x->SetBinLabel(7, "ApplyNoHighMultCollInPrevRof"); + x->SetBinLabel(8, "INEL > 0"); + x->SetBinLabel(9, "|vz|<10"); + x->SetBinLabel(10, "Occupancy<500"); + } + + template + bool isEventSelected(CheckCol const& col) + { + histos.fill(HIST("EventHist"), 1); + + if (!col.sel8()) { + return false; + } + histos.fill(HIST("EventHist"), 2); + + if (isApplySameBunchPileup && !col.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + return false; + } + histos.fill(HIST("EventHist"), 3); + + if (isApplyGoodZvtxFT0vsPV && !col.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + return false; + } + histos.fill(HIST("EventHist"), 4); + + if (isApplyNoCollInTimeRangeStandard && !col.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { + return false; + } + histos.fill(HIST("EventHist"), 5); + + if (isApplyNoCollInRofStandard && !col.selection_bit(o2::aod::evsel::kNoCollInRofStandard)) { + return false; + } + histos.fill(HIST("EventHist"), 6); + + if (isApplyNoHighMultCollInPrevRof && !col.selection_bit(o2::aod::evsel::kNoHighMultCollInPrevRof)) { + return false; + } + histos.fill(HIST("EventHist"), 7); + + if (isApplyInelgt0 && !col.isInelGt0()) { + return false; + } + histos.fill(HIST("EventHist"), 8); + + if (std::abs(col.posZ()) >= vtxRange) { + return false; + } + histos.fill(HIST("EventHist"), 9); + + auto occu = isApplyFT0CbasedOccupancy ? col.ft0cOccupancyInTimeRange() : col.trackOccupancyInTimeRange(); + if (isApplyOccuCut && occu > occuRange) { + return false; + } + histos.fill(HIST("EventHist"), 10); + return true; + } + + template + bool isTrackSelected(CheckTrack const& track) + { + if (std::abs(track.eta()) >= etaRange) { + return false; + } + histos.fill(HIST("PhiVsEtaHistNoCut"), track.phi(), track.eta()); + if (isApplyExtraPhiCut && ((track.phi() > extraphicut1 && track.phi() < extraphicut2) || track.phi() <= extraphicut3 || track.phi() >= extraphicut4)) { + return false; + } + histos.fill(HIST("PhiVsEtaHistWithCut"), track.phi(), track.eta()); + return true; + } + + template + bool isGenTrackSelected(CheckGenTrack const& track) + { + if (!track.isPhysicalPrimary()) { + return false; + } + if (!track.producedByGenerator()) { + return false; + } + auto pdgTrack = pdg->GetParticle(track.pdgCode()); + if (pdgTrack == nullptr) { + return false; + } + if (std::abs(pdgTrack->Charge()) < kMinCharge) { + return false; + } + if (std::abs(track.eta()) >= etaRange) { + return false; + } + if (isApplyExtraPhiCut && ((track.phi() > extraphicut1 && track.phi() < extraphicut2) || track.phi() <= extraphicut3 || track.phi() >= extraphicut4)) { + return false; + } + return true; + } + + Filter fTrackSelectionITS = ncheckbit(aod::track::v001::detectorMap, (uint8_t)o2::aod::track::ITS) && + ncheckbit(aod::track::trackCutFlag, TrackSelectionIts); + Filter fTrackSelectionTPC = ifnode(ncheckbit(aod::track::v001::detectorMap, (uint8_t)o2::aod::track::TPC), + ncheckbit(aod::track::trackCutFlag, TrackSelectionTpc), true); + Filter fTrackSelectionDCA = ifnode(dcaZ.node() > 0.f, nabs(aod::track::dcaZ) <= dcaZ && ncheckbit(aod::track::trackCutFlag, TrackSelectionDcaxyOnly), + ncheckbit(aod::track::trackCutFlag, TrackSelectionDca)); + Filter fTracksPt = aod::track::pt > cfgPtCutMin; + + + void processDataPbPb(ColDataTablePbPb::iterator const& cols, FilTrackDataTable const& tracks) + { + if (!isEventSelected(cols)) { + return; + } + histos.fill(HIST("VtxZHist"), cols.posZ()); + histos.fill(HIST("CentPercentileHist"), cols.centFT0C()); + histos.fill(HIST("hdatazvtxcent"), cols.posZ(), cols.centFT0C()); + + for (const auto& track : tracks) { + if (!isTrackSelected(track)) { + continue; + } + histos.fill(HIST("hdatahistPbPb"), cols.posZ(), cols.centFT0C(), track.pt(), kGlobalplusITS); + if (track.hasTPC()) { + histos.fill(HIST("hdatahistPbPb"), cols.posZ(), cols.centFT0C(), track.pt(), kGlobalonly); + } else { + histos.fill(HIST("hdatahistPbPb"), cols.posZ(), cols.centFT0C(), track.pt(), kITSonly); + } + } + } + + void processDatapp(ColDataTablepp::iterator const& cols, FilTrackDataTable const& tracks) + { + if (!isEventSelected(cols)) { + return; + } + histos.fill(HIST("VtxZHist"), cols.posZ()); + + for (const auto& track : tracks) { + if (!isTrackSelected(track)) { + continue; + } + histos.fill(HIST("hdatahistpp"), cols.posZ(), track.pt(), kGlobalplusITS); + if (track.hasTPC()) { + histos.fill(HIST("hdatahistpp"), cols.posZ(), track.pt(), kGlobalonly); + } else { + histos.fill(HIST("hdatahistpp"), cols.posZ(), track.pt(), kITSonly); + } + } + } + + void processMCPbPb(ColMCTrueTable::iterator const&, ColMCRecTablePbPb const& RecCols, TrackMCTrueTable const& GenParticles, FilTrackMCRecTable const& RecTracks) + { + + for (const auto& RecCol : RecCols) { + if (!isEventSelected(RecCol)) { + continue; + } + histos.fill(HIST("VtxZHist"), RecCol.posZ()); + histos.fill(HIST("CentPercentileMCRecHist"), RecCol.centFT0C()); + histos.fill(HIST("hmczvtxcent"), RecCol.posZ(), RecCol.centFT0C()); + + auto recTracksPart = RecTracks.sliceBy(perCollision, RecCol.globalIndex()); + for (const auto& Rectrack : recTracksPart) { + if (!isTrackSelected(Rectrack)) { + continue; + } + histos.fill(HIST("hmcrechistPbPb"), RecCol.posZ(), RecCol.centFT0C(), Rectrack.pt(), kGlobalplusITS); + if (Rectrack.hasTPC()) { + histos.fill(HIST("hmcrechistPbPb"), RecCol.posZ(), RecCol.centFT0C(), Rectrack.pt(), kGlobalonly); + } else { + histos.fill(HIST("hmcrechistPbPb"), RecCol.posZ(), RecCol.centFT0C(), Rectrack.pt(), kITSonly); + } + } // track (mcrec) loop + + for (const auto& particle : GenParticles) { + if (!isGenTrackSelected(particle)) { + continue; + } + histos.fill(HIST("hmcgenhistPbPb"), RecCol.posZ(), RecCol.centFT0C(), particle.pt()); + } // track (mcgen) loop + } // collision loop + } + + void processMCpp(ColMCTrueTable::iterator const&, ColMCRecTablepp const& RecCols, TrackMCTrueTable const& GenParticles, FilTrackMCRecTable const& RecTracks) + { + + for (const auto& RecCol : RecCols) { + if (!isEventSelected(RecCol)) { + continue; + } + histos.fill(HIST("VtxZHist"), RecCol.posZ()); + + auto recTracksPart = RecTracks.sliceBy(perCollision, RecCol.globalIndex()); + for (const auto& Rectrack : recTracksPart) { + if (!isTrackSelected(Rectrack)) { + continue; + } + histos.fill(HIST("hmcrechistpp"), RecCol.posZ(), Rectrack.pt(), kGlobalplusITS); + if (Rectrack.hasTPC()) { + histos.fill(HIST("hmcrechistpp"), RecCol.posZ(), Rectrack.pt(), kGlobalonly); + } else { + histos.fill(HIST("hmcrechistpp"), RecCol.posZ(), Rectrack.pt(), kITSonly); + } + } // track (mcrec) loop + + for (const auto& particle : GenParticles) { + if (!isGenTrackSelected(particle)) { + continue; + } + histos.fill(HIST("hmcgenhistpp"), RecCol.posZ(), particle.pt()); + } // track (mcgen) loop + } // collision loop + } + + void processEvtLossSigLossMCpp(soa::Join::iterator const& mcCollision, ColMCRecTablepp const& RecCols, TrackMCTrueTable const& GenParticles) + { + if (isApplyInelgt0 && !mcCollision.isInelGt0()) { + return; + } + if (std::abs(mcCollision.posZ()) >= vtxRange) { + return; + } + // All generated events + histos.fill(HIST("MCEventHist"), 1); + + bool atLeastOne = false; + auto numcontributors = -999; + for (const auto& RecCol : RecCols) { + if (!isEventSelected(RecCol)) { + continue; + } + if (RecCol.numContrib() <= numcontributors) { + continue; + } else { + numcontributors = RecCol.numContrib(); + } + atLeastOne = true; + } + if (atLeastOne) { + histos.fill(HIST("MCEventHist"), 2); + } + for (const auto& particle : GenParticles) { + if (!isGenTrackSelected(particle)) { + continue; + } + // All generated particles + histos.fill(HIST("hgenptBeforeEvtSel"), particle.pt()); + if (atLeastOne) { + // All generated particles with at least one reconstructed collision (signal loss estimation) + histos.fill(HIST("hgenptAfterEvtSel"), particle.pt()); + } + } + } + + void processEvtLossSigLossMCPbPb(soa::Join::iterator const& mcCollision, ColMCRecTablePbPb const& RecCols, TrackMCTrueTable const& GenParticles) + { + if (isApplyInelgt0 && !mcCollision.isInelGt0()) { + return; + } + if (std::abs(mcCollision.posZ()) >= vtxRange) { + return; + } + // All generated events + histos.fill(HIST("MCEventHist"), 1); + histos.fill(HIST("hImpactParameterGen"), mcCollision.impactParameter()); + + bool atLeastOne = false; + auto centrality = -999.; + auto numcontributors = -999; + for (const auto& RecCol : RecCols) { + if (!isEventSelected(RecCol)) { + continue; + } + if (RecCol.numContrib() <= numcontributors) { + continue; + } else { + numcontributors = RecCol.numContrib(); + } + centrality = RecCol.centFT0C(); + atLeastOne = true; + } + if (atLeastOne) { + histos.fill(HIST("MCEventHist"), 2); + histos.fill(HIST("hImpactParameterRec"), mcCollision.impactParameter()); + histos.fill(HIST("hImpactParvsCentrRec"), centrality, mcCollision.impactParameter()); + } + for (const auto& particle : GenParticles) { + if (!isGenTrackSelected(particle)) { + continue; + } + // All generated particles + histos.fill(HIST("hgenptBeforeEvtSelPbPb"), particle.pt(), mcCollision.impactParameter()); + if (atLeastOne) { + // All generated particles with at least one reconstructed collision (signal loss estimation) + histos.fill(HIST("hgenptAfterEvtSelPbPb"), particle.pt(), mcCollision.impactParameter()); + } + } + } + + PROCESS_SWITCH(ChargedparticleRaa, processDataPbPb, "process data heavy-ion", false); + PROCESS_SWITCH(ChargedparticleRaa, processDatapp, "process data pp", false); + PROCESS_SWITCH(ChargedparticleRaa, processMCPbPb, "process MC heavy-ion", false); + PROCESS_SWITCH(ChargedparticleRaa, processMCpp, "process MC pp", false); + PROCESS_SWITCH(ChargedparticleRaa, processEvtLossSigLossMCpp, "process Signal Loss, Event Loss", false); + PROCESS_SWITCH(ChargedparticleRaa, processEvtLossSigLossMCPbPb, "process Signal Loss, Event Loss", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From 63978ed6da848c1362b75f8975d783f721d2b3c4 Mon Sep 17 00:00:00 2001 From: abmodak <67369858+abmodak@users.noreply.github.com> Date: Wed, 1 Oct 2025 17:52:22 +0200 Subject: [PATCH 2/5] Update CMakeLists.txt --- PWGLF/Tasks/Nuspex/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/PWGLF/Tasks/Nuspex/CMakeLists.txt b/PWGLF/Tasks/Nuspex/CMakeLists.txt index 38d5704f683..49d0e1a336d 100644 --- a/PWGLF/Tasks/Nuspex/CMakeLists.txt +++ b/PWGLF/Tasks/Nuspex/CMakeLists.txt @@ -165,4 +165,9 @@ o2physics_add_dpl_workflow(pikp-raa-analysis PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(chargedparticle-raa + SOURCES ChargedparticleRaa.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + endif() From adc0f445a88c232b3f9f3540266716613950af00 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 1 Oct 2025 15:53:47 +0000 Subject: [PATCH 3/5] Please consider the following formatting changes --- PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx | 42 ++++++++++++----------- 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx b/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx index 38ffcc00142..a1103b0b728 100644 --- a/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx +++ b/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx @@ -15,20 +15,20 @@ /// \author Abhi Modak (abhi.modak@cern.ch) /// \since October 01, 2025 -#include -#include -#include -#include - +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "PWGMM/Mult/DataModel/Index.h" #include "PWGMM/Mult/DataModel/bestCollisionTable.h" -#include "CCDB/BasicCCDBManager.h" -#include "Common/Core/trackUtilities.h" + #include "Common/CCDB/EventSelectionParams.h" #include "Common/Core/TrackSelection.h" +#include "Common/Core/trackUtilities.h" #include "Common/DataModel/Centrality.h" -#include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/PIDResponse.h" #include "Common/DataModel/TrackSelectionTables.h" + +#include "CCDB/BasicCCDBManager.h" #include "CommonConstants/MathConstants.h" #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" @@ -38,9 +38,12 @@ #include "Framework/runDataProcessing.h" #include "ReconstructionDataFormats/GlobalTrackID.h" #include "ReconstructionDataFormats/Track.h" -#include "PWGMM/Mult/DataModel/Index.h" -#include "Common/DataModel/PIDResponse.h" -#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include + +#include +#include +#include using namespace o2; using namespace o2::framework; @@ -277,7 +280,6 @@ struct ChargedparticleRaa { ncheckbit(aod::track::trackCutFlag, TrackSelectionDca)); Filter fTracksPt = aod::track::pt > cfgPtCutMin; - void processDataPbPb(ColDataTablePbPb::iterator const& cols, FilTrackDataTable const& tracks) { if (!isEventSelected(cols)) { @@ -306,7 +308,7 @@ struct ChargedparticleRaa { return; } histos.fill(HIST("VtxZHist"), cols.posZ()); - + for (const auto& track : tracks) { if (!isTrackSelected(track)) { continue; @@ -341,7 +343,7 @@ struct ChargedparticleRaa { histos.fill(HIST("hmcrechistPbPb"), RecCol.posZ(), RecCol.centFT0C(), Rectrack.pt(), kGlobalonly); } else { histos.fill(HIST("hmcrechistPbPb"), RecCol.posZ(), RecCol.centFT0C(), Rectrack.pt(), kITSonly); - } + } } // track (mcrec) loop for (const auto& particle : GenParticles) { @@ -361,7 +363,7 @@ struct ChargedparticleRaa { continue; } histos.fill(HIST("VtxZHist"), RecCol.posZ()); - + auto recTracksPart = RecTracks.sliceBy(perCollision, RecCol.globalIndex()); for (const auto& Rectrack : recTracksPart) { if (!isTrackSelected(Rectrack)) { @@ -372,7 +374,7 @@ struct ChargedparticleRaa { histos.fill(HIST("hmcrechistpp"), RecCol.posZ(), Rectrack.pt(), kGlobalonly); } else { histos.fill(HIST("hmcrechistpp"), RecCol.posZ(), Rectrack.pt(), kITSonly); - } + } } // track (mcrec) loop for (const auto& particle : GenParticles) { @@ -394,7 +396,7 @@ struct ChargedparticleRaa { } // All generated events histos.fill(HIST("MCEventHist"), 1); - + bool atLeastOne = false; auto numcontributors = -999; for (const auto& RecCol : RecCols) { @@ -435,7 +437,7 @@ struct ChargedparticleRaa { // All generated events histos.fill(HIST("MCEventHist"), 1); histos.fill(HIST("hImpactParameterGen"), mcCollision.impactParameter()); - + bool atLeastOne = false; auto centrality = -999.; auto numcontributors = -999; @@ -467,8 +469,8 @@ struct ChargedparticleRaa { histos.fill(HIST("hgenptAfterEvtSelPbPb"), particle.pt(), mcCollision.impactParameter()); } } - } - + } + PROCESS_SWITCH(ChargedparticleRaa, processDataPbPb, "process data heavy-ion", false); PROCESS_SWITCH(ChargedparticleRaa, processDatapp, "process data pp", false); PROCESS_SWITCH(ChargedparticleRaa, processMCPbPb, "process MC heavy-ion", false); From 4f483139fad59e9683237ebf1991195f7faa4c09 Mon Sep 17 00:00:00 2001 From: abmodak <67369858+abmodak@users.noreply.github.com> Date: Wed, 1 Oct 2025 17:58:00 +0200 Subject: [PATCH 4/5] Fix o2 linter error --- PWGLF/Tasks/Nuspex/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/Tasks/Nuspex/CMakeLists.txt b/PWGLF/Tasks/Nuspex/CMakeLists.txt index 49d0e1a336d..7e7e4d99c8a 100644 --- a/PWGLF/Tasks/Nuspex/CMakeLists.txt +++ b/PWGLF/Tasks/Nuspex/CMakeLists.txt @@ -166,7 +166,7 @@ o2physics_add_dpl_workflow(pikp-raa-analysis COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(chargedparticle-raa - SOURCES ChargedparticleRaa.cxx + SOURCES chargedparticleRaa.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) From ca8c06a4d0552ae80c523c657fe3bdf4b7c8b065 Mon Sep 17 00:00:00 2001 From: abmodak <67369858+abmodak@users.noreply.github.com> Date: Wed, 1 Oct 2025 18:10:43 +0200 Subject: [PATCH 5/5] Update chargedparticleRaa.cxx --- PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx b/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx index a1103b0b728..e0155a6e514 100644 --- a/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx +++ b/PWGLF/Tasks/Nuspex/chargedparticleRaa.cxx @@ -131,22 +131,22 @@ struct ChargedparticleRaa { histos.add("PhiVsEtaHistNoCut", "PhiVsEtaHistNoCut", kTH2D, {axisPhi, axisEta}, false); histos.add("PhiVsEtaHistWithCut", "PhiVsEtaHistWithCut", kTH2D, {axisPhi, axisEta}, false); - if (processDataPbPb) { + if (doprocessDataPbPb) { histos.add("hdatazvtxcent", "hdatazvtxcent", kTH2D, {axisVtxZ, centAxis}, false); histos.add("hdatahistPbPb", "hdatahistPbPb", kTHnSparseD, {axisVtxZ, centAxis, axisPt, axisTrackType}, false); } - if (processDatapp) { + if (doprocessDatapp) { histos.add("hdatahistpp", "hdatahistpp", kTHnSparseD, {axisVtxZ, axisPt, axisTrackType}, false); } - if (processMCPbPb) { + if (doprocessMCPbPb) { histos.add("hmczvtxcent", "hmczvtxcent", kTH2D, {axisVtxZ, centAxis}, false); histos.add("hmcrechistPbPb", "hmcrechistPbPb", kTHnSparseD, {axisVtxZ, centAxis, axisPt, axisTrackType}, false); histos.add("hmcgenhistPbPb", "hmcgenhistPbPb", kTHnSparseD, {axisVtxZ, centAxis, axisPt}, false); } - if (processMCpp) { + if (doprocessMCpp) { histos.add("hmcrechistpp", "hmcrechistpp", kTHnSparseD, {axisVtxZ, axisPt, axisTrackType}, false); histos.add("hmcgenhistpp", "hmcgenhistpp", kTHnSparseD, {axisVtxZ, axisPt}, false); }