From fca416f544ab4575c46f9526986657410b8bc056 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 7 Aug 2025 12:54:09 +0000 Subject: [PATCH] Please consider the following formatting changes --- .../cascadeAnalysisLightIonsDerivedData.cxx | 539 +++++++++--------- 1 file changed, 283 insertions(+), 256 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 01b65073f3e..994c01ad43f 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -27,15 +27,14 @@ #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/PIDResponse.h" #include "Common/DataModel/TrackSelectionTables.h" + #include "CommonConstants/MathConstants.h" #include "CommonConstants/PhysicsConstants.h" - #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" #include "Framework/O2DatabasePDGPlugin.h" #include "Framework/runDataProcessing.h" - #include "ReconstructionDataFormats/Track.h" #include @@ -60,7 +59,6 @@ using DaughterTracks = soa::Join; using CollisionMCTrueTable = soa::Join; using CascadeMCCores = soa::Join; - struct CascadeAnalysisLightIonsDerivedData { // Instantiate the CCDB service and API interface @@ -81,11 +79,23 @@ struct CascadeAnalysisLightIonsDerivedData { // Define histogram registries HistogramRegistry registryData{ - "registryData", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + "registryData", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; HistogramRegistry registryMC{ - "registryMC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + "registryMC", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; HistogramRegistry registryQC{ - "registryQC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + "registryQC", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; // Global analysis parameters Configurable zVtx{"zVtx", 10.0, "Maximum zVertex"}; @@ -150,35 +160,39 @@ struct CascadeAnalysisLightIonsDerivedData { Configurable v0masswindow{"v0masswindow", 0.005, "v0 mass window"}; Configurable competingmassrej{"competingmassrej", 0.008, "Competing mass rejection"}; - + // Axes parameters ConfigurableAxis centEstimatorHistBin{"centEstimatorHistBin", {501, -0.5, 500.5}, ""}; - ConfigurableAxis centralityBinning{"centralityBinning",{VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100},""}; + ConfigurableAxis centralityBinning{"centralityBinning", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, ""}; ConfigurableAxis axisNch{"axisNch", {500, 0.0f, +1000.0f}, "Number of charged particles"}; - - // Centrality estimator + + // Centrality estimator Configurable centralityEstimator{"centralityEstimator", 0, "0 = FT0C, 1 = FTOM, 2 = FV0A, 3 = NGlobal"}; - + // List of estimators - enum Option { kFT0C, kFT0M, kFV0A, kNGlobal}; + enum Option { kFT0C, + kFT0M, + kFV0A, + kNGlobal }; // For manual sliceBy PresliceUnsorted> perMcCollision = aod::v0data::straMCCollisionId; - void init(InitContext const &) { + void init(InitContext const&) + { // setting CCDB service ccdb->setURL(ccdbConfigurations.ccdbUrl); ccdb->setCaching(true); ccdb->setFatalWhenNull(false); ccdb->setLocalObjectValidityChecking(); ccdb->setCreatedNotAfter( - std::chrono::duration_cast( - std::chrono::system_clock::now().time_since_epoch()) - .count()); + std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count()); // Axes and Binning AxisSpec axisCentEstimator = {centEstimatorHistBin, "CentEstimator", - "CentEstimatorAxis"}; + "CentEstimatorAxis"}; AxisSpec centAxis = {centralityBinning, "Centrality", "CentralityAxis"}; const AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; const AxisSpec etaAxis{18, -0.9, 0.9, "#eta"}; @@ -195,35 +209,35 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.add("number_of_events_data", "number of events in data", HistType::kTH1D, {{20, -0.5f, +19.5f}}); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(1, "All collisions"); + ->GetXaxis() + ->SetBinLabel(1, "All collisions"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(2, "sel8 cut"); + ->GetXaxis() + ->SetBinLabel(2, "sel8 cut"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(3, "posZ cut"); + ->GetXaxis() + ->SetBinLabel(3, "posZ cut"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(4, "kNoITSROFrameBorder"); + ->GetXaxis() + ->SetBinLabel(4, "kNoITSROFrameBorder"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(5, "kNoTimeFrameBorder"); + ->GetXaxis() + ->SetBinLabel(5, "kNoTimeFrameBorder"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(6, "kIsVertexITSTPC"); + ->GetXaxis() + ->SetBinLabel(6, "kIsVertexITSTPC"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); + ->GetXaxis() + ->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(8, "kIsVertexTOFmatched"); + ->GetXaxis() + ->SetBinLabel(8, "kIsVertexTOFmatched"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(9, "kIsVertexTRDmatched"); + ->GetXaxis() + ->SetBinLabel(9, "kIsVertexTRDmatched"); registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(10, "kNoSameBunchPileup"); + ->GetXaxis() + ->SetBinLabel(10, "kNoSameBunchPileup"); // QC Histograms registryQC.add("hVertexZdata", "hVertexZdata", HistType::kTH1F, {vertexZAxis}); @@ -242,8 +256,8 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {axisCentEstimator}); registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, - {axisCentEstimator,axisNch}); - + {axisCentEstimator, axisNch}); + // Histograms for xi (data) registryData.add("hMassXipos", "hMassXipos", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); @@ -253,7 +267,7 @@ struct CascadeAnalysisLightIonsDerivedData { HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); registryData.add("hMassXinegSelected", "hMassXinegSelected", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - + // Histograms for omega (data) registryData.add("hMassOmegapos", "hMassOmegapos", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); @@ -272,35 +286,35 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.add("number_of_events_mc_rec", "number of events in mc_rec", HistType::kTH1D, {{20, -0.5f, +19.5f}}); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(1, "All collisions"); + ->GetXaxis() + ->SetBinLabel(1, "All collisions"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(2, "sel8 cut"); + ->GetXaxis() + ->SetBinLabel(2, "sel8 cut"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(3, "posZ cut"); + ->GetXaxis() + ->SetBinLabel(3, "posZ cut"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(4, "kNoITSROFrameBorder"); + ->GetXaxis() + ->SetBinLabel(4, "kNoITSROFrameBorder"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(5, "kNoTimeFrameBorder"); + ->GetXaxis() + ->SetBinLabel(5, "kNoTimeFrameBorder"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(6, "kIsVertexITSTPC"); + ->GetXaxis() + ->SetBinLabel(6, "kIsVertexITSTPC"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); + ->GetXaxis() + ->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(8, "kIsVertexTOFmatched"); + ->GetXaxis() + ->SetBinLabel(8, "kIsVertexTOFmatched"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(9, "kIsVertexTRDmatched"); + ->GetXaxis() + ->SetBinLabel(9, "kIsVertexTRDmatched"); registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(10, "kNoSameBunchPileup"); + ->GetXaxis() + ->SetBinLabel(10, "kNoSameBunchPileup"); // QC Histograms registryQC.add("hVertexZRec", "hVertexZRec", @@ -330,8 +344,8 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {axisCentEstimator}); registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, - {axisCentEstimator,axisNch}); - + {axisCentEstimator, axisNch}); + // Histograms for xi (mc) registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); @@ -358,7 +372,7 @@ struct CascadeAnalysisLightIonsDerivedData { "hMassOmeganegSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); } - + if (doprocessMonteCarloGen) { // Histograms for mc generated // QC Histograms @@ -369,13 +383,13 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.add("h2dGenXiPlusVsMultMC_RecoedEvt", "h2dGenXiPlusVsMultMC_RecoedEvt", HistType::kTH2F, {axisNch, ptAxis}); registryMC.add("h2dGenXiMinusVsMultMC", "h2dGenXiMinusVsMultMC", HistType::kTH2F, {axisNch, ptAxis}); registryMC.add("h2dGenXiPlusVsMultMC", "h2dGenXiPlusVsMultMC", HistType::kTH2F, {axisNch, ptAxis}); - + // Histograms for omega (mc) registryMC.add("h2dGenOmegaMinusVsMultMC_RecoedEvt", "h2dGenOmegaMinusVsMultMC_RecoedEvt", HistType::kTH2F, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaPlusVsMultMC_RecoedEvt", "h2dGenOmegaPlusVsMultMC_RecoedEvt", HistType::kTH2F, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaMinusVsMultMC", "h2dGenOmegaMinusVsMultMC", HistType::kTH2F, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaPlusVsMultMC", "h2dGenOmegaPlusVsMultMC", HistType::kTH2F, {axisNch, ptAxis}); - + // Histograms for event loss/splitting registryMC.add("hGenEvents", "hGenEvents", HistType::kTH2F, {{axisNch}, {2, -0.5f, +1.5f}}); registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(1, "All gen. events"); @@ -387,8 +401,6 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.add("hCentralityVsMultMC", "hCentralityVsMultMC", HistType::kTH2F, {{101, 0.0f, 101.0f}, axisNch}); } - - } // ______________________________________________________ @@ -419,7 +431,8 @@ struct CascadeAnalysisLightIonsDerivedData { // Single-Track Selection template - bool passedSingleTrackSelection(const Track &track) { + bool passedSingleTrackSelection(const Track& track) + { if (requireITS && (!track.hasITS())) return false; if (requireITS && track.itsNCls() < minITSnCls) @@ -440,9 +453,10 @@ struct CascadeAnalysisLightIonsDerivedData { // Xi Selection template - bool passedXiSelection(const Xi &casc, const TrackPos &ptrack, - const TrackNeg &ntrack, const TrackBac &btrack, - const Coll &coll) { + bool passedXiSelection(const Xi& casc, const TrackPos& ptrack, + const TrackNeg& ntrack, const TrackBac& btrack, + const Coll& coll) + { if (!passedSingleTrackSelection(ptrack)) return false; if (!passedSingleTrackSelection(ntrack)) @@ -547,9 +561,10 @@ struct CascadeAnalysisLightIonsDerivedData { // Omega Selection template - bool passedOmegaSelection(const Omega &casc, const TrackPos &ptrack, - const TrackNeg &ntrack, const TrackBac &btrack, - const Coll &coll) { + bool passedOmegaSelection(const Omega& casc, const TrackPos& ptrack, + const TrackNeg& ntrack, const TrackBac& btrack, + const Coll& coll) + { if (!passedSingleTrackSelection(ptrack)) return false; if (!passedSingleTrackSelection(ntrack)) @@ -648,7 +663,7 @@ struct CascadeAnalysisLightIonsDerivedData { } return true; } - + // Return the list of indices to the recoed collision associated to a given MC collision. template std::vector getListOfRecoCollIndices(TMCollisions const& mcCollisions, TCollisions const& collisions) @@ -659,56 +674,55 @@ struct CascadeAnalysisLightIonsDerivedData { int biggestNContribs = -1; int bestCollisionIndex = -1; for (auto const& collision : groupedCollisions) { - + // event selections if (applySel8 && !collision.sel8()) continue; - + if (applyVtxZ && std::fabs(collision.posZ()) > zVtx) continue; - + if (rejectITSROFBorder && !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { continue; } - + if (rejectTFBorder && !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { continue; } - + if (requireVertexITSTPC && !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { continue; } - + if (requireIsGoodZvtxFT0VsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { continue; } - + if (requireIsVertexTOFmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { continue; } - + if (requireIsVertexTRDmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { continue; } - + if (rejectSameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { continue; } - + // Find the collision with the biggest nbr of PV contributors // Follows what was done here: https://github.com/AliceO2Group/O2Physics/blob/master/Common/TableProducer/mcCollsExtra.cxx#L93 if (biggestNContribs < collision.multPVTotalContributors()) { biggestNContribs = collision.multPVTotalContributors(); bestCollisionIndex = collision.globalIndex(); } - } listBestCollisionIdx[mcCollision.globalIndex()] = bestCollisionIndex; } @@ -719,97 +733,101 @@ struct CascadeAnalysisLightIonsDerivedData { template void fillGeneratedEventProperties(TMCCollisions const& mcCollisionss, TCollisions const& collisions) { - std::vector listBestCollisionIdx(mcCollisionss.size()); - for (auto const& mcCollisions : mcCollisionss) { - - // event selections - if (applyVtxZ && std::fabs(mcCollisions.posZ()) > zVtx) + std::vector listBestCollisionIdx(mcCollisionss.size()); + for (auto const& mcCollisions : mcCollisionss) { + + // event selections + if (applyVtxZ && std::fabs(mcCollisions.posZ()) > zVtx) return; - - registryMC.fill(HIST("hGenEvents"), mcCollisions.multMCNParticlesEta05(), 0 /* all gen. events*/); - - auto groupedCollisions = getGroupedCollisions(collisions, mcCollisions.globalIndex()); - // Check if there is at least one of the reconstructed collisions associated to this MC collision - // If so, we consider it - bool atLeastOne = false; - int biggestNContribs = -1; - float centrality = 100.5f; - int nCollisions = 0; - for (auto const& collision : groupedCollisions) { - - // event selections - if (applySel8 && !collision.sel8()) - continue; - - if (applyVtxZ && std::fabs(collision.posZ()) > zVtx) - continue; - - if (rejectITSROFBorder && - !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { - continue; - } - - if (rejectTFBorder && - !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { - continue; - } - - if (requireVertexITSTPC && - !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { - continue; - } - - if (requireIsGoodZvtxFT0VsPV && - !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { - continue; - } - - if (requireIsVertexTOFmatched && - !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { - continue; - } - - if (requireIsVertexTRDmatched && - !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { - continue; - } - - if (rejectSameBunchPileup && - !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { - continue; - } - - - if (biggestNContribs < collision.multPVTotalContributors()) { - biggestNContribs = collision.multPVTotalContributors(); - if(centralityEstimator == Option::kFT0C) centrality = collision.centFT0C(); - if(centralityEstimator == Option::kFT0M) centrality = collision.centFT0M(); - if(centralityEstimator == Option::kFV0A) centrality = collision.centFV0A(); - if(centralityEstimator == Option::kNGlobal) centrality = collision.centNGlobal(); - } - nCollisions++; - - atLeastOne = true; - } - - registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), centrality, groupedCollisions.size()); - registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), centrality, nCollisions); - registryMC.fill(HIST("hCentralityVsMultMC"), centrality, mcCollisions.multMCNParticlesEta05()); - - registryQC.fill(HIST("hVertexZGen"), mcCollisions.posZ()); - - if (atLeastOne) { - registryMC.fill(HIST("hGenEvents"), mcCollisions.multMCNParticlesEta05(), 1 /* at least 1 rec. event*/); - - registryMC.fill(HIST("hGenEventCentrality"), centrality); - } - } - return; + + registryMC.fill(HIST("hGenEvents"), mcCollisions.multMCNParticlesEta05(), 0 /* all gen. events*/); + + auto groupedCollisions = getGroupedCollisions(collisions, mcCollisions.globalIndex()); + // Check if there is at least one of the reconstructed collisions associated to this MC collision + // If so, we consider it + bool atLeastOne = false; + int biggestNContribs = -1; + float centrality = 100.5f; + int nCollisions = 0; + for (auto const& collision : groupedCollisions) { + + // event selections + if (applySel8 && !collision.sel8()) + continue; + + if (applyVtxZ && std::fabs(collision.posZ()) > zVtx) + continue; + + if (rejectITSROFBorder && + !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { + continue; + } + + if (rejectTFBorder && + !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + continue; + } + + if (requireVertexITSTPC && + !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { + continue; + } + + if (requireIsGoodZvtxFT0VsPV && + !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + continue; + } + + if (requireIsVertexTOFmatched && + !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + continue; + } + + if (requireIsVertexTRDmatched && + !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { + continue; + } + + if (rejectSameBunchPileup && + !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + continue; + } + + if (biggestNContribs < collision.multPVTotalContributors()) { + biggestNContribs = collision.multPVTotalContributors(); + if (centralityEstimator == Option::kFT0C) + centrality = collision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + centrality = collision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + centrality = collision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + centrality = collision.centNGlobal(); + } + nCollisions++; + + atLeastOne = true; + } + + registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), centrality, groupedCollisions.size()); + registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), centrality, nCollisions); + registryMC.fill(HIST("hCentralityVsMultMC"), centrality, mcCollisions.multMCNParticlesEta05()); + + registryQC.fill(HIST("hVertexZGen"), mcCollisions.posZ()); + + if (atLeastOne) { + registryMC.fill(HIST("hGenEvents"), mcCollisions.multMCNParticlesEta05(), 1 /* at least 1 rec. event*/); + + registryMC.fill(HIST("hGenEventCentrality"), centrality); + } + } + return; } void processData(SelCollisions::iterator const& collision, CascadeCandidates const& fullCascades, - DaughterTracks const& tracks) { + DaughterTracks const& tracks) + { // Fill event counter before event selection registryData.fill(HIST("number_of_events_data"), 0); @@ -857,16 +875,16 @@ struct CascadeAnalysisLightIonsDerivedData { return; } registryData.fill( - HIST("number_of_events_data"), - 7 /* PV with at least one contributor matched with TOF */); + HIST("number_of_events_data"), + 7 /* PV with at least one contributor matched with TOF */); if (requireIsVertexTRDmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { return; } registryData.fill( - HIST("number_of_events_data"), - 8 /* PV with at least one contributor matched with TRD */); + HIST("number_of_events_data"), + 8 /* PV with at least one contributor matched with TRD */); if (rejectSameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { @@ -877,21 +895,25 @@ struct CascadeAnalysisLightIonsDerivedData { // Store the Zvtx registryQC.fill(HIST("hVertexZdata"), std::fabs(collision.posZ())); - + // Store the event multiplicity using different estimators float multiplicity = -1.0f; - if(centralityEstimator == Option::kFT0C) multiplicity = collision.centFT0C(); - if(centralityEstimator == Option::kFT0M) multiplicity = collision.centFT0M(); - if(centralityEstimator == Option::kFV0A) multiplicity = collision.centFV0A(); - if(centralityEstimator == Option::kNGlobal) multiplicity = collision.centNGlobal(); - + if (centralityEstimator == Option::kFT0C) + multiplicity = collision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + multiplicity = collision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + multiplicity = collision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + multiplicity = collision.centNGlobal(); + registryData.fill(HIST("hCentEstimator"), multiplicity); registryData.fill(HIST("hCentralityVsNch"), multiplicity, collision.multNTracksPVeta1()); - + // Loop over cascades for (const auto& casc : fullCascades) { - if (etaMin > casc.bacheloreta() || casc.bacheloreta() > etaMax || - etaMin > casc.negativeeta() || casc.negativeeta() > etaMax || + if (etaMin > casc.bacheloreta() || casc.bacheloreta() > etaMax || + etaMin > casc.negativeeta() || casc.negativeeta() > etaMax || etaMin > casc.positiveeta() || casc.positiveeta() > etaMax) continue; // remove acceptance that's badly reproduced by MC / superfluous in future @@ -903,15 +925,15 @@ struct CascadeAnalysisLightIonsDerivedData { // ------------------------------------- Store selctions distribution for QC registryQC.fill(HIST("hv0cosPAdata"), casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ())); registryQC.fill(HIST("hcasccosPAdata"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); - registryQC.fill(HIST("hv0radiusdata"),casc.v0radius()); - registryQC.fill(HIST("hcascradiusdata"),casc.cascradius()); - registryQC.fill(HIST("hdcaV0daughtersdata"),casc.dcaV0daughters()); - registryQC.fill(HIST("hdcacascdaughtersdata"),casc.dcacascdaughters()); - registryQC.fill(HIST("hdcapostopvdata"),casc.dcapostopv()); - registryQC.fill(HIST("hdcanegtopvdata"),casc.dcanegtopv()); - registryQC.fill(HIST("hdcabachtopvdata"),casc.dcabachtopv()); - registryQC.fill(HIST("hdcav0topvdata"),casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ())); - + registryQC.fill(HIST("hv0radiusdata"), casc.v0radius()); + registryQC.fill(HIST("hcascradiusdata"), casc.cascradius()); + registryQC.fill(HIST("hdcaV0daughtersdata"), casc.dcaV0daughters()); + registryQC.fill(HIST("hdcacascdaughtersdata"), casc.dcacascdaughters()); + registryQC.fill(HIST("hdcapostopvdata"), casc.dcapostopv()); + registryQC.fill(HIST("hdcanegtopvdata"), casc.dcanegtopv()); + registryQC.fill(HIST("hdcabachtopvdata"), casc.dcabachtopv()); + registryQC.fill(HIST("hdcav0topvdata"), casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ())); + // ------------------------------------- Store selctions distribution for analysis if (casc.sign() < 0) { registryData.fill(HIST("hMassXineg"), multiplicity, @@ -951,20 +973,21 @@ struct CascadeAnalysisLightIonsDerivedData { PROCESS_SWITCH(cascadeAnalysisLightIonsDerivedData, processData, "Process data", true); - void processMonteCarloRec(SimCollisions const& RecCols, - CascadeMCCandidates const& fullCascades, - DaughterTracks const& mcTracks, - CollisionMCTrueTable const& mcCollisions, - CascadeMCCores const& CascMCCores) { - + void processMonteCarloRec(SimCollisions const& RecCols, + CascadeMCCandidates const& fullCascades, + DaughterTracks const& mcTracks, + CollisionMCTrueTable const& mcCollisions, + CascadeMCCores const& CascMCCores) + { + for (const auto& RecCol : RecCols) { - + // Fill event counter before event selection registryMC.fill(HIST("number_of_events_mc_rec"), 0); - + // Initialize CCDB objects using the BC info initCCDB(RecCol); - + // event selections if (applySel8 && !RecCol.sel8()) continue; @@ -1007,16 +1030,16 @@ struct CascadeAnalysisLightIonsDerivedData { continue; } registryMC.fill( - HIST("number_of_events_mc_rec"), - 7 /* PV with at least one contributor matched with TOF */); + HIST("number_of_events_mc_rec"), + 7 /* PV with at least one contributor matched with TOF */); if (requireIsVertexTRDmatched && !RecCol.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { continue; } registryMC.fill( - HIST("number_of_events_mc_rec"), - 8 /* PV with at least one contributor matched with TRD */); + HIST("number_of_events_mc_rec"), + 8 /* PV with at least one contributor matched with TRD */); if (rejectSameBunchPileup && !RecCol.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { @@ -1030,23 +1053,27 @@ struct CascadeAnalysisLightIonsDerivedData { // Store the event multiplicity using different estimators float multiplicityMcRec = -1.0f; - - if(centralityEstimator == Option::kFT0C) multiplicityMcRec = RecCol.centFT0C(); - if(centralityEstimator == Option::kFT0M) multiplicityMcRec = RecCol.centFT0M(); - if(centralityEstimator == Option::kFV0A) multiplicityMcRec = RecCol.centFV0A(); - if(centralityEstimator == Option::kNGlobal) multiplicityMcRec = RecCol.centNGlobal(); - + + if (centralityEstimator == Option::kFT0C) + multiplicityMcRec = RecCol.centFT0C(); + if (centralityEstimator == Option::kFT0M) + multiplicityMcRec = RecCol.centFT0M(); + if (centralityEstimator == Option::kFV0A) + multiplicityMcRec = RecCol.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + multiplicityMcRec = RecCol.centNGlobal(); + registryMC.fill(HIST("hCentEstimator_truerec"), multiplicityMcRec); registryMC.fill(HIST("hCentralityVsNch_truerec"), multiplicityMcRec, RecCol.multNTracksPVeta1()); for (const auto& casc : fullCascades) { - if (etaMin > casc.bacheloreta() || casc.bacheloreta() > etaMax || - etaMin > casc.negativeeta() || casc.negativeeta() > etaMax || + if (etaMin > casc.bacheloreta() || casc.bacheloreta() > etaMax || + etaMin > casc.negativeeta() || casc.negativeeta() > etaMax || etaMin > casc.positiveeta() || casc.positiveeta() > etaMax) continue; // remove acceptance that's badly reproduced by MC / superfluous in future - + if (!casc.has_cascMCCore()) continue; @@ -1055,28 +1082,28 @@ struct CascadeAnalysisLightIonsDerivedData { auto bach = casc.bachTrackExtra_as(); auto pos = casc.posTrackExtra_as(); auto neg = casc.negTrackExtra_as(); - + int pdgParent = cascMC.pdgCode(); bool isPhysPrim = cascMC.isPhysicalPrimary(); if (pdgParent == 0) continue; if (!isPhysPrim) continue; - + float ptmc = RecoDecay::sqrtSumOfSquares(cascMC.pxMC(), cascMC.pyMC()); // ------------------------------------- Store selctions distribution for QC registryQC.fill(HIST("hv0cosPARec"), casc.v0cosPA(RecCol.posX(), RecCol.posY(), RecCol.posZ())); registryQC.fill(HIST("hcasccosPARec"), casc.casccosPA(RecCol.posX(), RecCol.posY(), RecCol.posZ())); - registryQC.fill(HIST("hv0radiusRec"),casc.v0radius()); - registryQC.fill(HIST("hcascradiusRec"),casc.cascradius()); - registryQC.fill(HIST("hdcaV0daughtersRec"),casc.dcaV0daughters()); - registryQC.fill(HIST("hdcacascdaughtersRec"),casc.dcacascdaughters()); - registryQC.fill(HIST("hdcapostopvRec"),casc.dcapostopv()); - registryQC.fill(HIST("hdcanegtopvRec"),casc.dcanegtopv()); - registryQC.fill(HIST("hdcabachtopvRec"),casc.dcabachtopv()); - registryQC.fill(HIST("hdcav0topvRec"),casc.dcav0topv(RecCol.posX(), RecCol.posY(), RecCol.posZ())); - + registryQC.fill(HIST("hv0radiusRec"), casc.v0radius()); + registryQC.fill(HIST("hcascradiusRec"), casc.cascradius()); + registryQC.fill(HIST("hdcaV0daughtersRec"), casc.dcaV0daughters()); + registryQC.fill(HIST("hdcacascdaughtersRec"), casc.dcacascdaughters()); + registryQC.fill(HIST("hdcapostopvRec"), casc.dcapostopv()); + registryQC.fill(HIST("hdcanegtopvRec"), casc.dcanegtopv()); + registryQC.fill(HIST("hdcabachtopvRec"), casc.dcabachtopv()); + registryQC.fill(HIST("hdcav0topvRec"), casc.dcav0topv(RecCol.posX(), RecCol.posY(), RecCol.posZ())); + // ------------------------------------- Store selctions distribution for analysis if (casc.sign() < 0) { if (pdgParent == kXiMinus) { @@ -1126,45 +1153,49 @@ struct CascadeAnalysisLightIonsDerivedData { PROCESS_SWITCH(cascadeAnalysisLightIonsDerivedData, processMonteCarloRec, "Process MC", false); - - + void processMonteCarloGen(CollisionMCTrueTable const& mcCollisions, - CascadeMCCores const& CascMCCores, - SimCollisions const& RecCols) { - + CascadeMCCores const& CascMCCores, + SimCollisions const& RecCols) + { + // Fill generated event information (for event loss/splitting estimation) - fillGeneratedEventProperties(mcCollisions, RecCols); + fillGeneratedEventProperties(mcCollisions, RecCols); std::vector listBestCollisionIdx = getListOfRecoCollIndices(mcCollisions, RecCols); for (auto const& cascMC : CascMCCores) { - + int pdgParent = cascMC.pdgCode(); bool isPhysPrim = cascMC.isPhysicalPrimary(); if (pdgParent == 0) continue; if (!isPhysPrim) continue; - + float ptmc = RecoDecay::sqrtSumOfSquares(cascMC.pxMC(), cascMC.pyMC()); - + auto mcCollision = cascMC.template straMCCollision_as(); - + // event selections if (applyVtxZ && std::abs(mcCollision.posZ()) > zVtx) - return; - + return; + // Store the Zvtx registryQC.fill(HIST("hVertexZGen"), mcCollision.posZ()); - + float centrality = 100.5f; - + if (listBestCollisionIdx[mcCollision.globalIndex()] > -1) { auto collision = RecCols.iteratorAt(listBestCollisionIdx[mcCollision.globalIndex()]); - - if(centralityEstimator == Option::kFT0C) centrality = collision.centFT0C(); - if(centralityEstimator == Option::kFT0M) centrality = collision.centFT0M(); - if(centralityEstimator == Option::kFV0A) centrality = collision.centFV0A(); - if(centralityEstimator == Option::kNGlobal) centrality = collision.centNGlobal(); - + + if (centralityEstimator == Option::kFT0C) + centrality = collision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + centrality = collision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + centrality = collision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + centrality = collision.centNGlobal(); + if (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { registryMC.fill(HIST("h2dGenXiMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); } @@ -1178,7 +1209,7 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); } } - + if (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { registryMC.fill(HIST("h2dGenXiMinusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } @@ -1191,19 +1222,15 @@ struct CascadeAnalysisLightIonsDerivedData { if (cascMC.pdgCode() == kOmegaPlusBar && std::abs(cascMC.rapidityMC(2)) < rapcut) { registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } - - - } //cascMC loop - - - + } // cascMC loop } - + PROCESS_SWITCH(cascadeAnalysisLightIonsDerivedData, processMonteCarloGen, "Process MC", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ return WorkflowSpec{adaptAnalysisTask(cfgc)}; }