From 53dcef91934865e6ebe508e39b036ffa958924a7 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Sun, 21 Jun 2026 23:16:16 +0200 Subject: [PATCH 1/3] 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 2/3] 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 3/3] 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()); }