From cd626b8bce1b3b64d65ad013f55b4ef0470a4c82 Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Thu, 7 Aug 2025 15:29:21 +0200 Subject: [PATCH 01/24] Fix the capital letters --- PWGLF/Tasks/Strangeness/CMakeLists.txt | 5 + .../cascadeAnalysisLightIonsDerivedData.cxx | 1209 +++++++++++++++++ 2 files changed, 1214 insertions(+) create mode 100644 PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx diff --git a/PWGLF/Tasks/Strangeness/CMakeLists.txt b/PWGLF/Tasks/Strangeness/CMakeLists.txt index 5f88145c01d..2e2188248f0 100644 --- a/PWGLF/Tasks/Strangeness/CMakeLists.txt +++ b/PWGLF/Tasks/Strangeness/CMakeLists.txt @@ -155,3 +155,8 @@ o2physics_add_dpl_workflow(lambdatwopartpolarization SOURCES lambdaTwoPartPolarization.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(cascadeanalysislightions + SOURCES cascadeAnalysisLightIonsDerivedData.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx new file mode 100644 index 00000000000..283a9f77b82 --- /dev/null +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -0,0 +1,1209 @@ +// 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 cascadeAnalysisLightIonsDerivedData.cxx +/// +/// \brief Analysis of cascades (Xi, antiXi, Omega, antiOmega) in light-ion collisions using derived data +/// \author Sara Pucillo (sara.pucillo@cern.ch), Alberto Caliva (alberto.caliva@cern.ch) +/// \since August 06, 2025 + +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/CCDB/ctpRateFetcher.h" +#include "Common/Core/RecoDecay.h" +#include "Common/Core/TrackSelection.h" +#include "Common/Core/trackUtilities.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#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 +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::constants::math; +using namespace o2::constants::physics; +using std::array; + +using SelCollisions = soa::Join; +using SimCollisions = soa::Join; +using CascadeCandidates = soa::Join; +using CascadeMCCandidates = soa::Join; +using DaughterTracks = soa::Join; +using CollisionMCTrueTable = soa::Join; +using CascadeMCCores = soa::Join; + + +struct CascadeAnalysisLightIonsDerivedData { + + // Instantiate the CCDB service and API interface + // CCDB options + struct : ConfigurableGroup { + std::string prefix = "ccdbConfigurations"; // JSON group name + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable grpPath{"grpPath", "GLO/GRP/GRP", "Path of the grp file"}; + Configurable grpmagPath{"grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"}; + Configurable lutPath{"lutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"}; + Configurable geoPath{"geoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"}; + Configurable mVtxPath{"mVtxPath", "GLO/Calib/MeanVertex", "Path of the mean vertex file"}; + } ccdbConfigurations; + + o2::ccdb::CcdbApi ccdbApi; + Service ccdb; + int mRunNumber; + + // Define histogram registries + HistogramRegistry registryData{ + "registryData", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryMC{ + "registryMC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryQC{ + "registryQC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + // Global analysis parameters + Configurable zVtx{"zVtx", 10.0, "Maximum zVertex"}; + Configurable deltaEtaEdge{"deltaEtaEdge", 0.05, + "eta gap from the edge"}; + Configurable nBins{"nBins", 100, "N bins in all QC histos"}; + + // Event selections parameters + Configurable applySel8{"applySel8", true, "0 - no, 1 - yes"}; + Configurable applyVtxZ{"applyVtxZ", true, "0 - no, 1 - yes"}; + Configurable rejectITSROFBorder{"rejectITSROFBorder", true, "reject events at ITS ROF border"}; + Configurable rejectTFBorder{"rejectTFBorder", true, "reject events at TF border"}; + Configurable requireVertexITSTPC{"requireVertexITSTPC", false, "require events with at least one ITS-TPC track"}; + Configurable requireIsGoodZvtxFT0VsPV{"requireIsGoodZvtxFT0VsPV", false, "require is good Zvtx FT0 vs PV"}; + Configurable requireIsVertexTOFmatched{"requireIsVertexTOFmatched", false, "require events with at least one of vertex contributors matched to TOF"}; + Configurable requireIsVertexTRDmatched{"requireIsVertexTRDmatched", false, "require events with at least one of vertex contributors matched to TRD"}; + Configurable rejectSameBunchPileup{"rejectSameBunchPileup", true, "reject collisions in case of pileup with another collision in the same foundBC"}; + + // Track analysis Parameters + Configurable minITSnCls{"minITSnCls", 4.0f, + "min number of ITS clusters"}; + Configurable minTPCnClsFound{"minTPCnClsFound", 80.0f, + "min number of found TPC clusters"}; + Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 80.0f, + "min number of TPC crossed rows"}; + Configurable etaMin{"etaMin", -0.8f, "eta min"}; + Configurable etaMax{"etaMax", +0.8f, "eta max"}; + Configurable rapcut{"rapcut", +0.5f, "rapidity cut"}; + Configurable maxChi2TPC{"maxChi2TPC", 4.0f, + "max chi2 per cluster TPC"}; + Configurable requireITS{"requireITS", false, "require ITS hit"}; + Configurable requireTOF{"requireTOF", false, "require TOF hit"}; + + // Configurable parameters for PID selection + Configurable nsigmaTPCmin{"nsigmaTPCmin", -5.0f, "Minimum nsigma TPC"}; + Configurable nsigmaTPCmax{"nsigmaTPCmax", +5.0f, "Maximum nsigma TPC"}; + + // Configurable parameters for TOF PID selection + Configurable nsigmaTOFmin{"nsigmaTOFmin", -3.0f, "Minimum nsigma TOF"}; + Configurable nsigmaTOFmax{"nsigmaTOFmax", +3.0f, "Maximum nsigma TOF"}; + + // Topological Parameters + Configurable dcanegtoPVmin{"dcanegtoPVmin", 0.1f, + "Minimum DCA Neg To PV"}; + Configurable dcapostoPVmin{"dcapostoPVmin", 0.1f, + "Minimum DCA Pos To PV"}; + Configurable dcabachtopvMin{"dcabachtopvMin", 0.1f, + "Minimum DCA bachelor to PV"}; + Configurable dcaV0DaughtersMax{"dcaV0DaughtersMax", 0.7f, + "Maximum DCA Daughters"}; + Configurable dcaV0topvMin{"dcaV0topvMin", 0.02f, + "Minimum DCA V0 to PV"}; + Configurable dcaCascDaughtersMax{"dcaCascDaughtersMax", 0.8f, + "Maximum DCA Daughters"}; + Configurable v0cospaMin{"v0cospaMin", 0.99f, "Minimum V0 CosPA"}; + Configurable casccospaMin{"casccospaMin", 0.99f, + "Minimum Cascade CosPA"}; + Configurable minimumV0Radius{"minimumV0Radius", 2.5f, + "Minimum V0 Radius"}; + Configurable minimumCascRadius{"minimumCascRadius", 1.1f, + "Minimum Cascade Radius"}; + 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 axisNch{"axisNch", {500, 0.0f, +1000.0f}, "Number of charged particles"}; + + // Centrality estimator + Configurable centralityEstimator{"centralityEstimator", 0, "0 = FT0C, 1 = FTOM, 2 = FV0A, 3 = NGlobal"}; + + // List of estimators + enum Option { kFT0C, kFT0M, kFV0A, kNGlobal}; + + // For manual sliceBy + PresliceUnsorted> perMcCollision = aod::v0data::straMCCollisionId; + + 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()); + + // Axes and Binning + AxisSpec axisCentEstimator = {centEstimatorHistBin, "CentEstimator", + "CentEstimatorAxis"}; + AxisSpec centAxis = {centralityBinning, "Centrality", "CentralityAxis"}; + const AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; + const AxisSpec etaAxis{18, -0.9, 0.9, "#eta"}; + const AxisSpec ptAxis{100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}; + const AxisSpec invMassXiAxis{200, 1.28, 1.36, + "m_{p#pi#pi} (GeV/#it{c}^{2})"}; + const AxisSpec invMassOmegaAxis{200, 1.63, 1.71, + "m_{p#piK} (GeV/#it{c}^{2})"}; + const AxisSpec nsigmaTOFAxis{200, -10, 10, "n#sigma_{TOF}"}; + const AxisSpec nsigmaTPCAxis{200, -10, 10, "n#sigma_{TPC}"}; + + // Histograms for data + if (doprocessData) { + 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"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(2, "sel8 cut"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(3, "posZ cut"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(4, "kNoITSROFrameBorder"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(5, "kNoTimeFrameBorder"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(6, "kIsVertexITSTPC"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(8, "kIsVertexTOFmatched"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(9, "kIsVertexTRDmatched"); + registryData.get(HIST("number_of_events_data")) + ->GetXaxis() + ->SetBinLabel(10, "kNoSameBunchPileup"); + + // QC Histograms + registryQC.add("hVertexZdata", "hVertexZdata", HistType::kTH1F, {vertexZAxis}); + registryQC.add("hv0cosPAdata", "hv0cosPAdata", HistType::kTH1F, {{nBins, 0.95f, 1.f}}); + registryQC.add("hcasccosPAdata", "hcasccosPAdata", HistType::kTH1F, {{nBins, 0.95f, 1.f}}); + registryQC.add("hv0radiusdata", "hv0radiusdata", HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hcascradiusdata", "hcascradiusdata", HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hdcaV0daughtersdata", "hdcaV0daughtersdata", HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcacascdaughtersdata", "hdcacascdaughtersdata", HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcapostopvdata", "hdcapostopvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcanegtopvdata", "hdcanegtopvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcabachtopvdata", "hdcabachtopvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcav0topvdata", "hdcav0topvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + + // Multiplicity Histograms + registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, + {axisCentEstimator}); + registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, + {axisCentEstimator,axisNch}); + + // Histograms for xi (data) + registryData.add("hMassXipos", "hMassXipos", + HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXineg", "hMassXineg", + HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXiposSelected", "hMassXiposSelected", + 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}); + registryData.add("hMassOmeganeg", "hMassOmeganeg", + HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmegaposSelected", + "hMassOmegaposSelected", HistType::kTH3F, + {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganegSelected", + "hMassOmeganegSelected", HistType::kTH3F, + {centAxis, ptAxis, invMassOmegaAxis}); + } + + if (doprocessMonteCarloRec) { + // Histograms for mc reconstructed + 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"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(2, "sel8 cut"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(3, "posZ cut"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(4, "kNoITSROFrameBorder"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(5, "kNoTimeFrameBorder"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(6, "kIsVertexITSTPC"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(8, "kIsVertexTOFmatched"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(9, "kIsVertexTRDmatched"); + registryMC.get(HIST("number_of_events_mc_rec")) + ->GetXaxis() + ->SetBinLabel(10, "kNoSameBunchPileup"); + + // QC Histograms + registryQC.add("hVertexZRec", "hVertexZRec", + HistType::kTH1F, {{vertexZAxis}}); + registryQC.add("hv0cosPARec", "hv0cosPARec", + HistType::kTH1F, {{nBins, 0.95f, 1.f}}); + registryQC.add("hcasccosPARec", "hcasccosPARec", + HistType::kTH1F, {{nBins, 0.95f, 1.f}}); + registryQC.add("hv0radiusRec", "hv0radiusRec", + HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hcascradiusRec", "hcascradiusRec", + HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hdcaV0daughtersRec", "hdcaV0daughtersRec", + HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcacascdaughtersRec", "hdcacascdaughtersRec", + HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcapostopvRec", "hdcapostopvRec", + HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcanegtopvRec", "hdcanegtopvRec", + HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcabachtopvRec", "hdcabachtopvRec", + HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcav0topvRec", "hdcav0topvRec", + HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + + // Multiplicity Histograms + registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", + HistType::kTH1D, {axisCentEstimator}); + registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, + {axisCentEstimator,axisNch}); + + // Histograms for xi (mc) + registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", + HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXineg_truerec", "hMassXineg_truerec", + HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXiposSelected_truerec", + "hMassXiposSelected_truerec", HistType::kTH3F, + {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXinegSelected_truerec", + "hMassXinegSelected_truerec", HistType::kTH3F, + {centAxis, ptAxis, invMassXiAxis}); + + // Histograms for omega (mc) + registryMC.add("hMassOmegapos_truerec", + "hMassOmegapos_truerec", HistType::kTH3F, + {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmeganeg_truerec", + "hMassOmeganeg_truerec", HistType::kTH3F, + {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmegaposSelected_truerec", + "hMassOmegaposSelected_truerec", HistType::kTH3F, + {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmeganegSelected_truerec", + "hMassOmeganegSelected_truerec", HistType::kTH3F, + {centAxis, ptAxis, invMassOmegaAxis}); + } + + if (doprocessMonteCarloGen) { + // Histograms for mc generated + // QC Histograms + registryQC.add("hVertexZGen", "hVertexZGen", + HistType::kTH1F, {{vertexZAxis}}); + // Histograms for xi (mc) + registryMC.add("h2dGenXiMinusVsMultMC_RecoedEvt", "h2dGenXiMinusVsMultMC_RecoedEvt", HistType::kTH2F, {axisNch, ptAxis}); + 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"); + registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(2, "Gen. with at least 1 rec. events"); + registryMC.add("hGenEventCentrality", "hGenEventCentrality", kTH1D, {{101, 0.0f, 101.0f}}); + + registryMC.add("hCentralityVsNcoll_beforeEvSel", "hCentralityVsNcoll_beforeEvSel", HistType::kTH2F, {centAxis, {50, -0.5f, 49.5f}}); + registryMC.add("hCentralityVsNcoll_afterEvSel", "hCentralityVsNcoll_afterEvSel", HistType::kTH2F, {centAxis, {50, -0.5f, 49.5f}}); + + registryMC.add("hCentralityVsMultMC", "hCentralityVsMultMC", HistType::kTH2F, {{101, 0.0f, 101.0f}, axisNch}); + } + + + } + + // ______________________________________________________ + // Return slicing output + template + auto getGroupedCollisions(TCollisions const& collisions, int globalIndex) + { + return collisions.sliceBy(perMcCollision, globalIndex); + } + + template + void initCCDB(TCollision collision) + { + if (mRunNumber == collision.runNumber()) { + return; + } + + mRunNumber = collision.runNumber(); + } + + // Find ITS hit + // template + // bool hasITSHitOnLayer(const TrackIts& track, int layer) + // { + // int ibit = layer - 1; + // return (track.itsClusterMap() & (1 << ibit)); + // } + + // Single-Track Selection + template + bool passedSingleTrackSelection(const Track &track) { + if (requireITS && (!track.hasITS())) + return false; + if (requireITS && track.itsNCls() < minITSnCls) + return false; + if (!track.hasTPC()) + return false; + if (track.tpcNClsFound() < minTPCnClsFound) + return false; + if (track.tpcNClsCrossedRows() < minNCrossedRowsTPC) + return false; + if (track.tpcChi2NCl() > maxChi2TPC) + return false; + if (requireTOF && (!track.hasTOF())) + return false; + return true; + } + + // Xi Selection + template + 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)) + return false; + if (!passedSingleTrackSelection(btrack)) + return false; + + if (std::abs(casc.yXi()) > rapcut) + return false; + + // Xi+ Selection (Xi+ -> antiL + pi+) + if (casc.sign() > 0) { + + // PID Selections (TPC) + if (ntrack.tpcNSigmaPr() < nsigmaTPCmin || + ntrack.tpcNSigmaPr() > nsigmaTPCmax) + return false; + if (ptrack.tpcNSigmaPi() < nsigmaTPCmin || + ptrack.tpcNSigmaPi() > nsigmaTPCmax) + return false; + + // PID Selections (TOF) + if (requireTOF) { + if (casc.tofNSigmaXiLaPr() < nsigmaTOFmin || + casc.tofNSigmaXiLaPr() > nsigmaTOFmax) + return false; + if (casc.tofNSigmaXiLaPi() < nsigmaTOFmin || + casc.tofNSigmaXiLaPi() > nsigmaTOFmax) + return false; + } + } + + // Xi- Selection (Xi- -> L + pi-) + if (casc.sign() < 0) { + + // PID Selections (TPC) + if (ptrack.tpcNSigmaPr() < nsigmaTPCmin || + ptrack.tpcNSigmaPr() > nsigmaTPCmax) + return false; + if (ntrack.tpcNSigmaPi() < nsigmaTPCmin || + ntrack.tpcNSigmaPi() > nsigmaTPCmax) + return false; + + // PID Selections (TOF) + if (requireTOF) { + if (casc.tofNSigmaXiLaPr() < nsigmaTOFmin || + casc.tofNSigmaXiLaPr() > nsigmaTOFmax) + return false; + if (casc.tofNSigmaXiLaPi() < nsigmaTOFmin || + casc.tofNSigmaXiLaPi() > nsigmaTOFmax) + return false; + } + } + + if (casc.v0cosPA(coll.posX(), coll.posY(), coll.posZ()) < v0cospaMin) + return false; + if (casc.v0radius() < minimumV0Radius) + return false; + if (std::fabs(casc.dcaV0daughters()) > dcaV0DaughtersMax) + return false; + if (std::fabs(casc.dcapostopv()) < dcapostoPVmin) + return false; + if (std::fabs(casc.dcanegtopv()) < dcanegtoPVmin) + return false; + + if (casc.casccosPA(coll.posX(), coll.posY(), coll.posZ()) < casccospaMin) + return false; + if (casc.cascradius() < minimumCascRadius) + return false; + if (std::fabs(casc.dcabachtopv()) < dcabachtopvMin) + return false; + if (std::fabs(casc.dcav0topv(coll.posX(), coll.posY(), coll.posZ())) < + dcaV0topvMin) + return false; + if (std::fabs(casc.dcacascdaughters()) > dcaCascDaughtersMax) + return false; + + // V0 mass window + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > + v0masswindow) + return false; + + // reject candidates compatible with omega + if (std::abs(casc.mOmega() - o2::constants::physics::MassOmegaMinus) < + competingmassrej) + return false; + + // PID Selection on bachelor + if (btrack.tpcNSigmaPi() < nsigmaTPCmin || + btrack.tpcNSigmaPi() > nsigmaTPCmax) + return false; + + // PID Selections (TOF) + if (requireTOF) { + if (casc.tofNSigmaXiPi() < nsigmaTOFmin || + casc.tofNSigmaXiPi() > nsigmaTOFmax) + return false; + } + return true; + } + + // Omega Selection + template + 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)) + return false; + if (!passedSingleTrackSelection(btrack)) + return false; + + if (std::abs(casc.yOmega()) > rapcut) + return false; + + // Omega+ Selection (Omega+ -> antiL + K+) + if (casc.sign() > 0) { + // PID Selections (TPC) + if (ntrack.tpcNSigmaPr() < nsigmaTPCmin || + ntrack.tpcNSigmaPr() > nsigmaTPCmax) + return false; + if (ptrack.tpcNSigmaPi() < nsigmaTPCmin || + ptrack.tpcNSigmaPi() > nsigmaTPCmax) + return false; + + // PID Selections (TOF) + if (requireTOF) { + if (casc.tofNSigmaOmLaPr() < nsigmaTOFmin || + casc.tofNSigmaOmLaPr() > nsigmaTOFmax) + return false; + if (casc.tofNSigmaOmLaPi() < nsigmaTOFmin || + casc.tofNSigmaOmLaPi() > nsigmaTOFmax) + return false; + } + } + + // Omega- Selection (Omega- -> L + K-) + if (casc.sign() < 0) { + // PID Selections (TPC) + if (ptrack.tpcNSigmaPr() < nsigmaTPCmin || + ptrack.tpcNSigmaPr() > nsigmaTPCmax) + return false; + if (ntrack.tpcNSigmaPi() < nsigmaTPCmin || + ntrack.tpcNSigmaPi() > nsigmaTPCmax) + return false; + + // PID Selections (TOF) + if (requireTOF) { + if (casc.tofNSigmaOmLaPr() < nsigmaTOFmin || + casc.tofNSigmaOmLaPr() > nsigmaTOFmax) + return false; + if (casc.tofNSigmaOmLaPi() < nsigmaTOFmin || + casc.tofNSigmaOmLaPi() > nsigmaTOFmax) + return false; + } + } + + if (casc.v0cosPA(coll.posX(), coll.posY(), coll.posZ()) < v0cospaMin) + return false; + if (casc.v0radius() < minimumV0Radius) + return false; + if (std::fabs(casc.dcaV0daughters()) > dcaV0DaughtersMax) + return false; + if (std::fabs(casc.dcapostopv()) < dcapostoPVmin) + return false; + if (std::fabs(casc.dcanegtopv()) < dcanegtoPVmin) + return false; + + if (casc.casccosPA(coll.posX(), coll.posY(), coll.posZ()) < casccospaMin) + return false; + if (casc.cascradius() < minimumCascRadius) + return false; + if (std::fabs(casc.dcabachtopv()) < dcabachtopvMin) + return false; + if (std::fabs(casc.dcav0topv(coll.posX(), coll.posY(), coll.posZ())) < + dcaV0topvMin) + return false; + if (std::fabs(casc.dcacascdaughters()) > dcaCascDaughtersMax) + return false; + + // V0 mass window + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda0) > + v0masswindow) + return false; + + // Reject candidates compatible with Xi + if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) < + competingmassrej) + return false; + + // PID Selection on bachelor + if (btrack.tpcNSigmaKa() < nsigmaTPCmin || + btrack.tpcNSigmaKa() > nsigmaTPCmax) + return false; + + // PID Selections (TOF) + if (requireTOF) { + if (casc.tofNSigmaOmKa() < nsigmaTOFmin || + casc.tofNSigmaOmKa() > nsigmaTOFmax) + return false; + } + 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) + { + std::vector listBestCollisionIdx(mcCollisions.size()); + for (auto const& mcCollision : mcCollisions) { + auto groupedCollisions = getGroupedCollisions(collisions, mcCollision.globalIndex()); + 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; + } + return listBestCollisionIdx; + } + + // Fill generated event information (for event loss/splitting estimation) + 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) + 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) { + + // Fill event counter before event selection + registryData.fill(HIST("number_of_events_data"), 0); + + // Initialize CCDB objects using the BC info + initCCDB(collision); + + // event selections + if (applySel8 && !collision.sel8()) + return; + registryData.fill(HIST("number_of_events_data"), 1); + if (applyVtxZ && std::fabs(collision.posZ()) > zVtx) + return; + registryData.fill(HIST("number_of_events_data"), 2); + + if (rejectITSROFBorder && + !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { + return; + } + registryData.fill(HIST("number_of_events_data"), + 3 /* Not at ITS ROF border */); + + if (rejectTFBorder && + !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + return; + } + registryData.fill(HIST("number_of_events_data"), 4 /* Not at TF border */); + + if (requireVertexITSTPC && + !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { + return; + } + registryData.fill(HIST("number_of_events_data"), + 5 /* Contains at least one ITS-TPC track */); + + if (requireIsGoodZvtxFT0VsPV && + !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + return; + } + registryData.fill(HIST("number_of_events_data"), + 6 /* PV position consistency check */); + + if (requireIsVertexTOFmatched && + !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + return; + } + registryData.fill( + 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 */); + + if (rejectSameBunchPileup && + !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + return; + } + registryData.fill(HIST("number_of_events_data"), + 9 /* Not at same bunch pile-up */); + + // 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(); + + 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 || + etaMin > casc.positiveeta() || casc.positiveeta() > etaMax) + continue; // remove acceptance that's badly reproduced by MC / superfluous in future + + // Get cascade daughters + auto bach = casc.bachTrackExtra_as(); + auto pos = casc.posTrackExtra_as(); + auto neg = casc.negTrackExtra_as(); + + // ------------------------------------- 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())); + + // ------------------------------------- Store selctions distribution for analysis + if (casc.sign() < 0) { + registryData.fill(HIST("hMassXineg"), multiplicity, + casc.pt(), casc.mXi()); + registryData.fill(HIST("hMassOmeganeg"), multiplicity, + casc.pt(), casc.mOmega()); + } + if (casc.sign() > 0) { + registryData.fill(HIST("hMassXipos"), multiplicity, + casc.pt(), casc.mXi()); + registryData.fill(HIST("hMassOmegapos"), multiplicity, + casc.pt(), casc.mOmega()); + } + + if (casc.sign() < 0 && + passedXiSelection(casc, pos, neg, bach, collision)) { + registryData.fill(HIST("hMassXinegSelected"), + multiplicity, casc.pt(), casc.mXi()); + } + if (casc.sign() < 0 && + passedOmegaSelection(casc, pos, neg, bach, collision)) { + registryData.fill(HIST("hMassOmeganegSelected"), + multiplicity, casc.pt(), casc.mOmega()); + } + if (casc.sign() > 0 && + passedXiSelection(casc, pos, neg, bach, collision)) { + registryData.fill(HIST("hMassXiposSelected"), + multiplicity, casc.pt(), casc.mXi()); + } + if (casc.sign() > 0 && + passedOmegaSelection(casc, pos, neg, bach, collision)) { + registryData.fill(HIST("hMassOmegaposSelected"), + multiplicity, casc.pt(), casc.mOmega()); + } + } + } + + PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processData, "Process data", true); + + 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; + registryMC.fill(HIST("number_of_events_mc_rec"), 1); + + if (applyVtxZ && std::fabs(RecCol.posZ()) > zVtx) + continue; + registryMC.fill(HIST("number_of_events_mc_rec"), 2); + + if (rejectITSROFBorder && + !RecCol.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { + continue; + } + registryMC.fill(HIST("number_of_events_mc_rec"), + 3 /* Not at ITS ROF border */); + + if (rejectTFBorder && + !RecCol.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + continue; + } + registryMC.fill(HIST("number_of_events_mc_rec"), + 4 /* Not at TF border */); + + if (requireVertexITSTPC && + !RecCol.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { + continue; + } + registryMC.fill(HIST("number_of_events_mc_rec"), + 5 /* Contains at least one ITS-TPC track */); + + if (requireIsGoodZvtxFT0VsPV && + !RecCol.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + continue; + } + registryMC.fill(HIST("number_of_events_mc_rec"), + 6 /* PV position consistency check */); + + if (requireIsVertexTOFmatched && + !RecCol.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + continue; + } + registryMC.fill( + 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 */); + + if (rejectSameBunchPileup && + !RecCol.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + continue; + } + registryMC.fill(HIST("number_of_events_mc_rec"), + 9 /* Not at same bunch pile-up */); + + // Store the Zvtx + registryQC.fill(HIST("hVertexZRec"), RecCol.posZ()); + + // 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(); + + 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 || + etaMin > casc.positiveeta() || casc.positiveeta() > etaMax) + continue; // remove acceptance that's badly reproduced by MC / superfluous in future + + if (!casc.has_cascMCCore()) + continue; + + auto cascMC = casc.template cascMCCore_as(); + + 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())); + + // ------------------------------------- Store selctions distribution for analysis + if (casc.sign() < 0) { + if (pdgParent == kXiMinus) { + registryMC.fill(HIST("hMassXineg_truerec"), + multiplicityMcRec, ptmc, casc.mXi()); + } + if (pdgParent == kOmegaMinus) { + registryMC.fill(HIST("hMassOmeganeg_truerec"), + multiplicityMcRec, ptmc, + casc.mOmega()); + } + } + + if (casc.sign() > 0) { + if (pdgParent == kXiPlusBar) { + registryMC.fill(HIST("hMassXipos_truerec"), + multiplicityMcRec, ptmc, casc.mXi()); + } + if (pdgParent == kOmegaPlusBar) { + registryMC.fill(HIST("hMassOmegapos_truerec"), + multiplicityMcRec, ptmc, + casc.mOmega()); + } + } + + if (casc.sign() < 0 && pdgParent == kXiMinus && passedXiSelection(casc, pos, neg, bach, RecCol)) { + registryMC.fill(HIST("hMassXinegSelected_truerec"), + multiplicityMcRec, ptmc, casc.mXi()); + } + if (casc.sign() < 0 && pdgParent == kOmegaMinus && passedOmegaSelection(casc, pos, neg, bach, RecCol)) { + registryMC.fill(HIST("hMassOmeganegSelected_truerec"), + multiplicityMcRec, ptmc, casc.mOmega()); + } + if (casc.sign() > 0 && pdgParent == kXiPlusBar && passedXiSelection(casc, pos, neg, bach, RecCol)) { + registryMC.fill(HIST("hMassXiposSelected_truerec"), + multiplicityMcRec, ptmc, casc.mXi()); + } + if (casc.sign() > 0 && pdgParent == kOmegaPlusBar && passedOmegaSelection(casc, pos, neg, bach, RecCol)) { + registryMC.fill(HIST("hMassOmegaposSelected_truerec"), + multiplicityMcRec, ptmc, casc.mOmega()); + } + + } // casc loop + + } // rec.collision loop + } + + PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processMonteCarloRec, "Process MC", + false); + + + void processMonteCarloGen(CollisionMCTrueTable const& mcCollisions, + CascadeMCCores const& CascMCCores, + SimCollisions const& RecCols) { + + // Fill generated event information (for event loss/splitting estimation) + 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; + + // 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 (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { + registryMC.fill(HIST("h2dGenXiMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (cascMC.pdgCode() == kXiPlusBar && std::abs(cascMC.rapidityMC(0)) < rapcut) { + registryMC.fill(HIST("h2dGenXiPlusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (cascMC.pdgCode() == kOmegaMinus && std::abs(cascMC.rapidityMC(2)) < rapcut) { + registryMC.fill(HIST("h2dGenOmegaMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (cascMC.pdgCode() == kOmegaPlusBar && std::abs(cascMC.rapidityMC(2)) < rapcut) { + 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); + } + if (cascMC.pdgCode() == kXiPlusBar && std::abs(cascMC.rapidityMC(0)) < rapcut) { + registryMC.fill(HIST("h2dGenXiPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (cascMC.pdgCode() == kOmegaMinus && std::abs(cascMC.rapidityMC(2)) < rapcut) { + registryMC.fill(HIST("h2dGenOmegaMinusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (cascMC.pdgCode() == kOmegaPlusBar && std::abs(cascMC.rapidityMC(2)) < rapcut) { + registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + + + + } //cascMC loop + + + + } + + PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processMonteCarloGen, "Process MC", + false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From 2ffd459d62fbae0da04d8a7b24eeb565a8c61f27 Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Thu, 7 Aug 2025 16:12:06 +0200 Subject: [PATCH 02/24] Remove unused variables --- .../cascadeAnalysisLightIonsDerivedData.cxx | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 283a9f77b82..a7703649195 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -13,7 +13,7 @@ /// /// \brief Analysis of cascades (Xi, antiXi, Omega, antiOmega) in light-ion collisions using derived data /// \author Sara Pucillo (sara.pucillo@cern.ch), Alberto Caliva (alberto.caliva@cern.ch) -/// \since August 06, 2025 +/// \since August 07, 2025 #include "PWGLF/DataModel/LFStrangenessPIDTables.h" #include "PWGLF/DataModel/LFStrangenessTables.h" @@ -717,10 +717,10 @@ struct CascadeAnalysisLightIonsDerivedData { // Fill generated event information (for event loss/splitting estimation) template - void fillGeneratedEventProperties(TMCCollisions const& mcCollisionss, TCollisions const& collisions) + void fillGeneratedEventProperties(TMCCollisions const& mcCollisions, TCollisions const& collisions) { - std::vector listBestCollisionIdx(mcCollisionss.size()); - for (auto const& mcCollisions : mcCollisionss) { + std::vector listBestCollisionIdx(mcCollisions.size()); + for (auto const& mcCollisions : mcCollisions) { // event selections if (applyVtxZ && std::fabs(mcCollisions.posZ()) > zVtx) @@ -733,7 +733,6 @@ struct CascadeAnalysisLightIonsDerivedData { // If so, we consider it bool atLeastOne = false; int biggestNContribs = -1; - float centrality = 100.5f; int nCollisions = 0; for (auto const& collision : groupedCollisions) { @@ -809,7 +808,7 @@ struct CascadeAnalysisLightIonsDerivedData { void processData(SelCollisions::iterator const& collision, CascadeCandidates const& fullCascades, - DaughterTracks const& tracks) { + DaughterTracks const&) { // Fill event counter before event selection registryData.fill(HIST("number_of_events_data"), 0); @@ -951,11 +950,7 @@ 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&) { for (const auto& RecCol : RecCols) { From bc5686e17430bc3bf151589437b0454a3993ae62 Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Thu, 7 Aug 2025 17:08:24 +0200 Subject: [PATCH 03/24] Fix the problems with the variable centrality --- .../cascadeAnalysisLightIonsDerivedData.cxx | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index a7703649195..d9055b4fd6e 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -734,6 +734,7 @@ struct CascadeAnalysisLightIonsDerivedData { bool atLeastOne = false; int biggestNContribs = -1; int nCollisions = 0; + float multiplicitydata = -1.0f; for (auto const& collision : groupedCollisions) { // event selections @@ -778,29 +779,28 @@ struct CascadeAnalysisLightIonsDerivedData { 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(); + if(centralityEstimator == Option::kFT0C) multiplicitydata = collision.centFT0C(); + if(centralityEstimator == Option::kFT0M) multiplicitydata = collision.centFT0M(); + if(centralityEstimator == Option::kFV0A) multiplicitydata = collision.centFV0A(); + if(centralityEstimator == Option::kNGlobal) multiplicitydata = 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()); + registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), multiplicitydata, groupedCollisions.size()); + registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), multiplicitydata, nCollisions); + registryMC.fill(HIST("hCentralityVsMultMC"), multiplicitydata, 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); + registryMC.fill(HIST("hGenEventCentrality"), multiplicitydata); } } return; @@ -1150,15 +1150,15 @@ struct CascadeAnalysisLightIonsDerivedData { // Store the Zvtx registryQC.fill(HIST("hVertexZGen"), mcCollision.posZ()); - float centrality = 100.5f; + //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); From 3bc66e308914ead6e4b8013af1ebd8769f96ac8c Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Thu, 7 Aug 2025 17:48:52 +0200 Subject: [PATCH 04/24] Remove unused variable --- .../Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index d9055b4fd6e..72f4e18e6c7 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -1153,8 +1153,7 @@ struct CascadeAnalysisLightIonsDerivedData { //float centrality = 100.5f; if (listBestCollisionIdx[mcCollision.globalIndex()] > -1) { - auto collision = RecCols.iteratorAt(listBestCollisionIdx[mcCollision.globalIndex()]); - + //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(); From b7a3fe5ec2be303bc30e6cafe458a017945bfcce Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Fri, 8 Aug 2025 14:47:23 +0200 Subject: [PATCH 05/24] Fix formatting errors --- .../cascadeAnalysisLightIonsDerivedData.cxx | 655 ++++++------------ 1 file changed, 231 insertions(+), 424 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 72f4e18e6c7..b2bb03d9b72 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -1,6 +1,6 @@ // 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. +// 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". @@ -8,16 +8,15 @@ // 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 cascadeAnalysisLightIonsDerivedData.cxx +/// \brief analysis of cascades (Xi, antiXi, Omega, antiOmega) in light-ion collisions using derived data /// -/// \brief Analysis of cascades (Xi, antiXi, Omega, antiOmega) in light-ion collisions using derived data /// \author Sara Pucillo (sara.pucillo@cern.ch), Alberto Caliva (alberto.caliva@cern.ch) -/// \since August 07, 2025 +// #include "PWGLF/DataModel/LFStrangenessPIDTables.h" #include "PWGLF/DataModel/LFStrangenessTables.h" - #include "Common/CCDB/ctpRateFetcher.h" #include "Common/Core/RecoDecay.h" #include "Common/Core/TrackSelection.h" @@ -29,15 +28,12 @@ #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 #include #include @@ -60,7 +56,6 @@ using DaughterTracks = soa::Join; using CollisionMCTrueTable = soa::Join; using CascadeMCCores = soa::Join; - struct CascadeAnalysisLightIonsDerivedData { // Instantiate the CCDB service and API interface @@ -80,17 +75,13 @@ struct CascadeAnalysisLightIonsDerivedData { int mRunNumber; // Define histogram registries - HistogramRegistry registryData{ - "registryData", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; - HistogramRegistry registryMC{ - "registryMC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; - HistogramRegistry registryQC{ - "registryQC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryData{"registryData", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryMC{"registryMC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryQC{"registryQC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // Global analysis parameters Configurable zVtx{"zVtx", 10.0, "Maximum zVertex"}; - Configurable deltaEtaEdge{"deltaEtaEdge", 0.05, - "eta gap from the edge"}; + Configurable deltaEtaEdge{"deltaEtaEdge", 0.05, "eta gap from the edge"}; Configurable nBins{"nBins", 100, "N bins in all QC histos"}; // Event selections parameters @@ -105,17 +96,13 @@ struct CascadeAnalysisLightIonsDerivedData { Configurable rejectSameBunchPileup{"rejectSameBunchPileup", true, "reject collisions in case of pileup with another collision in the same foundBC"}; // Track analysis Parameters - Configurable minITSnCls{"minITSnCls", 4.0f, - "min number of ITS clusters"}; - Configurable minTPCnClsFound{"minTPCnClsFound", 80.0f, - "min number of found TPC clusters"}; - Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 80.0f, - "min number of TPC crossed rows"}; + Configurable minITSnCls{"minITSnCls", 4.0f, "min number of ITS clusters"}; + Configurable minTPCnClsFound{"minTPCnClsFound", 80.0f, "min number of found TPC clusters"}; + Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 80.0f, "min number of TPC crossed rows"}; Configurable etaMin{"etaMin", -0.8f, "eta min"}; Configurable etaMax{"etaMax", +0.8f, "eta max"}; Configurable rapcut{"rapcut", +0.5f, "rapidity cut"}; - Configurable maxChi2TPC{"maxChi2TPC", 4.0f, - "max chi2 per cluster TPC"}; + Configurable maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; Configurable requireITS{"requireITS", false, "require ITS hit"}; Configurable requireTOF{"requireTOF", false, "require TOF hit"}; @@ -128,37 +115,26 @@ struct CascadeAnalysisLightIonsDerivedData { Configurable nsigmaTOFmax{"nsigmaTOFmax", +3.0f, "Maximum nsigma TOF"}; // Topological Parameters - Configurable dcanegtoPVmin{"dcanegtoPVmin", 0.1f, - "Minimum DCA Neg To PV"}; - Configurable dcapostoPVmin{"dcapostoPVmin", 0.1f, - "Minimum DCA Pos To PV"}; - Configurable dcabachtopvMin{"dcabachtopvMin", 0.1f, - "Minimum DCA bachelor to PV"}; - Configurable dcaV0DaughtersMax{"dcaV0DaughtersMax", 0.7f, - "Maximum DCA Daughters"}; - Configurable dcaV0topvMin{"dcaV0topvMin", 0.02f, - "Minimum DCA V0 to PV"}; - Configurable dcaCascDaughtersMax{"dcaCascDaughtersMax", 0.8f, - "Maximum DCA Daughters"}; + Configurable dcanegtoPVmin{"dcanegtoPVmin", 0.1f, "Minimum DCA Neg To PV"}; + Configurable dcapostoPVmin{"dcapostoPVmin", 0.1f, "Minimum DCA Pos To PV"}; + Configurable dcabachtopvMin{"dcabachtopvMin", 0.1f, "Minimum DCA bachelor to PV"}; + Configurable dcaV0DaughtersMax{"dcaV0DaughtersMax", 0.7f, "Maximum DCA Daughters"}; + Configurable dcaV0topvMin{"dcaV0topvMin", 0.02f, "Minimum DCA V0 to PV"}; + Configurable dcaCascDaughtersMax{"dcaCascDaughtersMax", 0.8f, "Maximum DCA Daughters"}; Configurable v0cospaMin{"v0cospaMin", 0.99f, "Minimum V0 CosPA"}; - Configurable casccospaMin{"casccospaMin", 0.99f, - "Minimum Cascade CosPA"}; - Configurable minimumV0Radius{"minimumV0Radius", 2.5f, - "Minimum V0 Radius"}; - Configurable minimumCascRadius{"minimumCascRadius", 1.1f, - "Minimum Cascade Radius"}; + Configurable casccospaMin{"casccospaMin", 0.99f, "Minimum Cascade CosPA"}; + Configurable minimumV0Radius{"minimumV0Radius", 2.5f, "Minimum V0 Radius"}; + Configurable minimumCascRadius{"minimumCascRadius", 1.1f, "Minimum Cascade Radius"}; Configurable v0masswindow{"v0masswindow", 0.005, "v0 mass window"}; - Configurable competingmassrej{"competingmassrej", 0.008, - "Competing mass rejection"}; - + 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 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}; @@ -177,53 +153,29 @@ struct CascadeAnalysisLightIonsDerivedData { .count()); // Axes and Binning - AxisSpec axisCentEstimator = {centEstimatorHistBin, "CentEstimator", - "CentEstimatorAxis"}; + AxisSpec axisCentEstimator = {centEstimatorHistBin, "CentEstimator", "CentEstimatorAxis"}; AxisSpec centAxis = {centralityBinning, "Centrality", "CentralityAxis"}; const AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; const AxisSpec etaAxis{18, -0.9, 0.9, "#eta"}; const AxisSpec ptAxis{100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}; - const AxisSpec invMassXiAxis{200, 1.28, 1.36, - "m_{p#pi#pi} (GeV/#it{c}^{2})"}; - const AxisSpec invMassOmegaAxis{200, 1.63, 1.71, - "m_{p#piK} (GeV/#it{c}^{2})"}; + const AxisSpec invMassXiAxis{200, 1.28, 1.36, "m_{p#pi#pi} (GeV/#it{c}^{2})"}; + const AxisSpec invMassOmegaAxis{200, 1.63, 1.71, "m_{p#piK} (GeV/#it{c}^{2})"}; const AxisSpec nsigmaTOFAxis{200, -10, 10, "n#sigma_{TOF}"}; const AxisSpec nsigmaTPCAxis{200, -10, 10, "n#sigma_{TPC}"}; // Histograms for data if (doprocessData) { - 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"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(2, "sel8 cut"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(3, "posZ cut"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(4, "kNoITSROFrameBorder"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(5, "kNoTimeFrameBorder"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(6, "kIsVertexITSTPC"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(8, "kIsVertexTOFmatched"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(9, "kIsVertexTRDmatched"); - registryData.get(HIST("number_of_events_data")) - ->GetXaxis() - ->SetBinLabel(10, "kNoSameBunchPileup"); + 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"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(2, "sel8 cut"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(3, "posZ cut"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(4, "kNoITSROFrameBorder"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(5, "kNoTimeFrameBorder"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(6, "kIsVertexITSTPC"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(8, "kIsVertexTOFmatched"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); + registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); // QC Histograms registryQC.add("hVertexZdata", "hVertexZdata", HistType::kTH1F, {vertexZAxis}); @@ -239,143 +191,82 @@ struct CascadeAnalysisLightIonsDerivedData { registryQC.add("hdcav0topvdata", "hdcav0topvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); // Multiplicity Histograms - registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, - {axisCentEstimator}); - registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, - {axisCentEstimator,axisNch}); - + registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {axisCentEstimator}); + registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {axisCentEstimator,axisNch}); + // Histograms for xi (data) - registryData.add("hMassXipos", "hMassXipos", - HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXineg", "hMassXineg", - HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXiposSelected", "hMassXiposSelected", - HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXinegSelected", "hMassXinegSelected", - HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - + registryData.add("hMassXipos", "hMassXipos", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXineg", "hMassXineg", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXiposSelected", "hMassXiposSelected", 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}); - registryData.add("hMassOmeganeg", "hMassOmeganeg", - HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmegaposSelected", - "hMassOmegaposSelected", HistType::kTH3F, - {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmeganegSelected", - "hMassOmeganegSelected", HistType::kTH3F, - {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmegapos", "hMassOmegapos", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganeg", "hMassOmeganeg", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmegaposSelected", "hMassOmegaposSelected", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganegSelected", "hMassOmeganegSelected", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); } if (doprocessMonteCarloRec) { // Histograms for mc reconstructed - 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"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(2, "sel8 cut"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(3, "posZ cut"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(4, "kNoITSROFrameBorder"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(5, "kNoTimeFrameBorder"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(6, "kIsVertexITSTPC"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(8, "kIsVertexTOFmatched"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(9, "kIsVertexTRDmatched"); - registryMC.get(HIST("number_of_events_mc_rec")) - ->GetXaxis() - ->SetBinLabel(10, "kNoSameBunchPileup"); + 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"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(2, "sel8 cut"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(3, "posZ cut"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(4, "kNoITSROFrameBorder"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(5, "kNoTimeFrameBorder"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(6, "kIsVertexITSTPC"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(8, "kIsVertexTOFmatched"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); + registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); // QC Histograms - registryQC.add("hVertexZRec", "hVertexZRec", - HistType::kTH1F, {{vertexZAxis}}); - registryQC.add("hv0cosPARec", "hv0cosPARec", - HistType::kTH1F, {{nBins, 0.95f, 1.f}}); - registryQC.add("hcasccosPARec", "hcasccosPARec", - HistType::kTH1F, {{nBins, 0.95f, 1.f}}); - registryQC.add("hv0radiusRec", "hv0radiusRec", - HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); - registryQC.add("hcascradiusRec", "hcascradiusRec", - HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); - registryQC.add("hdcaV0daughtersRec", "hdcaV0daughtersRec", - HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); - registryQC.add("hdcacascdaughtersRec", "hdcacascdaughtersRec", - HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); - registryQC.add("hdcapostopvRec", "hdcapostopvRec", - HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcanegtopvRec", "hdcanegtopvRec", - HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcabachtopvRec", "hdcabachtopvRec", - HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcav0topvRec", "hdcav0topvRec", - HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hVertexZRec", "hVertexZRec", HistType::kTH1F, {{vertexZAxis}}); + registryQC.add("hv0cosPARec", "hv0cosPARec", HistType::kTH1F, {{nBins, 0.95f, 1.f}}); + registryQC.add("hcasccosPARec", "hcasccosPARec", HistType::kTH1F, {{nBins, 0.95f, 1.f}}); + registryQC.add("hv0radiusRec", "hv0radiusRec", HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hcascradiusRec", "hcascradiusRec", HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hdcaV0daughtersRec", "hdcaV0daughtersRec", HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcacascdaughtersRec", "hdcacascdaughtersRec", HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcapostopvRec", "hdcapostopvRec", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcanegtopvRec", "hdcanegtopvRec", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcabachtopvRec", "hdcabachtopvRec", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcav0topvRec", "hdcav0topvRec", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); // Multiplicity Histograms - registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", - HistType::kTH1D, {axisCentEstimator}); - registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, - {axisCentEstimator,axisNch}); - + registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {axisCentEstimator}); + registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {axisCentEstimator,axisNch}); + // Histograms for xi (mc) - registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", - HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryMC.add("hMassXineg_truerec", "hMassXineg_truerec", - HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryMC.add("hMassXiposSelected_truerec", - "hMassXiposSelected_truerec", HistType::kTH3F, - {centAxis, ptAxis, invMassXiAxis}); - registryMC.add("hMassXinegSelected_truerec", - "hMassXinegSelected_truerec", HistType::kTH3F, - {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXineg_truerec", "hMassXineg_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXiposSelected_truerec", "hMassXiposSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXinegSelected_truerec", "hMassXinegSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); // Histograms for omega (mc) - registryMC.add("hMassOmegapos_truerec", - "hMassOmegapos_truerec", HistType::kTH3F, - {centAxis, ptAxis, invMassOmegaAxis}); - registryMC.add("hMassOmeganeg_truerec", - "hMassOmeganeg_truerec", HistType::kTH3F, - {centAxis, ptAxis, invMassOmegaAxis}); - registryMC.add("hMassOmegaposSelected_truerec", - "hMassOmegaposSelected_truerec", HistType::kTH3F, - {centAxis, ptAxis, invMassOmegaAxis}); - registryMC.add("hMassOmeganegSelected_truerec", - "hMassOmeganegSelected_truerec", HistType::kTH3F, - {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmegapos_truerec", "hMassOmegapos_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmeganeg_truerec", "hMassOmeganeg_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmegaposSelected_truerec", "hMassOmegaposSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmeganegSelected_truerec", "hMassOmeganegSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); } - + if (doprocessMonteCarloGen) { // Histograms for mc generated // QC Histograms - registryQC.add("hVertexZGen", "hVertexZGen", - HistType::kTH1F, {{vertexZAxis}}); + registryQC.add("hVertexZGen", "hVertexZGen", HistType::kTH1F, {{vertexZAxis}}); // Histograms for xi (mc) registryMC.add("h2dGenXiMinusVsMultMC_RecoedEvt", "h2dGenXiMinusVsMultMC_RecoedEvt", HistType::kTH2F, {axisNch, ptAxis}); 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 +278,6 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.add("hCentralityVsMultMC", "hCentralityVsMultMC", HistType::kTH2F, {{101, 0.0f, 101.0f}, axisNch}); } - - } // ______________________________________________________ @@ -419,7 +308,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) @@ -442,7 +332,8 @@ struct CascadeAnalysisLightIonsDerivedData { typename TrackBac, typename Coll> bool passedXiSelection(const Xi &casc, const TrackPos &ptrack, const TrackNeg &ntrack, const TrackBac &btrack, - const Coll &coll) { + const Coll &coll) + { if (!passedSingleTrackSelection(ptrack)) return false; if (!passedSingleTrackSelection(ntrack)) @@ -549,7 +440,8 @@ struct CascadeAnalysisLightIonsDerivedData { typename TrackBac, typename Coll> bool passedOmegaSelection(const Omega &casc, const TrackPos &ptrack, const TrackNeg &ntrack, const TrackBac &btrack, - const Coll &coll) { + const Coll &coll) + { if (!passedSingleTrackSelection(ptrack)) return false; if (!passedSingleTrackSelection(ntrack)) @@ -648,7 +540,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 +551,47 @@ 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)) { + + if (rejectITSROFBorder && !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { continue; } - - if (rejectTFBorder && - !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + + if (rejectTFBorder && !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { continue; } - - if (requireVertexITSTPC && - !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { + + if (requireVertexITSTPC && !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { continue; } - - if (requireIsGoodZvtxFT0VsPV && - !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + + if (requireIsGoodZvtxFT0VsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { continue; } - - if (requireIsVertexTOFmatched && - !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + + if (requireIsVertexTOFmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { continue; } - - if (requireIsVertexTRDmatched && - !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { + + if (requireIsVertexTRDmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { continue; } - - if (rejectSameBunchPileup && - !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + + 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; } @@ -721,13 +604,12 @@ struct CascadeAnalysisLightIonsDerivedData { { std::vector listBestCollisionIdx(mcCollisions.size()); for (auto const& mcCollisions : mcCollisions) { - // 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 @@ -736,56 +618,48 @@ struct CascadeAnalysisLightIonsDerivedData { int nCollisions = 0; float multiplicitydata = -1.0f; 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)) { + + if (rejectITSROFBorder && !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { continue; } - - if (rejectTFBorder && - !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + + if (rejectTFBorder && !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { continue; } - - if (requireVertexITSTPC && - !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { + + if (requireVertexITSTPC && !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { continue; } - - if (requireIsGoodZvtxFT0VsPV && - !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + + if (requireIsGoodZvtxFT0VsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { continue; } - - if (requireIsVertexTOFmatched && - !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + + if (requireIsVertexTOFmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { continue; } - - if (requireIsVertexTRDmatched && - !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { + + if (requireIsVertexTRDmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { continue; } - - if (rejectSameBunchPileup && - !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + + if (rejectSameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { continue; } - + if (biggestNContribs < collision.multPVTotalContributors()) { biggestNContribs = collision.multPVTotalContributors(); if(centralityEstimator == Option::kFT0C) multiplicitydata = collision.centFT0C(); if(centralityEstimator == Option::kFT0M) multiplicitydata = collision.centFT0M(); if(centralityEstimator == Option::kFV0A) multiplicitydata = collision.centFV0A(); if(centralityEstimator == Option::kNGlobal) multiplicitydata = collision.centNGlobal(); - } + } nCollisions++; atLeastOne = true; @@ -794,7 +668,7 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), multiplicitydata, groupedCollisions.size()); registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), multiplicitydata, nCollisions); registryMC.fill(HIST("hCentralityVsMultMC"), multiplicitydata, mcCollisions.multMCNParticlesEta05()); - + registryQC.fill(HIST("hVertexZGen"), mcCollisions.posZ()); if (atLeastOne) { @@ -808,8 +682,8 @@ struct CascadeAnalysisLightIonsDerivedData { void processData(SelCollisions::iterator const& collision, CascadeCandidates const& fullCascades, - DaughterTracks const&) { - + DaughterTracks const&) + { // Fill event counter before event selection registryData.fill(HIST("number_of_events_data"), 0); @@ -824,73 +698,59 @@ struct CascadeAnalysisLightIonsDerivedData { return; registryData.fill(HIST("number_of_events_data"), 2); - if (rejectITSROFBorder && - !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { + if (rejectITSROFBorder && !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { return; } - registryData.fill(HIST("number_of_events_data"), - 3 /* Not at ITS ROF border */); + registryData.fill(HIST("number_of_events_data"), 3 /* Not at ITS ROF border */); - if (rejectTFBorder && - !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + if (rejectTFBorder && !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { return; } registryData.fill(HIST("number_of_events_data"), 4 /* Not at TF border */); - if (requireVertexITSTPC && - !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { + if (requireVertexITSTPC && !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { return; } - registryData.fill(HIST("number_of_events_data"), - 5 /* Contains at least one ITS-TPC track */); + registryData.fill(HIST("number_of_events_data"), 5 /* Contains at least one ITS-TPC track */); - if (requireIsGoodZvtxFT0VsPV && - !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + if (requireIsGoodZvtxFT0VsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { return; } - registryData.fill(HIST("number_of_events_data"), - 6 /* PV position consistency check */); + registryData.fill(HIST("number_of_events_data"), 6 /* PV position consistency check */); - if (requireIsVertexTOFmatched && - !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + if (requireIsVertexTOFmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { 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)) { + 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 */); + registryData.fill(HIST("number_of_events_data"), 8 /* PV with at least one contributor matched with TRD */); - if (rejectSameBunchPileup && - !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + if (rejectSameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { return; } - registryData.fill(HIST("number_of_events_data"), - 9 /* Not at same bunch pile-up */); + registryData.fill(HIST("number_of_events_data"), 9 /* Not at same bunch pile-up */); // 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(); - + 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 @@ -902,64 +762,51 @@ 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, - casc.pt(), casc.mXi()); - registryData.fill(HIST("hMassOmeganeg"), multiplicity, - casc.pt(), casc.mOmega()); + registryData.fill(HIST("hMassXineg"), multiplicity, casc.pt(), casc.mXi()); + registryData.fill(HIST("hMassOmeganeg"), multiplicity, casc.pt(), casc.mOmega()); } if (casc.sign() > 0) { - registryData.fill(HIST("hMassXipos"), multiplicity, - casc.pt(), casc.mXi()); - registryData.fill(HIST("hMassOmegapos"), multiplicity, - casc.pt(), casc.mOmega()); + registryData.fill(HIST("hMassXipos"), multiplicity, casc.pt(), casc.mXi()); + registryData.fill(HIST("hMassOmegapos"), multiplicity, casc.pt(), casc.mOmega()); } - if (casc.sign() < 0 && - passedXiSelection(casc, pos, neg, bach, collision)) { - registryData.fill(HIST("hMassXinegSelected"), - multiplicity, casc.pt(), casc.mXi()); + if (casc.sign() < 0 && passedXiSelection(casc, pos, neg, bach, collision)) { + registryData.fill(HIST("hMassXinegSelected"), multiplicity, casc.pt(), casc.mXi()); } - if (casc.sign() < 0 && - passedOmegaSelection(casc, pos, neg, bach, collision)) { - registryData.fill(HIST("hMassOmeganegSelected"), - multiplicity, casc.pt(), casc.mOmega()); + if (casc.sign() < 0 && passedOmegaSelection(casc, pos, neg, bach, collision)) { + registryData.fill(HIST("hMassOmeganegSelected"), multiplicity, casc.pt(), casc.mOmega()); } - if (casc.sign() > 0 && - passedXiSelection(casc, pos, neg, bach, collision)) { - registryData.fill(HIST("hMassXiposSelected"), - multiplicity, casc.pt(), casc.mXi()); + if (casc.sign() > 0 && passedXiSelection(casc, pos, neg, bach, collision)) { + registryData.fill(HIST("hMassXiposSelected"), multiplicity, casc.pt(), casc.mXi()); } - if (casc.sign() > 0 && - passedOmegaSelection(casc, pos, neg, bach, collision)) { - registryData.fill(HIST("hMassOmegaposSelected"), - multiplicity, casc.pt(), casc.mOmega()); + if (casc.sign() > 0 && passedOmegaSelection(casc, pos, neg, bach, collision)) { + registryData.fill(HIST("hMassOmegaposSelected"), multiplicity, casc.pt(), casc.mOmega()); } } } PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processData, "Process data", true); - void processMonteCarloRec(SimCollisions const& RecCols, CascadeMCCandidates const& fullCascades, DaughterTracks const&) { - + void processMonteCarloRec(SimCollisions const& RecCols, CascadeMCCandidates const& fullCascades, DaughterTracks const&) + { 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; @@ -969,79 +816,61 @@ struct CascadeAnalysisLightIonsDerivedData { continue; registryMC.fill(HIST("number_of_events_mc_rec"), 2); - if (rejectITSROFBorder && - !RecCol.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { + if (rejectITSROFBorder && !RecCol.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { continue; } - registryMC.fill(HIST("number_of_events_mc_rec"), - 3 /* Not at ITS ROF border */); + registryMC.fill(HIST("number_of_events_mc_rec"), 3 /* Not at ITS ROF border */); - if (rejectTFBorder && - !RecCol.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + if (rejectTFBorder && !RecCol.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { continue; } - registryMC.fill(HIST("number_of_events_mc_rec"), - 4 /* Not at TF border */); + registryMC.fill(HIST("number_of_events_mc_rec"), 4 /* Not at TF border */); - if (requireVertexITSTPC && - !RecCol.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { + if (requireVertexITSTPC && !RecCol.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { continue; } - registryMC.fill(HIST("number_of_events_mc_rec"), - 5 /* Contains at least one ITS-TPC track */); + registryMC.fill(HIST("number_of_events_mc_rec"), 5 /* Contains at least one ITS-TPC track */); - if (requireIsGoodZvtxFT0VsPV && - !RecCol.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + if (requireIsGoodZvtxFT0VsPV && !RecCol.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { continue; } - registryMC.fill(HIST("number_of_events_mc_rec"), - 6 /* PV position consistency check */); + registryMC.fill(HIST("number_of_events_mc_rec"), 6 /* PV position consistency check */); - if (requireIsVertexTOFmatched && - !RecCol.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + if (requireIsVertexTOFmatched && !RecCol.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { continue; } - registryMC.fill( - HIST("number_of_events_mc_rec"), - 7 /* PV with at least one contributor matched with TOF */); + registryMC.fill(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)) { + 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 */); + registryMC.fill(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)) { + if (rejectSameBunchPileup && !RecCol.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { continue; } - registryMC.fill(HIST("number_of_events_mc_rec"), - 9 /* Not at same bunch pile-up */); + registryMC.fill(HIST("number_of_events_mc_rec"), 9 /* Not at same bunch pile-up */); // Store the Zvtx registryQC.fill(HIST("hVertexZRec"), RecCol.posZ()); // 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(); - - registryMC.fill(HIST("hCentEstimator_truerec"), - multiplicityMcRec); + + 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; @@ -1050,115 +879,100 @@ 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) { - registryMC.fill(HIST("hMassXineg_truerec"), - multiplicityMcRec, ptmc, casc.mXi()); + registryMC.fill(HIST("hMassXineg_truerec"), multiplicityMcRec, ptmc, casc.mXi()); } if (pdgParent == kOmegaMinus) { - registryMC.fill(HIST("hMassOmeganeg_truerec"), - multiplicityMcRec, ptmc, - casc.mOmega()); + registryMC.fill(HIST("hMassOmeganeg_truerec"), multiplicityMcRec, ptmc, casc.mOmega()); } } if (casc.sign() > 0) { if (pdgParent == kXiPlusBar) { - registryMC.fill(HIST("hMassXipos_truerec"), - multiplicityMcRec, ptmc, casc.mXi()); + registryMC.fill(HIST("hMassXipos_truerec"), multiplicityMcRec, ptmc, casc.mXi()); } if (pdgParent == kOmegaPlusBar) { - registryMC.fill(HIST("hMassOmegapos_truerec"), - multiplicityMcRec, ptmc, - casc.mOmega()); + registryMC.fill(HIST("hMassOmegapos_truerec"), multiplicityMcRec, ptmc, casc.mOmega()); } } if (casc.sign() < 0 && pdgParent == kXiMinus && passedXiSelection(casc, pos, neg, bach, RecCol)) { - registryMC.fill(HIST("hMassXinegSelected_truerec"), - multiplicityMcRec, ptmc, casc.mXi()); + registryMC.fill(HIST("hMassXinegSelected_truerec"), multiplicityMcRec, ptmc, casc.mXi()); } if (casc.sign() < 0 && pdgParent == kOmegaMinus && passedOmegaSelection(casc, pos, neg, bach, RecCol)) { - registryMC.fill(HIST("hMassOmeganegSelected_truerec"), - multiplicityMcRec, ptmc, casc.mOmega()); + registryMC.fill(HIST("hMassOmeganegSelected_truerec"), multiplicityMcRec, ptmc, casc.mOmega()); } if (casc.sign() > 0 && pdgParent == kXiPlusBar && passedXiSelection(casc, pos, neg, bach, RecCol)) { - registryMC.fill(HIST("hMassXiposSelected_truerec"), - multiplicityMcRec, ptmc, casc.mXi()); + registryMC.fill(HIST("hMassXiposSelected_truerec"), multiplicityMcRec, ptmc, casc.mXi()); } if (casc.sign() > 0 && pdgParent == kOmegaPlusBar && passedOmegaSelection(casc, pos, neg, bach, RecCol)) { - registryMC.fill(HIST("hMassOmegaposSelected_truerec"), - multiplicityMcRec, ptmc, casc.mOmega()); + registryMC.fill(HIST("hMassOmegaposSelected_truerec"), multiplicityMcRec, ptmc, casc.mOmega()); } - } // casc loop - } // rec.collision loop } - PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processMonteCarloRec, "Process MC", - false); - - + PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processMonteCarloRec, "Process MC Rec", false); + void processMonteCarloGen(CollisionMCTrueTable const& mcCollisions, CascadeMCCores const& CascMCCores, - SimCollisions const& RecCols) { - + 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; - + // 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 (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { registryMC.fill(HIST("h2dGenXiMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); } @@ -1172,7 +986,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); } @@ -1185,17 +999,10 @@ struct CascadeAnalysisLightIonsDerivedData { if (cascMC.pdgCode() == kOmegaPlusBar && std::abs(cascMC.rapidityMC(2)) < rapcut) { registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } - - - } //cascMC loop - - - } - - PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processMonteCarloGen, "Process MC", - false); + + PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processMonteCarloGen, "Process MC Gen", false); }; WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { From 48ecb385e9d5dddd1a84368ace31a4ee078df65f Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Fri, 8 Aug 2025 15:19:10 +0200 Subject: [PATCH 06/24] Fix clang-format errors --- PWGLF/Tasks/Strangeness/CMakeLists.txt | 2 +- .../cascadeAnalysisLightIonsDerivedData.cxx | 270 ++++++++++-------- 2 files changed, 145 insertions(+), 127 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/CMakeLists.txt b/PWGLF/Tasks/Strangeness/CMakeLists.txt index 2e2188248f0..100b8667aab 100644 --- a/PWGLF/Tasks/Strangeness/CMakeLists.txt +++ b/PWGLF/Tasks/Strangeness/CMakeLists.txt @@ -155,7 +155,7 @@ o2physics_add_dpl_workflow(lambdatwopartpolarization SOURCES lambdaTwoPartPolarization.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) - + o2physics_add_dpl_workflow(cascadeanalysislightions SOURCES cascadeAnalysisLightIonsDerivedData.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index b2bb03d9b72..b472b16a40f 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -17,6 +17,7 @@ #include "PWGLF/DataModel/LFStrangenessPIDTables.h" #include "PWGLF/DataModel/LFStrangenessTables.h" + #include "Common/CCDB/ctpRateFetcher.h" #include "Common/Core/RecoDecay.h" #include "Common/Core/TrackSelection.h" @@ -26,14 +27,18 @@ #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 #include #include @@ -129,28 +134,32 @@ struct CascadeAnalysisLightIonsDerivedData { 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 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"}; @@ -192,7 +201,7 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {axisCentEstimator}); - registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {axisCentEstimator,axisNch}); + registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {axisCentEstimator, axisNch}); // Histograms for xi (data) registryData.add("hMassXipos", "hMassXipos", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); @@ -236,7 +245,7 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {axisCentEstimator}); - registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {axisCentEstimator,axisNch}); + registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {axisCentEstimator, axisNch}); // Histograms for xi (mc) registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); @@ -308,7 +317,7 @@ struct CascadeAnalysisLightIonsDerivedData { // Single-Track Selection template - bool passedSingleTrackSelection(const Track &track) + bool passedSingleTrackSelection(const Track& track) { if (requireITS && (!track.hasITS())) return false; @@ -330,9 +339,9 @@ 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; @@ -438,9 +447,9 @@ 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; @@ -602,82 +611,82 @@ struct CascadeAnalysisLightIonsDerivedData { template void fillGeneratedEventProperties(TMCCollisions const& mcCollisions, TCollisions const& collisions) { - std::vector listBestCollisionIdx(mcCollisions.size()); - for (auto const& mcCollisions : mcCollisions) { - // event selections - if (applyVtxZ && std::fabs(mcCollisions.posZ()) > zVtx) + std::vector listBestCollisionIdx(mcCollisions.size()); + for (auto const& mcCollisions : mcCollisions) { + // 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; - int nCollisions = 0; - float multiplicitydata = -1.0f; - 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) multiplicitydata = collision.centFT0C(); - if(centralityEstimator == Option::kFT0M) multiplicitydata = collision.centFT0M(); - if(centralityEstimator == Option::kFV0A) multiplicitydata = collision.centFV0A(); - if(centralityEstimator == Option::kNGlobal) multiplicitydata = collision.centNGlobal(); - } - nCollisions++; - - atLeastOne = true; - } - - registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), multiplicitydata, groupedCollisions.size()); - registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), multiplicitydata, nCollisions); - registryMC.fill(HIST("hCentralityVsMultMC"), multiplicitydata, 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"), multiplicitydata); - } - } - 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; + int nCollisions = 0; + float multiplicitydata = -1.0f; + 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) multiplicitydata = collision.centFT0C(); + if(centralityEstimator == Option::kFT0M) multiplicitydata = collision.centFT0M(); + if(centralityEstimator == Option::kFV0A) multiplicitydata = collision.centFV0A(); + if(centralityEstimator == Option::kNGlobal) multiplicitydata = collision.centNGlobal(); + } + nCollisions++; + + atLeastOne = true; + } + + registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), multiplicitydata, groupedCollisions.size()); + registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), multiplicitydata, nCollisions); + registryMC.fill(HIST("hCentralityVsMultMC"), multiplicitydata, 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"), multiplicitydata); + } + } + return; } void processData(SelCollisions::iterator const& collision, @@ -721,8 +730,7 @@ struct CascadeAnalysisLightIonsDerivedData { if (requireIsVertexTOFmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { return; } - registryData.fill( - HIST("number_of_events_data"), 7 /* PV with at least one contributor matched with TOF */); + registryData.fill(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; @@ -739,10 +747,15 @@ struct CascadeAnalysisLightIonsDerivedData { // 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()); @@ -762,14 +775,14 @@ 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) { @@ -857,10 +870,14 @@ 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()); @@ -892,14 +909,14 @@ struct CascadeAnalysisLightIonsDerivedData { // ------------------------------------- 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) { @@ -939,8 +956,8 @@ struct CascadeAnalysisLightIonsDerivedData { PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processMonteCarloRec, "Process MC Rec", 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); @@ -959,19 +976,19 @@ struct CascadeAnalysisLightIonsDerivedData { // event selections if (applyVtxZ && std::abs(mcCollision.posZ()) > zVtx) - return; + return; // Store the Zvtx registryQC.fill(HIST("hVertexZGen"), mcCollision.posZ()); - //float centrality = 100.5f; + // 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(); + // 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 (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { registryMC.fill(HIST("h2dGenXiMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); @@ -999,12 +1016,13 @@ 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 Gen", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) +{ return WorkflowSpec{adaptAnalysisTask(cfgc)}; } From 15e7e5e4efe427f549cd63fdaec9f03ef0db3206 Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Fri, 8 Aug 2025 15:24:11 +0200 Subject: [PATCH 07/24] Fix clang-format errors --- .../cascadeAnalysisLightIonsDerivedData.cxx | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index b472b16a40f..633d02046e3 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -30,13 +30,11 @@ #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 @@ -134,7 +132,7 @@ struct CascadeAnalysisLightIonsDerivedData { 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 @@ -149,7 +147,7 @@ struct CascadeAnalysisLightIonsDerivedData { // For manual sliceBy PresliceUnsorted> perMcCollision = aod::v0data::straMCCollisionId; - void init(InitContext const &) + void init(InitContext const& ) { // setting CCDB service ccdb->setURL(ccdbConfigurations.ccdbUrl); @@ -664,10 +662,14 @@ struct CascadeAnalysisLightIonsDerivedData { if (biggestNContribs < collision.multPVTotalContributors()) { biggestNContribs = collision.multPVTotalContributors(); - if(centralityEstimator == Option::kFT0C) multiplicitydata = collision.centFT0C(); - if(centralityEstimator == Option::kFT0M) multiplicitydata = collision.centFT0M(); - if(centralityEstimator == Option::kFV0A) multiplicitydata = collision.centFV0A(); - if(centralityEstimator == Option::kNGlobal) multiplicitydata = collision.centNGlobal(); + if (centralityEstimator == Option::kFT0C) + multiplicitydata = collision.centFT0C(); + if (centralityEstimator == Option::kFT0M) + multiplicitydata = collision.centFT0M(); + if (centralityEstimator == Option::kFV0A) + multiplicitydata = collision.centFV0A(); + if (centralityEstimator == Option::kNGlobal) + multiplicitydata = collision.centNGlobal(); } nCollisions++; @@ -1022,7 +1024,7 @@ struct CascadeAnalysisLightIonsDerivedData { PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processMonteCarloGen, "Process MC Gen", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } From d1cb402620770038bbbe9eb8d9fed500aa2f5739 Mon Sep 17 00:00:00 2001 From: Sara Pucillo Date: Fri, 8 Aug 2025 15:27:05 +0200 Subject: [PATCH 08/24] Fix clang-format errors --- PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 633d02046e3..5d7178c60e5 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -147,7 +147,7 @@ struct CascadeAnalysisLightIonsDerivedData { // For manual sliceBy PresliceUnsorted> perMcCollision = aod::v0data::straMCCollisionId; - void init(InitContext const& ) + void init(InitContext const&) { // setting CCDB service ccdb->setURL(ccdbConfigurations.ccdbUrl); From 39ee46b45b1de27263a96d30000b288e29e31307 Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Wed, 3 Sep 2025 14:01:13 +0200 Subject: [PATCH 09/24] Add correlation histograms --- .../cascadeAnalysisLightIonsDerivedData.cxx | 123 +++++++++++------- 1 file changed, 73 insertions(+), 50 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 5d7178c60e5..bc13a118f49 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -51,8 +51,8 @@ using namespace o2::constants::math; using namespace o2::constants::physics; using std::array; -using SelCollisions = soa::Join; -using SimCollisions = soa::Join; +using SelCollisions = soa::Join; +using SimCollisions = soa::Join; using CascadeCandidates = soa::Join; using CascadeMCCandidates = soa::Join; using DaughterTracks = soa::Join; @@ -93,7 +93,7 @@ struct CascadeAnalysisLightIonsDerivedData { Configurable rejectITSROFBorder{"rejectITSROFBorder", true, "reject events at ITS ROF border"}; Configurable rejectTFBorder{"rejectTFBorder", true, "reject events at TF border"}; Configurable requireVertexITSTPC{"requireVertexITSTPC", false, "require events with at least one ITS-TPC track"}; - Configurable requireIsGoodZvtxFT0VsPV{"requireIsGoodZvtxFT0VsPV", false, "require is good Zvtx FT0 vs PV"}; + Configurable requireIsGoodZvtxFT0VsPV{"requireIsGoodZvtxFT0VsPV", true, "require is good Zvtx FT0 vs PV"}; Configurable requireIsVertexTOFmatched{"requireIsVertexTOFmatched", false, "require events with at least one of vertex contributors matched to TOF"}; Configurable requireIsVertexTRDmatched{"requireIsVertexTRDmatched", false, "require events with at least one of vertex contributors matched to TRD"}; Configurable rejectSameBunchPileup{"rejectSameBunchPileup", true, "reject collisions in case of pileup with another collision in the same foundBC"}; @@ -134,6 +134,7 @@ struct CascadeAnalysisLightIonsDerivedData { 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 axisNch{"axisNch", {500, 0.0f, +1000.0f}, "Number of charged particles"}; + ConfigurableAxis axisMult{"axisMult", {500, 0.0f, +1000.0f}, "Multiplicity"}; // Centrality estimator Configurable centralityEstimator{"centralityEstimator", 0, "0 = FT0C, 1 = FTOM, 2 = FV0A, 3 = NGlobal"}; @@ -200,6 +201,7 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {axisCentEstimator}); registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {axisCentEstimator, axisNch}); + registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {axisCentEstimator, axisMult}); // Histograms for xi (data) registryData.add("hMassXipos", "hMassXipos", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); @@ -244,6 +246,7 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {axisCentEstimator}); registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {axisCentEstimator, axisNch}); + registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {axisCentEstimator, axisMult}); // Histograms for xi (mc) registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); @@ -623,7 +626,7 @@ struct CascadeAnalysisLightIonsDerivedData { bool atLeastOne = false; int biggestNContribs = -1; int nCollisions = 0; - float multiplicitydata = -1.0f; + float centralitydata = -1.0f; for (auto const& collision : groupedCollisions) { // event selections if (applySel8 && !collision.sel8()) @@ -663,29 +666,29 @@ struct CascadeAnalysisLightIonsDerivedData { if (biggestNContribs < collision.multPVTotalContributors()) { biggestNContribs = collision.multPVTotalContributors(); if (centralityEstimator == Option::kFT0C) - multiplicitydata = collision.centFT0C(); + centralitydata = collision.centFT0C(); if (centralityEstimator == Option::kFT0M) - multiplicitydata = collision.centFT0M(); + centralitydata = collision.centFT0M(); if (centralityEstimator == Option::kFV0A) - multiplicitydata = collision.centFV0A(); + centralitydata = collision.centFV0A(); if (centralityEstimator == Option::kNGlobal) - multiplicitydata = collision.centNGlobal(); + centralitydata = collision.centNGlobal(); } nCollisions++; atLeastOne = true; } - registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), multiplicitydata, groupedCollisions.size()); - registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), multiplicitydata, nCollisions); - registryMC.fill(HIST("hCentralityVsMultMC"), multiplicitydata, mcCollisions.multMCNParticlesEta05()); + registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), centralitydata, groupedCollisions.size()); + registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), centralitydata, nCollisions); + registryMC.fill(HIST("hCentralityVsMultMC"), centralitydata, 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"), multiplicitydata); + registryMC.fill(HIST("hGenEventCentrality"), centralitydata); } } return; @@ -747,20 +750,30 @@ struct CascadeAnalysisLightIonsDerivedData { // Store the Zvtx registryQC.fill(HIST("hVertexZdata"), std::fabs(collision.posZ())); - // Store the event multiplicity using different estimators + // Store the event centrality using different estimators + float centrality = -1.0f; 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) { + centrality = collision.centFT0C(); + multiplicity = collision.multFT0C(); + } + if (centralityEstimator == Option::kFT0M) { + centrality = collision.centFT0M(); + multiplicity = collision.multFT0C() + collision.multFT0A(); + } + if (centralityEstimator == Option::kFV0A) { + centrality = collision.centFV0A(); + multiplicity = collision.multFV0A(); + } + if (centralityEstimator == Option::kNGlobal) { + centrality = collision.centNGlobal(); + multiplicity = collision.multNTracksGlobal(); + } - registryData.fill(HIST("hCentEstimator"), multiplicity); - registryData.fill(HIST("hCentralityVsNch"), multiplicity, collision.multNTracksPVeta1()); + registryData.fill(HIST("hCentEstimator"), centrality); + registryData.fill(HIST("hCentralityVsNch"), centrality, collision.multNTracksPVeta1()); + registryData.fill(HIST("hCentralityVsMultiplicity"), centrality, multiplicity); // Loop over cascades for (const auto& casc : fullCascades) { @@ -788,25 +801,25 @@ struct CascadeAnalysisLightIonsDerivedData { // ------------------------------------- Store selctions distribution for analysis if (casc.sign() < 0) { - registryData.fill(HIST("hMassXineg"), multiplicity, casc.pt(), casc.mXi()); - registryData.fill(HIST("hMassOmeganeg"), multiplicity, casc.pt(), casc.mOmega()); + registryData.fill(HIST("hMassXineg"), centrality, casc.pt(), casc.mXi()); + registryData.fill(HIST("hMassOmeganeg"), centrality, casc.pt(), casc.mOmega()); } if (casc.sign() > 0) { - registryData.fill(HIST("hMassXipos"), multiplicity, casc.pt(), casc.mXi()); - registryData.fill(HIST("hMassOmegapos"), multiplicity, casc.pt(), casc.mOmega()); + registryData.fill(HIST("hMassXipos"), centrality, casc.pt(), casc.mXi()); + registryData.fill(HIST("hMassOmegapos"), centrality, casc.pt(), casc.mOmega()); } if (casc.sign() < 0 && passedXiSelection(casc, pos, neg, bach, collision)) { - registryData.fill(HIST("hMassXinegSelected"), multiplicity, casc.pt(), casc.mXi()); + registryData.fill(HIST("hMassXinegSelected"), centrality, casc.pt(), casc.mXi()); } if (casc.sign() < 0 && passedOmegaSelection(casc, pos, neg, bach, collision)) { - registryData.fill(HIST("hMassOmeganegSelected"), multiplicity, casc.pt(), casc.mOmega()); + registryData.fill(HIST("hMassOmeganegSelected"), centrality, casc.pt(), casc.mOmega()); } if (casc.sign() > 0 && passedXiSelection(casc, pos, neg, bach, collision)) { - registryData.fill(HIST("hMassXiposSelected"), multiplicity, casc.pt(), casc.mXi()); + registryData.fill(HIST("hMassXiposSelected"), centrality, casc.pt(), casc.mXi()); } if (casc.sign() > 0 && passedOmegaSelection(casc, pos, neg, bach, collision)) { - registryData.fill(HIST("hMassOmegaposSelected"), multiplicity, casc.pt(), casc.mOmega()); + registryData.fill(HIST("hMassOmegaposSelected"), centrality, casc.pt(), casc.mOmega()); } } } @@ -869,20 +882,30 @@ struct CascadeAnalysisLightIonsDerivedData { // Store the Zvtx registryQC.fill(HIST("hVertexZRec"), RecCol.posZ()); - // Store the event multiplicity using different estimators + // Store the event centrality using different estimators + float centralityMcRec = -1.0f; 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) { + centralityMcRec = RecCol.centFT0C(); + multiplicityMcRec = RecCol.multFT0C(); + } + if (centralityEstimator == Option::kFT0M) { + centralityMcRec = RecCol.centFT0M(); + multiplicityMcRec = RecCol.multFT0C() + RecCol.multFT0A(); + } + if (centralityEstimator == Option::kFV0A) { + centralityMcRec = RecCol.centFV0A(); + multiplicityMcRec = RecCol.multFV0A(); + } + if (centralityEstimator == Option::kNGlobal) { + centralityMcRec = RecCol.centNGlobal(); + multiplicityMcRec = RecCol.multNTracksGlobal(); + } - registryMC.fill(HIST("hCentEstimator_truerec"), multiplicityMcRec); - registryMC.fill(HIST("hCentralityVsNch_truerec"), multiplicityMcRec, RecCol.multNTracksPVeta1()); + registryMC.fill(HIST("hCentEstimator_truerec"), centralityMcRec); + registryMC.fill(HIST("hCentralityVsNch_truerec"), centralityMcRec, RecCol.multNTracksPVeta1()); + registryMC.fill(HIST("hCentralityVsMultiplicity_truerec"), centralityMcRec, multiplicityMcRec); for (const auto& casc : fullCascades) { if (etaMin > casc.bacheloreta() || casc.bacheloreta() > etaMax || @@ -923,33 +946,33 @@ struct CascadeAnalysisLightIonsDerivedData { // ------------------------------------- Store selctions distribution for analysis if (casc.sign() < 0) { if (pdgParent == kXiMinus) { - registryMC.fill(HIST("hMassXineg_truerec"), multiplicityMcRec, ptmc, casc.mXi()); + registryMC.fill(HIST("hMassXineg_truerec"), centralityMcRec, ptmc, casc.mXi()); } if (pdgParent == kOmegaMinus) { - registryMC.fill(HIST("hMassOmeganeg_truerec"), multiplicityMcRec, ptmc, casc.mOmega()); + registryMC.fill(HIST("hMassOmeganeg_truerec"), centralityMcRec, ptmc, casc.mOmega()); } } if (casc.sign() > 0) { if (pdgParent == kXiPlusBar) { - registryMC.fill(HIST("hMassXipos_truerec"), multiplicityMcRec, ptmc, casc.mXi()); + registryMC.fill(HIST("hMassXipos_truerec"), centralityMcRec, ptmc, casc.mXi()); } if (pdgParent == kOmegaPlusBar) { - registryMC.fill(HIST("hMassOmegapos_truerec"), multiplicityMcRec, ptmc, casc.mOmega()); + registryMC.fill(HIST("hMassOmegapos_truerec"), centralityMcRec, ptmc, casc.mOmega()); } } if (casc.sign() < 0 && pdgParent == kXiMinus && passedXiSelection(casc, pos, neg, bach, RecCol)) { - registryMC.fill(HIST("hMassXinegSelected_truerec"), multiplicityMcRec, ptmc, casc.mXi()); + registryMC.fill(HIST("hMassXinegSelected_truerec"), centralityMcRec, ptmc, casc.mXi()); } if (casc.sign() < 0 && pdgParent == kOmegaMinus && passedOmegaSelection(casc, pos, neg, bach, RecCol)) { - registryMC.fill(HIST("hMassOmeganegSelected_truerec"), multiplicityMcRec, ptmc, casc.mOmega()); + registryMC.fill(HIST("hMassOmeganegSelected_truerec"), centralityMcRec, ptmc, casc.mOmega()); } if (casc.sign() > 0 && pdgParent == kXiPlusBar && passedXiSelection(casc, pos, neg, bach, RecCol)) { - registryMC.fill(HIST("hMassXiposSelected_truerec"), multiplicityMcRec, ptmc, casc.mXi()); + registryMC.fill(HIST("hMassXiposSelected_truerec"), centralityMcRec, ptmc, casc.mXi()); } if (casc.sign() > 0 && pdgParent == kOmegaPlusBar && passedOmegaSelection(casc, pos, neg, bach, RecCol)) { - registryMC.fill(HIST("hMassOmegaposSelected_truerec"), multiplicityMcRec, ptmc, casc.mOmega()); + registryMC.fill(HIST("hMassOmegaposSelected_truerec"), centralityMcRec, ptmc, casc.mOmega()); } } // casc loop } // rec.collision loop From b9c19e8e83b141e263efcb05c5186d448b170396 Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Wed, 3 Sep 2025 15:40:03 +0200 Subject: [PATCH 10/24] Switch back to StraEvSels --- .../Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index bc13a118f49..2453c10309a 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -51,8 +51,8 @@ using namespace o2::constants::math; using namespace o2::constants::physics; using std::array; -using SelCollisions = soa::Join; -using SimCollisions = soa::Join; +using SelCollisions = soa::Join; +using SimCollisions = soa::Join; using CascadeCandidates = soa::Join; using CascadeMCCandidates = soa::Join; using DaughterTracks = soa::Join; From 49b251b990b98f37a3d993e660633f5c436ff4da Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Sat, 6 Sep 2025 11:44:34 +0200 Subject: [PATCH 11/24] Add the subscription to CascadeMCCores in the processMonteCarloRec process function --- PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 2453c10309a..08474177861 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -826,7 +826,7 @@ struct CascadeAnalysisLightIonsDerivedData { PROCESS_SWITCH(CascadeAnalysisLightIonsDerivedData, processData, "Process data", true); - void processMonteCarloRec(SimCollisions const& RecCols, CascadeMCCandidates const& fullCascades, DaughterTracks const&) + void processMonteCarloRec(SimCollisions const& RecCols, CascadeMCCandidates const& fullCascades, DaughterTracks const&, CascadeMCCores const&) { for (const auto& RecCol : RecCols) { // Fill event counter before event selection From 89519fda675d696d23ec99a4df898b0c052d99ae Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Tue, 16 Sep 2025 12:29:15 +0200 Subject: [PATCH 12/24] Add 2D histogram for event selections vs centrality + improve binning --- .../cascadeAnalysisLightIonsDerivedData.cxx | 246 +++++++++++------- 1 file changed, 147 insertions(+), 99 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 08474177861..faeab56ee2a 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -51,8 +51,8 @@ using namespace o2::constants::math; using namespace o2::constants::physics; using std::array; -using SelCollisions = soa::Join; -using SimCollisions = soa::Join; +using SelCollisions = soa::Join; +using SimCollisions = soa::Join; using CascadeCandidates = soa::Join; using CascadeMCCandidates = soa::Join; using DaughterTracks = soa::Join; @@ -131,10 +131,10 @@ 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 centEstimatorHistBin{"centEstimatorHistBin", {101, 0.0f, 101.0f}, ""}; 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"}; - ConfigurableAxis axisMult{"axisMult", {500, 0.0f, +1000.0f}, "Multiplicity"}; + ConfigurableAxis axisNch{"axisNch", {500, 0.0f, +5000.0f}, "Number of charged particles"}; + ConfigurableAxis axisMult{"axisMult", {500, 0.0f, +100000.0f}, "Multiplicity"}; // Centrality estimator Configurable centralityEstimator{"centralityEstimator", 0, "0 = FT0C, 1 = FTOM, 2 = FV0A, 3 = NGlobal"}; @@ -185,18 +185,31 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); + registryData.add("number_of_events_data_vs_centrality", "number of events in data vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, axisCentEstimator}); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(1, "All collisions"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(2, "sel8 cut"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(3, "posZ cut"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(4, "kNoITSROFrameBorder"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(5, "kNoTimeFrameBorder"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(6, "kIsVertexITSTPC"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(8, "kIsVertexTOFmatched"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); + registryData.get(HIST("number_of_events_data_vs_centrality"))->GetYaxis()->SetTitle("Centrality (%)"); + // QC Histograms - registryQC.add("hVertexZdata", "hVertexZdata", HistType::kTH1F, {vertexZAxis}); - registryQC.add("hv0cosPAdata", "hv0cosPAdata", HistType::kTH1F, {{nBins, 0.95f, 1.f}}); - registryQC.add("hcasccosPAdata", "hcasccosPAdata", HistType::kTH1F, {{nBins, 0.95f, 1.f}}); - registryQC.add("hv0radiusdata", "hv0radiusdata", HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); - registryQC.add("hcascradiusdata", "hcascradiusdata", HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); - registryQC.add("hdcaV0daughtersdata", "hdcaV0daughtersdata", HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); - registryQC.add("hdcacascdaughtersdata", "hdcacascdaughtersdata", HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); - registryQC.add("hdcapostopvdata", "hdcapostopvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcanegtopvdata", "hdcanegtopvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcabachtopvdata", "hdcabachtopvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcav0topvdata", "hdcav0topvdata", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hVertexZdata", "hVertexZdata", HistType::kTH1D, {vertexZAxis}); + registryQC.add("hv0cosPAdata", "hv0cosPAdata", HistType::kTH1D, {{nBins, 0.95f, 1.f}}); + registryQC.add("hcasccosPAdata", "hcasccosPAdata", HistType::kTH1D, {{nBins, 0.95f, 1.f}}); + registryQC.add("hv0radiusdata", "hv0radiusdata", HistType::kTH1D, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hcascradiusdata", "hcascradiusdata", HistType::kTH1D, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hdcaV0daughtersdata", "hdcaV0daughtersdata", HistType::kTH1D, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcacascdaughtersdata", "hdcacascdaughtersdata", HistType::kTH1D, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcapostopvdata", "hdcapostopvdata", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcanegtopvdata", "hdcanegtopvdata", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcabachtopvdata", "hdcabachtopvdata", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcav0topvdata", "hdcav0topvdata", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); // Multiplicity Histograms registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {axisCentEstimator}); @@ -204,16 +217,16 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {axisCentEstimator, axisMult}); // Histograms for xi (data) - registryData.add("hMassXipos", "hMassXipos", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXineg", "hMassXineg", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXiposSelected", "hMassXiposSelected", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXinegSelected", "hMassXinegSelected", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXipos", "hMassXipos", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXineg", "hMassXineg", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXiposSelected", "hMassXiposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXinegSelected", "hMassXinegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); // Histograms for omega (data) - registryData.add("hMassOmegapos", "hMassOmegapos", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmeganeg", "hMassOmeganeg", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmegaposSelected", "hMassOmegaposSelected", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmeganegSelected", "hMassOmeganegSelected", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmegapos", "hMassOmegapos", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganeg", "hMassOmeganeg", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmegaposSelected", "hMassOmegaposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganegSelected", "hMassOmeganegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); } if (doprocessMonteCarloRec) { @@ -230,18 +243,31 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); + registryMC.add("number_of_events_mc_rec_vs_centrality", "number of events in mc_rec vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, axisCentEstimator}); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(1, "All collisions"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(2, "sel8 cut"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(3, "posZ cut"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(4, "kNoITSROFrameBorder"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(5, "kNoTimeFrameBorder"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(6, "kIsVertexITSTPC"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(7, "kIsGoodZvtxFT0vsPV"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(8, "kIsVertexTOFmatched"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); + registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetYaxis()->SetTitle("Centrality (%)"); + // QC Histograms - registryQC.add("hVertexZRec", "hVertexZRec", HistType::kTH1F, {{vertexZAxis}}); - registryQC.add("hv0cosPARec", "hv0cosPARec", HistType::kTH1F, {{nBins, 0.95f, 1.f}}); - registryQC.add("hcasccosPARec", "hcasccosPARec", HistType::kTH1F, {{nBins, 0.95f, 1.f}}); - registryQC.add("hv0radiusRec", "hv0radiusRec", HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); - registryQC.add("hcascradiusRec", "hcascradiusRec", HistType::kTH1F, {{nBins, 0.0f, 5.0f}}); - registryQC.add("hdcaV0daughtersRec", "hdcaV0daughtersRec", HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); - registryQC.add("hdcacascdaughtersRec", "hdcacascdaughtersRec", HistType::kTH1F, {{nBins, 0.0f, 1.5f}}); - registryQC.add("hdcapostopvRec", "hdcapostopvRec", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcanegtopvRec", "hdcanegtopvRec", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcabachtopvRec", "hdcabachtopvRec", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); - registryQC.add("hdcav0topvRec", "hdcav0topvRec", HistType::kTH1F, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hVertexZRec", "hVertexZRec", HistType::kTH1D, {{vertexZAxis}}); + registryQC.add("hv0cosPARec", "hv0cosPARec", HistType::kTH1D, {{nBins, 0.95f, 1.f}}); + registryQC.add("hcasccosPARec", "hcasccosPARec", HistType::kTH1D, {{nBins, 0.95f, 1.f}}); + registryQC.add("hv0radiusRec", "hv0radiusRec", HistType::kTH1D, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hcascradiusRec", "hcascradiusRec", HistType::kTH1D, {{nBins, 0.0f, 5.0f}}); + registryQC.add("hdcaV0daughtersRec", "hdcaV0daughtersRec", HistType::kTH1D, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcacascdaughtersRec", "hdcacascdaughtersRec", HistType::kTH1D, {{nBins, 0.0f, 1.5f}}); + registryQC.add("hdcapostopvRec", "hdcapostopvRec", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcanegtopvRec", "hdcanegtopvRec", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcabachtopvRec", "hdcabachtopvRec", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); + registryQC.add("hdcav0topvRec", "hdcav0topvRec", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); // Multiplicity Histograms registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {axisCentEstimator}); @@ -249,44 +275,44 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {axisCentEstimator, axisMult}); // Histograms for xi (mc) - registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryMC.add("hMassXineg_truerec", "hMassXineg_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryMC.add("hMassXiposSelected_truerec", "hMassXiposSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); - registryMC.add("hMassXinegSelected_truerec", "hMassXinegSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXineg_truerec", "hMassXineg_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXiposSelected_truerec", "hMassXiposSelected_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryMC.add("hMassXinegSelected_truerec", "hMassXinegSelected_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); // Histograms for omega (mc) - registryMC.add("hMassOmegapos_truerec", "hMassOmegapos_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); - registryMC.add("hMassOmeganeg_truerec", "hMassOmeganeg_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); - registryMC.add("hMassOmegaposSelected_truerec", "hMassOmegaposSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); - registryMC.add("hMassOmeganegSelected_truerec", "hMassOmeganegSelected_truerec", HistType::kTH3F, {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmegapos_truerec", "hMassOmegapos_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmeganeg_truerec", "hMassOmeganeg_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmegaposSelected_truerec", "hMassOmegaposSelected_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryMC.add("hMassOmeganegSelected_truerec", "hMassOmeganegSelected_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); } if (doprocessMonteCarloGen) { // Histograms for mc generated // QC Histograms - registryQC.add("hVertexZGen", "hVertexZGen", HistType::kTH1F, {{vertexZAxis}}); + registryQC.add("hVertexZGen", "hVertexZGen", HistType::kTH1D, {{vertexZAxis}}); // Histograms for xi (mc) - registryMC.add("h2dGenXiMinusVsMultMC_RecoedEvt", "h2dGenXiMinusVsMultMC_RecoedEvt", HistType::kTH2F, {axisNch, ptAxis}); - 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}); + registryMC.add("h2dGenXiMinusVsMultMC_RecoedEvt", "h2dGenXiMinusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenXiPlusVsMultMC_RecoedEvt", "h2dGenXiPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenXiMinusVsMultMC", "h2dGenXiMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenXiPlusVsMultMC", "h2dGenXiPlusVsMultMC", HistType::kTH2D, {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}); + registryMC.add("h2dGenOmegaMinusVsMultMC_RecoedEvt", "h2dGenOmegaMinusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenOmegaPlusVsMultMC_RecoedEvt", "h2dGenOmegaPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenOmegaMinusVsMultMC", "h2dGenOmegaMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenOmegaPlusVsMultMC", "h2dGenOmegaPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); // Histograms for event loss/splitting - registryMC.add("hGenEvents", "hGenEvents", HistType::kTH2F, {{axisNch}, {2, -0.5f, +1.5f}}); + registryMC.add("hGenEvents", "hGenEvents", HistType::kTH2D, {{axisNch}, {2, -0.5f, +1.5f}}); registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(1, "All gen. events"); registryMC.get(HIST("hGenEvents"))->GetYaxis()->SetBinLabel(2, "Gen. with at least 1 rec. events"); registryMC.add("hGenEventCentrality", "hGenEventCentrality", kTH1D, {{101, 0.0f, 101.0f}}); - registryMC.add("hCentralityVsNcoll_beforeEvSel", "hCentralityVsNcoll_beforeEvSel", HistType::kTH2F, {centAxis, {50, -0.5f, 49.5f}}); - registryMC.add("hCentralityVsNcoll_afterEvSel", "hCentralityVsNcoll_afterEvSel", HistType::kTH2F, {centAxis, {50, -0.5f, 49.5f}}); + registryMC.add("hCentralityVsNcoll_beforeEvSel", "hCentralityVsNcoll_beforeEvSel", HistType::kTH2D, {centAxis, {50, -0.5f, 49.5f}}); + registryMC.add("hCentralityVsNcoll_afterEvSel", "hCentralityVsNcoll_afterEvSel", HistType::kTH2D, {centAxis, {50, -0.5f, 49.5f}}); - registryMC.add("hCentralityVsMultMC", "hCentralityVsMultMC", HistType::kTH2F, {{101, 0.0f, 101.0f}, axisNch}); + registryMC.add("hCentralityVsMultMC", "hCentralityVsMultMC", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); } } @@ -704,73 +730,85 @@ struct CascadeAnalysisLightIonsDerivedData { // Initialize CCDB objects using the BC info initCCDB(collision); + // Define the event centrality using different estimators + float centrality = -1.0f; + float multiplicity = -1.0f; + + if (centralityEstimator == Option::kFT0C) { + centrality = collision.centFT0C(); + multiplicity = collision.multFT0C(); + } + if (centralityEstimator == Option::kFT0M) { + centrality = collision.centFT0M(); + multiplicity = collision.multFT0C() + collision.multFT0A(); + } + if (centralityEstimator == Option::kFV0A) { + centrality = collision.centFV0A(); + multiplicity = collision.multFV0A(); + } + if (centralityEstimator == Option::kNGlobal) { + centrality = collision.centNGlobal(); + multiplicity = collision.multNTracksGlobal(); + } + // event selections if (applySel8 && !collision.sel8()) return; registryData.fill(HIST("number_of_events_data"), 1); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 1, centrality); + if (applyVtxZ && std::fabs(collision.posZ()) > zVtx) return; registryData.fill(HIST("number_of_events_data"), 2); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 2, centrality); + if (rejectITSROFBorder && !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { return; } registryData.fill(HIST("number_of_events_data"), 3 /* Not at ITS ROF border */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 3, centrality); if (rejectTFBorder && !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { return; } registryData.fill(HIST("number_of_events_data"), 4 /* Not at TF border */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 4, centrality); if (requireVertexITSTPC && !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { return; } registryData.fill(HIST("number_of_events_data"), 5 /* Contains at least one ITS-TPC track */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 5, centrality); if (requireIsGoodZvtxFT0VsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { return; } registryData.fill(HIST("number_of_events_data"), 6 /* PV position consistency check */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 6, centrality); if (requireIsVertexTOFmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { return; } registryData.fill(HIST("number_of_events_data"), 7 /* PV with at least one contributor matched with TOF */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 7, centrality); 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 */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 8, centrality); if (rejectSameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { return; } registryData.fill(HIST("number_of_events_data"), 9 /* Not at same bunch pile-up */); + registryData.fill(HIST("number_of_events_data_vs_centrality"), 9, centrality); // Store the Zvtx - registryQC.fill(HIST("hVertexZdata"), std::fabs(collision.posZ())); - - // Store the event centrality using different estimators - float centrality = -1.0f; - float multiplicity = -1.0f; - - if (centralityEstimator == Option::kFT0C) { - centrality = collision.centFT0C(); - multiplicity = collision.multFT0C(); - } - if (centralityEstimator == Option::kFT0M) { - centrality = collision.centFT0M(); - multiplicity = collision.multFT0C() + collision.multFT0A(); - } - if (centralityEstimator == Option::kFV0A) { - centrality = collision.centFV0A(); - multiplicity = collision.multFV0A(); - } - if (centralityEstimator == Option::kNGlobal) { - centrality = collision.centNGlobal(); - multiplicity = collision.multNTracksGlobal(); - } + registryQC.fill(HIST("hVertexZdata"), collision.posZ()); + // Store the event centrality registryData.fill(HIST("hCentEstimator"), centrality); registryData.fill(HIST("hCentralityVsNch"), centrality, collision.multNTracksPVeta1()); registryData.fill(HIST("hCentralityVsMultiplicity"), centrality, multiplicity); @@ -835,74 +873,84 @@ struct CascadeAnalysisLightIonsDerivedData { // Initialize CCDB objects using the BC info initCCDB(RecCol); + // Define the event centrality using different estimators + float centralityMcRec = -1.0f; + float multiplicityMcRec = -1.0f; + + if (centralityEstimator == Option::kFT0C) { + centralityMcRec = RecCol.centFT0C(); + multiplicityMcRec = RecCol.multFT0C(); + } + if (centralityEstimator == Option::kFT0M) { + centralityMcRec = RecCol.centFT0M(); + multiplicityMcRec = RecCol.multFT0C() + RecCol.multFT0A(); + } + if (centralityEstimator == Option::kFV0A) { + centralityMcRec = RecCol.centFV0A(); + multiplicityMcRec = RecCol.multFV0A(); + } + if (centralityEstimator == Option::kNGlobal) { + centralityMcRec = RecCol.centNGlobal(); + multiplicityMcRec = RecCol.multNTracksGlobal(); + } + // event selections if (applySel8 && !RecCol.sel8()) continue; registryMC.fill(HIST("number_of_events_mc_rec"), 1); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 1, centralityMcRec); if (applyVtxZ && std::fabs(RecCol.posZ()) > zVtx) continue; registryMC.fill(HIST("number_of_events_mc_rec"), 2); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 2, centralityMcRec); if (rejectITSROFBorder && !RecCol.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { continue; } registryMC.fill(HIST("number_of_events_mc_rec"), 3 /* Not at ITS ROF border */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 3, centralityMcRec); if (rejectTFBorder && !RecCol.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { continue; } registryMC.fill(HIST("number_of_events_mc_rec"), 4 /* Not at TF border */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 4, centralityMcRec); if (requireVertexITSTPC && !RecCol.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { continue; } registryMC.fill(HIST("number_of_events_mc_rec"), 5 /* Contains at least one ITS-TPC track */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 5, centralityMcRec); if (requireIsGoodZvtxFT0VsPV && !RecCol.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { continue; } registryMC.fill(HIST("number_of_events_mc_rec"), 6 /* PV position consistency check */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 6, centralityMcRec); if (requireIsVertexTOFmatched && !RecCol.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { continue; } registryMC.fill(HIST("number_of_events_mc_rec"), 7 /* PV with at least one contributor matched with TOF */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 7, centralityMcRec); 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 */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 8, centralityMcRec); if (rejectSameBunchPileup && !RecCol.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { continue; } registryMC.fill(HIST("number_of_events_mc_rec"), 9 /* Not at same bunch pile-up */); + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 9, centralityMcRec); // Store the Zvtx registryQC.fill(HIST("hVertexZRec"), RecCol.posZ()); - // Store the event centrality using different estimators - float centralityMcRec = -1.0f; - float multiplicityMcRec = -1.0f; - - if (centralityEstimator == Option::kFT0C) { - centralityMcRec = RecCol.centFT0C(); - multiplicityMcRec = RecCol.multFT0C(); - } - if (centralityEstimator == Option::kFT0M) { - centralityMcRec = RecCol.centFT0M(); - multiplicityMcRec = RecCol.multFT0C() + RecCol.multFT0A(); - } - if (centralityEstimator == Option::kFV0A) { - centralityMcRec = RecCol.centFV0A(); - multiplicityMcRec = RecCol.multFV0A(); - } - if (centralityEstimator == Option::kNGlobal) { - centralityMcRec = RecCol.centNGlobal(); - multiplicityMcRec = RecCol.multNTracksGlobal(); - } - + // Store the event centrality registryMC.fill(HIST("hCentEstimator_truerec"), centralityMcRec); registryMC.fill(HIST("hCentralityVsNch_truerec"), centralityMcRec, RecCol.multNTracksPVeta1()); registryMC.fill(HIST("hCentralityVsMultiplicity_truerec"), centralityMcRec, multiplicityMcRec); From 463e4fb8b584b6f40aaeabc5a52bd4a2254e7792 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 16 Sep 2025 10:30:35 +0000 Subject: [PATCH 13/24] Please consider the following formatting changes --- PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index faeab56ee2a..8f2c2e55b22 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -762,7 +762,6 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.fill(HIST("number_of_events_data"), 2); registryData.fill(HIST("number_of_events_data_vs_centrality"), 2, centrality); - if (rejectITSROFBorder && !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { return; } From 87fa9982231b00cca423d656f78cc0c82acd0276 Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Tue, 16 Sep 2025 12:57:34 +0200 Subject: [PATCH 14/24] Update cascadeAnalysisLightIonsDerivedData.cxx --- .../Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 8f2c2e55b22..d6486d8c8ac 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -51,8 +51,8 @@ using namespace o2::constants::math; using namespace o2::constants::physics; using std::array; -using SelCollisions = soa::Join; -using SimCollisions = soa::Join; +using SelCollisions = soa::Join; +using SimCollisions = soa::Join; using CascadeCandidates = soa::Join; using CascadeMCCandidates = soa::Join; using DaughterTracks = soa::Join; From 64766732d827cb0d3283e40a377252a5a82f0d8a Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Thu, 9 Oct 2025 11:36:42 +0200 Subject: [PATCH 15/24] Add 2D histograms for corrections + improve binning --- .../cascadeAnalysisLightIonsDerivedData.cxx | 40 ++++++++++++------- 1 file changed, 26 insertions(+), 14 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index d6486d8c8ac..bc8502049a9 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -185,7 +185,7 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); - registryData.add("number_of_events_data_vs_centrality", "number of events in data vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, axisCentEstimator}); + registryData.add("number_of_events_data_vs_centrality", "number of events in data vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, {101, 0.0f, 101.0f}); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(1, "All collisions"); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(2, "sel8 cut"); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(3, "posZ cut"); @@ -212,9 +212,9 @@ struct CascadeAnalysisLightIonsDerivedData { registryQC.add("hdcav0topvdata", "hdcav0topvdata", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); // Multiplicity Histograms - registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {axisCentEstimator}); - registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {axisCentEstimator, axisNch}); - registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {axisCentEstimator, axisMult}); + registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {101, 0.0f, 101.0f}); + registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {101, 0.0f, 101.0f, axisNch}); + registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); // Histograms for xi (data) registryData.add("hMassXipos", "hMassXipos", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); @@ -243,7 +243,7 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryMC.get(HIST("number_of_events_mc_rec"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); - registryMC.add("number_of_events_mc_rec_vs_centrality", "number of events in mc_rec vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, axisCentEstimator}); + registryMC.add("number_of_events_mc_rec_vs_centrality", "number of events in mc_rec vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, {101, 0.0f, 101.0f}}); registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(1, "All collisions"); registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(2, "sel8 cut"); registryMC.get(HIST("number_of_events_mc_rec_vs_centrality"))->GetXaxis()->SetBinLabel(3, "posZ cut"); @@ -270,9 +270,9 @@ struct CascadeAnalysisLightIonsDerivedData { registryQC.add("hdcav0topvRec", "hdcav0topvRec", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); // Multiplicity Histograms - registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {axisCentEstimator}); - registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {axisCentEstimator, axisNch}); - registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {axisCentEstimator, axisMult}); + registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {101, 0.0f, 101.0f}); + registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); + registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); // Histograms for xi (mc) registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); @@ -296,12 +296,16 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.add("h2dGenXiPlusVsMultMC_RecoedEvt", "h2dGenXiPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenXiMinusVsMultMC", "h2dGenXiMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenXiPlusVsMultMC", "h2dGenXiPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenXiMinus", "h2dGenXiMinus", HistType::kTH2D, {{101, 0.0f, 101.0f}, ptAxis}); + registryMC.add("h2dGenXiPlus", "h2dGenXiPlus", HistType::kTH2D, {{101, 0.0f, 101.0f}, ptAxis}); // Histograms for omega (mc) registryMC.add("h2dGenOmegaMinusVsMultMC_RecoedEvt", "h2dGenOmegaMinusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaPlusVsMultMC_RecoedEvt", "h2dGenOmegaPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaMinusVsMultMC", "h2dGenOmegaMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaPlusVsMultMC", "h2dGenOmegaPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); + registryMC.add("h2dGenOmegaMinus", "h2dGenOmegaMinus", HistType::kTH2D, {{101, 0.0f, 101.0f}, ptAxis}); + registryMC.add("h2dGenOmegaPlus", "h2dGenOmegaPlus", HistType::kTH2D, {{101, 0.0f, 101.0f}, ptAxis}); // Histograms for event loss/splitting registryMC.add("hGenEvents", "hGenEvents", HistType::kTH2D, {{axisNch}, {2, -0.5f, +1.5f}}); @@ -751,6 +755,8 @@ struct CascadeAnalysisLightIonsDerivedData { multiplicity = collision.multNTracksGlobal(); } + registryData.fill(HIST("number_of_events_data_vs_centrality"), 0, centrality); + // event selections if (applySel8 && !collision.sel8()) return; @@ -893,6 +899,8 @@ struct CascadeAnalysisLightIonsDerivedData { multiplicityMcRec = RecCol.multNTracksGlobal(); } + registryMC.fill(HIST("number_of_events_mc_rec_vs_centrality"), 0, centralityMcRec); + // event selections if (applySel8 && !RecCol.sel8()) continue; @@ -1053,14 +1061,14 @@ struct CascadeAnalysisLightIonsDerivedData { // Store the Zvtx registryQC.fill(HIST("hVertexZGen"), mcCollision.posZ()); - // float centrality = 100.5f; + 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(); + 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 (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { registryMC.fill(HIST("h2dGenXiMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); @@ -1077,15 +1085,19 @@ struct CascadeAnalysisLightIonsDerivedData { } if (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { + registryMC.fill(HIST("h2dGenXiMinus"), centralityMC, ptmc); registryMC.fill(HIST("h2dGenXiMinusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kXiPlusBar && std::abs(cascMC.rapidityMC(0)) < rapcut) { + registryMC.fill(HIST("h2dGenXiPlus"), centralityMC, ptmc); registryMC.fill(HIST("h2dGenXiPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kOmegaMinus && std::abs(cascMC.rapidityMC(2)) < rapcut) { + registryMC.fill(HIST("h2dGenOmegaMinus"), centralityMC, ptmc); registryMC.fill(HIST("h2dGenOmegaMinusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } if (cascMC.pdgCode() == kOmegaPlusBar && std::abs(cascMC.rapidityMC(2)) < rapcut) { + registryMC.fill(HIST("h2dGenOmegaPlus"), centralityMC, ptmc); registryMC.fill(HIST("h2dGenOmegaPlusVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); } } // cascMC loop From f3084453992002555bd0bc6f66a821c8ab18d6c1 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 9 Oct 2025 09:39:51 +0000 Subject: [PATCH 16/24] Please consider the following formatting changes --- .../cascadeAnalysisLightIonsDerivedData.cxx | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index bc8502049a9..09466ef5c4f 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -1065,10 +1065,14 @@ struct CascadeAnalysisLightIonsDerivedData { 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); From 591a846d56b127647b69750ec71ed65275b93316 Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Thu, 9 Oct 2025 12:40:16 +0200 Subject: [PATCH 17/24] Update cascadeAnalysisLightIonsDerivedData.cxx --- .../cascadeAnalysisLightIonsDerivedData.cxx | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 09466ef5c4f..43b31cef598 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -185,7 +185,7 @@ struct CascadeAnalysisLightIonsDerivedData { registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(9, "kIsVertexTRDmatched"); registryData.get(HIST("number_of_events_data"))->GetXaxis()->SetBinLabel(10, "kNoSameBunchPileup"); - registryData.add("number_of_events_data_vs_centrality", "number of events in data vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, {101, 0.0f, 101.0f}); + registryData.add("number_of_events_data_vs_centrality", "number of events in data vs centrality", HistType::kTH2D, {{20, -0.5f, +19.5f}, {101, 0.0f, 101.0f}}); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(1, "All collisions"); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(2, "sel8 cut"); registryData.get(HIST("number_of_events_data_vs_centrality"))->GetXaxis()->SetBinLabel(3, "posZ cut"); @@ -212,8 +212,8 @@ struct CascadeAnalysisLightIonsDerivedData { registryQC.add("hdcav0topvdata", "hdcav0topvdata", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); // Multiplicity Histograms - registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {101, 0.0f, 101.0f}); - registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {101, 0.0f, 101.0f, axisNch}); + registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {{101, 0.0f, 101.0f}}); + registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {{101, 0.0f, 101.0f, axisNch}); registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); // Histograms for xi (data) @@ -270,7 +270,7 @@ struct CascadeAnalysisLightIonsDerivedData { registryQC.add("hdcav0topvRec", "hdcav0topvRec", HistType::kTH1D, {{nBins, 0.0f, 2.0f}}); // Multiplicity Histograms - registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {101, 0.0f, 101.0f}); + registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {{101, 0.0f, 101.0f}}); registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); @@ -1061,18 +1061,18 @@ struct CascadeAnalysisLightIonsDerivedData { // Store the Zvtx registryQC.fill(HIST("hVertexZGen"), mcCollision.posZ()); - float centrality = 100.5f; + float centralityMC = 100.5f; if (listBestCollisionIdx[mcCollision.globalIndex()] > -1) { auto collision = RecCols.iteratorAt(listBestCollisionIdx[mcCollision.globalIndex()]); if (centralityEstimator == Option::kFT0C) - centrality = collision.centFT0C(); + centralityMC = collision.centFT0C(); if (centralityEstimator == Option::kFT0M) - centrality = collision.centFT0M(); + centralityMC = collision.centFT0M(); if (centralityEstimator == Option::kFV0A) - centrality = collision.centFV0A(); + centralityMC = collision.centFV0A(); if (centralityEstimator == Option::kNGlobal) - centrality = collision.centNGlobal(); + centralityMC = collision.centNGlobal(); if (cascMC.pdgCode() == kXiMinus && std::abs(cascMC.rapidityMC(0)) < rapcut) { registryMC.fill(HIST("h2dGenXiMinusVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); From 722d9ff018a0518345cff14373b2a85da364637e Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 9 Oct 2025 10:42:40 +0000 Subject: [PATCH 18/24] Please consider the following formatting changes --- .../cascadeAnalysisLightIonsDerivedData.cxx | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 43b31cef598..5c8e5ec03a8 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -214,19 +214,19 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {{101, 0.0f, 101.0f}}); registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {{101, 0.0f, 101.0f, axisNch}); - registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); - - // Histograms for xi (data) - registryData.add("hMassXipos", "hMassXipos", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXineg", "hMassXineg", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXiposSelected", "hMassXiposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXinegSelected", "hMassXinegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); - - // Histograms for omega (data) - registryData.add("hMassOmegapos", "hMassOmegapos", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmeganeg", "hMassOmeganeg", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmegaposSelected", "hMassOmegaposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmeganegSelected", "hMassOmeganegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); + + // Histograms for xi (data) + registryData.add("hMassXipos", "hMassXipos", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXineg", "hMassXineg", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXiposSelected", "hMassXiposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXinegSelected", "hMassXinegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + + // Histograms for omega (data) + registryData.add("hMassOmegapos", "hMassOmegapos", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganeg", "hMassOmeganeg", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmegaposSelected", "hMassOmegaposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganegSelected", "hMassOmeganegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); } if (doprocessMonteCarloRec) { From a41448d1a5c0ab0e633decd8aba05e214637955d Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Thu, 9 Oct 2025 12:47:28 +0200 Subject: [PATCH 19/24] Update cascadeAnalysisLightIonsDerivedData.cxx --- PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 5c8e5ec03a8..b715b7de2b8 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -213,7 +213,7 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {{101, 0.0f, 101.0f}}); - registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {{101, 0.0f, 101.0f, axisNch}); + registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); // Histograms for xi (data) From 7bb97275d995d44a2db410b5e24e90b6fe79df2d Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 9 Oct 2025 10:48:01 +0000 Subject: [PATCH 20/24] Please consider the following formatting changes --- .../cascadeAnalysisLightIonsDerivedData.cxx | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index b715b7de2b8..1a536b79547 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -214,19 +214,19 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {{101, 0.0f, 101.0f}}); registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); - registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); - - // Histograms for xi (data) - registryData.add("hMassXipos", "hMassXipos", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXineg", "hMassXineg", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXiposSelected", "hMassXiposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); - registryData.add("hMassXinegSelected", "hMassXinegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); - - // Histograms for omega (data) - registryData.add("hMassOmegapos", "hMassOmegapos", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmeganeg", "hMassOmeganeg", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmegaposSelected", "hMassOmegaposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); - registryData.add("hMassOmeganegSelected", "hMassOmeganegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); + + // Histograms for xi (data) + registryData.add("hMassXipos", "hMassXipos", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXineg", "hMassXineg", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXiposSelected", "hMassXiposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + registryData.add("hMassXinegSelected", "hMassXinegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); + + // Histograms for omega (data) + registryData.add("hMassOmegapos", "hMassOmegapos", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganeg", "hMassOmeganeg", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmegaposSelected", "hMassOmegaposSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); + registryData.add("hMassOmeganegSelected", "hMassOmeganegSelected", HistType::kTH3D, {centAxis, ptAxis, invMassOmegaAxis}); } if (doprocessMonteCarloRec) { From e8fe8ed6130fb3dd536a84e1d7325fc6f4774068 Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Wed, 22 Oct 2025 09:52:21 +0200 Subject: [PATCH 21/24] Fixing MC functions --- .../cascadeAnalysisLightIonsDerivedData.cxx | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 1a536b79547..d3be5c3bd3a 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -214,7 +214,8 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {{101, 0.0f, 101.0f}}); registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); - registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); + if (centralityEstimator == Option::kNGlobal) registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); + else registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); // Histograms for xi (data) registryData.add("hMassXipos", "hMassXipos", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); @@ -272,7 +273,8 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {{101, 0.0f, 101.0f}}); registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); - registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); + if (centralityEstimator == Option::kNGlobal) registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); + else registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); // Histograms for xi (mc) registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); @@ -643,10 +645,10 @@ struct CascadeAnalysisLightIonsDerivedData { void fillGeneratedEventProperties(TMCCollisions const& mcCollisions, TCollisions const& collisions) { std::vector listBestCollisionIdx(mcCollisions.size()); - for (auto const& mcCollisions : mcCollisions) { + for (auto const& mcCollision : mcCollisions) { // event selections if (applyVtxZ && std::fabs(mcCollisions.posZ()) > zVtx) - return; + continue; registryMC.fill(HIST("hGenEvents"), mcCollisions.multMCNParticlesEta05(), 0 /* all gen. events*/); @@ -1056,7 +1058,7 @@ struct CascadeAnalysisLightIonsDerivedData { // event selections if (applyVtxZ && std::abs(mcCollision.posZ()) > zVtx) - return; + continue; // Store the Zvtx registryQC.fill(HIST("hVertexZGen"), mcCollision.posZ()); From 3bf8e5724bdda7a96011f476c03cebbcc17ece8a Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 22 Oct 2025 07:53:48 +0000 Subject: [PATCH 22/24] Please consider the following formatting changes --- .../cascadeAnalysisLightIonsDerivedData.cxx | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index d3be5c3bd3a..6c566ccd6ab 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -214,8 +214,10 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryData.add("hCentEstimator", "hCentEstimator", HistType::kTH1D, {{101, 0.0f, 101.0f}}); registryData.add("hCentralityVsNch", "hCentralityVsNch", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); - if (centralityEstimator == Option::kNGlobal) registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); - else registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); + if (centralityEstimator == Option::kNGlobal) + registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); + else + registryData.add("hCentralityVsMultiplicity", "hCentralityVsMultiplicity", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); // Histograms for xi (data) registryData.add("hMassXipos", "hMassXipos", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); @@ -273,8 +275,10 @@ struct CascadeAnalysisLightIonsDerivedData { // Multiplicity Histograms registryMC.add("hCentEstimator_truerec", "hCentEstimator_truerec", HistType::kTH1D, {{101, 0.0f, 101.0f}}); registryMC.add("hCentralityVsNch_truerec", "hCentralityVsNch_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); - if (centralityEstimator == Option::kNGlobal) registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); - else registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); + if (centralityEstimator == Option::kNGlobal) + registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisNch}); + else + registryMC.add("hCentralityVsMultiplicity_truerec", "hCentralityVsMultiplicity_truerec", HistType::kTH2D, {{101, 0.0f, 101.0f}, axisMult}); // Histograms for xi (mc) registryMC.add("hMassXipos_truerec", "hMassXipos_truerec", HistType::kTH3D, {centAxis, ptAxis, invMassXiAxis}); From f4fbd453dde38d8c48ed0afe0800062da2f36542 Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Wed, 22 Oct 2025 10:34:55 +0200 Subject: [PATCH 23/24] Update cascadeAnalysisLightIonsDerivedData.cxx --- .../cascadeAnalysisLightIonsDerivedData.cxx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index 6c566ccd6ab..f8eefa65f22 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -651,12 +651,12 @@ struct CascadeAnalysisLightIonsDerivedData { std::vector listBestCollisionIdx(mcCollisions.size()); for (auto const& mcCollision : mcCollisions) { // event selections - if (applyVtxZ && std::fabs(mcCollisions.posZ()) > zVtx) + if (applyVtxZ && std::fabs(mcCollision.posZ()) > zVtx) continue; - registryMC.fill(HIST("hGenEvents"), mcCollisions.multMCNParticlesEta05(), 0 /* all gen. events*/); + registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 0 /* all gen. events*/); - auto groupedCollisions = getGroupedCollisions(collisions, mcCollisions.globalIndex()); + auto groupedCollisions = getGroupedCollisions(collisions, mcCollision.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; @@ -717,12 +717,12 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.fill(HIST("hCentralityVsNcoll_beforeEvSel"), centralitydata, groupedCollisions.size()); registryMC.fill(HIST("hCentralityVsNcoll_afterEvSel"), centralitydata, nCollisions); - registryMC.fill(HIST("hCentralityVsMultMC"), centralitydata, mcCollisions.multMCNParticlesEta05()); + registryMC.fill(HIST("hCentralityVsMultMC"), centralitydata, mcCollision.multMCNParticlesEta05()); - registryQC.fill(HIST("hVertexZGen"), mcCollisions.posZ()); + registryQC.fill(HIST("hVertexZGen"), mcCollision.posZ()); if (atLeastOne) { - registryMC.fill(HIST("hGenEvents"), mcCollisions.multMCNParticlesEta05(), 1 /* at least 1 rec. event*/); + registryMC.fill(HIST("hGenEvents"), mcCollision.multMCNParticlesEta05(), 1 /* at least 1 rec. event*/); registryMC.fill(HIST("hGenEventCentrality"), centralitydata); } From d41e7257ca81b721bdb2b740af340e00e09ee229 Mon Sep 17 00:00:00 2001 From: spucillo <93769017+spucillo@users.noreply.github.com> Date: Thu, 23 Oct 2025 18:12:38 +0200 Subject: [PATCH 24/24] Fixing some configurables and variables --- .../cascadeAnalysisLightIonsDerivedData.cxx | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx index f8eefa65f22..eebff2725ae 100644 --- a/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx +++ b/PWGLF/Tasks/Strangeness/cascadeAnalysisLightIonsDerivedData.cxx @@ -132,7 +132,7 @@ struct CascadeAnalysisLightIonsDerivedData { Configurable competingmassrej{"competingmassrej", 0.008, "Competing mass rejection"}; // Axes parameters ConfigurableAxis centEstimatorHistBin{"centEstimatorHistBin", {101, 0.0f, 101.0f}, ""}; - ConfigurableAxis centralityBinning{"centralityBinning", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, ""}; + ConfigurableAxis centralityBinning{"centralityBinning", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f}, ""}; ConfigurableAxis axisNch{"axisNch", {500, 0.0f, +5000.0f}, "Number of charged particles"}; ConfigurableAxis axisMult{"axisMult", {500, 0.0f, +100000.0f}, "Multiplicity"}; @@ -302,16 +302,16 @@ struct CascadeAnalysisLightIonsDerivedData { registryMC.add("h2dGenXiPlusVsMultMC_RecoedEvt", "h2dGenXiPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenXiMinusVsMultMC", "h2dGenXiMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenXiPlusVsMultMC", "h2dGenXiPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); - registryMC.add("h2dGenXiMinus", "h2dGenXiMinus", HistType::kTH2D, {{101, 0.0f, 101.0f}, ptAxis}); - registryMC.add("h2dGenXiPlus", "h2dGenXiPlus", HistType::kTH2D, {{101, 0.0f, 101.0f}, ptAxis}); + registryMC.add("h2dGenXiMinus", "h2dGenXiMinus", HistType::kTH2D, {centAxis, ptAxis}); + registryMC.add("h2dGenXiPlus", "h2dGenXiPlus", HistType::kTH2D, {centAxis, ptAxis}); // Histograms for omega (mc) registryMC.add("h2dGenOmegaMinusVsMultMC_RecoedEvt", "h2dGenOmegaMinusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaPlusVsMultMC_RecoedEvt", "h2dGenOmegaPlusVsMultMC_RecoedEvt", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaMinusVsMultMC", "h2dGenOmegaMinusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); registryMC.add("h2dGenOmegaPlusVsMultMC", "h2dGenOmegaPlusVsMultMC", HistType::kTH2D, {axisNch, ptAxis}); - registryMC.add("h2dGenOmegaMinus", "h2dGenOmegaMinus", HistType::kTH2D, {{101, 0.0f, 101.0f}, ptAxis}); - registryMC.add("h2dGenOmegaPlus", "h2dGenOmegaPlus", HistType::kTH2D, {{101, 0.0f, 101.0f}, ptAxis}); + registryMC.add("h2dGenOmegaMinus", "h2dGenOmegaMinus", HistType::kTH2D, {centAxis, ptAxis}); + registryMC.add("h2dGenOmegaPlus", "h2dGenOmegaPlus", HistType::kTH2D, {centAxis, ptAxis}); // Histograms for event loss/splitting registryMC.add("hGenEvents", "hGenEvents", HistType::kTH2D, {{axisNch}, {2, -0.5f, +1.5f}}); @@ -662,7 +662,7 @@ struct CascadeAnalysisLightIonsDerivedData { bool atLeastOne = false; int biggestNContribs = -1; int nCollisions = 0; - float centralitydata = -1.0f; + float centralitydata = 100.5f; for (auto const& collision : groupedCollisions) { // event selections if (applySel8 && !collision.sel8()) @@ -741,8 +741,8 @@ struct CascadeAnalysisLightIonsDerivedData { initCCDB(collision); // Define the event centrality using different estimators - float centrality = -1.0f; - float multiplicity = -1.0f; + float centrality = -1; + float multiplicity = -1; if (centralityEstimator == Option::kFT0C) { centrality = collision.centFT0C(); @@ -885,8 +885,8 @@ struct CascadeAnalysisLightIonsDerivedData { initCCDB(RecCol); // Define the event centrality using different estimators - float centralityMcRec = -1.0f; - float multiplicityMcRec = -1.0f; + float centralityMcRec = -1; + float multiplicityMcRec = -1; if (centralityEstimator == Option::kFT0C) { centralityMcRec = RecCol.centFT0C();