From 53dcef91934865e6ebe508e39b036ffa958924a7 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Sun, 21 Jun 2026 23:16:16 +0200 Subject: [PATCH 01/10] Separate process function for sigma efficiency studies --- PWGLF/DataModel/LFLambda1405Table.h | 65 ++++++ PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 187 +++++++++++++++--- 2 files changed, 228 insertions(+), 24 deletions(-) diff --git a/PWGLF/DataModel/LFLambda1405Table.h b/PWGLF/DataModel/LFLambda1405Table.h index 103065146c6..20c38431f85 100644 --- a/PWGLF/DataModel/LFLambda1405Table.h +++ b/PWGLF/DataModel/LFLambda1405Table.h @@ -45,12 +45,14 @@ DECLARE_SOA_COLUMN(NSigmaTOFPiKink, nSigmaTOFPiKink, float); //! Number of sigma DECLARE_SOA_COLUMN(NSigmaTPCPrKink, nSigmaTPCPrKink, float); //! Number of sigmas for the proton candidate from Sigma kink in TPC DECLARE_SOA_COLUMN(NSigmaTOFPrKink, nSigmaTOFPrKink, float); //! Number of sigmas for the proton candidate from Sigma kink in TOF DECLARE_SOA_COLUMN(DCAKinkDauToPV, dcaKinkDauToPV, float); //! DCA of the kink daughter to the primary vertex +DECLARE_SOA_COLUMN(DCASigmaToPV, dcaSigmaToPV, float); //! DCA of the sigma to the primary vertex DECLARE_SOA_COLUMN(NSigmaTPCPiDau, nSigmaTPCPiDau, float); //! Number of sigmas for the lambda1405 pion daughter in TPC DECLARE_SOA_COLUMN(NSigmaTOFPiDau, nSigmaTOFPiDau, float); //! Number of sigmas for the lambda1405 pion daughter in TOF // Event properties DECLARE_SOA_COLUMN(Centrality, centrality, float); //! Centrality of the candidate DECLARE_SOA_COLUMN(Occupancy, occupancy, float); //! Occupancy of the candidate +DECLARE_SOA_COLUMN(PvContrib, pvContrib, float); //! Number of primary vertex contributors // Flow columns DECLARE_SOA_COLUMN(ScalarProd, scalarProd, float); //! Scalar product of the candidate @@ -61,6 +63,41 @@ DECLARE_SOA_COLUMN(MassMC, massMC, float); //! Invariant mass of t DECLARE_SOA_COLUMN(SigmaPdgCode, sigmaPdgCode, int); //! PDG code of the Sigma daughter DECLARE_SOA_COLUMN(KinkDauPdgCode, kinkDauPdgCode, int); //! PDG code of the kink daughter +// Sigma efficiency MC columns +DECLARE_SOA_COLUMN(PxSigma, pxSigma, float); //! Px of the sigma candidate +DECLARE_SOA_COLUMN(PySigma, pySigma, float); //! Py of the sigma candidate +DECLARE_SOA_COLUMN(PzSigma, pzSigma, float); //! Pz of the sigma candidate +DECLARE_SOA_COLUMN(MassSigma, massSigma, float); //! Mass of the sigma candidate +DECLARE_SOA_COLUMN(DeltaPxSigma, deltaPxSigma, float); //! Gen-reco diff of sigma p_x +DECLARE_SOA_COLUMN(DeltaPySigma, deltaPySigma, float); //! Gen-reco diff of sigma p_y +DECLARE_SOA_COLUMN(DeltaPzSigma, deltaPzSigma, float); //! Gen-reco diff of sigma p_z +DECLARE_SOA_COLUMN(DeltaPtSigma, deltaPtSigma, float); //! Gen-reco diff of sigma p_z +DECLARE_SOA_COLUMN(DeltaRadiusSigma, deltaRadiusSigma, float); //! Gen-reco diff of sigma radius +DECLARE_SOA_COLUMN(DeltaMassSigma, deltaMassSigma, float); //! Gen-reco diff of sigma mass +DECLARE_SOA_COLUMN(GenPhiSigma, genPhiSigma, float); //! Gen-reco diff of sigma phi +DECLARE_SOA_COLUMN(GenEtaSigma, genEtaSigma, float); //! Gen-reco diff of sigma eta +DECLARE_SOA_COLUMN(DeltaPxSigmaRecalc, deltaPxSigmaRecalc, float); //! reco recalc-original diff of sigma p_x +DECLARE_SOA_COLUMN(DeltaPySigmaRecalc, deltaPySigmaRecalc, float); //! reco recalc-original diff of sigma p_y +DECLARE_SOA_COLUMN(DeltaPzSigmaRecalc, deltaPzSigmaRecalc, float); //! reco recalc-original diff of sigma p_z +DECLARE_SOA_COLUMN(AlphaAPSigmaRecalc, alphaAPSigmaRecalc, float); //! Alpha of the Sigma +DECLARE_SOA_COLUMN(QtAPSigmaRecalc, qtAPSigmaRecalc, float); //! qT of the Sigma +DECLARE_SOA_COLUMN(PxKinkDaug, pxKinkDaug, float); //! Px of the sigma candidate +DECLARE_SOA_COLUMN(PyKinkDaug, pyKinkDaug, float); //! Py of the sigma candidate +DECLARE_SOA_COLUMN(PzKinkDaug, pzKinkDaug, float); //! Pz of the sigma candidate +DECLARE_SOA_COLUMN(PtKinkDaug, ptKinkDaug, float); //! Pt of the sigma candidate +DECLARE_SOA_COLUMN(DeltaPxKinkDaug, deltaPxKinkDaug, float); //! Gen-reco diff of kink daughter p_x +DECLARE_SOA_COLUMN(DeltaPyKinkDaug, deltaPyKinkDaug, float); //! Gen-reco diff of kink daughter p_y +DECLARE_SOA_COLUMN(DeltaPzKinkDaug, deltaPzKinkDaug, float); //! Gen-reco diff of kink daughter p_z +DECLARE_SOA_COLUMN(DeltaPtKinkDaug, deltaPtKinkDaug, float); //! Gen-reco diff of kink daughter p_t +DECLARE_SOA_COLUMN(GenPhiKinkDaug, genPhiKinkDaug, float); //! Gen-reco diff of kink daughter phi +DECLARE_SOA_COLUMN(GenEtaKinkDaug, genEtaKinkDaug, float); //! Gen-reco diff of kink daughter eta +DECLARE_SOA_COLUMN(XKinkVtx, xKinkVtx, float); //! X of kink vertex +DECLARE_SOA_COLUMN(YKinkVtx, yKinkVtx, float); //! Y of kink vertex +DECLARE_SOA_COLUMN(ZKinkVtx, zKinkVtx, float); //! Z of kink vertex +DECLARE_SOA_COLUMN(DeltaXKinkVtx, deltaXKinkVtx, float); //! Gen-reco diff of X of kink vertex +DECLARE_SOA_COLUMN(DeltaYKinkVtx, deltaYKinkVtx, float); //! Gen-reco diff of Y of kink vertex +DECLARE_SOA_COLUMN(DeltaZKinkVtx, deltaZKinkVtx, float); //! Gen-reco diff of Z of kink vertex + } // namespace lambda1405 DECLARE_SOA_TABLE(Lambda1405Cands, "AOD", "LAMBDA1405", @@ -102,6 +139,34 @@ DECLARE_SOA_TABLE(Lambda1405CandsMC, "AOD", "MCLAMBDA1405", lambda1405::PtMC, lambda1405::MassMC, lambda1405::SigmaPdgCode, lambda1405::KinkDauPdgCode, lambda1405::Centrality, lambda1405::Occupancy); +DECLARE_SOA_TABLE(Lambda1405SigmaEffMC, "AOD", "MCL1405SIGEFF", + o2::soa::Index<>, + lambda1405::PxSigma, lambda1405::DeltaPxSigma, + lambda1405::PySigma, lambda1405::DeltaPySigma, + lambda1405::PzSigma, lambda1405::DeltaPzSigma, + lambda1405::PtSigma, lambda1405::DeltaPtSigma, + lambda1405::RadiusSigma, lambda1405::DeltaRadiusSigma, + lambda1405::MassSigma, lambda1405::DeltaMassSigma, + lambda1405::DeltaPxSigmaRecalc, + lambda1405::DeltaPySigmaRecalc, + lambda1405::DeltaPzSigmaRecalc, + lambda1405::GenPhiSigma, + lambda1405::GenEtaSigma, + lambda1405::PxKinkDaug, lambda1405::DeltaPxKinkDaug, + lambda1405::PyKinkDaug, lambda1405::DeltaPyKinkDaug, + lambda1405::PzKinkDaug, lambda1405::DeltaPzKinkDaug, + lambda1405::PtKinkDaug, lambda1405::DeltaPtKinkDaug, + lambda1405::GenPhiKinkDaug, + lambda1405::GenEtaKinkDaug, + lambda1405::XKinkVtx, lambda1405::DeltaXKinkVtx, + lambda1405::YKinkVtx, lambda1405::DeltaYKinkVtx, + lambda1405::ZKinkVtx, lambda1405::DeltaZKinkVtx, + lambda1405::AlphaAPSigma, lambda1405::QtAPSigma, + lambda1405::AlphaAPSigmaRecalc, lambda1405::QtAPSigmaRecalc, + lambda1405::DCAKinkDauToPV, lambda1405::DCASigmaToPV, + lambda1405::SigmaPdgCode, lambda1405::KinkDauPdgCode, + lambda1405::Centrality, lambda1405::Occupancy, lambda1405::PvContrib); + } // namespace o2::aod #endif // PWGLF_DATAMODEL_LFLAMBDA1405TABLE_H_ diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index e8771cbb8a6..df6947ed90e 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -120,6 +120,7 @@ struct lambda1405analysis { Produces outputDataTable; // Output table for Lambda(1405) candidates Produces outputDataFlowTable; // Output table for Lambda(1405) flow analysis Produces outputDataTableMC; // Output table for Lambda(1405) candidates in MC + Produces outputSigmaEffMC; // Output table for Lambda(1405) sigma efficiency in MC Service ccdb; @@ -168,6 +169,7 @@ struct lambda1405analysis { Configurable downSampleFactor{"downSampleFactor", 1., "Fraction of candidates to keep in TTree"}; Configurable ptDownSampleMax{"ptDownSampleMax", 10., "Maximum pt for the application of the downsampling factor"}; + Configurable skipBkgSigmas{"skipBkgSigmas", true, "If true, skip un-matched sigmas in efficiency process function"}; Configurable fillOutputTree{"fillOutputTree", true, "If true, fill the output tree with Lambda(1405) candidates"}; Configurable doLikeSignBkg{"doLikeSignBkg", false, "Use like-sign background"}; Configurable useTof{"useTof", false, "Use Tof for PID for pion candidates"}; @@ -446,6 +448,11 @@ struct lambda1405analysis { rLambda1405.add("h2PtMassMC", "h2PtMassMC", {HistType::kTH2F, {ptAxis, lambda1405MassAxis}}); } + if (doprocessMcSigmasCentSel) { + rSigmaPlus.add("hSparseGenSigmaPlus", "THn for generated Sigma plus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); + rSigmaMinus.add("hSparseGenSigmaMinus", "THn for generated Sigma minus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); + } + // Functional selections funcMinQtAlphaAP = TF1("funcMinQtAlphaAP", Form("%s", cutSigmaQtAPMin.value.data()), -1, 1); LOGF(info, "funcMinQtAlphaAP: %s", Form("%s", cutSigmaQtAPMin.value.data())); @@ -518,7 +525,7 @@ struct lambda1405analysis { double pMother = std::sqrt(sigmaPx * sigmaPx + sigmaPy * sigmaPy + sigmaPz * sigmaPz); if (pMother < 1e-12f) { - LOG(info) << "Recalculation of Sigma momentum failed: mother momentum is zero " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz; + LOG(debug) << "Recalculation of Sigma momentum failed: mother momentum is zero " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz; return -999.f; } if (isSigmaMinus) { @@ -538,7 +545,7 @@ struct lambda1405analysis { double C = 4.0 * eChDau * eChDau * massSigma * massSigma - K * K; if (std::abs(A) < 1e-6f) { - LOG(info) << "Recalculation of Sigma momentum failed: A is zero " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", A = " << A << ", B = " << B << ", C = " << C; + LOG(debug) << "Recalculation of Sigma momentum failed: A is zero " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", A = " << A << ", B = " << B << ", C = " << C; return -999.f; } if (isSigmaMinus) { @@ -549,7 +556,7 @@ struct lambda1405analysis { double D = B * B - 4.0 * A * C; if (D < 0.0) { - LOG(info) << "Recalculation of Sigma momentum failed: D is negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", A = " << A << ", B = " << B << ", C = " << C << ", D = " << D; + LOG(debug) << "Recalculation of Sigma momentum failed: D is negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", A = " << A << ", B = " << B << ", C = " << C << ", D = " << D; return -999.f; } if (isSigmaMinus) { @@ -562,7 +569,7 @@ struct lambda1405analysis { double P1 = (-B + sqrtD) / (2.0 * A); double P2 = (-B - sqrtD) / (2.0 * A); if (P2 < 0.0 && P1 < 0.0) { - LOG(info) << "Recalculation of Sigma momentum failed: both solutions are negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", P1: " << P1 << ", P2: " << P2; + LOG(debug) << "Recalculation of Sigma momentum failed: both solutions are negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", P1: " << P1 << ", P2: " << P2; return -999.f; } if (isSigmaMinus) { @@ -1079,20 +1086,16 @@ struct lambda1405analysis { template bool checkSigmaKinkMC(const mcTrack& mcTrackSigma, const mcTrack& mcTrackKinkDau, float sigmaAbsPDG, float kinkAbsPDG, aod::McParticles const&) { - LOG(info) << "Checking Sigma kink decay for MC tracks: Sigma PDG = " << mcTrackSigma.pdgCode() << ", Kink daughter PDG = " << mcTrackKinkDau.pdgCode(); if (std::abs(mcTrackSigma.pdgCode()) != sigmaAbsPDG || std::abs(mcTrackKinkDau.pdgCode()) != kinkAbsPDG) { - LOG(info) << "PDG codes do not match expected values: Sigma PDG = " << sigmaAbsPDG << ", Kink daughter PDG = " << kinkAbsPDG; return false; // Not a valid Sigma kink decay } if (!mcTrackKinkDau.has_mothers()) { - LOG(info) << "Kink daughter has no mothers"; return false; // No mothers found } // Check if the kink comes from the Sigma bool isKinkFromSigma = false; for (const auto& mcMother : mcTrackKinkDau.template mothers_as()) { if (mcMother.globalIndex() == mcTrackSigma.globalIndex()) { - LOG(info) << "Kink daughter comes from the Sigma"; isKinkFromSigma = true; break; } @@ -1271,42 +1274,31 @@ struct lambda1405analysis { const TTrack& tracks, const aod::McParticles& particlesMC) { - LOG(info) << "Filling output MC for " << recoCollisions.size() << " collisions, " << sigmaCands.size() << " Sigma candidates, and " << tracks.size() << " tracks"; for (const auto& collision : recoCollisions) { - LOG(info) << "\n\nProcessing collision with global index: " << collision.globalIndex() << " and " << sigmaCands.size() << " Sigma candidates, and " << tracks.size() << " tracks"; if (std::abs(collision.posZ()) > cutZVertex) { // || !collision.sel8()) { - LOG(info) << "Collision failed Z vertex cut: " << collision.posZ(); continue; } - LOG(info) << "Collision passed Z vertex cut: " << collision.posZ(); rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); float centMult = getCentMult(collision); - LOG(info) << "Collision centrality: " << centMult; if (centMult < centMultMin || centMult > centMultMax) { - LOG(info) << "Collision failed centrality cut: " << centMult; continue; } - LOG(info) << "Collision passed centrality cut: " << centMult; rEventSelection.fill(HIST("hCentMultVsPvContrib"), centMult, collision.numContrib()); rEventSelection.fill(HIST("hOccVsPvContrib"), collision.ft0cOccupancyInTimeRange(), collision.numContrib()); rEventSelection.fill(HIST("hCentVsOcc"), centMult, collision.ft0cOccupancyInTimeRange()); auto sigmaCandsPerCol = sigmaCands.sliceBy(mKinkPerCol, collision.globalIndex()); auto tracksPerCol = tracks.sliceBy(mPerColTracks, collision.globalIndex()); - LOG(info) << "Start loop on " << sigmaCandsPerCol.size() << " Sigma candidates ... "; for (const auto& sigmaCand : sigmaCandsPerCol) { - LOG(info) << "Processing Sigma candidate with global index: " << sigmaCand.globalIndex(); // Perform the sigma matching here, so sigma histograms // can be used for efficiency studies on the sigma auto labelSigma = trackLabelsMC.rawIteratorAt(sigmaCand.trackMothId()); auto labelKinkDaug = trackLabelsMC.rawIteratorAt(sigmaCand.trackDaugId()); if (!labelSigma.has_mcParticle()) { - LOG(info) << "Sigma candidate with global index: " << sigmaCand.globalIndex() << " is not matched to MC particle"; rSelections.fill(HIST("hRecoNotMatchedCounter"), 1); // Sigma not matched } if (!labelKinkDaug.has_mcParticle()) { - LOG(info) << "Kink daughter candidate with global index: " << sigmaCand.globalIndex() << " is not matched to MC particle"; rSelections.fill(HIST("hRecoNotMatchedCounter"), 2); // Kink daughter not matched } auto genSigma = labelSigma.template mcParticle_as(); @@ -1317,20 +1309,15 @@ struct lambda1405analysis { bool isSigmaPlusToPrKink = checkSigmaKinkMC(genSigma, genKinkDaug, PDG_t::kSigmaPlus, PDG_t::kProton, particlesMC); if (!isSigmaMinusKink && !isSigmaPlusToPiKink && !isSigmaPlusToPrKink) { - LOG(info) << "Candidate is not a valid Sigma kink decay, skipping ..."; continue; // Skip if not a valid Sigma kink decay } if (isSigmaMinusKink) { - LOG(info) << "Filling h2DeltaGenRecoPtSigmaMinus with: " << sigmaCand.ptMoth() - genSigma.pt() << ", " << sigmaCand.ptMoth(); rSigmaMinus.fill(HIST("h2DeltaGenRecoPtSigmaMinus"), sigmaCand.ptMoth() - genSigma.pt(), sigmaCand.ptMoth()); } if (isSigmaPlusToPiKink || isSigmaPlusToPrKink) { - LOG(info) << "Filling h2DeltaGenRecoPtSigmaPlus with: " << sigmaCand.ptMoth() - genSigma.pt() << ", " << sigmaCand.ptMoth(); rSigmaPlus.fill(HIST("h2DeltaGenRecoPtSigmaPlus"), sigmaCand.ptMoth() - genSigma.pt(), sigmaCand.ptMoth()); } - std::vector selectedCandidates; - LOG(info) << "Constructing Lambda(1405) candidates from Sigma candidate with global index: " << sigmaCand.globalIndex(); constructCollCandidates(collision, sigmaCand, tracksPerCol, selectedCandidates); for (const auto& lambda1405Cand : selectedCandidates) { rLambda1405.fill(HIST("hRecoL1405"), 0., lambda1405Cand.pt()); // All reconstructed @@ -1486,6 +1473,158 @@ struct lambda1405analysis { fillOutputMc(recoCollisions, kinkCands, trackLabelsMC, tracks, particlesMC); } PROCESS_SWITCH(lambda1405analysis, processMcWCentSel, "MC processing with centrality selection", false); + + void processMcSigmasCentSel(McRecoCollisionsCentSel const& recoCollisions, + aod::KinkCands const& kinkCands, + aod::McTrackLabels const& trackLabelsMC, + aod::McParticles const& particlesMC, + const aod::BCs&) + { + // Loop over kink candidates to fill Sigma efficiency histograms + for (const auto& collision : recoCollisions) { + if (std::abs(collision.posZ()) > cutZVertex) { // || !collision.sel8()) { + continue; + } + rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); + float centMult = getCentMult(collision); + if (centMult < centMultMin || centMult > centMultMax) { + continue; + } + + rEventSelection.fill(HIST("hCentMultVsPvContrib"), centMult, collision.numContrib()); + rEventSelection.fill(HIST("hOccVsPvContrib"), collision.ft0cOccupancyInTimeRange(), collision.numContrib()); + rEventSelection.fill(HIST("hCentVsOcc"), centMult, collision.ft0cOccupancyInTimeRange()); + + // Compute occupancy and pv contrib of the generated collision + const auto& recoCollsPerMcColl = recoCollisions.sliceBy(colPerMcCollision, collision.mcCollisionId()); + if (recoCollsPerMcColl.size() == 0) { + continue; // Skip if no reconstructed collisions associated with this MC collision + } + unsigned genNumContrib = 0; + float genOcc{0.f}; + float genCentMult{0.f}; + for (const auto& recCol : recoCollsPerMcColl) { + genNumContrib = recCol.numContrib() > genNumContrib ? recCol.numContrib() : genNumContrib; + genOcc = recCol.ft0cOccupancyInTimeRange() > genOcc ? recCol.ft0cOccupancyInTimeRange() : genOcc; + genCentMult = getCentMult(collision) > genCentMult ? getCentMult(collision) : genCentMult; + } + + auto sigmaCandsPerCol = sigmaCands.sliceBy(mKinkPerCol, collision.globalIndex()); + for (const auto& sigmaCand : sigmaCandsPerCol) { + + auto labelSigma = trackLabelsMC.rawIteratorAt(sigmaCand.trackMothId()); + auto labelKinkDaug = trackLabelsMC.rawIteratorAt(sigmaCand.trackDaugId()); + if (!labelSigma.has_mcParticle() || !labelKinkDaug.has_mcParticle()) { + continue; // No generated particles + } + auto genSigma = labelSigma.template mcParticle_as(); + auto genKinkDaug = labelKinkDaug.template mcParticle_as(); + + bool isSigmaMinusKink = checkSigmaKinkMC(genSigma, genKinkDaug, PDG_t::kSigmaMinus, PDG_t::kPiPlus, particlesMC); + bool isSigmaPlusToPiKink = checkSigmaKinkMC(genSigma, genKinkDaug, PDG_t::kSigmaPlus, PDG_t::kPiPlus, particlesMC); + bool isSigmaPlusToPrKink = checkSigmaKinkMC(genSigma, genKinkDaug, PDG_t::kSigmaPlus, PDG_t::kProton, particlesMC); + + if (skipBkgSigmas && (!isSigmaMinusKink && !isSigmaPlusToPiKink && !isSigmaPlusToPrKink)) { + continue; // Skip if not a valid Sigma kink decay + } + + float sigmaPt = sigmaCand.ptMoth(); + float kinkPt = sigmaCand.ptDaug(); + if (downSampleFactor < 1.) { + float const pseudoRndm = sigmaPt * 1000. - static_cast(sigmaPt * 1000); + if (sigmaPt < ptDownSampleMax && pseudoRndm >= downSampleFactor) { + continue; + } + } + + std::array sigmaMomReco{sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth()}; + std::array kinkMomReco{sigmaCand.pxDaug(), sigmaCand.pyDaug(), sigmaCand.pzDaug()}; + float recoSigmaAlphaAP = alphaAP(sigmaMomReco, kinkMomReco); + float recoSigmaQtAP = qtAP(sigmaMomReco, kinkMomReco); + + // Recompute the sigma momentum + bool success{false}; + float sigmaPRecalc = recalcSigmaMomReco(success, isSigmaMinusKink, + sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth(), + sigmaCand.pxDaug(), sigmaCand.pyDaug(), sigmaCand.pzDaug()); + if (!success && skipSigmasFailedRecompMom) { + return; + } + if (success) { + float sigmaPOriginal = std::sqrt(sigmaCand.pxMoth() * sigmaCand.pxMoth() + + sigmaCand.pyMoth() * sigmaCand.pyMoth() + + sigmaCand.pzMoth() * sigmaCand.pzMoth()); + if (sigmaPRecalc > 0.f && sigmaPOriginal > 0.f) { + float scale = sigmaPRecalc / sigmaPOriginal; + sigmaMomReco[0] *= scale; + sigmaMomReco[1] *= scale; + sigmaMomReco[2] *= scale; + + sigmaPt = std::sqrt(sigmaMomReco[0] * sigmaMomReco[0] + sigmaMomReco[1] * sigmaMomReco[1]); + if (lambda1405Cand.isSigmaMinus) { + rSigmaMinus.fill(HIST("hDeltaPxRecalcSigmaMinus"), sigmaMomReco[0] - sigmaCand.pxMoth(), sigmaCand.pxMoth()); + rSigmaMinus.fill(HIST("hDeltaPyRecalcSigmaMinus"), sigmaMomReco[1] - sigmaCand.pyMoth(), sigmaCand.pyMoth()); + rSigmaMinus.fill(HIST("hDeltaPzRecalcSigmaMinus"), sigmaMomReco[2] - sigmaCand.pzMoth(), sigmaCand.pzMoth()); + rSigmaMinus.fill(HIST("hRecalcPtFactorSigmaMinus"), scale, sigmaPOriginal); + } else { + rSigmaPlus.fill(HIST("hDeltaPxRecalcSigmaPlus"), sigmaMomReco[0] - sigmaCand.pxMoth(), sigmaCand.pxMoth()); + rSigmaPlus.fill(HIST("hDeltaPyRecalcSigmaPlus"), sigmaMomReco[1] - sigmaCand.pyMoth(), sigmaCand.pyMoth()); + rSigmaPlus.fill(HIST("hDeltaPzRecalcSigmaPlus"), sigmaMomReco[2] - sigmaCand.pzMoth(), sigmaCand.pzMoth()); + rSigmaPlus.fill(HIST("hRecalcPtFactorSigmaPlus"), scale, sigmaPOriginal); + } + } + } + + float recoRecalcPtSigmaAlphaAP = alphaAP(sigmaMomReco, kinkMomReco); + float recoRecalcPtSigmaQtAP = qtAP(sigmaMomReco, kinkMomReco); + float massSigma = isSigmaMinusKink ? sigmaCand.mSigmaMinus : sigmaCand.mSigmaPlus; + + // Generated properties + float genMassSigma{-1.f}; + if (isSigmaMinusKink || isSigmaPlusToPiKink || isSigmaPlusToPrKink) { + genMassSigma = std::sqrt(genSigma.e() * genSigma.e() - genSigma.p() * genSigma.p()); + std::array sigmaMomGen{sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth()}; + std::array kinkMomGen{sigmaCand.pxDaug(), sigmaCand.pyDaug(), sigmaCand.pzDaug()}; + float genSigmaAlphaAP = alphaAP(sigmaMomGen, kinkMomGen); + float genSigmaQtAP = qtAP(sigmaMomGen, kinkMomGen); + if (isSigmaMinusKink) { + rSigmaMinus.fill(HIST("hSparseGenSigmaMinus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, genCentMult, genNumContrib, genOcc); + } else if (isSigmaPlusKink) { + rSigmaPlus.fill(HIST("hSparseGenSigmaPlus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, genCentMult, genNumContrib, genOcc); + } + } + + // Fill table with sigma properties for efficiency studies + outputSigmaEffMC( + sigmaCand.pxMoth, sigmaCand.pxMoth - genSigma.px(), + sigmaCand.pyMoth, sigmaCand.pyMoth - genSigma.py(), + sigmaCand.pzMoth, sigmaCand.pzMoth - genSigma.pz(), + sigmaPt, sigmaPt - genSigma.pz(), + massSigma, massSigma - genMassSigma, + sigmaCand.pxMoth - sigmaMomReco[0], + sigmaCand.pyMoth - sigmaMomReco[1], + sigmaCand.pzMoth - sigmaMomReco[2], + genSigma.phi(), + genSigma.eta(), + sigmaCand.pxDaug, sigmaCand.pxDaug - genKinkDaug.px(), + sigmaCand.pyDaug, sigmaCand.pyDaug - genKinkDaug.py(), + sigmaCand.pzDaug, sigmaCand.pzDaug - genKinkDaug.pz(), + kinkPt, kinkPt - genKinkDaug.pz(), + genKinkDaug.phi(), + genKinkDaug.eta(), + sigmaCand.xDecVtx, sigmaCand.xDecVtx - genKinkDaug.vx, + sigmaCand.yDecVtx, sigmaCand.yDecVtx - genKinkDaug.vy, + sigmaCand.zDecVtx, sigmaCand.zDecVtx - genKinkDaug.vz, + recoSigmaAlphaAP, recoSigmaQtAP, + recoRecalcPtSigmaQtAP, recoRecalcPtSigmaQtAP, + sigmaCand.dcaDaugPv, sigmaCand.dcaMothPv, + genSigma.pdgCode(), genKinkDaug.pdgCode(), + centMult, collision.ft0cOccupancyInTimeRange(), collision.numContrib()); + } + } + } + PROCESS_SWITCH(lambda1405analysis, processMcSigmasCentSel, "MC processing for sigma efficiency studies", false); + }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { From 6a56bc1f85d201bbf32ab6260bf0dbf257c02580 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 17 Jul 2026 10:23:55 +0000 Subject: [PATCH 02/10] Please consider the following formatting changes --- PWGLF/DataModel/LFLambda1405Table.h | 68 +++++++++---------- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 5 +- 2 files changed, 36 insertions(+), 37 deletions(-) diff --git a/PWGLF/DataModel/LFLambda1405Table.h b/PWGLF/DataModel/LFLambda1405Table.h index 20c38431f85..25277d1445b 100644 --- a/PWGLF/DataModel/LFLambda1405Table.h +++ b/PWGLF/DataModel/LFLambda1405Table.h @@ -64,39 +64,39 @@ DECLARE_SOA_COLUMN(SigmaPdgCode, sigmaPdgCode, int); //! PDG code of the Sig DECLARE_SOA_COLUMN(KinkDauPdgCode, kinkDauPdgCode, int); //! PDG code of the kink daughter // Sigma efficiency MC columns -DECLARE_SOA_COLUMN(PxSigma, pxSigma, float); //! Px of the sigma candidate -DECLARE_SOA_COLUMN(PySigma, pySigma, float); //! Py of the sigma candidate -DECLARE_SOA_COLUMN(PzSigma, pzSigma, float); //! Pz of the sigma candidate -DECLARE_SOA_COLUMN(MassSigma, massSigma, float); //! Mass of the sigma candidate -DECLARE_SOA_COLUMN(DeltaPxSigma, deltaPxSigma, float); //! Gen-reco diff of sigma p_x -DECLARE_SOA_COLUMN(DeltaPySigma, deltaPySigma, float); //! Gen-reco diff of sigma p_y -DECLARE_SOA_COLUMN(DeltaPzSigma, deltaPzSigma, float); //! Gen-reco diff of sigma p_z -DECLARE_SOA_COLUMN(DeltaPtSigma, deltaPtSigma, float); //! Gen-reco diff of sigma p_z -DECLARE_SOA_COLUMN(DeltaRadiusSigma, deltaRadiusSigma, float); //! Gen-reco diff of sigma radius -DECLARE_SOA_COLUMN(DeltaMassSigma, deltaMassSigma, float); //! Gen-reco diff of sigma mass -DECLARE_SOA_COLUMN(GenPhiSigma, genPhiSigma, float); //! Gen-reco diff of sigma phi -DECLARE_SOA_COLUMN(GenEtaSigma, genEtaSigma, float); //! Gen-reco diff of sigma eta -DECLARE_SOA_COLUMN(DeltaPxSigmaRecalc, deltaPxSigmaRecalc, float); //! reco recalc-original diff of sigma p_x -DECLARE_SOA_COLUMN(DeltaPySigmaRecalc, deltaPySigmaRecalc, float); //! reco recalc-original diff of sigma p_y -DECLARE_SOA_COLUMN(DeltaPzSigmaRecalc, deltaPzSigmaRecalc, float); //! reco recalc-original diff of sigma p_z -DECLARE_SOA_COLUMN(AlphaAPSigmaRecalc, alphaAPSigmaRecalc, float); //! Alpha of the Sigma -DECLARE_SOA_COLUMN(QtAPSigmaRecalc, qtAPSigmaRecalc, float); //! qT of the Sigma -DECLARE_SOA_COLUMN(PxKinkDaug, pxKinkDaug, float); //! Px of the sigma candidate -DECLARE_SOA_COLUMN(PyKinkDaug, pyKinkDaug, float); //! Py of the sigma candidate -DECLARE_SOA_COLUMN(PzKinkDaug, pzKinkDaug, float); //! Pz of the sigma candidate -DECLARE_SOA_COLUMN(PtKinkDaug, ptKinkDaug, float); //! Pt of the sigma candidate -DECLARE_SOA_COLUMN(DeltaPxKinkDaug, deltaPxKinkDaug, float); //! Gen-reco diff of kink daughter p_x -DECLARE_SOA_COLUMN(DeltaPyKinkDaug, deltaPyKinkDaug, float); //! Gen-reco diff of kink daughter p_y -DECLARE_SOA_COLUMN(DeltaPzKinkDaug, deltaPzKinkDaug, float); //! Gen-reco diff of kink daughter p_z -DECLARE_SOA_COLUMN(DeltaPtKinkDaug, deltaPtKinkDaug, float); //! Gen-reco diff of kink daughter p_t -DECLARE_SOA_COLUMN(GenPhiKinkDaug, genPhiKinkDaug, float); //! Gen-reco diff of kink daughter phi -DECLARE_SOA_COLUMN(GenEtaKinkDaug, genEtaKinkDaug, float); //! Gen-reco diff of kink daughter eta -DECLARE_SOA_COLUMN(XKinkVtx, xKinkVtx, float); //! X of kink vertex -DECLARE_SOA_COLUMN(YKinkVtx, yKinkVtx, float); //! Y of kink vertex -DECLARE_SOA_COLUMN(ZKinkVtx, zKinkVtx, float); //! Z of kink vertex -DECLARE_SOA_COLUMN(DeltaXKinkVtx, deltaXKinkVtx, float); //! Gen-reco diff of X of kink vertex -DECLARE_SOA_COLUMN(DeltaYKinkVtx, deltaYKinkVtx, float); //! Gen-reco diff of Y of kink vertex -DECLARE_SOA_COLUMN(DeltaZKinkVtx, deltaZKinkVtx, float); //! Gen-reco diff of Z of kink vertex +DECLARE_SOA_COLUMN(PxSigma, pxSigma, float); //! Px of the sigma candidate +DECLARE_SOA_COLUMN(PySigma, pySigma, float); //! Py of the sigma candidate +DECLARE_SOA_COLUMN(PzSigma, pzSigma, float); //! Pz of the sigma candidate +DECLARE_SOA_COLUMN(MassSigma, massSigma, float); //! Mass of the sigma candidate +DECLARE_SOA_COLUMN(DeltaPxSigma, deltaPxSigma, float); //! Gen-reco diff of sigma p_x +DECLARE_SOA_COLUMN(DeltaPySigma, deltaPySigma, float); //! Gen-reco diff of sigma p_y +DECLARE_SOA_COLUMN(DeltaPzSigma, deltaPzSigma, float); //! Gen-reco diff of sigma p_z +DECLARE_SOA_COLUMN(DeltaPtSigma, deltaPtSigma, float); //! Gen-reco diff of sigma p_z +DECLARE_SOA_COLUMN(DeltaRadiusSigma, deltaRadiusSigma, float); //! Gen-reco diff of sigma radius +DECLARE_SOA_COLUMN(DeltaMassSigma, deltaMassSigma, float); //! Gen-reco diff of sigma mass +DECLARE_SOA_COLUMN(GenPhiSigma, genPhiSigma, float); //! Gen-reco diff of sigma phi +DECLARE_SOA_COLUMN(GenEtaSigma, genEtaSigma, float); //! Gen-reco diff of sigma eta +DECLARE_SOA_COLUMN(DeltaPxSigmaRecalc, deltaPxSigmaRecalc, float); //! reco recalc-original diff of sigma p_x +DECLARE_SOA_COLUMN(DeltaPySigmaRecalc, deltaPySigmaRecalc, float); //! reco recalc-original diff of sigma p_y +DECLARE_SOA_COLUMN(DeltaPzSigmaRecalc, deltaPzSigmaRecalc, float); //! reco recalc-original diff of sigma p_z +DECLARE_SOA_COLUMN(AlphaAPSigmaRecalc, alphaAPSigmaRecalc, float); //! Alpha of the Sigma +DECLARE_SOA_COLUMN(QtAPSigmaRecalc, qtAPSigmaRecalc, float); //! qT of the Sigma +DECLARE_SOA_COLUMN(PxKinkDaug, pxKinkDaug, float); //! Px of the sigma candidate +DECLARE_SOA_COLUMN(PyKinkDaug, pyKinkDaug, float); //! Py of the sigma candidate +DECLARE_SOA_COLUMN(PzKinkDaug, pzKinkDaug, float); //! Pz of the sigma candidate +DECLARE_SOA_COLUMN(PtKinkDaug, ptKinkDaug, float); //! Pt of the sigma candidate +DECLARE_SOA_COLUMN(DeltaPxKinkDaug, deltaPxKinkDaug, float); //! Gen-reco diff of kink daughter p_x +DECLARE_SOA_COLUMN(DeltaPyKinkDaug, deltaPyKinkDaug, float); //! Gen-reco diff of kink daughter p_y +DECLARE_SOA_COLUMN(DeltaPzKinkDaug, deltaPzKinkDaug, float); //! Gen-reco diff of kink daughter p_z +DECLARE_SOA_COLUMN(DeltaPtKinkDaug, deltaPtKinkDaug, float); //! Gen-reco diff of kink daughter p_t +DECLARE_SOA_COLUMN(GenPhiKinkDaug, genPhiKinkDaug, float); //! Gen-reco diff of kink daughter phi +DECLARE_SOA_COLUMN(GenEtaKinkDaug, genEtaKinkDaug, float); //! Gen-reco diff of kink daughter eta +DECLARE_SOA_COLUMN(XKinkVtx, xKinkVtx, float); //! X of kink vertex +DECLARE_SOA_COLUMN(YKinkVtx, yKinkVtx, float); //! Y of kink vertex +DECLARE_SOA_COLUMN(ZKinkVtx, zKinkVtx, float); //! Z of kink vertex +DECLARE_SOA_COLUMN(DeltaXKinkVtx, deltaXKinkVtx, float); //! Gen-reco diff of X of kink vertex +DECLARE_SOA_COLUMN(DeltaYKinkVtx, deltaYKinkVtx, float); //! Gen-reco diff of Y of kink vertex +DECLARE_SOA_COLUMN(DeltaZKinkVtx, deltaZKinkVtx, float); //! Gen-reco diff of Z of kink vertex } // namespace lambda1405 @@ -158,7 +158,7 @@ DECLARE_SOA_TABLE(Lambda1405SigmaEffMC, "AOD", "MCL1405SIGEFF", lambda1405::PtKinkDaug, lambda1405::DeltaPtKinkDaug, lambda1405::GenPhiKinkDaug, lambda1405::GenEtaKinkDaug, - lambda1405::XKinkVtx, lambda1405::DeltaXKinkVtx, + lambda1405::XKinkVtx, lambda1405::DeltaXKinkVtx, lambda1405::YKinkVtx, lambda1405::DeltaYKinkVtx, lambda1405::ZKinkVtx, lambda1405::DeltaZKinkVtx, lambda1405::AlphaAPSigma, lambda1405::QtAPSigma, diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index df6947ed90e..63440e1dfde 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -449,7 +449,7 @@ struct lambda1405analysis { } if (doprocessMcSigmasCentSel) { - rSigmaPlus.add("hSparseGenSigmaPlus", "THn for generated Sigma plus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); + rSigmaPlus.add("hSparseGenSigmaPlus", "THn for generated Sigma plus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); rSigmaMinus.add("hSparseGenSigmaMinus", "THn for generated Sigma minus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); } @@ -1578,7 +1578,7 @@ struct lambda1405analysis { float recoRecalcPtSigmaAlphaAP = alphaAP(sigmaMomReco, kinkMomReco); float recoRecalcPtSigmaQtAP = qtAP(sigmaMomReco, kinkMomReco); float massSigma = isSigmaMinusKink ? sigmaCand.mSigmaMinus : sigmaCand.mSigmaPlus; - + // Generated properties float genMassSigma{-1.f}; if (isSigmaMinusKink || isSigmaPlusToPiKink || isSigmaPlusToPrKink) { @@ -1624,7 +1624,6 @@ struct lambda1405analysis { } } PROCESS_SWITCH(lambda1405analysis, processMcSigmasCentSel, "MC processing for sigma efficiency studies", false); - }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { From 2b1f459d146007406c38224e0b3a310c24f9ce13 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Fri, 17 Jul 2026 12:41:00 +0200 Subject: [PATCH 03/10] Fix Megalinter --- PWGLF/DataModel/LFLambda1405Table.h | 12 +++--- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 42 +++++++++---------- 2 files changed, 27 insertions(+), 27 deletions(-) diff --git a/PWGLF/DataModel/LFLambda1405Table.h b/PWGLF/DataModel/LFLambda1405Table.h index 25277d1445b..7c9b60afdd3 100644 --- a/PWGLF/DataModel/LFLambda1405Table.h +++ b/PWGLF/DataModel/LFLambda1405Table.h @@ -44,8 +44,8 @@ DECLARE_SOA_COLUMN(NSigmaTPCPiKink, nSigmaTPCPiKink, float); //! Number of sigma DECLARE_SOA_COLUMN(NSigmaTOFPiKink, nSigmaTOFPiKink, float); //! Number of sigmas for the pion candidate from Sigma kink in TOF DECLARE_SOA_COLUMN(NSigmaTPCPrKink, nSigmaTPCPrKink, float); //! Number of sigmas for the proton candidate from Sigma kink in TPC DECLARE_SOA_COLUMN(NSigmaTOFPrKink, nSigmaTOFPrKink, float); //! Number of sigmas for the proton candidate from Sigma kink in TOF -DECLARE_SOA_COLUMN(DCAKinkDauToPV, dcaKinkDauToPV, float); //! DCA of the kink daughter to the primary vertex -DECLARE_SOA_COLUMN(DCASigmaToPV, dcaSigmaToPV, float); //! DCA of the sigma to the primary vertex +DECLARE_SOA_COLUMN(DcaKinkDauToPv, dcaKinkDauToPv, float); //! DCA of the kink daughter to the primary vertex +DECLARE_SOA_COLUMN(DcaSigmaToPv, dcaSigmaToPv, float); //! DCA of the sigma to the primary vertex DECLARE_SOA_COLUMN(NSigmaTPCPiDau, nSigmaTPCPiDau, float); //! Number of sigmas for the lambda1405 pion daughter in TPC DECLARE_SOA_COLUMN(NSigmaTOFPiDau, nSigmaTOFPiDau, float); //! Number of sigmas for the lambda1405 pion daughter in TOF @@ -109,7 +109,7 @@ DECLARE_SOA_TABLE(Lambda1405Cands, "AOD", "LAMBDA1405", lambda1405::PtKink, lambda1405::NSigmaTPCPiKink, lambda1405::NSigmaTOFPiKink, lambda1405::NSigmaTPCPrKink, lambda1405::NSigmaTOFPrKink, - lambda1405::DCAKinkDauToPV, + lambda1405::DcaKinkDauToPv, lambda1405::NSigmaTPCPiDau, lambda1405::NSigmaTOFPiDau, lambda1405::Centrality, lambda1405::Occupancy); @@ -121,7 +121,7 @@ DECLARE_SOA_TABLE(Lambda1405Flow, "AOD", "LAMBDA1405FLOW", lambda1405::AlphaAPSigma, lambda1405::QtAPSigma, lambda1405::NSigmaTPCPiKink, lambda1405::NSigmaTOFPiKink, lambda1405::NSigmaTPCPrKink, lambda1405::NSigmaTOFPrKink, - lambda1405::DCAKinkDauToPV, + lambda1405::DcaKinkDauToPv, lambda1405::NSigmaTPCPiDau, lambda1405::NSigmaTOFPiDau, lambda1405::ScalarProd, lambda1405::Centrality); @@ -134,7 +134,7 @@ DECLARE_SOA_TABLE(Lambda1405CandsMC, "AOD", "MCLAMBDA1405", lambda1405::PtKink, lambda1405::NSigmaTPCPiKink, lambda1405::NSigmaTOFPiKink, lambda1405::NSigmaTPCPrKink, lambda1405::NSigmaTOFPrKink, - lambda1405::DCAKinkDauToPV, + lambda1405::DcaKinkDauToPv, lambda1405::NSigmaTPCPiDau, lambda1405::NSigmaTOFPiDau, lambda1405::PtMC, lambda1405::MassMC, lambda1405::SigmaPdgCode, lambda1405::KinkDauPdgCode, lambda1405::Centrality, lambda1405::Occupancy); @@ -163,7 +163,7 @@ DECLARE_SOA_TABLE(Lambda1405SigmaEffMC, "AOD", "MCL1405SIGEFF", lambda1405::ZKinkVtx, lambda1405::DeltaZKinkVtx, lambda1405::AlphaAPSigma, lambda1405::QtAPSigma, lambda1405::AlphaAPSigmaRecalc, lambda1405::QtAPSigmaRecalc, - lambda1405::DCAKinkDauToPV, lambda1405::DCASigmaToPV, + lambda1405::DcaKinkDauToPv, lambda1405::DcaSigmaToPv, lambda1405::SigmaPdgCode, lambda1405::KinkDauPdgCode, lambda1405::Centrality, lambda1405::Occupancy, lambda1405::PvContrib); diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index 63440e1dfde..458dabd8271 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -1544,9 +1544,9 @@ struct lambda1405analysis { // Recompute the sigma momentum bool success{false}; - float sigmaPRecalc = recalcSigmaMomReco(success, isSigmaMinusKink, - sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth(), - sigmaCand.pxDaug(), sigmaCand.pyDaug(), sigmaCand.pzDaug()); + float sigmaPRecalc = recalcSigmaMom(success, isSigmaMinusKink, + sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth(), + sigmaCand.pxDaug(), sigmaCand.pyDaug(), sigmaCand.pzDaug()); if (!success && skipSigmasFailedRecompMom) { return; } @@ -1561,7 +1561,7 @@ struct lambda1405analysis { sigmaMomReco[2] *= scale; sigmaPt = std::sqrt(sigmaMomReco[0] * sigmaMomReco[0] + sigmaMomReco[1] * sigmaMomReco[1]); - if (lambda1405Cand.isSigmaMinus) { + if (isSigmaMinusKink) { rSigmaMinus.fill(HIST("hDeltaPxRecalcSigmaMinus"), sigmaMomReco[0] - sigmaCand.pxMoth(), sigmaCand.pxMoth()); rSigmaMinus.fill(HIST("hDeltaPyRecalcSigmaMinus"), sigmaMomReco[1] - sigmaCand.pyMoth(), sigmaCand.pyMoth()); rSigmaMinus.fill(HIST("hDeltaPzRecalcSigmaMinus"), sigmaMomReco[2] - sigmaCand.pzMoth(), sigmaCand.pzMoth()); @@ -1589,35 +1589,35 @@ struct lambda1405analysis { float genSigmaQtAP = qtAP(sigmaMomGen, kinkMomGen); if (isSigmaMinusKink) { rSigmaMinus.fill(HIST("hSparseGenSigmaMinus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, genCentMult, genNumContrib, genOcc); - } else if (isSigmaPlusKink) { + } else if (isSigmaPlusToPiKink || isSigmaPlusToPrKink) { rSigmaPlus.fill(HIST("hSparseGenSigmaPlus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, genCentMult, genNumContrib, genOcc); } } // Fill table with sigma properties for efficiency studies outputSigmaEffMC( - sigmaCand.pxMoth, sigmaCand.pxMoth - genSigma.px(), - sigmaCand.pyMoth, sigmaCand.pyMoth - genSigma.py(), - sigmaCand.pzMoth, sigmaCand.pzMoth - genSigma.pz(), - sigmaPt, sigmaPt - genSigma.pz(), + sigmaCand.pxMoth(), sigmaCand.pxMoth() - genSigma.px(), + sigmaCand.pyMoth(), sigmaCand.pyMoth() - genSigma.py(), + sigmaCand.pzMoth(), sigmaCand.pzMoth() - genSigma.pz(), + sigmaCand.pt(), sigmaCand.pt() - genSigma.pt(), massSigma, massSigma - genMassSigma, - sigmaCand.pxMoth - sigmaMomReco[0], - sigmaCand.pyMoth - sigmaMomReco[1], - sigmaCand.pzMoth - sigmaMomReco[2], + sigmaCand.pxMoth() - sigmaMomReco[0], + sigmaCand.pyMoth() - sigmaMomReco[1], + sigmaCand.pzMoth() - sigmaMomReco[2], genSigma.phi(), genSigma.eta(), - sigmaCand.pxDaug, sigmaCand.pxDaug - genKinkDaug.px(), - sigmaCand.pyDaug, sigmaCand.pyDaug - genKinkDaug.py(), - sigmaCand.pzDaug, sigmaCand.pzDaug - genKinkDaug.pz(), - kinkPt, kinkPt - genKinkDaug.pz(), + sigmaCand.pxDaug(), sigmaCand.pxDaug() - genKinkDaug.px(), + sigmaCand.pyDaug(), sigmaCand.pyDaug() - genKinkDaug.py(), + sigmaCand.pzDaug(), sigmaCand.pzDaug() - genKinkDaug.pz(), + kinkPt, kinkPt - genKinkDaug.pt(), genKinkDaug.phi(), genKinkDaug.eta(), - sigmaCand.xDecVtx, sigmaCand.xDecVtx - genKinkDaug.vx, - sigmaCand.yDecVtx, sigmaCand.yDecVtx - genKinkDaug.vy, - sigmaCand.zDecVtx, sigmaCand.zDecVtx - genKinkDaug.vz, + sigmaCand.xDecVtx(), sigmaCand.xDecVtx() - genKinkDaug.vx(), + sigmaCand.yDecVtx(), sigmaCand.yDecVtx() - genKinkDaug.vy(), + sigmaCand.zDecVtx(), sigmaCand.zDecVtx() - genKinkDaug.vz(), recoSigmaAlphaAP, recoSigmaQtAP, - recoRecalcPtSigmaQtAP, recoRecalcPtSigmaQtAP, - sigmaCand.dcaDaugPv, sigmaCand.dcaMothPv, + recoRecalcPtSigmaAlphaAP, recoRecalcPtSigmaQtAP, + sigmaCand.dcaDaugPv(), sigmaCand.dcaMothPv(), genSigma.pdgCode(), genKinkDaug.pdgCode(), centMult, collision.ft0cOccupancyInTimeRange(), collision.numContrib()); } From 9b1a6b8b8e69df6f0236108e8c5c25b1f597e862 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Tue, 28 Jul 2026 11:10:56 +0200 Subject: [PATCH 04/10] Group configurables --- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 154 +++++++++--------- 1 file changed, 79 insertions(+), 75 deletions(-) diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index 458dabd8271..d9cd5a289c9 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -131,29 +131,36 @@ struct lambda1405analysis { HistogramRegistry rSigmaPlus{"sigmaPlus", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry rSelections{"selections", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // Configurable for event selection - Configurable cutZVertex{"cutZVertex", 10.0f, "Accepted z-vertex range (cm)"}; - Configurable cutEtaDaughter{"cutEtaDaughter", 0.8f, "Eta cut for daughter tracks"}; - Configurable cutDcaToPvSigma{"cutDcaToPvSigma", 0.1f, "Max DCA to primary vertex for Sigma candidates (cm)"}; - Configurable cutDcaToPvPiFromSigma{"cutDcaToPvPiFromSigma", 2., "Min DCA to primary vertex for pion from Sigma candidates (cm)"}; - - Configurable cutMinPtL1405{"cutMinPtL1405", 2.0f, "Minimum pT cut for Lambda(1405) candidates (GeV/c)"}; - Configurable cutUpperMass{"cutUpperMass", 1.6f, "Upper mass cut for Lambda(1405) candidates (GeV/c^2)"}; - Configurable cutSigmaRadius{"cutSigmaRadius", 20.f, "Minimum radius for Sigma candidates (cm)"}; - Configurable cutSigmaMass{"cutSigmaMass", 0.1, "Sigma mass window (MeV/c^2)"}; - Configurable cutItsNClusKinkMin{"cutItsNClusKinkMin", 1, "Minimum number of ITS clusters for kink daughter"}; - Configurable cutItsNClusKinkMax{"cutItsNClusKinkMax", 3, "Maximum number of ITS clusters for kink daughter"}; - Configurable cutNTpcClus{"cutNTpcClus", 90, "Minimum number of Tpc clusters for pion candidate"}; - Configurable cutNSigTpc{"cutNSigTpc", 3, "NSigTpcPion"}; - Configurable cutNSigTof{"cutNSigTof", 3, "NSigTofPion"}; - Configurable cutMaxDcaZBach{"cutMaxDcaZBach", 0.1, "Maximum DcaZ for bachelor pion (cm)"}; - Configurable dcaXYBachNSigmaMax{"dcaXYBachNSigmaMax", 7, "Cut on number of sigma deviations from expected DCA in the transverse direction"}; - Configurable dcaXYPtBachFunc{"dcaXYPtBachFunc", "(0.0026+0.005/(x^1.01))", "Functional form of pt-dependent DCAxy cut"}; - Configurable cutSigmaQtAPMin{"cutSigmaQtAPMin", "0.17", "Functional form of minimum qT(alpha) selection"}; - Configurable cutSigmaQtAPMax{"cutSigmaQtAPMax", "0.2", "Functional form of minimum qT(alpha) selection"}; - Configurable cutMinBachPiPtVsL1405Pt{"cutMinBachPiPtVsL1405Pt", "0", "Functional form of minimum qT(alpha) selection"}; - Configurable cutMaxBachPiPtVsL1405Pt{"cutMaxBachPiPtVsL1405Pt", "10", "Functional form of minimum qT(alpha) selection"}; - Configurable cutMinSigmaPtVsL1405Pt{"cutMinSigmaPtVsL1405Pt", "0", "Functional form of minimum qT(alpha) selection"}; - Configurable cutMaxSigmaPtVsL1405Pt{"cutMaxSigmaPtVsL1405Pt", "10", "Functional form of minimum qT(alpha) selection"}; + struct : o2::framework::ConfigurableGroup { + Configurable cutZVertex{"cutZVertex", 10.0f, "Accepted z-vertex range (cm)"}; + Configurable centMultMin{"centMultMin", 0., "Minimum collision centrality/multiplicity accepted"}; + Configurable centMultMax{"centMultMax", 100., "Maximum collision centrality/multiplicity accepted"}; + Configurable occupancyMax{"occupancyMax", 3000000., "Maximum collision occupancy accepted"}; + } eventSelection; + + struct : o2::framework::ConfigurableGroup { + Configurable cutEtaDaughter{"cutEtaDaughter", 0.8f, "Eta cut for daughter tracks"}; + Configurable cutDcaToPvSigma{"cutDcaToPvSigma", 0.1f, "Max DCA to primary vertex for Sigma candidates (cm)"}; + Configurable cutDcaToPvPiFromSigma{"cutDcaToPvPiFromSigma", 2., "Min DCA to primary vertex for pion from Sigma candidates (cm)"}; + Configurable cutMinPtL1405{"cutMinPtL1405", 2.0f, "Minimum pT cut for Lambda(1405) candidates (GeV/c)"}; + Configurable cutUpperMass{"cutUpperMass", 1.6f, "Upper mass cut for Lambda(1405) candidates (GeV/c^2)"}; + Configurable cutSigmaRadius{"cutSigmaRadius", 20.f, "Minimum radius for Sigma candidates (cm)"}; + Configurable cutSigmaMass{"cutSigmaMass", 0.1, "Sigma mass window (MeV/c^2)"}; + Configurable cutItsNClusKinkMin{"cutItsNClusKinkMin", 1, "Minimum number of ITS clusters for kink daughter"}; + Configurable cutItsNClusKinkMax{"cutItsNClusKinkMax", 3, "Maximum number of ITS clusters for kink daughter"}; + Configurable cutNTpcClus{"cutNTpcClus", 90, "Minimum number of Tpc clusters for pion candidate"}; + Configurable cutNSigTpc{"cutNSigTpc", 3, "NSigTpcPion"}; + Configurable cutNSigTof{"cutNSigTof", 3, "NSigTofPion"}; + Configurable cutMaxDcaZBach{"cutMaxDcaZBach", 0.1, "Maximum DcaZ for bachelor pion (cm)"}; + Configurable dcaXYBachNSigmaMax{"dcaXYBachNSigmaMax", 7, "Cut on number of sigma deviations from expected DCA in the transverse direction"}; + Configurable dcaXYPtBachFunc{"dcaXYPtBachFunc", "(0.0026+0.005/(x^1.01))", "Functional form of pt-dependent DCAxy cut"}; + Configurable cutSigmaQtAPMin{"cutSigmaQtAPMin", "0.17", "Functional form of minimum qT(alpha) selection"}; + Configurable cutSigmaQtAPMax{"cutSigmaQtAPMax", "0.2", "Functional form of minimum qT(alpha) selection"}; + Configurable cutMinBachPiPtVsL1405Pt{"cutMinBachPiPtVsL1405Pt", "0", "Functional form of minimum qT(alpha) selection"}; + Configurable cutMaxBachPiPtVsL1405Pt{"cutMaxBachPiPtVsL1405Pt", "10", "Functional form of minimum qT(alpha) selection"}; + Configurable cutMinSigmaPtVsL1405Pt{"cutMinSigmaPtVsL1405Pt", "0", "Functional form of minimum qT(alpha) selection"}; + Configurable cutMaxSigmaPtVsL1405Pt{"cutMaxSigmaPtVsL1405Pt", "10", "Functional form of minimum qT(alpha) selection"}; + } selections; // Configurables for flow analysis Configurable centMultMin{"centMultMin", 0., "Minimum collision centrality/multiplicity accepted"}; @@ -454,21 +461,21 @@ struct lambda1405analysis { } // Functional selections - funcMinQtAlphaAP = TF1("funcMinQtAlphaAP", Form("%s", cutSigmaQtAPMin.value.data()), -1, 1); - LOGF(info, "funcMinQtAlphaAP: %s", Form("%s", cutSigmaQtAPMin.value.data())); - funcMaxQtAlphaAP = TF1("funcMaxQtAlphaAP", Form("%s", cutSigmaQtAPMax.value.data()), -1, 1); - LOGF(info, "funcMaxQtAlphaAP: %s", Form("%s", cutSigmaQtAPMax.value.data())); - funcMinBachPiPtVsL1405Pt = TF1("funcMinBachPiPtVsL1405Pt", Form("%s", cutMinBachPiPtVsL1405Pt.value.data()), 0., 100); - LOGF(info, "funcMinBachPiPtVsL1405Pt: %s", Form("%s", cutMinBachPiPtVsL1405Pt.value.data())); - funcMaxBachPiPtVsL1405Pt = TF1("funcMaxBachPiPtVsL1405Pt", Form("%s", cutMaxBachPiPtVsL1405Pt.value.data()), 0., 100); - LOGF(info, "funcMaxBachPiPtVsL1405Pt: %s", Form("%s", cutMaxBachPiPtVsL1405Pt.value.data())); - funcMinSigmaPtVsL1405Pt = TF1("funcMinSigmaPtVsL1405Pt", Form("%s", cutMinSigmaPtVsL1405Pt.value.data()), 0., 100); - LOGF(info, "funcMinSigmaPtVsL1405Pt: %s", Form("%s", cutMinSigmaPtVsL1405Pt.value.data())); - funcMaxSigmaPtVsL1405Pt = TF1("funcMaxSigmaPtVsL1405Pt", Form("%s", cutMaxSigmaPtVsL1405Pt.value.data()), 0., 100); - LOGF(info, "funcMaxSigmaPtVsL1405Pt: %s", Form("%s", cutMaxSigmaPtVsL1405Pt.value.data())); - funcDcaXYPtCutBachPi = TF1("funcDcaXYPtCutBachPi", Form("[0]*%s", dcaXYPtBachFunc.value.data()), 0.001, 100); - funcDcaXYPtCutBachPi.SetParameter(0, dcaXYBachNSigmaMax); - LOGF(info, "DCAxy pt-dependence function: %s", Form("[0]*%s", dcaXYPtBachFunc.value.data())); + funcMinQtAlphaAP = TF1("funcMinQtAlphaAP", Form("%s", selections.cutSigmaQtAPMin.value.data()), -1, 1); + LOGF(info, "funcMinQtAlphaAP: %s", Form("%s", selections.cutSigmaQtAPMin.value.data())); + funcMaxQtAlphaAP = TF1("funcMaxQtAlphaAP", Form("%s", selections.cutSigmaQtAPMax.value.data()), -1, 1); + LOGF(info, "funcMaxQtAlphaAP: %s", Form("%s", selections.cutSigmaQtAPMax.value.data())); + funcMinBachPiPtVsL1405Pt = TF1("funcMinBachPiPtVsL1405Pt", Form("%s", selections.cutMinBachPiPtVsL1405Pt.value.data()), 0., 100); + LOGF(info, "funcMinBachPiPtVsL1405Pt: %s", Form("%s", selections.cutMinBachPiPtVsL1405Pt.value.data())); + funcMaxBachPiPtVsL1405Pt = TF1("funcMaxBachPiPtVsL1405Pt", Form("%s", selections.cutMaxBachPiPtVsL1405Pt.value.data()), 0., 100); + LOGF(info, "funcMaxBachPiPtVsL1405Pt: %s", Form("%s", selections.cutMaxBachPiPtVsL1405Pt.value.data())); + funcMinSigmaPtVsL1405Pt = TF1("funcMinSigmaPtVsL1405Pt", Form("%s", selections.cutMinSigmaPtVsL1405Pt.value.data()), 0., 100); + LOGF(info, "funcMinSigmaPtVsL1405Pt: %s", Form("%s", selections.cutMinSigmaPtVsL1405Pt.value.data())); + funcMaxSigmaPtVsL1405Pt = TF1("funcMaxSigmaPtVsL1405Pt", Form("%s", selections.cutMaxSigmaPtVsL1405Pt.value.data()), 0., 100); + LOGF(info, "funcMaxSigmaPtVsL1405Pt: %s", Form("%s", selections.cutMaxSigmaPtVsL1405Pt.value.data())); + funcDcaXYPtCutBachPi = TF1("funcDcaXYPtCutBachPi", Form("[0]*%s", selections.dcaXYPtBachFunc.value.data()), 0.001, 100); + funcDcaXYPtCutBachPi.SetParameter(0, selections.dcaXYBachNSigmaMax); + LOGF(info, "DCAxy pt-dependence function: %s", Form("[0]*%s", selections.dcaXYPtBachFunc.value.data())); rSelections.print(); rSigmaMinus.print(); @@ -591,31 +598,28 @@ struct lambda1405analysis { } template - bool selectPiBach(const TTrack& candidate, const o2::dataformats::VertexBase& vtx, float centMult) + bool selectPiBach(const TTrack& candidate, float centMult) { - if (std::abs(candidate.tpcNSigmaPi()) > cutNSigTpc) { + if (std::abs(candidate.tpcNSigmaPi()) > selections.cutNSigTpc) { return false; } rSelections.fill(HIST("hSelectionsBachPi"), 2); // Nsigma Tpc - if (candidate.tpcNClsFound() < cutNTpcClus) { + if (candidate.tpcNClsFound() < selections.cutNTpcClus) { return false; } rSelections.fill(HIST("hSelectionsBachPi"), 3); // Tpc clusters - if (std::abs(candidate.eta()) > cutEtaDaughter) { + if (std::abs(candidate.eta()) > selections.cutEtaDaughter) { return false; } rSelections.fill(HIST("hSelectionsBachPi"), 4); // Eta selection - o2::track::TrackParCov trackParCovTrack = getTrackParCov(candidate); - std::array dcaInfoMoth; - o2::base::Propagator::Instance()->propagateToDCABxByBz({vtx.getX(), vtx.getY(), vtx.getZ()}, - trackParCovTrack, 2.f, static_cast(cfgMaterialCorrection.value), - &dcaInfoMoth); - rLambda1405.fill(HIST("h3BachPiDcaXYVsPt"), candidate.pt(), dcaInfoMoth[0], centMult); - rLambda1405.fill(HIST("h3BachPiDcaZVsPt"), candidate.pt(), dcaInfoMoth[1], centMult); - if (std::abs(dcaInfoMoth[0]) > funcDcaXYPtCutBachPi.Eval(candidate.pt()) || std::abs(dcaInfoMoth[1]) > cutMaxDcaZBach) { + std::array dcaInfoBachPi{candidate.dcaXY(), candidate.dcaZ()}; + rLambda1405.fill(HIST("h3BachPiDcaXYVsPt"), candidate.pt(), dcaInfoBachPi[0], centMult); + rLambda1405.fill(HIST("h3BachPiDcaZVsPt"), candidate.pt(), dcaInfoBachPi[1], centMult); + if (std::abs(dcaInfoBachPi[0]) > funcDcaXYPtCutBachPi.Eval(candidate.pt()) || + std::abs(dcaInfoBachPi[1]) > selections.cutMaxDcaZBach) { return false; } rSelections.fill(HIST("hSelectionsBachPi"), 5); // DCA selection @@ -628,22 +632,22 @@ struct lambda1405analysis { { rSelections.fill(HIST("hSelectionsKinkPi"), 0); // All pion kink candidates - if (std::abs(candidate.tpcNSigmaPi()) > cutNSigTpc) { + if (std::abs(candidate.tpcNSigmaPi()) > selections.cutNSigTpc) { return false; } rSelections.fill(HIST("hSelectionsKinkPi"), 1); // Nsigma Tpc - if (candidate.tpcNClsFound() < cutNTpcClus) { + if (candidate.tpcNClsFound() < selections.cutNTpcClus) { return false; } rSelections.fill(HIST("hSelectionsKinkPi"), 2); // Tpc clusters - if (std::abs(candidate.eta()) > cutEtaDaughter) { + if (std::abs(candidate.eta()) > selections.cutEtaDaughter) { return false; } rSelections.fill(HIST("hSelectionsKinkPi"), 3); // Eta selection - if (candidate.itsNCls() < cutItsNClusKinkMin || candidate.itsNCls() > cutItsNClusKinkMax) { + if (candidate.itsNCls() < selections.cutItsNClusKinkMin || candidate.itsNCls() > selections.cutItsNClusKinkMax) { return false; } rSelections.fill(HIST("hSelectionsKinkPi"), 4); // ITS clusters @@ -653,7 +657,7 @@ struct lambda1405analysis { } rSelections.fill(HIST("hSelectionsKinkPi"), 5); // has Tof - if (useTof && std::abs(candidate.tofNSigmaPi()) > cutNSigTof) { + if (useTof && std::abs(candidate.tofNSigmaPi()) > selections.cutNSigTof) { return false; } rSelections.fill(HIST("hSelectionsKinkPi"), 6); // Nsigma Tof @@ -666,22 +670,22 @@ struct lambda1405analysis { { rSelections.fill(HIST("hSelectionsKinkPr"), 0); // All proton kink candidates - if (std::abs(candidate.tpcNSigmaPr()) > cutNSigTpc) { + if (std::abs(candidate.tpcNSigmaPr()) > selections.cutNSigTpc) { return false; } rSelections.fill(HIST("hSelectionsKinkPr"), 1); // Nsigma Tpc - if (candidate.tpcNClsFound() < cutNTpcClus) { + if (candidate.tpcNClsFound() < selections.cutNTpcClus) { return false; } rSelections.fill(HIST("hSelectionsKinkPr"), 2); // Tpc clusters - if (std::abs(candidate.eta()) > cutEtaDaughter) { + if (std::abs(candidate.eta()) > selections.cutEtaDaughter) { return false; } rSelections.fill(HIST("hSelectionsKinkPr"), 3); // eta selection - if (candidate.itsNCls() < cutItsNClusKinkMin || candidate.itsNCls() > cutItsNClusKinkMax) { + if (candidate.itsNCls() < selections.cutItsNClusKinkMin || candidate.itsNCls() > selections.cutItsNClusKinkMax) { return false; } rSelections.fill(HIST("hSelectionsKinkPr"), 4); // ITS clusters @@ -691,7 +695,7 @@ struct lambda1405analysis { } rSelections.fill(HIST("hSelectionsKinkPr"), 5); // has Tof - if (useTof && std::abs(candidate.tofNSigmaPr()) > cutNSigTof) { + if (useTof && std::abs(candidate.tofNSigmaPr()) > selections.cutNSigTof) { return false; } rSelections.fill(HIST("hSelectionsKinkPr"), 6); // Nsigma Tof @@ -914,12 +918,12 @@ struct lambda1405analysis { rSigmaPlus.fill(HIST("h2PtPrKinkNSigBeforeCuts"), kinkDauTrack.pt(), kinkDauTrack.tpcNSigmaPr()); } - if (lambda1405Cand.isSigmaMinus && (sigmaCand.mSigmaMinus() < o2::constants::physics::MassSigmaMinus - cutSigmaMass || - sigmaCand.mSigmaMinus() > o2::constants::physics::MassSigmaMinus + cutSigmaMass)) { + if (lambda1405Cand.isSigmaMinus && (sigmaCand.mSigmaMinus() < o2::constants::physics::MassSigmaMinus - selections.cutSigmaMass || + sigmaCand.mSigmaMinus() > o2::constants::physics::MassSigmaMinus + selections.cutSigmaMass)) { return; } - if (lambda1405Cand.isSigmaPlus && (sigmaCand.mSigmaPlus() < o2::constants::physics::MassSigmaPlus - cutSigmaMass || - sigmaCand.mSigmaPlus() > o2::constants::physics::MassSigmaPlus + cutSigmaMass)) { + if (lambda1405Cand.isSigmaPlus && (sigmaCand.mSigmaPlus() < o2::constants::physics::MassSigmaPlus - selections.cutSigmaMass || + sigmaCand.mSigmaPlus() > o2::constants::physics::MassSigmaPlus + selections.cutSigmaMass)) { return; } if (lambda1405Cand.isSigmaMinus) { @@ -928,7 +932,7 @@ struct lambda1405analysis { rSelections.fill(HIST("hSelectionsSigmaPlus"), 3); // Passed mass sel } - if (std::abs(sigmaCand.dcaMothPv()) > cutDcaToPvSigma) { + if (std::abs(sigmaCand.dcaMothPv()) > selections.cutDcaToPvSigma) { return; } if (lambda1405Cand.isSigmaMinus) { @@ -937,7 +941,7 @@ struct lambda1405analysis { rSelections.fill(HIST("hSelectionsSigmaPlus"), 4); // Passed cutDcaToPvSigma } - if (std::abs(sigmaCand.dcaDaugPv()) < cutDcaToPvPiFromSigma) { + if (std::abs(sigmaCand.dcaDaugPv()) < selections.cutDcaToPvPiFromSigma) { return; } if (lambda1405Cand.isSigmaMinus) { @@ -947,7 +951,7 @@ struct lambda1405analysis { } float sigmaRad = std::hypot(sigmaCand.xDecVtx(), sigmaCand.yDecVtx()); - if (sigmaRad < cutSigmaRadius) { + if (sigmaRad < selections.cutSigmaRadius) { return; } if (lambda1405Cand.isSigmaMinus) { @@ -1017,7 +1021,7 @@ struct lambda1405analysis { } rSelections.fill(HIST("hSelectionsBachPi"), 1); - if (!selectPiBach(piTrack, primaryVertex, lambda1405Cand.centMult)) { + if (!selectPiBach(piTrack, lambda1405Cand.centMult)) { continue; } rSelections.fill(HIST("hSelectionsL1405"), 2); // Bach Pi selection @@ -1029,7 +1033,7 @@ struct lambda1405analysis { } else if (lambda1405Cand.isSigmaPlus) { invMass = RecoDecay::m(std::array{sigmaMom, piMom}, std::array{o2::constants::physics::MassSigmaPlus, o2::constants::physics::MassPiMinus}); } - if (invMass > cutUpperMass) { + if (invMass > selections.cutUpperMass) { continue; } rSelections.fill(HIST("hSelectionsL1405"), 3); // Upper mass selection @@ -1072,7 +1076,7 @@ struct lambda1405analysis { } rSelections.fill(HIST("hSelectionsL1405"), 4); // Pt correlations - if (lambda1405Cand.pt() < cutMinPtL1405) { + if (lambda1405Cand.pt() < selections.cutMinPtL1405) { continue; } rSelections.fill(HIST("hSelectionsL1405"), 5); // Accepted @@ -1104,14 +1108,14 @@ struct lambda1405analysis { } template - void fillOutputData(const TCollision& collision, const TCand& sigmaCands, const TTrack& tracks) + void fillOutputData(const TCollision& collision, const TCand& sigmaCands, const TTrack& tracks, TBinningType binPolicy) { - if (std::abs(collision.posZ()) > cutZVertex || !collision.sel8()) { + if (std::abs(collision.posZ()) > eventSelection.cutZVertex || !collision.sel8()) { return; } rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); float centMult = getCentMult(collision); - if (centMult < centMultMin || centMult > centMultMax) { + if (centMult < eventSelection.centMultMin || centMult > eventSelection.centMultMax) { return; } rEventSelection.fill(HIST("hCentMultVsPvContrib"), centMult, collision.numContrib()); @@ -1275,12 +1279,12 @@ struct lambda1405analysis { const aod::McParticles& particlesMC) { for (const auto& collision : recoCollisions) { - if (std::abs(collision.posZ()) > cutZVertex) { // || !collision.sel8()) { + if (std::abs(collision.posZ()) > eventSelection.cutZVertex) { // || !collision.sel8()) { continue; } rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); float centMult = getCentMult(collision); - if (centMult < centMultMin || centMult > centMultMax) { + if (centMult < eventSelection.centMultMin || centMult > eventSelection.centMultMax) { continue; } rEventSelection.fill(HIST("hCentMultVsPvContrib"), centMult, collision.numContrib()); From 47129566d4935e5a82c8520cb94ca436ec88de99 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Tue, 28 Jul 2026 11:11:37 +0200 Subject: [PATCH 05/10] Event mixing --- PWGLF/DataModel/LFLambda1405Table.h | 10 +- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 307 ++++++++++++------ 2 files changed, 214 insertions(+), 103 deletions(-) diff --git a/PWGLF/DataModel/LFLambda1405Table.h b/PWGLF/DataModel/LFLambda1405Table.h index 7c9b60afdd3..3beda8dd667 100644 --- a/PWGLF/DataModel/LFLambda1405Table.h +++ b/PWGLF/DataModel/LFLambda1405Table.h @@ -98,6 +98,9 @@ DECLARE_SOA_COLUMN(DeltaXKinkVtx, deltaXKinkVtx, float); //! Gen-reco DECLARE_SOA_COLUMN(DeltaYKinkVtx, deltaYKinkVtx, float); //! Gen-reco diff of Y of kink vertex DECLARE_SOA_COLUMN(DeltaZKinkVtx, deltaZKinkVtx, float); //! Gen-reco diff of Z of kink vertex +// Event mixing +DECLARE_SOA_COLUMN(PoolBin, poolBin, int); //! Signed pT of the Sigma daughter for mixed events + } // namespace lambda1405 DECLARE_SOA_TABLE(Lambda1405Cands, "AOD", "LAMBDA1405", @@ -111,7 +114,7 @@ DECLARE_SOA_TABLE(Lambda1405Cands, "AOD", "LAMBDA1405", lambda1405::NSigmaTPCPrKink, lambda1405::NSigmaTOFPrKink, lambda1405::DcaKinkDauToPv, lambda1405::NSigmaTPCPiDau, lambda1405::NSigmaTOFPiDau, - lambda1405::Centrality, lambda1405::Occupancy); + lambda1405::Centrality, lambda1405::Occupancy, lambda1405::PoolBin); DECLARE_SOA_TABLE(Lambda1405Flow, "AOD", "LAMBDA1405FLOW", o2::soa::Index<>, @@ -123,7 +126,7 @@ DECLARE_SOA_TABLE(Lambda1405Flow, "AOD", "LAMBDA1405FLOW", lambda1405::NSigmaTPCPrKink, lambda1405::NSigmaTOFPrKink, lambda1405::DcaKinkDauToPv, lambda1405::NSigmaTPCPiDau, lambda1405::NSigmaTOFPiDau, - lambda1405::ScalarProd, lambda1405::Centrality); + lambda1405::ScalarProd, lambda1405::Centrality, lambda1405::PoolBin); DECLARE_SOA_TABLE(Lambda1405CandsMC, "AOD", "MCLAMBDA1405", o2::soa::Index<>, @@ -144,8 +147,6 @@ DECLARE_SOA_TABLE(Lambda1405SigmaEffMC, "AOD", "MCL1405SIGEFF", lambda1405::PxSigma, lambda1405::DeltaPxSigma, lambda1405::PySigma, lambda1405::DeltaPySigma, lambda1405::PzSigma, lambda1405::DeltaPzSigma, - lambda1405::PtSigma, lambda1405::DeltaPtSigma, - lambda1405::RadiusSigma, lambda1405::DeltaRadiusSigma, lambda1405::MassSigma, lambda1405::DeltaMassSigma, lambda1405::DeltaPxSigmaRecalc, lambda1405::DeltaPySigmaRecalc, @@ -155,7 +156,6 @@ DECLARE_SOA_TABLE(Lambda1405SigmaEffMC, "AOD", "MCL1405SIGEFF", lambda1405::PxKinkDaug, lambda1405::DeltaPxKinkDaug, lambda1405::PyKinkDaug, lambda1405::DeltaPyKinkDaug, lambda1405::PzKinkDaug, lambda1405::DeltaPzKinkDaug, - lambda1405::PtKinkDaug, lambda1405::DeltaPtKinkDaug, lambda1405::GenPhiKinkDaug, lambda1405::GenEtaKinkDaug, lambda1405::XKinkVtx, lambda1405::DeltaXKinkVtx, diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index d9cd5a289c9..635b63c4d82 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -24,6 +24,7 @@ #include "Common/DataModel/PIDResponseTOF.h" #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/Qvectors.h" +#include "Common/DataModel/TrackSelectionTables.h" #include #include @@ -61,11 +62,14 @@ using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; -using TracksFull = soa::Join; -using CollisionsFull = soa::Join; -using CollisionsFullWCentQVecs = soa::Join; -using CollisionsFullMc = soa::Join; -using CollisionsFullMcWCent = soa::Join; +using TracksFull = soa::Join; +using CollisionsFull = soa::Join; +using CollisionsFullWQVecs = soa::Join; +using CollisionsFullMc = soa::Join; +// using CollisionsFullMcWCent = soa::Join; + +using BinningCentPosZ = ColumnBinningPolicy; +using BinningMultPosZ = ColumnBinningPolicy, aod::collision::PosZ>; enum L1405DecayType { kSigmaMinusPiToPiPiNeutron = 0, kSigmaPlusPiToPiPiNeutron, @@ -113,6 +117,8 @@ struct lambda1405candidate { float occupancy = -1; // Occupancy of the collision float scalarProd = -1; // Scalar product for flow analysis + + int poolBin = -1; // Pool bin for event mixing }; struct lambda1405analysis { @@ -163,14 +169,13 @@ struct lambda1405analysis { } selections; // Configurables for flow analysis - Configurable centMultMin{"centMultMin", 0., "Minimum collision centrality/multiplicity accepted"}; - Configurable centMultMax{"centMultMax", 100., "Maximum collision centrality/multiplicity accepted"}; - Configurable occupancyMax{"occupancyMax", 3000000., "Maximum collision occupancy accepted"}; Configurable minDEta{"minDEta", -1., "Minimum delta eta between L1405-track pairs"}; Configurable assTrkMinPt{"assTrkMinPt", 0., "Minimum pT of associated track for 2PC"}; Configurable assTrkMaxPt{"assTrkMaxPt", 10., "Maximum pT of associated track for 2PC"}; Configurable saveDEtaDPhi{"saveDEtaDPhi", false, "If true, save the dEta and dPhi distributions for Lambda(1405) candidates"}; Configurable fillFlowTree{"fillFlowTree", false, "If true, fill the output tree with Lambda(1405) candidates"}; + Configurable useCentrality{"useCentrality", true, "If true, use centrality for binning"}; + Configurable numberEventsMixed{"numberEventsMixed", 5, "Number of events mixed in ME process"}; // Downsample for table filling Configurable downSampleFactor{"downSampleFactor", 1., "Fraction of candidates to keep in TTree"}; @@ -191,19 +196,26 @@ struct lambda1405analysis { TF1 funcMinQtAlphaAP, funcMaxQtAlphaAP, funcMinBachPiPtVsL1405Pt, funcMaxBachPiPtVsL1405Pt, funcMinSigmaPtVsL1405Pt, funcMaxSigmaPtVsL1405Pt, funcDcaXYPtCutBachPi; - using CollisionsCentSel = soa::Filtered; - using McRecoCollisionsCentSel = soa::Filtered; + using CollisionsSel = soa::Filtered; + using CollisionsSelWQVecs = soa::Filtered; + using McRecoCollisionsSel = soa::Filtered; - Filter filterOccupancy = aod::evsel::ft0cOccupancyInTimeRange <= occupancyMax; + Filter filterOccupancy = aod::evsel::ft0cOccupancyInTimeRange <= eventSelection.occupancyMax; PresliceUnsorted colPerMcCollision = aod::mccollisionlabel::mcCollisionId; + SliceCache cache; + + int poolBins{0}; + // Needed for DCA propagation of bachelor tracks int mRunNumber; float mBz; o2::base::MatLayerCylSet* lut = nullptr; // Configurable axes + ConfigurableAxis zPoolBins{"zPoolBins", {VARIABLE_WIDTH, -10.0, -2.5, 2.5, 10.0}, "Z vertex position pools"}; + ConfigurableAxis centMultPoolBins{"centMultPoolBins", {VARIABLE_WIDTH, 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100}, "Event cent/mult pools"}; ConfigurableAxis axisPvContrib{"axisPvContrib", {5000, 0., 5000.}, ""}; ConfigurableAxis axisCent{"axisCent", {100, 0., 100.}, ""}; ConfigurableAxis axisOccupancy{"axisOccupancy", {100, 0., 140000.}, ""}; @@ -233,6 +245,10 @@ struct lambda1405analysis { void init(InitContext const&) { + // Define pool bins + poolBins = (centMultPoolBins->size() - 2) * (zPoolBins->size() - 2); + const AxisSpec axisPoolBin = {poolBins, -0.5, static_cast(poolBins) - 0.5, "PoolBin"}; + // Axes const AxisSpec ptAxis{axisPtL1405, "#it{p}_{T} (GeV/#it{c})"}; const AxisSpec pCompAxisL1405{axisPCompsL1405, "#it{p}_{comp} (GeV/#it{c})"}; @@ -262,6 +278,10 @@ struct lambda1405analysis { rEventSelection.add("hCentMultVsPvContrib", "hCentMultVsPvContrib", {HistType::kTH2F, {centMultAxis, pvContribAxis}}); rEventSelection.add("hOccVsPvContrib", "hOccVsPvContrib", {HistType::kTH2F, {occAxis, pvContribAxis}}); rEventSelection.add("hCentVsOcc", "hCentVsOcc", {HistType::kTH2F, {centMultAxis, occAxis}}); + rEventSelection.add("hCentPoolBin", "Centrality pool bin", {HistType::kTH2F, {{axisCent}, {axisPoolBin}}}); + rEventSelection.add("hZVtxPoolBin", "Z vtx pool bin", {HistType::kTH2F, {{vertexZAxis}, {axisPoolBin}}}); + rEventSelection.add("hMultPoolBin", "Multiplicity pool bin", {HistType::kTH2F, {{axisCent}, {axisPoolBin}}}); + rEventSelection.add("hPoolBins", "Pool bins", {HistType::kTH1F, {{102, -1.5, 100.5}}}); // Sigma- candidate properties rSigmaMinus.add("hMassXiMinusSigmaMinus", "hMassXiMinusSigmaMinus", {HistType::kTH2F, {xiMassAxis, sigmaMassAxis}}); @@ -328,18 +348,18 @@ struct lambda1405analysis { rLambda1405.add("h3BachPiDcaXYVsPt", "h3BachPiDcaXYVsPt", {HistType::kTH3F, {ptKinkDaugAxis, dcaBachPiAxis, centMultAxis}}); rLambda1405.add("h3BachPiDcaZVsPt", "h3BachPiDcaZVsPt", {HistType::kTH3F, {ptKinkDaugAxis, dcaBachPiAxis, centMultAxis}}); // Sparse histograms - std::vector axesMass = {lambda1405MassAxis, ptAxis, sigmaMassAxis, dcaSigmaToPvAxis, dcaKinkToPvAxis}; - if (doprocessMc || doprocessMcWCentSel) { + std::vector axesMass = {axisPoolBin, lambda1405MassAxis, ptAxis, sigmaMassAxis, dcaSigmaToPvAxis, dcaKinkToPvAxis}; + if (doprocessMc) { axesMass.push_back(pvContribAxis); } else { axesMass.push_back(centMultAxis); } rLambda1405.add("hSparseL1405", "THn for mass peak", HistType::kTHnSparseF, axesMass); - std::vector axesScalarProd = {lambda1405MassAxis, ptAxis, sigmaMassAxis, dcaSigmaToPvAxis, dcaKinkToPvAxis, centMultAxis, scalarProdAxis}; - if (doprocessDataWCentQVecs) { + std::vector axesScalarProd = {axisPoolBin, lambda1405MassAxis, ptAxis, sigmaMassAxis, dcaSigmaToPvAxis, dcaKinkToPvAxis, centMultAxis, scalarProdAxis}; + if (doprocessDataWQVecsSameEvent || doprocessDataWQVecsMixedEvent) { rLambda1405.add("hSparseL1405ScalProd", "THn for SP", HistType::kTHnSparseF, axesScalarProd); } - std::vector axesCorrel = {lambda1405MassAxis, ptAxis, deltaEtaAxis, deltaPhiAxis}; + std::vector axesCorrel = {axisPoolBin, lambda1405MassAxis, ptAxis, deltaEtaAxis, deltaPhiAxis}; if (saveDEtaDPhi) { rLambda1405.add("hSparseL1405Correl", "THn for 2PC", HistType::kTHnSparseF, axesCorrel); } @@ -406,14 +426,14 @@ struct lambda1405analysis { rSelections.get(HIST("hSelectionsKinkPr"))->GetXaxis()->SetBinLabel(6, "has TOF"); rSelections.get(HIST("hSelectionsKinkPr"))->GetXaxis()->SetBinLabel(7, "N#sigma TOF"); - if (doprocessDataWCentQVecs) { + if (doprocessDataWQVecsSameEvent || doprocessDataWQVecsMixedEvent) { rLambda1405.add("hScalarProd", "hScalarProd", {HistType::kTH2F, {scalarProdAxis, ptAxis}}); std::vector axesFlow = {lambda1405MassAxis, ptAxis, centMultAxis, scalarProdAxis}; rLambda1405.add("hSparseFlowL1405", "THn for SP", HistType::kTHnSparseF, axesFlow); } // Add MC histograms - if (doprocessMc || doprocessMcWCentSel) { + if (doprocessMc) { rSelections.add("hRecoNotMatchedCounter", "hRecoNotMatchedCounter", {HistType::kTH1D, {{4, -0.5, 3.5f}}}); rSelections.get(HIST("hRecoNotMatchedCounter"))->GetXaxis()->SetBinLabel(1, "#Lambda(1405)"); @@ -456,7 +476,9 @@ struct lambda1405analysis { } if (doprocessMcSigmasCentSel) { + rSigmaPlus.add("hSparseGenFromRecoSigmaPlus", "THn for generated Sigma plus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); rSigmaPlus.add("hSparseGenSigmaPlus", "THn for generated Sigma plus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); + rSigmaMinus.add("hSparseGenFromRecoSigmaMinus", "THn for generated Sigma minus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); rSigmaMinus.add("hSparseGenSigmaMinus", "THn for generated Sigma minus", {HistType::kTHnSparseF, {sigmaMassAxis, ptAxis, alphaAxis, qtAxis, sigmaRadiusAxis, centMultAxis, occAxis, pvContribAxis}}); } @@ -490,13 +512,32 @@ struct lambda1405analysis { ccdb->setLocalObjectValidityChecking(); } + /// Get the binning pool associated to the collision + /// \param collision is the collision + /// \param binPolicy is the binning policy for the correlation + template + int getPoolBin(const TColl& collision, const TBinningType& binPolicy) + { + int poolBin{0}; + float centMult = getCentMult(collision); + poolBin = binPolicy.getBin(std::make_tuple(centMult, collision.posZ())); + if constexpr (std::is_same_v) { + rEventSelection.fill(HIST("hCentPoolBin"), centMult, poolBin); + } else if constexpr (std::is_same_v) { + rEventSelection.fill(HIST("hMultPoolBin"), centMult, poolBin); + } + rEventSelection.fill(HIST("hZVtxPoolBin"), collision.posZ(), poolBin); + rEventSelection.fill(HIST("hPoolBins"), poolBin); + return poolBin; + } + template float getCentMult(const TCollision& collision) { - if constexpr (requires { collision.centFT0C(); }) { + if (useCentrality) { return collision.centFT0C(); } else { - return collision.multFT0C(); + return collision.multFT0M(); } } @@ -755,24 +796,8 @@ struct lambda1405analysis { rLambda1405.fill(HIST("h2BachPiPtNSigTpc"), cand.bachPiPt, cand.bachPiNSigTpc); rLambda1405.fill(HIST("h2BachPiPtNSigTof"), cand.bachPiPt, cand.bachPiNSigTof); - // std::vector axesMass = {lambda1405MassAxis, ptAxis, sigmaMassAxis, dcaSigmaToPvAxis, dcaKinkToPvAxis}; - // if (doprocessMc || doprocessMcWCentSel) { - // axesMass.push_back(pvContribAxis); - // } else { - // axesMass.push_back(centMultAxis); - // } - // rLambda1405.add("hSparseL1405", "THn for mass peak", HistType::kTHnSparseF, axes); - // std::vector axesScalarProd = {lambda1405MassAxis, ptAxis, sigmaMassAxis, dcaSigmaToPvAxis, dcaKinkToPvAxis, centMultAxis, scalarProdAxis}; - // if (doprocessDataWCentQVecs) { - // rLambda1405.add("hSparseL1405ScalProd", "THn for SP", HistType::kTHnSparseF, axesScalarProd); - // } - // std::vector axesCorrel = {lambda1405MassAxis, ptAxis, deltaEtaAxis, deltaPhiAxis}; - // if (saveDEtaDPhi) { - // rLambda1405.add("hSparseL1405Correl", "THn for 2PC", HistType::kTHnSparseF, axesCorrel); - // } - auto hSparseMass = rLambda1405.get(HIST("hSparseL1405")); - std::vector sparseMassEntry = {cand.massL1405, cand.pt(), cand.sigmaMinusMass, cand.dcaSigmaToPv, cand.kinkDcaDauToPv}; + std::vector sparseMassEntry = {static_cast(cand.poolBin), cand.massL1405, cand.pt(), cand.sigmaMinusMass, cand.dcaSigmaToPv, cand.kinkDcaDauToPv}; if constexpr (IsMC) { sparseMassEntry.push_back(cand.pvContrib); } else { @@ -780,14 +805,14 @@ struct lambda1405analysis { } hSparseMass->Fill(sparseMassEntry.data()); if constexpr (FillQVectors) { - std::vector sparseScalProdEntry = {cand.massL1405, cand.pt(), cand.sigmaMinusMass, cand.dcaSigmaToPv, cand.kinkDcaDauToPv}; + std::vector sparseScalProdEntry = {static_cast(cand.poolBin), cand.massL1405, cand.pt(), cand.sigmaMinusMass, cand.dcaSigmaToPv, cand.kinkDcaDauToPv}; sparseScalProdEntry.push_back(cand.centMult); sparseScalProdEntry.push_back(cand.scalarProd); auto hSparseScalProd = rLambda1405.get(HIST("hSparseL1405ScalProd")); hSparseScalProd->Fill(sparseScalProdEntry.data()); } if constexpr (FillCorrelations) { - std::vector sparseCorrelEntry = {cand.massL1405, cand.pt(), cand.sigmaMinusMass, cand.dcaSigmaToPv, cand.kinkDcaDauToPv}; + std::vector sparseCorrelEntry = {static_cast(cand.poolBin), cand.massL1405, cand.pt(), cand.sigmaMinusMass, cand.dcaSigmaToPv, cand.kinkDcaDauToPv}; auto hSparseCorrel = rLambda1405.get(HIST("hSparseL1405Correl")); sparseCorrelEntry.push_back(0.0); // Δη sparseCorrelEntry.push_back(0.0); // Δφ @@ -815,37 +840,22 @@ struct lambda1405analysis { } } - void initCCDB(aod::BCs::iterator const& bc) + template + void constructCollCandidates(const TColl& collision, + aod::KinkCands::iterator const& sigmaCand, + TracksFull const& tracks, + std::vector& selectedCandidates, + TBinningType binPolicy) { - if (mRunNumber == bc.runNumber()) { - return; - } - mRunNumber = bc.runNumber(); - LOG(info) << "Initializing CCDB for run " << mRunNumber; - o2::parameters::GRPMagField* grpmag = ccdb->getForRun(grpmagPath, mRunNumber); - o2::base::Propagator::initFieldFromGRP(grpmag); - mBz = grpmag->getNominalL3Field(); - - if (!lut) { - lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get(lutPath)); - } - o2::base::Propagator::Instance()->setMatLUT(lut); - LOG(info) << "Task initialized for run " << mRunNumber << " with magnetic field " << mBz << " kZG"; - } - - template - void constructCollCandidates(const TColl& collision, aod::KinkCands::iterator const& sigmaCand, TracksFull const& tracks, std::vector& selectedCandidates) - { - - // Retrieve primary vertex, once for all candidates in the collision - auto const& bc = collision.template bc_as(); - initCCDB(bc); - o2::dataformats::VertexBase primaryVertex; - primaryVertex.setPos({collision.posX(), collision.posY(), collision.posZ()}); - primaryVertex.setCov(collision.covXX(), collision.covXY(), collision.covYY(), collision.covXZ(), collision.covYZ(), collision.covZZ()); lambda1405candidate lambda1405Cand{}; + if constexpr (!IsMc) { + // Set pool bin + int const poolBin = getPoolBin(collision, binPolicy); + lambda1405Cand.poolBin = poolBin; + } + rSelections.fill(HIST("hSelectionsL1405"), 0); // All candidates rSelections.fill(HIST("hSelectionsSigmaMinus"), 0); // All Sigma- candidates rSelections.fill(HIST("hSelectionsSigmaPlus"), 0); // All Sigma+ candidates @@ -1107,7 +1117,7 @@ struct lambda1405analysis { return isKinkFromSigma; // Return true if the kink comes from the Sigma } - template + template void fillOutputData(const TCollision& collision, const TCand& sigmaCands, const TTrack& tracks, TBinningType binPolicy) { if (std::abs(collision.posZ()) > eventSelection.cutZVertex || !collision.sel8()) { @@ -1124,7 +1134,7 @@ struct lambda1405analysis { for (const auto& sigmaCand : sigmaCands) { std::vector selectedCandidates; - constructCollCandidates(collision, sigmaCand, tracks, selectedCandidates); + constructCollCandidates(collision, sigmaCand, tracks, selectedCandidates, binPolicy); for (const auto& lambda1405Cand : selectedCandidates) { if (lambda1405Cand.isSigmaMinus) { rLambda1405.fill(HIST("h2SigmaMinusMassVsLambdaMass"), lambda1405Cand.massL1405, lambda1405Cand.sigmaMinusMass); @@ -1149,7 +1159,7 @@ struct lambda1405analysis { lambda1405Cand.kinkPrNSigTpc, lambda1405Cand.kinkPrNSigTof, lambda1405Cand.kinkDcaDauToPv, lambda1405Cand.bachPiNSigTpc, lambda1405Cand.bachPiNSigTof, - lambda1405Cand.centMult, lambda1405Cand.occupancy); + lambda1405Cand.centMult, lambda1405Cand.occupancy, lambda1405Cand.poolBin); } else { outputDataFlowTable(ptCand, lambda1405Cand.massL1405, lambda1405Cand.sigmaPt, @@ -1159,7 +1169,7 @@ struct lambda1405analysis { lambda1405Cand.kinkPrNSigTpc, lambda1405Cand.kinkPrNSigTof, lambda1405Cand.kinkDcaDauToPv, lambda1405Cand.bachPiNSigTpc, lambda1405Cand.bachPiNSigTof, - lambda1405Cand.scalarProd, lambda1405Cand.centMult); + lambda1405Cand.scalarProd, lambda1405Cand.centMult, lambda1405Cand.poolBin); } } @@ -1181,23 +1191,93 @@ struct lambda1405analysis { } } - void processData(CollisionsFull::iterator const& collision, + void processDataSameEvent(CollisionsSel::iterator const& collision, aod::KinkCands const& kinkCands, TracksFull const& tracks, const aod::BCs&) { - fillOutputData(collision, kinkCands, tracks); + if (useCentrality) { + BinningCentPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; + fillOutputData(collision, kinkCands, tracks, binPolicy); + } else { + BinningMultPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; + fillOutputData(collision, kinkCands, tracks, binPolicy); + } + } + PROCESS_SWITCH(lambda1405analysis, processDataSameEvent, "Data processing", true); + + void processDataWQVecsSameEvent(CollisionsSelWQVecs::iterator const& collision, + aod::KinkCands const& kinkCands, + TracksFull const& tracks, + const aod::BCs&) + { + BinningCentPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; + fillOutputData(collision, kinkCands, tracks, binPolicy); } - PROCESS_SWITCH(lambda1405analysis, processData, "Data processing", true); + PROCESS_SWITCH(lambda1405analysis, processDataWQVecsSameEvent, "Data processing with centrality and Q vectors info", false); - void processDataWCentQVecs(CollisionsCentSel::iterator const& collision, + void processDataMixedEvent(CollisionsFull const& collisions, aod::KinkCands const& kinkCands, TracksFull const& tracks, const aod::BCs&) { - fillOutputData(collision, kinkCands, tracks); + auto pairsTuple = std::make_tuple(kinkCands, tracks); + if (useCentrality) { + BinningCentPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; + Pair const pairs{binPolicy, numberEventsMixed, -1, collisions, pairsTuple, &cache}; + for (const auto& [sigmasColl, sigmas, bachPisColl, bachPis] : pairs) { + if (sigmas.size() == 0 || bachPis.size() == 0) { + continue; + } + int const poolBinSigma = getPoolBin(sigmasColl, binPolicy); + int const poolBinBachPi = getPoolBin(bachPisColl, binPolicy); + if (poolBinBachPi != poolBinSigma) { + LOG(debug) << "Different poolBins for sigma and bachelor pi: " << poolBinSigma << " vs " << poolBinBachPi; + continue; + } + fillOutputData(sigmasColl, sigmas, bachPis, binPolicy); + } + } else { + BinningMultPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; + Pair const pairs{binPolicy, numberEventsMixed, -1, collisions, pairsTuple, &cache}; + for (const auto& [sigmasColl, sigmas, bachPisColl, bachPis] : pairs) { + if (sigmas.size() == 0 || bachPis.size() == 0) { + continue; + } + int const poolBinSigma = getPoolBin(sigmasColl, binPolicy); + int const poolBinBachPi = getPoolBin(bachPisColl, binPolicy); + if (poolBinBachPi != poolBinSigma) { + LOG(debug) << "Different poolBins for sigma and bachelor pi: " << poolBinSigma << " vs " << poolBinBachPi; + continue; + } + fillOutputData(sigmasColl, sigmas, bachPis, binPolicy); + } + } + } + PROCESS_SWITCH(lambda1405analysis, processDataMixedEvent, "Data event mixing processing", false); + + void processDataWQVecsMixedEvent(CollisionsSelWQVecs const& collisions, + aod::KinkCands const& kinkCands, + TracksFull const& tracks, + const aod::BCs&) + { + auto pairsTuple = std::make_tuple(kinkCands, tracks); + BinningCentPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; + Pair const pairs{binPolicy, numberEventsMixed, -1, collisions, pairsTuple, &cache}; + for (const auto& [sigmasColl, sigmas, bachPisColl, bachPis] : pairs) { + if (sigmas.size() == 0 || bachPis.size() == 0) { + continue; + } + int const poolBinSigma = getPoolBin(sigmasColl, binPolicy); + int const poolBinBachPi = getPoolBin(bachPisColl, binPolicy); + if (poolBinBachPi != poolBinSigma) { + LOG(debug) << "Different poolBins for sigma and bachelor pi: " << poolBinSigma << " vs " << poolBinBachPi; + continue; + } + fillOutputData(sigmasColl, sigmas, bachPis, binPolicy); + } } - PROCESS_SWITCH(lambda1405analysis, processDataWCentQVecs, "Data processing with centrality and Q vectors info", false); + PROCESS_SWITCH(lambda1405analysis, processDataWQVecsMixedEvent, "Data event mixing with centrality and Q vectors info", false); template int matchGenDecay(const TMother& motherPart, const aod::McParticles& mcParticles, std::array& daugsIdxs) @@ -1322,7 +1402,8 @@ struct lambda1405analysis { rSigmaPlus.fill(HIST("h2DeltaGenRecoPtSigmaPlus"), sigmaCand.ptMoth() - genSigma.pt(), sigmaCand.ptMoth()); } std::vector selectedCandidates; - constructCollCandidates(collision, sigmaCand, tracksPerCol, selectedCandidates); + const int dummyPoolBin{-1}; // Not used in MC, but required by the function signature + constructCollCandidates(collision, sigmaCand, tracksPerCol, selectedCandidates, dummyPoolBin); for (const auto& lambda1405Cand : selectedCandidates) { rLambda1405.fill(HIST("hRecoL1405"), 0., lambda1405Cand.pt()); // All reconstructed @@ -1467,31 +1548,21 @@ struct lambda1405analysis { } PROCESS_SWITCH(lambda1405analysis, processMc, "MC processing", false); - void processMcWCentSel(McRecoCollisionsCentSel const& recoCollisions, - aod::KinkCands const& kinkCands, - aod::McTrackLabels const& trackLabelsMC, - aod::McParticles const& particlesMC, - TracksFull const& tracks, - const aod::BCs&) - { - fillOutputMc(recoCollisions, kinkCands, trackLabelsMC, tracks, particlesMC); - } - PROCESS_SWITCH(lambda1405analysis, processMcWCentSel, "MC processing with centrality selection", false); - - void processMcSigmasCentSel(McRecoCollisionsCentSel const& recoCollisions, - aod::KinkCands const& kinkCands, + void processMcSigmasCentSel(McRecoCollisionsSel const& recoCollisions, + aod::KinkCands const& sigmaCands, aod::McTrackLabels const& trackLabelsMC, aod::McParticles const& particlesMC, + aod::McCollisions const&, const aod::BCs&) { // Loop over kink candidates to fill Sigma efficiency histograms for (const auto& collision : recoCollisions) { - if (std::abs(collision.posZ()) > cutZVertex) { // || !collision.sel8()) { + if (std::abs(collision.posZ()) > eventSelection.cutZVertex) { // || !collision.sel8()) { continue; } rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); float centMult = getCentMult(collision); - if (centMult < centMultMin || centMult > centMultMax) { + if (centMult < eventSelection.centMultMin || centMult > eventSelection.centMultMax) { continue; } @@ -1533,7 +1604,6 @@ struct lambda1405analysis { } float sigmaPt = sigmaCand.ptMoth(); - float kinkPt = sigmaCand.ptDaug(); if (downSampleFactor < 1.) { float const pseudoRndm = sigmaPt * 1000. - static_cast(sigmaPt * 1000); if (sigmaPt < ptDownSampleMax && pseudoRndm >= downSampleFactor) { @@ -1581,7 +1651,7 @@ struct lambda1405analysis { float recoRecalcPtSigmaAlphaAP = alphaAP(sigmaMomReco, kinkMomReco); float recoRecalcPtSigmaQtAP = qtAP(sigmaMomReco, kinkMomReco); - float massSigma = isSigmaMinusKink ? sigmaCand.mSigmaMinus : sigmaCand.mSigmaPlus; + float massSigma = isSigmaMinusKink ? sigmaCand.mSigmaMinus() : sigmaCand.mSigmaPlus(); // Generated properties float genMassSigma{-1.f}; @@ -1591,10 +1661,11 @@ struct lambda1405analysis { std::array kinkMomGen{sigmaCand.pxDaug(), sigmaCand.pyDaug(), sigmaCand.pzDaug()}; float genSigmaAlphaAP = alphaAP(sigmaMomGen, kinkMomGen); float genSigmaQtAP = qtAP(sigmaMomGen, kinkMomGen); + float sigmaRadius = std::hypot(genKinkDaug.vx(), genKinkDaug.vy()); if (isSigmaMinusKink) { - rSigmaMinus.fill(HIST("hSparseGenSigmaMinus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, genCentMult, genNumContrib, genOcc); + rSigmaMinus.fill(HIST("hSparseGenFromRecoSigmaMinus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, sigmaRadius, genCentMult, genNumContrib, genOcc); } else if (isSigmaPlusToPiKink || isSigmaPlusToPrKink) { - rSigmaPlus.fill(HIST("hSparseGenSigmaPlus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, genCentMult, genNumContrib, genOcc); + rSigmaPlus.fill(HIST("hSparseGenFromRecoSigmaPlus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, sigmaRadius, genCentMult, genNumContrib, genOcc); } } @@ -1603,7 +1674,6 @@ struct lambda1405analysis { sigmaCand.pxMoth(), sigmaCand.pxMoth() - genSigma.px(), sigmaCand.pyMoth(), sigmaCand.pyMoth() - genSigma.py(), sigmaCand.pzMoth(), sigmaCand.pzMoth() - genSigma.pz(), - sigmaCand.pt(), sigmaCand.pt() - genSigma.pt(), massSigma, massSigma - genMassSigma, sigmaCand.pxMoth() - sigmaMomReco[0], sigmaCand.pyMoth() - sigmaMomReco[1], @@ -1613,7 +1683,6 @@ struct lambda1405analysis { sigmaCand.pxDaug(), sigmaCand.pxDaug() - genKinkDaug.px(), sigmaCand.pyDaug(), sigmaCand.pyDaug() - genKinkDaug.py(), sigmaCand.pzDaug(), sigmaCand.pzDaug() - genKinkDaug.pz(), - kinkPt, kinkPt - genKinkDaug.pt(), genKinkDaug.phi(), genKinkDaug.eta(), sigmaCand.xDecVtx(), sigmaCand.xDecVtx() - genKinkDaug.vx(), @@ -1626,6 +1695,48 @@ struct lambda1405analysis { centMult, collision.ft0cOccupancyInTimeRange(), collision.numContrib()); } } + + // generated sigmas + for (const auto& genSigma : particlesMC) { + if (std::abs(genSigma.pdgCode()) != PDG_t::kSigmaMinus && std::abs(genSigma.pdgCode()) != PDG_t::kSigmaPlus) { + continue; // Only consider Sigma candidates + } + + const auto& recoCollsPerMcColl = recoCollisions.sliceBy(colPerMcCollision, genSigma.mcCollision().globalIndex()); + if (recoCollsPerMcColl.size() == 0) { + continue; // Skip if no reconstructed collisions associated with this MC collision + } + + unsigned genNumContrib = 0; + float genOcc{0.f}; + float genCentMult{0.f}; + for (const auto& recCol : recoCollsPerMcColl) { + genNumContrib = recCol.numContrib() > genNumContrib ? recCol.numContrib() : genNumContrib; + genOcc = recCol.ft0cOccupancyInTimeRange() > genOcc ? recCol.ft0cOccupancyInTimeRange() : genOcc; + genCentMult = getCentMult(recCol) > genCentMult ? getCentMult(recCol) : genCentMult; + } + + // Check the sigma daughter of the kink decay + std::vector arrSigmaDaugs = {}; + RecoDecay::getDaughters(genSigma, &arrSigmaDaugs, std::array{0}, 1); + for (auto iProng = 0u; iProng < arrSigmaDaugs.size(); ++iProng) { + auto daughSigma = particlesMC.rawIteratorAt(arrSigmaDaugs[iProng]); + float genMassSigma = std::sqrt(genSigma.e() * genSigma.e() - genSigma.p() * genSigma.p()); + std::array sigmaMomGen{genSigma.px(), genSigma.py(), genSigma.pz()}; + std::array kinkMomGen{daughSigma.px(), daughSigma.py(), daughSigma.pz()}; + float genSigmaAlphaAP = alphaAP(sigmaMomGen, kinkMomGen); + float genSigmaQtAP = qtAP(sigmaMomGen, kinkMomGen); + float sigmaRadius = std::hypot(daughSigma.vx(), daughSigma.vy()); + + if (std::abs(daughSigma.pdgCode()) == PDG_t::kPiPlus && std::abs(genSigma.pdgCode()) == PDG_t::kSigmaMinus) { + rSigmaMinus.fill(HIST("hSparseGenSigmaMinus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, sigmaRadius, genCentMult, genNumContrib, genOcc); + } else if (std::abs(daughSigma.pdgCode()) == PDG_t::kPiPlus && std::abs(genSigma.pdgCode()) == PDG_t::kSigmaPlus) { + rSigmaPlus.fill(HIST("hSparseGenSigmaPlus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, sigmaRadius, genCentMult, genNumContrib, genOcc); + } else if (std::abs(daughSigma.pdgCode()) == PDG_t::kProton && std::abs(genSigma.pdgCode()) == PDG_t::kSigmaPlus) { + rSigmaPlus.fill(HIST("hSparseGenSigmaPlus"), genMassSigma, genSigma.pt(), genSigmaAlphaAP, genSigmaQtAP, sigmaRadius, genCentMult, genNumContrib, genOcc); + } + } + } } PROCESS_SWITCH(lambda1405analysis, processMcSigmasCentSel, "MC processing for sigma efficiency studies", false); }; From 882fc5b3dbb9fe3d6700354a5d8daa71470ec9e4 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 28 Jul 2026 09:12:28 +0000 Subject: [PATCH 06/10] Please consider the following formatting changes --- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index 635b63c4d82..4e9ac815f06 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -143,7 +143,7 @@ struct lambda1405analysis { Configurable centMultMax{"centMultMax", 100., "Maximum collision centrality/multiplicity accepted"}; Configurable occupancyMax{"occupancyMax", 3000000., "Maximum collision occupancy accepted"}; } eventSelection; - + struct : o2::framework::ConfigurableGroup { Configurable cutEtaDaughter{"cutEtaDaughter", 0.8f, "Eta cut for daughter tracks"}; Configurable cutDcaToPvSigma{"cutDcaToPvSigma", 0.1f, "Max DCA to primary vertex for Sigma candidates (cm)"}; @@ -1192,9 +1192,9 @@ struct lambda1405analysis { } void processDataSameEvent(CollisionsSel::iterator const& collision, - aod::KinkCands const& kinkCands, - TracksFull const& tracks, - const aod::BCs&) + aod::KinkCands const& kinkCands, + TracksFull const& tracks, + const aod::BCs&) { if (useCentrality) { BinningCentPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; @@ -1207,9 +1207,9 @@ struct lambda1405analysis { PROCESS_SWITCH(lambda1405analysis, processDataSameEvent, "Data processing", true); void processDataWQVecsSameEvent(CollisionsSelWQVecs::iterator const& collision, - aod::KinkCands const& kinkCands, - TracksFull const& tracks, - const aod::BCs&) + aod::KinkCands const& kinkCands, + TracksFull const& tracks, + const aod::BCs&) { BinningCentPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; fillOutputData(collision, kinkCands, tracks, binPolicy); @@ -1257,9 +1257,9 @@ struct lambda1405analysis { PROCESS_SWITCH(lambda1405analysis, processDataMixedEvent, "Data event mixing processing", false); void processDataWQVecsMixedEvent(CollisionsSelWQVecs const& collisions, - aod::KinkCands const& kinkCands, - TracksFull const& tracks, - const aod::BCs&) + aod::KinkCands const& kinkCands, + TracksFull const& tracks, + const aod::BCs&) { auto pairsTuple = std::make_tuple(kinkCands, tracks); BinningCentPosZ binPolicy{{centMultPoolBins, zPoolBins}, true}; From 0aa097902204ad6d4cb19ca630e2cecf4cf76231 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Tue, 28 Jul 2026 11:59:44 +0200 Subject: [PATCH 07/10] Fix unused variables --- PWGLF/DataModel/LFLambda1405Table.h | 3 +-- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 26 ++++++++----------- 2 files changed, 12 insertions(+), 17 deletions(-) diff --git a/PWGLF/DataModel/LFLambda1405Table.h b/PWGLF/DataModel/LFLambda1405Table.h index 3beda8dd667..0cfc6a8f64e 100644 --- a/PWGLF/DataModel/LFLambda1405Table.h +++ b/PWGLF/DataModel/LFLambda1405Table.h @@ -9,11 +9,10 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -/// /// \file LFLambda1405Tables.h /// \brief Slim tables for Lambda(1405) candidates -/// \author Francesco Mazzaschi /// +/// \author Francesco Mazzaschi #ifndef PWGLF_DATAMODEL_LFLAMBDA1405TABLE_H_ #define PWGLF_DATAMODEL_LFLAMBDA1405TABLE_H_ diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index 4e9ac815f06..cb77680a480 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -209,8 +209,6 @@ struct lambda1405analysis { int poolBins{0}; // Needed for DCA propagation of bachelor tracks - int mRunNumber; - float mBz; o2::base::MatLayerCylSet* lut = nullptr; // Configurable axes @@ -505,8 +503,6 @@ struct lambda1405analysis { rLambda1405.print(); // Info for DCA propagation of bachelor tracks - mRunNumber = 0; - mBz = 0; ccdb->setURL(ccdbPath); ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); @@ -614,10 +610,10 @@ struct lambda1405analysis { } double sqrtD = std::sqrt(D); - double P1 = (-B + sqrtD) / (2.0 * A); - double P2 = (-B - sqrtD) / (2.0 * A); - if (P2 < 0.0 && P1 < 0.0) { - LOG(debug) << "Recalculation of Sigma momentum failed: both solutions are negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", P1: " << P1 << ", P2: " << P2; + double p1 = (-B + sqrtD) / (2.0 * A); + double p2 = (-B - sqrtD) / (2.0 * A); + if (p2 < 0.0 && p1 < 0.0) { + LOG(debug) << "Recalculation of Sigma momentum failed: both solutions are negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", p1: " << p1 << ", p2: " << p2; return -999.f; } if (isSigmaMinus) { @@ -627,15 +623,15 @@ struct lambda1405analysis { } success = true; - if (P2 < 0.0) { - return static_cast(P1); + if (p2 < 0.0) { + return static_cast(p1); } - if (P1 < 0.0) { - return static_cast(P2); + if (p1 < 0.0) { + return static_cast(p2); } - double p1Diff = std::abs(P1 - pMother); - double p2Diff = std::abs(P2 - pMother); - return static_cast((p1Diff < p2Diff) ? P1 : P2); + double p1Diff = std::abs(p1 - pMother); + double p2Diff = std::abs(p2 - pMother); + return static_cast((p1Diff < p2Diff) ? p1 : p2); } template From a256ed4771f17682143204d53afca0a59adfdd10 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Tue, 28 Jul 2026 12:07:39 +0200 Subject: [PATCH 08/10] Fix magic numbers --- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 23 ++++++++++--------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index cb77680a480..b13d8eb47c0 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -122,7 +122,7 @@ struct lambda1405candidate { }; struct lambda1405analysis { - int lambda1405PdgCode = 102132; // PDG code for Lambda(1405) + int lambda1405PdgCode = 102132; // PDG code for Lambda(1405); o2-linter: disable=pdg/explicit-code Produces outputDataTable; // Output table for Lambda(1405) candidates Produces outputDataFlowTable; // Output table for Lambda(1405) flow analysis Produces outputDataTableMC; // Output table for Lambda(1405) candidates in MC @@ -568,7 +568,8 @@ struct lambda1405analysis { double massSigma = isSigmaMinus ? o2::constants::physics::MassSigmaMinus : o2::constants::physics::MassSigmaPlus; double pMother = std::sqrt(sigmaPx * sigmaPx + sigmaPy * sigmaPy + sigmaPz * sigmaPz); - if (pMother < 1e-12f) { + float zeroValTolerance{1e-12f}; + if (pMother < zeroValTolerance) { LOG(debug) << "Recalculation of Sigma momentum failed: mother momentum is zero " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz; return -999.f; } @@ -588,7 +589,7 @@ struct lambda1405analysis { double B = -4.0 * a * K; double C = 4.0 * eChDau * eChDau * massSigma * massSigma - K * K; - if (std::abs(A) < 1e-6f) { + if (std::abs(A) < zeroValTolerance) { LOG(debug) << "Recalculation of Sigma momentum failed: A is zero " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", A = " << A << ", B = " << B << ", C = " << C; return -999.f; } @@ -598,20 +599,20 @@ struct lambda1405analysis { rSelections.fill(HIST("hRecalcSigmaPlusMom"), 2); // Non-zero A } - double D = B * B - 4.0 * A * C; - if (D < 0.0) { - LOG(debug) << "Recalculation of Sigma momentum failed: D is negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", A = " << A << ", B = " << B << ", C = " << C << ", D = " << D; + double det = B * B - 4.0 * A * C; + if (det < 0.0) { + LOG(debug) << "Recalculation of Sigma momentum failed: determinant is negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", A = " << A << ", B = " << B << ", C = " << C << ", determinant = " << det; return -999.f; } if (isSigmaMinus) { - rSelections.fill(HIST("hRecalcSigmaMinusMom"), 3); // Positive D + rSelections.fill(HIST("hRecalcSigmaMinusMom"), 3); // Positive determinant } else { - rSelections.fill(HIST("hRecalcSigmaPlusMom"), 3); // Positive D + rSelections.fill(HIST("hRecalcSigmaPlusMom"), 3); // Positive determinant } - double sqrtD = std::sqrt(D); - double p1 = (-B + sqrtD) / (2.0 * A); - double p2 = (-B - sqrtD) / (2.0 * A); + double sqrtDet = std::sqrt(det); + double p1 = (-B + sqrtDet) / (2.0 * A); + double p2 = (-B - sqrtDet) / (2.0 * A); if (p2 < 0.0 && p1 < 0.0) { LOG(debug) << "Recalculation of Sigma momentum failed: both solutions are negative " << sigmaPx << ", " << sigmaPy << ", " << sigmaPz << ", p1: " << p1 << ", p2: " << p2; return -999.f; From a86085eca50ef012a48ac3149c72da2603564847 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Tue, 28 Jul 2026 12:10:55 +0200 Subject: [PATCH 09/10] Fix pdg magic number --- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index b13d8eb47c0..ead5d0d0645 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -122,7 +122,7 @@ struct lambda1405candidate { }; struct lambda1405analysis { - int lambda1405PdgCode = 102132; // PDG code for Lambda(1405); o2-linter: disable=pdg/explicit-code + int lambda1405PdgCode = 102132; // o2-linter: disable=pdg/explicit-code Produces outputDataTable; // Output table for Lambda(1405) candidates Produces outputDataFlowTable; // Output table for Lambda(1405) flow analysis Produces outputDataTableMC; // Output table for Lambda(1405) candidates in MC From 68e23bc2c5f2e4ea66d45d8602933930ff052957 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Tue, 28 Jul 2026 13:01:59 +0200 Subject: [PATCH 10/10] Integrate flow table --- PWGLF/DataModel/LFLambda1405Table.h | 13 +------------ PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 16 +++------------- 2 files changed, 4 insertions(+), 25 deletions(-) diff --git a/PWGLF/DataModel/LFLambda1405Table.h b/PWGLF/DataModel/LFLambda1405Table.h index 0cfc6a8f64e..44339682b7c 100644 --- a/PWGLF/DataModel/LFLambda1405Table.h +++ b/PWGLF/DataModel/LFLambda1405Table.h @@ -113,20 +113,9 @@ DECLARE_SOA_TABLE(Lambda1405Cands, "AOD", "LAMBDA1405", lambda1405::NSigmaTPCPrKink, lambda1405::NSigmaTOFPrKink, lambda1405::DcaKinkDauToPv, lambda1405::NSigmaTPCPiDau, lambda1405::NSigmaTOFPiDau, + lambda1405::ScalarProd, lambda1405::Centrality, lambda1405::Occupancy, lambda1405::PoolBin); -DECLARE_SOA_TABLE(Lambda1405Flow, "AOD", "LAMBDA1405FLOW", - o2::soa::Index<>, - lambda1405::Pt, lambda1405::Mass, - lambda1405::PtSigma, - lambda1405::SigmaMinusMass, lambda1405::SigmaPlusMass, - lambda1405::AlphaAPSigma, lambda1405::QtAPSigma, - lambda1405::NSigmaTPCPiKink, lambda1405::NSigmaTOFPiKink, - lambda1405::NSigmaTPCPrKink, lambda1405::NSigmaTOFPrKink, - lambda1405::DcaKinkDauToPv, - lambda1405::NSigmaTPCPiDau, lambda1405::NSigmaTOFPiDau, - lambda1405::ScalarProd, lambda1405::Centrality, lambda1405::PoolBin); - DECLARE_SOA_TABLE(Lambda1405CandsMC, "AOD", "MCLAMBDA1405", o2::soa::Index<>, lambda1405::Px, lambda1405::Py, lambda1405::Pz, diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index ead5d0d0645..10b85c03f2b 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -124,7 +124,6 @@ struct lambda1405candidate { struct lambda1405analysis { int lambda1405PdgCode = 102132; // o2-linter: disable=pdg/explicit-code Produces outputDataTable; // Output table for Lambda(1405) candidates - Produces outputDataFlowTable; // Output table for Lambda(1405) flow analysis Produces outputDataTableMC; // Output table for Lambda(1405) candidates in MC Produces outputSigmaEffMC; // Output table for Lambda(1405) sigma efficiency in MC @@ -809,7 +808,7 @@ struct lambda1405analysis { hSparseScalProd->Fill(sparseScalProdEntry.data()); } if constexpr (FillCorrelations) { - std::vector sparseCorrelEntry = {static_cast(cand.poolBin), cand.massL1405, cand.pt(), cand.sigmaMinusMass, cand.dcaSigmaToPv, cand.kinkDcaDauToPv}; + std::vector sparseCorrelEntry = {static_cast(cand.poolBin), cand.massL1405, cand.pt()}; auto hSparseCorrel = rLambda1405.get(HIST("hSparseL1405Correl")); sparseCorrelEntry.push_back(0.0); // Δη sparseCorrelEntry.push_back(0.0); // Δφ @@ -1156,17 +1155,8 @@ struct lambda1405analysis { lambda1405Cand.kinkPrNSigTpc, lambda1405Cand.kinkPrNSigTof, lambda1405Cand.kinkDcaDauToPv, lambda1405Cand.bachPiNSigTpc, lambda1405Cand.bachPiNSigTof, - lambda1405Cand.centMult, lambda1405Cand.occupancy, lambda1405Cand.poolBin); - } else { - outputDataFlowTable(ptCand, lambda1405Cand.massL1405, - lambda1405Cand.sigmaPt, - lambda1405Cand.sigmaMinusMass, lambda1405Cand.sigmaPlusMass, - lambda1405Cand.sigmaAlphaAP, lambda1405Cand.sigmaQtAP, - lambda1405Cand.kinkPiNSigTpc, lambda1405Cand.kinkPiNSigTof, - lambda1405Cand.kinkPrNSigTpc, lambda1405Cand.kinkPrNSigTof, - lambda1405Cand.kinkDcaDauToPv, - lambda1405Cand.bachPiNSigTpc, lambda1405Cand.bachPiNSigTof, - lambda1405Cand.scalarProd, lambda1405Cand.centMult, lambda1405Cand.poolBin); + lambda1405Cand.scalarProd, + lambda1405Cand.centMult, lambda1405Cand.occupancy, lambda1405Cand.poolBin); // 24 } }