From e5ce65214bd2cd1b7cc7085a46761e5060cd7540 Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Sun, 21 Jun 2026 23:16:16 +0200 Subject: [PATCH 1/4] Sigma eff vs. PV contrib + Sparse addition --- PWGLF/DataModel/LFLambda1405Table.h | 5 +- PWGLF/TableProducer/Common/kinkBuilder.cxx | 97 +++-- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 349 +++++++++++------- 3 files changed, 302 insertions(+), 149 deletions(-) diff --git a/PWGLF/DataModel/LFLambda1405Table.h b/PWGLF/DataModel/LFLambda1405Table.h index 31721f634e3..c0fa355edb0 100644 --- a/PWGLF/DataModel/LFLambda1405Table.h +++ b/PWGLF/DataModel/LFLambda1405Table.h @@ -74,8 +74,9 @@ DECLARE_SOA_TABLE(Lambda1405Cands, "AOD", "LAMBDA1405", DECLARE_SOA_TABLE(Lambda1405Flow, "AOD", "LAMBDA1405FLOW", o2::soa::Index<>, - lambda1405::Pt, - lambda1405::Mass, lambda1405::SigmaMinusMass, lambda1405::SigmaPlusMass, + lambda1405::Pt, lambda1405::Mass, + lambda1405::PtSigma, + lambda1405::SigmaMinusMass, lambda1405::SigmaPlusMass, lambda1405::AlphaAPSigma, lambda1405::QtAPSigma, lambda1405::NSigmaTPCPiKink, lambda1405::NSigmaTOFPiKink, lambda1405::NSigmaTPCPrKink, lambda1405::NSigmaTOFPrKink, diff --git a/PWGLF/TableProducer/Common/kinkBuilder.cxx b/PWGLF/TableProducer/Common/kinkBuilder.cxx index 4ae1e77b7c0..dbbd1cce5e6 100644 --- a/PWGLF/TableProducer/Common/kinkBuilder.cxx +++ b/PWGLF/TableProducer/Common/kinkBuilder.cxx @@ -96,7 +96,10 @@ std::shared_ptr hDCAMothToPV; std::shared_ptr hDCADaugToPV; std::shared_ptr hMothDecRad2; std::shared_ptr hGenCandidates; -std::shared_ptr hRecCandidates; +std::shared_ptr hGenDecayRadius; +std::shared_ptr hRecCandidatesRecoPt; +std::shared_ptr hRecCandidatesGenPt; +std::shared_ptr hRecCandidatesDeltaPt; std::array, NMatchedDecays> hGenPtKinkAngle; std::array, NMatchedDecays> hRecPtKinkAngle; } // namespace @@ -362,21 +365,27 @@ struct kinkBuilder { if (doprocessMc || doprocessMcWCent) { if (skipBkgCands) { - hRecCandidates = qaRegistry.add("hRecCandidates", "hRecCandidates;Counts;", {HistType::kTH2F, {{NMatchedDecays, -0.5, static_cast(NMatchedDecays) - 0.5}, absPtAxis}}); - hRecCandidates->GetXaxis()->SetBinLabel(1, "#Sigma^{-} #rightarrow n#pi^{-}"); - hRecCandidates->GetXaxis()->SetBinLabel(2, "#Sigma^{+} #rightarrow n#pi^{+}"); - hRecCandidates->GetXaxis()->SetBinLabel(3, "#Sigma^{+} #rightarrow p#pi^{0}"); + hRecCandidatesRecoPt = qaRegistry.add("hRecCandidatesRecoPt", "hRecCandidates;Counts;Reco #it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {{NMatchedDecays, -0.5, static_cast(NMatchedDecays) - 0.5}, absPtAxis}}); + hRecCandidatesRecoPt->GetXaxis()->SetBinLabel(1, "#Sigma^{-} #rightarrow n#pi^{-}"); + hRecCandidatesRecoPt->GetXaxis()->SetBinLabel(2, "#Sigma^{+} #rightarrow n#pi^{+}"); + hRecCandidatesRecoPt->GetXaxis()->SetBinLabel(3, "#Sigma^{+} #rightarrow p#pi^{0}"); + hRecCandidatesGenPt = qaRegistry.add("hRecCandidatesGenPt", "hRecCandidatesGenPt;Counts;Gen #it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {{NMatchedDecays, -0.5, static_cast(NMatchedDecays) - 0.5}, absPtAxis}}); + hRecCandidatesGenPt->GetXaxis()->SetBinLabel(1, "#Sigma^{-} #rightarrow n#pi^{-}"); + hRecCandidatesGenPt->GetXaxis()->SetBinLabel(2, "#Sigma^{+} #rightarrow n#pi^{+}"); + hRecCandidatesGenPt->GetXaxis()->SetBinLabel(3, "#Sigma^{+} #rightarrow p#pi^{0}"); + hRecCandidatesDeltaPt = qaRegistry.add("hRecCandidatesDeltaPt", "hRecCandidatesDeltaPt;Counts;#Delta p_{T} (GeV/c)", {HistType::kTH2F, {{400, -0.5, 0.5}, absPtAxis}}); } - hGenCandidates = qaRegistry.add("hGenCandidates", "hGenCandidates;Counts;", {HistType::kTH2F, {{NMatchedDecays, -0.5, static_cast(NMatchedDecays) - 0.5}, absPtAxis}}); + hGenDecayRadius = qaRegistry.add("hGenDecayRadius", "hGenDecayRadius;Radius (cm); #it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {{300, 0, 30}, absPtAxis}}); + hGenCandidates = qaRegistry.add("hGenCandidates", "hGenCandidates;Counts;Gen #it{p}_{T} (GeV/#it{c})", {HistType::kTH2F, {{NMatchedDecays, -0.5, static_cast(NMatchedDecays) - 0.5}, absPtAxis}}); hGenCandidates->GetXaxis()->SetBinLabel(1, "#Sigma^{-} #rightarrow n#pi^{-}"); hGenCandidates->GetXaxis()->SetBinLabel(2, "#Sigma^{+} #rightarrow n#pi^{+}"); hGenCandidates->GetXaxis()->SetBinLabel(3, "#Sigma^{+} #rightarrow p#pi^{0}"); - hRecPtKinkAngle[SigmaMinusToPiMinusNeutron] = qaRegistry.add("hRecPtKinkAngleSigmaMinusToPiMinusNeutron", "Rec Pt vs KinkAngle #Sigma^{-} #rightarrow #pi^{-}n;Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); - hRecPtKinkAngle[SigmaPlusToPiPlusNeutron] = qaRegistry.add("hRecPtKinkAngleSigmaPlusToPiPlusNeutron", "Rec Pt vs KinkAngle #Sigma^{+} #rightarrow #pi^{+}n;Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); - hRecPtKinkAngle[SigmaPlusToProtonPi0] = qaRegistry.add("hRecPtKinkAngleSigmaPlusToProtonPi0", "Rec Pt vs KinkAngle #Sigma^{+} #rightarrow p#pi^{0};Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); - hGenPtKinkAngle[SigmaMinusToPiMinusNeutron] = qaRegistry.add("hGenPtKinkAngleSigmaMinusToPiMinusNeutron", "Gen Pt vs KinkAngle #Sigma^{-} #rightarrow #pi^{-}n;Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); - hGenPtKinkAngle[SigmaPlusToPiPlusNeutron] = qaRegistry.add("hGenPtKinkAngleSigmaPlusToPiPlusNeutron", "Gen Pt vs KinkAngle #Sigma^{+} #rightarrow #pi^{+}n;Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); - hGenPtKinkAngle[SigmaPlusToProtonPi0] = qaRegistry.add("hGenPtKinkAngleSigmaPlusToProtonPi0", "Gen Pt vs KinkAngle #Sigma^{+} #rightarrow p#pi^{0};Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); + hRecPtKinkAngle[SigmaMinusToPiMinusNeutron] = qaRegistry.add("hRecPtKinkAngleSigmaMinusToPi", "Rec Pt vs KinkAngle #Sigma^{-} #rightarrow #pi^{-}n;Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); + hRecPtKinkAngle[SigmaPlusToPiPlusNeutron] = qaRegistry.add("hRecPtKinkAngleSigmaPlusToPi", "Rec Pt vs KinkAngle #Sigma^{+} #rightarrow #pi^{+}n;Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); + hRecPtKinkAngle[SigmaPlusToProtonPi0] = qaRegistry.add("hRecPtKinkAngleSigmaPlusToPr", "Rec Pt vs KinkAngle #Sigma^{+} #rightarrow p#pi^{0};Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); + hGenPtKinkAngle[SigmaMinusToPiMinusNeutron] = qaRegistry.add("hGenPtKinkAngleSigmaMinusToPi", "Gen Pt vs KinkAngle #Sigma^{-} #rightarrow #pi^{-}n;Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); + hGenPtKinkAngle[SigmaPlusToPiPlusNeutron] = qaRegistry.add("hGenPtKinkAngleSigmaPlusToPi", "Gen Pt vs KinkAngle #Sigma^{+} #rightarrow #pi^{+}n;Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); + hGenPtKinkAngle[SigmaPlusToProtonPi0] = qaRegistry.add("hGenPtKinkAngleSigmaPlusToPr", "Gen Pt vs KinkAngle #Sigma^{+} #rightarrow p#pi^{0};Counts;", {HistType::kTH2F, {absPtAxis, kinkAngleAxis}}); } } @@ -402,12 +411,14 @@ struct kinkBuilder { return false; hSelMotherQA->Fill(4.f, isPositive); - h2ItsClsMothBeforeSel->Fill(candidate.itsNCls(), candidate.itsNClsInnerBarrel()); - if (candidate.itsNCls() >= nItsTotalLayers - 1) + int itsTotCls = static_cast(candidate.itsNCls()); + int itsIBCls = static_cast(candidate.itsNClsInnerBarrel()); + h2ItsClsMothBeforeSel->Fill(itsTotCls, itsIBCls); + if (itsTotCls >= nItsTotalLayers - 1) return false; hSelMotherQA->Fill(5.f, isPositive); - if (candidate.itsNClsInnerBarrel() != nItsInnerBarrelLayers) + if (itsIBCls != nItsInnerBarrelLayers) return false; hSelMotherQA->Fill(6.f, isPositive); @@ -440,8 +451,10 @@ struct kinkBuilder { return false; hSelDaugQA->Fill(3.f, isPositive); - h2ItsClsDaugBeforeSel->Fill(candidate.itsNCls(), candidate.itsNClsInnerBarrel()); - if (candidate.itsNClsInnerBarrel() != 0) + int itsTotCls = static_cast(candidate.itsNCls()); + int itsIBCls = static_cast(candidate.itsNClsInnerBarrel()); + h2ItsClsDaugBeforeSel->Fill(itsTotCls, itsIBCls); + if (itsIBCls != 0) return false; hSelDaugQA->Fill(4.f, isPositive); @@ -649,7 +662,7 @@ struct kinkBuilder { LOG(info) << "Task initialized for run " << mRunNumber << " with magnetic field " << mBz << " kZG"; } - template + template void buildSvPool(const TColls& collisions, const TTracks& tracks, const TAmbiTracks& ambiguousTracks, const aod::BCs& bcs) { svCreator.clearPools(); @@ -660,8 +673,38 @@ struct kinkBuilder { continue; } - bool isDaug = selectDaugTrack(track); - bool isMoth = selectMothTrack(track); + bool canBeMoth = true; + bool canBeDaug = true; + + if constexpr (isMC) { + if (!track.has_mcParticle()) { + LOG(debug) << "Track has no MC particle"; + canBeMoth = false; + canBeDaug = false; + continue; + } + auto genPart = track.template mcParticle_as(); + + canBeMoth = std::find( + mothMatchPdgCodes.begin(), + mothMatchPdgCodes.end(), + std::abs(genPart.pdgCode())) != mothMatchPdgCodes.end(); + + canBeDaug = false; + for (auto mother : genPart.template mothers_as()) { + if (std::find( + mothMatchPdgCodes.begin(), + mothMatchPdgCodes.end(), + std::abs(mother.pdgCode())) != mothMatchPdgCodes.end()) { + canBeDaug = true; + break; + } + } + } + + bool isMoth = canBeMoth && selectMothTrack(track); + bool isDaug = canBeDaug && selectDaugTrack(track); + if (!isDaug && !isMoth) { continue; } @@ -675,7 +718,7 @@ struct kinkBuilder { { kinkCandidates.clear(); - buildSvPool(collisions, tracks, ambiTracks, bcs); + buildSvPool(collisions, tracks, ambiTracks, bcs); auto& kinkPool = svCreator.getSVCandPool(collisions, !unlikeSignBkg); bool isAccepted = false; for (const auto& svCand : kinkPool) { @@ -762,7 +805,12 @@ struct kinkBuilder { { kinkCandidates.clear(); - buildSvPool(mcRecoCollisions, tracksMc, ambiTracksMc, bcs); + if (skipBkgCands) { + buildSvPool(mcRecoCollisions, tracksMc, ambiTracksMc, bcs); + } else { + buildSvPool(mcRecoCollisions, tracksMc, ambiTracksMc, bcs); + } + auto& kinkPool = svCreator.getSVCandPool(mcRecoCollisions, !unlikeSignBkg); for (const auto& svCand : kinkPool) { // Perform matching of the kink candidate @@ -787,7 +835,9 @@ struct kinkBuilder { if (decayChannel < 0) { continue; // Skip candidates that do not match the decay channels of interest } - hRecCandidates->Fill(decayChannel, trackMoth.pt()); // Decay channel match bin + hRecCandidatesRecoPt->Fill(decayChannel, trackMoth.pt()); // Decay channel match bin + hRecCandidatesGenPt->Fill(decayChannel, genMothPart.pt()); // Decay channel match bin + hRecCandidatesDeltaPt->Fill((trackMoth.pt() - genMothPart.pt()) / genMothPart.pt(), genMothPart.pt()); // Decay channel match bin } bool isAccepted = false; buildKinkCand(svCand, tracksMc, isAccepted, mcRecoCollisions); @@ -831,6 +881,7 @@ struct kinkBuilder { auto daughI = mcParticles.rawIteratorAt(arrDaughIdxs[iProng]); if (std::abs(daughI.pdgCode()) == PDG_t::kPiPlus || std::abs(daughI.pdgCode()) == PDG_t::kProton) { hGenPtKinkAngle[decayChannel]->Fill(mcPart.pt(), std::abs(mcPart.phi() - daughI.phi()) * radToDeg); + hGenDecayRadius->Fill(std::hypot(daughI.vx(), daughI.vy()), mcPart.pt()); } } } diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index 70faab3295e..500c27f8046 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -77,26 +77,32 @@ struct lambda1405candidate { float sigmaPt = -1; // pT of the Sigma daughter float sigmaAlphaAP = -1; // Alpha of the Sigma float sigmaQtAP = -1; // qT of the Sigma + float sigmaRadius = -1; // Radius of the Sigma decay vertex + float dcaSigmaToPv = -1; // DCA of the Sigma candidate to the primary vertex float kinkPt = -1; // pT of the kink daughter float kinkPiNSigTpc = -1; // Number of sigmas for the pion candidate from Sigma kink in Tpc float kinkPiNSigTof = -1; // Number of sigmas for the pion candidate from Sigma kink in Tof float kinkPrNSigTpc = -1; // Number of sigmas for the proton candidate from Sigma kink in Tpc float kinkPrNSigTof = -1; // Number of sigmas for the proton candidate from Sigma kink in Tof float kinkDcaDauToPv = -1; // DCA of the kink daughter to the primary vertex - float sigmaRadius = -1; // Radius of the Sigma decay vertex - float piPt = -1; // pT of the pion daughter + float bachPiPt = -1; // pT of the pion daughter float bachPiNSigTpc = -1; // Number of sigmas for the pion candidate float bachPiNSigTof = -1; // Number of sigmas for the pion candidate using Tof int kinkDauId = 0; // Id of the pion from Sigma decay in MC int sigmaId = 0; // Id of the Sigma candidate in MC - int piId = 0; // Id of the pion candidate in MC + int bachPiId = 0; // Id of the pion candidate in MC + + float cent = -1; // Centrality of the collision + float pvContrib = -1; // Number of contributors to the primary vertex float scalarProd = -1; // Scalar product for flow analysis }; struct lambda1405analysis { int lambda1405PdgCode = 102132; // PDG code for Lambda(1405) + int sigmaMinusPdgCode = 3112; // PDG code for Lambda(1405) + int sigmaPlusPdgCode = 3222; // PDG code for Lambda(1405) 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 @@ -112,6 +118,7 @@ struct lambda1405analysis { 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)"}; @@ -146,8 +153,11 @@ struct lambda1405analysis { Filter filterCentrality = aod::cent::centFT0C >= centralityMin && aod::cent::centFT0C <= centralityMax; + PresliceUnsorted colPerMcCollision = aod::mccollisionlabel::mcCollisionId; + // Configurable axes - ConfigurableAxis axisCent{"axisCent", {10000, 0., 100.}, ""}; + ConfigurableAxis axisPvContrib{"axisPvContrib", {5000, 0., 5000.}, ""}; + ConfigurableAxis axisCent{"axisCent", {100, 0., 100.}, ""}; ConfigurableAxis axisPtL1405{"axisPtL1405", {100, 0., 10.}, ""}; ConfigurableAxis axisPCompsL1405{"axisPCompsL1405", {100, -10., 10.}, ""}; ConfigurableAxis axisPtKinkDaug{"axisPtKinkDaug", {100, 0., 10.}, ""}; @@ -176,48 +186,49 @@ struct lambda1405analysis { const AxisSpec pCompAxisL1405{axisPCompsL1405, "#it{p}_{comp} (GeV/#it{c})"}; const AxisSpec ptKinkDaugAxis{axisPtKinkDaug, "#it{p}_{T}^{#pi} (GeV/#it{c})"}; const AxisSpec ptResolutionAxis{axisPtResolution, "#it{p}_{T}^{rec} - #it{p}_{T}^{gen} (GeV/#it{c})"}; - const AxisSpec lambda1405MassAxis{axisMassL1405, "m (GeV/#it{c}^{2})"}; - const AxisSpec xi1530MassAxis{axisXi1530Mass, "m (GeV/#it{c}^{2})"}; + const AxisSpec lambda1405MassAxis{axisMassL1405, "m(#Sigma#pi) (GeV/#it{c}^{2})"}; + const AxisSpec xi1530MassAxis{axisXi1530Mass, "m(#Xi#pi) (GeV/#it{c}^{2})"}; const AxisSpec massResolutionAxis{axisMassResolution, "m_{rec} - m_{gen} (GeV/#it{c}^{2})"}; const AxisSpec nSigmaAxis{axisNSig, "n#sigma_{#pi}"}; - const AxisSpec sigmaMassAxis{axisSigmaMass, "m (GeV/#it{c}^{2})"}; - const AxisSpec xiMassAxis{axisXiMass, "m (GeV/#it{c}^{2})"}; - const AxisSpec vertexZAxis{axisVertexZ, "vrtx_{Z} [cm]"}; + const AxisSpec sigmaMassAxis{axisSigmaMass, "m(#Sigma) (GeV/#it{c}^{2})"}; + const AxisSpec xiMassAxis{axisXiMass, "m(#Xi) (GeV/#it{c}^{2})"}; + const AxisSpec vertexZAxis{axisVertexZ, "vtx_{Z} (cm)"}; const AxisSpec qtAxis{axisQtAP, "q_{T, AP}"}; const AxisSpec alphaAxis{axisAlphaAP, "#alpha_{AP}"}; - const AxisSpec sigmaRadiusAxis{axisSigmaRadius, "#Sigma radius (cm)"}; - const AxisSpec centAxis{axisCent, "Centrality"}; - const AxisSpec dcaSigmaToPvBinsAxis{axisDcaSigmaToPv, "DCA of mother to Pv"}; - const AxisSpec dcaKinkToPvBinsAxis{axisDcaKinkToPv, "DCA of kink to Pv"}; + const AxisSpec sigmaRadiusAxis{axisSigmaRadius, "Dec. radius #Sigma (cm)"}; + const AxisSpec centAxis{axisCent, "Centrality (%)"}; + const AxisSpec pvContribAxis{axisPvContrib, "PV Contributors"}; + const AxisSpec dcaSigmaToPvBinsAxis{axisDcaSigmaToPv, "#Sigma DCA to PV (cm)"}; + const AxisSpec dcaKinkToPvBinsAxis{axisDcaKinkToPv, "Kink daug. DCA to PV (cm)"}; const AxisSpec scalarProdAxis{axisScalarProd, "SP"}; rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}}); // Sigma- candidate properties - rSigmaMinus.add("hSigmaMinusPt", "hSigmaMinusPt", {HistType::kTH1D, {ptAxis}}); rSigmaMinus.add("hMassXiMinusSigmaMinus", "hMassXiMinusSigmaMinus", {HistType::kTH2F, {xiMassAxis, sigmaMassAxis}}); rSigmaMinus.add("h2PtMassSigmaMinusBeforeCuts", "h2PtMassSigmaMinusBeforeCuts", {HistType::kTH2F, {ptAxis, sigmaMassAxis}}); rSigmaMinus.add("h2PtPiKinkNSigBeforeCutsSigmaMinus", "h2PtPiKinkNSigBeforeCutsSigmaMinus", {HistType::kTH2F, {ptAxis, nSigmaAxis}}); rSigmaMinus.add("h2dPtMassSigmaMinus", "h2dPtMassSigmaMinus", {HistType::kTH2F, {ptAxis, sigmaMassAxis}}); + rSigmaMinus.add("h2dPvContribMassSigmaMinus", "h2dPvContribMassSigmaMinus", {HistType::kTH2F, {pvContribAxis, sigmaMassAxis}}); + rSigmaMinus.add("h2dPvContribPtSigmaMinus", "h2dPvContribPtSigmaMinus", {HistType::kTH2F, {pvContribAxis, ptAxis}}); rSigmaMinus.add("h2KinkPiPtNSigTofSigmaMinus", "h2KinkPiPtNSigTofSigmaMinus", {HistType::kTH2F, {ptKinkDaugAxis, nSigmaAxis}}); rSigmaMinus.add("hSigmaMinusArmPod", "hSigmaMinusArmPod", {HistType::kTH2D, {alphaAxis, qtAxis}}); rSigmaMinus.add("hSigmaMinusRadius", "hSigmaMinusRadius", {HistType::kTH2F, {sigmaRadiusAxis, ptAxis}}); rSigmaMinus.add("hSigmaMinusDcaToPv", "hSigmaMinusDcaToPv", {HistType::kTH2F, {dcaSigmaToPvBinsAxis, ptAxis}}); - rSigmaMinus.add("hSigmaMinusKinkPt", "hSigmaMinusKinkPt", {HistType::kTH1D, {ptKinkDaugAxis}}); rSigmaMinus.add("hSigmaMinusKinkTpcNSigPi", "hSigmaMinusKinkTpcNSigPi", {HistType::kTH2F, {nSigmaAxis, ptKinkDaugAxis}}); rSigmaMinus.add("hSigmaMinusKinkTofNSigPi", "hSigmaMinusKinkTofNSigPi", {HistType::kTH2F, {nSigmaAxis, ptKinkDaugAxis}}); rSigmaMinus.add("hSigmaMinusDcaKinkDauToPv", "hSigmaMinusDcaKinkDauToPv", {HistType::kTH2F, {dcaKinkToPvBinsAxis, ptAxis}}); // Sigma+ candidate properties - rSigmaPlus.add("hSigmaPlusPt", "hSigmaPlusPt", {HistType::kTH1D, {ptAxis}}); rSigmaPlus.add("h2PtMassSigmaPlusBeforeCuts", "h2PtMassSigmaPlusBeforeCuts", {HistType::kTH2F, {ptAxis, sigmaMassAxis}}); - rSigmaPlus.add("h2PtPrKinkNSigBeforeCutsSigmaPlus", "h2PtPrKinkNSigBeforeCutsSigmaPlus", {HistType::kTH2F, {ptAxis, nSigmaAxis}}); + rSigmaPlus.add("h2PtPrKinkNSigBeforeCuts", "h2PtPrKinkNSigBeforeCuts", {HistType::kTH2F, {ptAxis, nSigmaAxis}}); rSigmaPlus.add("h2dPtMassSigmaPlus", "h2dPtMassSigmaPlus", {HistType::kTH2F, {ptAxis, sigmaMassAxis}}); + rSigmaPlus.add("h2dPvContribMassSigmaPlus", "h2dPvContribMassSigmaPlus", {HistType::kTH2F, {pvContribAxis, sigmaMassAxis}}); + rSigmaPlus.add("h2dPvContribPtSigmaPlus", "h2dPvContribPtSigmaPlus", {HistType::kTH2F, {pvContribAxis, ptAxis}}); rSigmaPlus.add("h2KinkPrPtNSigTofSigmaPlus", "h2KinkPrPtNSigTofSigmaPlus", {HistType::kTH2F, {ptKinkDaugAxis, nSigmaAxis}}); rSigmaPlus.add("hSigmaPlusArmPod", "hSigmaPlusArmPod", {HistType::kTH2F, {alphaAxis, qtAxis}}); rSigmaPlus.add("hSigmaPlusRadius", "hSigmaPlusRadius", {HistType::kTH2F, {sigmaRadiusAxis, ptAxis}}); rSigmaPlus.add("hSigmaPlusDcaToPv", "hSigmaPlusDcaToPv", {HistType::kTH2F, {dcaSigmaToPvBinsAxis, ptAxis}}); - rSigmaPlus.add("hSigmaPlusKinkPt", "hSigmaPlusKinkPt", {HistType::kTH1D, {ptKinkDaugAxis}}); rSigmaPlus.add("hSigmaPlusKinkTpcNSigPr", "hSigmaPlusKinkTpcNSigPr", {HistType::kTH2F, {nSigmaAxis, ptKinkDaugAxis}}); rSigmaPlus.add("hSigmaPlusKinkTofNSigPr", "hSigmaPlusKinkTofNSigPr", {HistType::kTH2F, {nSigmaAxis, ptKinkDaugAxis}}); rSigmaPlus.add("hSigmaPlusDcaKinkDauToPv", "hSigmaPlusDcaKinkDauToPv", {HistType::kTH2F, {dcaKinkToPvBinsAxis, ptKinkDaugAxis}}); @@ -235,19 +246,27 @@ struct lambda1405analysis { rLambda1405.add("hPt", "hPt", {HistType::kTH1D, {ptAxis}}); rLambda1405.add("hPhi", "hPhi", {HistType::kTH1D, {{128, -o2::constants::math::PI, o2::constants::math::PI}}}); // Pion daughter properties - rLambda1405.add("hBachPiPt", "hBachPiPt", {HistType::kTH1D, {ptKinkDaugAxis}}); rLambda1405.add("h2BachPiPtNSigTof", "h2BachPiPtNSigTof", {HistType::kTH2F, {ptKinkDaugAxis, nSigmaAxis}}); rLambda1405.add("h2BachPiPtNSigTpc", "h2BachPiPtNSigTpc", {HistType::kTH2F, {ptKinkDaugAxis, nSigmaAxis}}); + // Sparse histogram + std::vector axes = {lambda1405MassAxis, ptAxis, sigmaMassAxis, alphaAxis, qtAxis, dcaSigmaToPvBinsAxis, dcaKinkToPvBinsAxis}; + if (doprocessDataWCentQVecs) { + axes.push_back(centAxis); + axes.push_back(scalarProdAxis); + } + if (doprocessMc || doprocessMcWCentSel) { + axes.push_back(pvContribAxis); + } + rLambda1405.add("hSparseL1405", "THn for SP", HistType::kTHnSparseF, axes); // Selection QA - rSelections.add("hSelectionsL1405", "hSelectionsL1405", {HistType::kTH1D, {{7, -0.f, 6.5f}}}); + rSelections.add("hSelectionsL1405", "hSelectionsL1405", {HistType::kTH1D, {{6, -0.f, 5.5f}}}); rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(1, "All"); rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(2, "Passed Sigma sel"); rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(3, "Passed Bach PID sel"); rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(4, "Upper mass sel"); - rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(5, "Correl. #Sigma #it{p}_{T} sel"); - rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(6, "Correl. bach. #pi #it{p}_{T} sel"); - rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(7, "Accepted"); + rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(5, "#it{p}_{T} Correl"); + rSelections.get(HIST("hSelectionsL1405"))->GetXaxis()->SetBinLabel(6, "Accepted"); rSelections.add("hSelectionsSigmaPlus", "hSelectionsSigmaPlus", {HistType::kTH1D, {{7, -0.f, 6.5f}}}); rSelections.get(HIST("hSelectionsSigmaPlus"))->GetXaxis()->SetBinLabel(1, "All"); rSelections.get(HIST("hSelectionsSigmaPlus"))->GetXaxis()->SetBinLabel(2, "Passed kink sel"); @@ -295,29 +314,32 @@ struct lambda1405analysis { } if (doprocessMc || doprocessMcWCentSel) { - // Add MC histograms if needed, to sigmaminus - rLambda1405.add("hRecoL1405", "hRecoL1405;;Counts", {HistType::kTH2F, {{6, -0.5, 5.5}, ptAxis}}); - rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(1, "Reconstructed #Lambda(1405)"); - rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(2, "Has MC particle"); - rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(3, "Has #Sigma daug"); - rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(4, "Has bach #pi"); - rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(5, "Has mothers"); - rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(6, "Has same mother"); + // Add MC histograms + rSigmaPlus.add("h2GenSigmaPlusPvContribPt", "h2GenSigmaPlusPvContribPt", {HistType::kTH2F, {pvContribAxis, ptAxis}}); + rSigmaMinus.add("h2GenSigmaMinusPvContribPt", "h2GenSigmaMinusPvContribPt", {HistType::kTH2F, {pvContribAxis, ptAxis}}); + + rLambda1405.add("hRecoL1405", "hRecoL1405;;Counts", {HistType::kTH2F, {{4, -0.5, 3.5}, ptAxis}}); + rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(1, "Reco #Lambda(1405)"); + rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(2, "Has bach #pi"); + rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(3, "Has mothers"); + rLambda1405.get(HIST("hRecoL1405"))->GetXaxis()->SetBinLabel(4, "Matched"); rLambda1405.add("hGenL1405", "hGenL1405;;Counts", {HistType::kTH2F, {{3, -0.5, 2.5}, ptAxis}}); rLambda1405.get(HIST("hGenL1405"))->GetXaxis()->SetBinLabel(1, "#Lambda(1405) #rightarrow #Sigma^{-} #pi^{+} #rightarrow n #pi^{-} #pi^{+}"); rLambda1405.get(HIST("hGenL1405"))->GetXaxis()->SetBinLabel(2, "#Lambda(1405) #rightarrow #Sigma^{+} #pi^{-} #rightarrow n #pi^{+} #pi^{-}"); rLambda1405.get(HIST("hGenL1405"))->GetXaxis()->SetBinLabel(3, "#Lambda(1405) #rightarrow #Sigma^{+} #pi^{-} #rightarrow p #pi^{0} #pi^{-}"); + rLambda1405.add("h2GenL1405PvContribPt", "h2GenL1405PvContribPt", {HistType::kTH2F, {pvContribAxis, ptAxis}}); + rLambda1405.add("h2RecL1405PvContribPt", "h2RecL1405PvContribPt", {HistType::kTH2F, {pvContribAxis, ptAxis}}); rLambda1405.add("h2GenSigmaMinusArmPod", "h2GenSigmaMinusArmPod", {HistType::kTH2F, {alphaAxis, qtAxis}}); rLambda1405.add("h2GenSigmaPlusArmPod", "h2GenSigmaPlusArmPod", {HistType::kTH2F, {alphaAxis, qtAxis}}); - rLambda1405.add("h2GenPtVsBachPtSigmaMinusPiToPiPiNeutron", "h2GenPtVsBachPtSigmaMinusPiToPiPiNeutron;#Lambda(1405) #it{p}_{T} (GeV/c); Bach #pi #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); - rLambda1405.add("h2GenPtVsBachPtSigmaPlusPiToPiPiN", "h2GenPtVsBachPtSigmaPlusPiToPiPiN;#Lambda(1405) #it{p}_{T} (GeV/c); Bach #pi #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); - rLambda1405.add("h2GenPtVsBachPtSigmaPlusPiToPiPiP", "h2GenPtVsBachPtSigmaPlusPiToPiPiP;#Lambda(1405) #it{p}_{T} (GeV/c); Bach #pi #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); - rLambda1405.add("h2GenPtVsSigmaPtSigmaMinusPiToPiPiNeutron", "h2GenPtVsBachPtSigmaMinusPiToPiPiNeutron;#Lambda(1405) #it{p}_{T} (GeV/c); #Sigma #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); - rLambda1405.add("h2GenPtVsSigmaPtSigmaPlusPiToPiPiN", "h2GenPtVsBachPtSigmaPlusPiToPiPiN;#Lambda(1405) #it{p}_{T} (GeV/c); #Sigma #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); - rLambda1405.add("h2GenPtVsSigmaPtSigmaPlusPiToPiPiP", "h2GenPtVsBachPtSigmaPlusPiToPiPiP;#Lambda(1405) #it{p}_{T} (GeV/c); #Sigma #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); - rLambda1405.add("h2GenSigmaPtVsKinkPtSigmaMinusPiToPiPiNeutron", "h2GenSigmaPtVsKinkPtSigmaMinusPiToPiPiNeutron;#Sigma #it{p}_{T} (GeV/c); Kink #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); - rLambda1405.add("h2GenSigmaPtVsKinkPtSigmaPlusPiToPiPiN", "h2GenSigmaPtVsKinkPtSigmaPlusPiTo Pi PiNeutron;#Sigma #it{p}_{T} (GeV/c); Kink #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); - rLambda1405.add("h2GenSigmaPtVsKinkPtSigmaPlusPiToPiPiP", "h2GenSigmaPtVsKinkPtSigmaPlusPiToPiPiP;#Sigma #it{p}_{T} (GeV/c); Kink #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenPtVsBachPtSigmaMinus", "h2GenPtVsBachPtSigmaMinus;#Lambda(1405) #it{p}_{T} (GeV/c); Bach #pi #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenPtVsBachPtSigmaPlusToPi", "h2GenPtVsBachPtSigmaPlusToPi;#Lambda(1405) #it{p}_{T} (GeV/c); Bach #pi #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenPtVsBachPtSigmaPlusToPr", "h2GenPtVsBachPtSigmaPlusToPr;#Lambda(1405) #it{p}_{T} (GeV/c); Bach #pi #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenPtVsSigmaMinusPt", "h2GenPtVsBachPtSigmaMinus;#Lambda(1405) #it{p}_{T} (GeV/c); #Sigma #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenPtVsSigmaPlusToPiPt", "h2GenPtVsBachPtSigmaPlusToPi;#Lambda(1405) #it{p}_{T} (GeV/c); #Sigma #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenPtVsSigmaPlusToPrPt", "h2GenPtVsBachPtSigmaPlusToPr;#Lambda(1405) #it{p}_{T} (GeV/c); #Sigma #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenSigmaPtVsKinkPtSigmaMinus", "h2GenSigmaPtVsKinkPtSigmaMinus;#Sigma #it{p}_{T} (GeV/c); Kink #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenSigmaPtVsPiKinkPt", "h2GenSigmaPtVsPiKinkPt;#Sigma #it{p}_{T} (GeV/c); Kink #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); + rLambda1405.add("h2GenSigmaPtVsPrKinkPt", "h2GenSigmaPtVsPrKinkPt;#Sigma #it{p}_{T} (GeV/c); Kink #it{p}_{T} (GeV/c)", {HistType::kTH2F, {ptAxis, ptAxis}}); rLambda1405.add("h2MassResolutionFromSigmaMinus", "h2MassResolutionFromSigmaMinus", {HistType::kTH2F, {lambda1405MassAxis, massResolutionAxis}}); rLambda1405.add("h2PtResolutionFromSigmaMinus", "h2PtResolutionFromSigmaMinus", {HistType::kTH2F, {ptAxis, ptResolutionAxis}}); rLambda1405.add("h2MassResolutionFromSigmaPlus", "h2MassResolutionFromSigmaPlus", {HistType::kTH2F, {lambda1405MassAxis, massResolutionAxis}}); @@ -338,6 +360,11 @@ struct lambda1405analysis { 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())); + + rSelections.print(); + rSigmaMinus.print(); + rSigmaPlus.print(); + rLambda1405.print(); } float alphaAP(const std::array& momMother, const std::array& momKink) @@ -459,35 +486,35 @@ struct lambda1405analysis { if (lambda1405Cand.isSigmaPlus) { rSigmaPlus.fill(HIST("h2dPtMassSigmaPlus"), sigmaCand.ptMoth(), sigmaCand.mSigmaPlus()); + rSigmaPlus.fill(HIST("h2dPvContribMassSigmaPlus"), lambda1405Cand.pvContrib, sigmaCand.mSigmaPlus()); + rSigmaPlus.fill(HIST("h2dPvContribPtSigmaPlus"), lambda1405Cand.pvContrib, sigmaCand.ptMoth()); rSigmaPlus.fill(HIST("hMassXiMinusSigmaPlus"), sigmaCand.mXiMinus(), sigmaCand.mSigmaPlus()); rSigmaPlus.fill(HIST("hSigmaPlusArmPod"), lambda1405Cand.sigmaAlphaAP, lambda1405Cand.sigmaQtAP); - rSigmaPlus.fill(HIST("hSigmaPlusPt"), sigmaCand.ptMoth()); rSigmaPlus.fill(HIST("hSigmaPlusRadius"), lambda1405Cand.sigmaRadius, sigmaCand.ptMoth()); rSigmaPlus.fill(HIST("hSigmaPlusDcaToPv"), sigmaCand.dcaMothPv(), sigmaCand.ptMoth()); rSigmaPlus.fill(HIST("hSigmaPlusDcaKinkDauToPv"), sigmaCand.dcaDaugPv(), sigmaCand.ptMoth()); rSigmaPlus.fill(HIST("h2KinkPrPtNSigTofSigmaPlus"), lambda1405Cand.kinkPt, lambda1405Cand.kinkPrNSigTof); // Fill QA histos for kink daughter - rSigmaPlus.fill(HIST("hSigmaPlusKinkPt"), kinkDauTrack.pt()); rSigmaPlus.fill(HIST("hSigmaPlusKinkTpcNSigPr"), kinkDauTrack.tpcNSigmaPr(), kinkDauTrack.pt()); rSigmaPlus.fill(HIST("hSigmaPlusKinkTofNSigPr"), kinkDauTrack.tofNSigmaPr(), kinkDauTrack.pt()); } else { rSigmaMinus.fill(HIST("h2dPtMassSigmaMinus"), sigmaCand.ptMoth(), sigmaCand.mSigmaMinus()); + rSigmaMinus.fill(HIST("h2dPvContribMassSigmaMinus"), lambda1405Cand.pvContrib, sigmaCand.mSigmaMinus()); + rSigmaMinus.fill(HIST("h2dPvContribPtSigmaMinus"), lambda1405Cand.pvContrib, sigmaCand.ptMoth()); rSigmaMinus.fill(HIST("hMassXiMinusSigmaMinus"), sigmaCand.mXiMinus(), sigmaCand.mSigmaMinus()); rSigmaMinus.fill(HIST("hSigmaMinusArmPod"), lambda1405Cand.sigmaAlphaAP, lambda1405Cand.sigmaQtAP); - rSigmaMinus.fill(HIST("hSigmaMinusPt"), sigmaCand.ptMoth()); rSigmaMinus.fill(HIST("hSigmaMinusRadius"), lambda1405Cand.sigmaRadius, sigmaCand.ptMoth()); rSigmaMinus.fill(HIST("hSigmaMinusDcaToPv"), sigmaCand.dcaMothPv(), sigmaCand.ptMoth()); rSigmaMinus.fill(HIST("hSigmaMinusDcaKinkDauToPv"), sigmaCand.dcaDaugPv(), sigmaCand.ptMoth()); rSigmaMinus.fill(HIST("h2KinkPiPtNSigTofSigmaMinus"), lambda1405Cand.kinkPt, lambda1405Cand.kinkPiNSigTof); // Fill QA histos for kink daughter - rSigmaMinus.fill(HIST("hSigmaMinusKinkPt"), kinkDauTrack.pt()); rSigmaMinus.fill(HIST("hSigmaMinusKinkTpcNSigPi"), kinkDauTrack.tpcNSigmaPi(), kinkDauTrack.pt()); rSigmaMinus.fill(HIST("hSigmaMinusKinkTofNSigPi"), kinkDauTrack.tofNSigmaPi(), kinkDauTrack.pt()); } } - template - void fillHistosLambda1405(const lambda1405candidate& cand, const TTrack& piTrack) + template + void fillHistosLambda1405(const lambda1405candidate& cand) { // Fill QA histos for Lambda(1405) candidate @@ -500,12 +527,24 @@ struct lambda1405analysis { rLambda1405.fill(HIST("hPhi"), cand.phi); // Bachelor Pi - rLambda1405.fill(HIST("hBachPiPt"), piTrack.pt()); - rLambda1405.fill(HIST("h2BachPiPtNSigTpc"), piTrack.pt(), piTrack.tpcNSigmaPi()); - rLambda1405.fill(HIST("h2BachPiPtNSigTof"), piTrack.pt(), piTrack.tofNSigmaPi()); + rLambda1405.fill(HIST("h2BachPiPtNSigTpc"), cand.bachPiPt, cand.bachPiNSigTpc); + rLambda1405.fill(HIST("h2BachPiPtNSigTof"), cand.bachPiPt, cand.bachPiNSigTof); + + // Fill sparse histo + std::vector sparseEntry = {cand.massL1405, cand.pt(), cand.sigmaMinusMass, cand.sigmaAlphaAP, cand.sigmaQtAP, cand.dcaSigmaToPv, cand.kinkDcaDauToPv}; + if constexpr (IsMC) { + sparseEntry.push_back(cand.pvContrib); + } + if (doprocessDataWCentQVecs) { + sparseEntry.push_back(cand.cent); + sparseEntry.push_back(cand.scalarProd); + } + auto hSparse = rLambda1405.get(HIST("hSparseL1405")); + hSparse->Fill(sparseEntry.data()); } - void constructCollCandidates(aod::KinkCands::iterator const& sigmaCand, TracksFull const& tracks, std::vector& selectedCandidates) + template + void constructCollCandidates(const TColl& collision, aod::KinkCands::iterator const& sigmaCand, TracksFull const& tracks, std::vector& selectedCandidates) { lambda1405candidate lambda1405Cand{}; @@ -514,7 +553,7 @@ struct lambda1405analysis { rSelections.fill(HIST("hSelectionsSigmaMinus"), 0); // All Sigma- candidates rSelections.fill(HIST("hSelectionsSigmaPlus"), 0); // All Sigma+ candidates - auto kinkDauTrack = sigmaCand.trackDaug_as(); + auto kinkDauTrack = sigmaCand.template trackDaug_as(); bool isPiKink = selectPiKink(kinkDauTrack); bool isPrKink = selectPrKink(kinkDauTrack); if (!isPiKink && !isPrKink) { @@ -538,7 +577,7 @@ struct lambda1405analysis { } if (lambda1405Cand.isSigmaPlus) { rSigmaPlus.fill(HIST("h2PtMassSigmaPlusBeforeCuts"), sigmaCand.ptMoth(), sigmaCand.mSigmaPlus()); - rSigmaPlus.fill(HIST("h2PtPrKinkNSigBeforeCutsSigmaPlus"), kinkDauTrack.pt(), kinkDauTrack.tpcNSigmaPr()); + rSigmaPlus.fill(HIST("h2PtPrKinkNSigBeforeCuts"), kinkDauTrack.pt(), kinkDauTrack.tpcNSigmaPr()); } if (lambda1405Cand.isSigmaMinus && (sigmaCand.mSigmaMinus() < o2::constants::physics::MassSigmaMinus - cutSigmaMass || @@ -584,18 +623,18 @@ struct lambda1405analysis { } auto kinkDauMom = std::array{sigmaCand.pxDaug(), sigmaCand.pyDaug(), sigmaCand.pzDaug()}; - auto sigmaMom = std::array{sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth()}; + auto sigmaMom = std::array{sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth()}; // Sigma properties - lambda1405Cand.sigmaId = sigmaCand.globalIndex(); + lambda1405Cand.sigmaId = sigmaCand.globalIndex(); lambda1405Cand.sigmaMinusMass = sigmaCand.mSigmaMinus(); - lambda1405Cand.sigmaPlusMass = sigmaCand.mSigmaPlus(); - lambda1405Cand.xiMinusMass = sigmaCand.mXiMinus(); - lambda1405Cand.sigmaSign = sigmaCand.mothSign(); - lambda1405Cand.sigmaAlphaAP = alphaAP(sigmaMom, kinkDauMom); - lambda1405Cand.sigmaQtAP = qtAP(sigmaMom, kinkDauMom); - lambda1405Cand.sigmaPt = sigmaCand.ptMoth(); - lambda1405Cand.sigmaRadius = sigmaRad; - lambda1405Cand.kinkDcaDauToPv = sigmaCand.dcaDaugPv(); + lambda1405Cand.sigmaPlusMass = sigmaCand.mSigmaPlus(); + lambda1405Cand.xiMinusMass = sigmaCand.mXiMinus(); + lambda1405Cand.sigmaSign = sigmaCand.mothSign(); + lambda1405Cand.sigmaAlphaAP = alphaAP(sigmaMom, kinkDauMom); + lambda1405Cand.sigmaQtAP = qtAP(sigmaMom, kinkDauMom); + lambda1405Cand.sigmaPt = sigmaCand.ptMoth(); + lambda1405Cand.sigmaRadius = sigmaRad; + lambda1405Cand.dcaSigmaToPv = sigmaCand.dcaMothPv(); if (lambda1405Cand.sigmaQtAP < funcMinQtAlphaAP.Eval(lambda1405Cand.sigmaAlphaAP) || lambda1405Cand.sigmaQtAP > funcMaxQtAlphaAP.Eval(lambda1405Cand.sigmaAlphaAP)) { @@ -614,10 +653,20 @@ struct lambda1405analysis { lambda1405Cand.kinkPiNSigTof = kinkDauTrack.tofNSigmaPi(); lambda1405Cand.kinkPrNSigTpc = kinkDauTrack.tpcNSigmaPr(); lambda1405Cand.kinkPrNSigTof = kinkDauTrack.tofNSigmaPr(); + lambda1405Cand.kinkDcaDauToPv = sigmaCand.dcaDaugPv(); - fillHistosSigma(lambda1405Cand, sigmaCand, kinkDauTrack); rSelections.fill(HIST("hSelectionsL1405"), 1); // Passed Sigma sel + // Collision properties + lambda1405Cand.pvContrib = collision.numContrib(); + if constexpr ( requires{collision.centFT0C();} ) { + lambda1405Cand.cent = collision.centFT0C(); + } else { + lambda1405Cand.cent = -1; // Not available + } + + fillHistosSigma(lambda1405Cand, sigmaCand, kinkDauTrack); + for (const auto& piTrack : tracks) { rSelections.fill(HIST("hSelectionsBachPi"), 0); // All bachelors @@ -656,8 +705,8 @@ struct lambda1405analysis { rSelections.fill(HIST("hSelectionsL1405"), 3); // Upper mass selection // Daughter Pi properties - lambda1405Cand.piId = piTrack.globalIndex(); - lambda1405Cand.piPt = piTrack.pt(); + lambda1405Cand.bachPiId = piTrack.globalIndex(); + lambda1405Cand.bachPiPt = piTrack.pt(); lambda1405Cand.bachPiNSigTpc = piTrack.tpcNSigmaPi(); if (useTof) { lambda1405Cand.bachPiNSigTof = piTrack.tofNSigmaPi(); @@ -671,24 +720,34 @@ struct lambda1405analysis { lambda1405Cand.px = sigmaMom[0] + piMom[0]; lambda1405Cand.py = sigmaMom[1] + piMom[1]; lambda1405Cand.pz = sigmaMom[2] + piMom[2]; + lambda1405Cand.phi = std::atan2(lambda1405Cand.py, lambda1405Cand.px); lambda1405Cand.scalarProd = -1; + if constexpr (requires { collision.qvecFT0CRe(); }) { + float const xQVec = collision.qvecFT0CRe(); + float const yQVec = collision.qvecFT0CIm(); + float const cos2Phi = std::cos(2 * lambda1405Cand.phi); + float const sin2Phi = std::sin(2 * lambda1405Cand.phi); + lambda1405Cand.scalarProd = cos2Phi * xQVec + sin2Phi * yQVec; + } // Check correlations between transverse momenta of L1405, sigma and bachelor pi if (std::hypot(sigmaCand.pxMoth(), sigmaCand.pyMoth()) < funcMinSigmaPtVsL1405Pt.Eval(lambda1405Cand.pt()) || std::hypot(sigmaCand.pxMoth(), sigmaCand.pyMoth()) > funcMaxSigmaPtVsL1405Pt.Eval(lambda1405Cand.pt())) { continue; } - rSelections.fill(HIST("hSelectionsL1405"), 4); // Accepted - + if (piTrack.pt() < funcMinBachPiPtVsL1405Pt.Eval(lambda1405Cand.pt()) || - piTrack.pt() > funcMaxBachPiPtVsL1405Pt.Eval(lambda1405Cand.pt())) { + piTrack.pt() > funcMaxBachPiPtVsL1405Pt.Eval(lambda1405Cand.pt())) { + continue; + } + rSelections.fill(HIST("hSelectionsL1405"), 4); // Pt correlations + + if (lambda1405Cand.pt() < cutMinPtL1405) { continue; } rSelections.fill(HIST("hSelectionsL1405"), 5); // Accepted - fillHistosLambda1405(lambda1405Cand, piTrack); - rSelections.fill(HIST("hSelectionsL1405"), 6); // Accepted selectedCandidates.push_back(lambda1405Cand); } } @@ -727,7 +786,7 @@ struct lambda1405analysis { rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); for (const auto& sigmaCand : sigmaCands) { std::vector selectedCandidates; - constructCollCandidates(sigmaCand, tracks, selectedCandidates); + constructCollCandidates(collision, sigmaCand, tracks, selectedCandidates); for (auto& lambda1405Cand : selectedCandidates) { if (lambda1405Cand.isSigmaMinus) { rLambda1405.fill(HIST("h2SigmaMinusMassVsLambdaMass"), lambda1405Cand.massL1405, lambda1405Cand.sigmaMinusMass); @@ -760,7 +819,6 @@ struct lambda1405analysis { lambda1405Cand.scalarProd = cos2Phi * xQVec + sin2Phi * yQVec; float const ptCand = lambda1405Cand.pt(); rLambda1405.fill(HIST("hScalarProd"), lambda1405Cand.scalarProd, ptCand); - rLambda1405.fill(HIST("hSparseFlowL1405"), lambda1405Cand.massL1405, ptCand, collision.centFT0C(), lambda1405Cand.scalarProd); if (fillFlowTree) { if (downSampleFactor < 1.) { float const pseudoRndm = ptCand * 1000. - static_cast(ptCand * 1000); @@ -769,6 +827,7 @@ struct lambda1405analysis { } } outputDataFlowTable(ptCand, lambda1405Cand.massL1405, + lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMinusMass, lambda1405Cand.sigmaPlusMass, lambda1405Cand.sigmaAlphaAP, lambda1405Cand.sigmaQtAP, lambda1405Cand.kinkPiNSigTpc, lambda1405Cand.kinkPiNSigTof, @@ -778,17 +837,22 @@ struct lambda1405analysis { lambda1405Cand.scalarProd, collision.centFT0C()); } } + fillHistosLambda1405(lambda1405Cand); } } } - void processData(CollisionsFull::iterator const& collision, aod::KinkCands const& kinkCands, TracksFull const& tracks) + void processData(CollisionsFull::iterator const& collision, + aod::KinkCands const& kinkCands, + TracksFull const& tracks) { fillOutputData(collision, kinkCands, tracks); } PROCESS_SWITCH(lambda1405analysis, processData, "Data processing", true); - void processDataWCentQVecs(CollisionsCentSel::iterator const& collision, aod::KinkCands const& kinkCands, TracksFull const& tracks) + void processDataWCentQVecs(CollisionsCentSel::iterator const& collision, + aod::KinkCands const& kinkCands, + TracksFull const& tracks) { fillOutputData(collision, kinkCands, tracks); } @@ -867,11 +931,16 @@ struct lambda1405analysis { } template - void fillOutputMc(const TCollision& collisions, const aod::KinkCands& sigmaCands, const aod::McTrackLabels& trackLabelsMC, const TTrack& tracks, const aod::McParticles& particlesMC) + void fillOutputMc(const TCollision& recoCollisions, + const aod::KinkCands& sigmaCands, + const aod::McTrackLabels& trackLabelsMC, + const TTrack& tracks, + const aod::McParticles& particlesMC) { - for (const auto& collision : collisions) { + for (const auto& collision : recoCollisions) { if constexpr (requires { collision.centFT0C(); }) { - if (collision.centFT0C() < centralityMin || collision.centFT0C() > centralityMax) { + auto cent = collision.centFT0C(); + if (cent < centralityMin || cent > centralityMax) { return; } } @@ -882,53 +951,51 @@ struct lambda1405analysis { auto sigmaCandsPerCol = sigmaCands.sliceBy(mKinkPerCol, collision.globalIndex()); auto tracksPerCol = tracks.sliceBy(mPerColTracks, collision.globalIndex()); for (const auto& sigmaCand : sigmaCandsPerCol) { - std::vector selectedCandidates; - constructCollCandidates(sigmaCand, tracksPerCol, selectedCandidates); - for (auto& lambda1405Cand : selectedCandidates) { - rLambda1405.fill(HIST("hRecoL1405"), 0., lambda1405Cand.pt()); // All reconstructed - // Do MC association - auto mcLabPiKink = trackLabelsMC.rawIteratorAt(lambda1405Cand.kinkDauId); - auto mcLabSigma = trackLabelsMC.rawIteratorAt(lambda1405Cand.sigmaId); - auto mcLabPi = trackLabelsMC.rawIteratorAt(lambda1405Cand.piId); - if (!mcLabSigma.has_mcParticle() || !mcLabPiKink.has_mcParticle() || !mcLabPi.has_mcParticle()) { - continue; // Skip if no valid MC association - } - rLambda1405.fill(HIST("hRecoL1405"), 1., lambda1405Cand.pt()); // All with associated MC particle + // 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() || !labelKinkDaug.has_mcParticle()) { + continue; // Skip if no valid MC association + } + auto genSigma = labelSigma.template mcParticle_as(); + auto genKinkDaug = labelKinkDaug.template mcParticle_as(); - auto mcTrackKink = mcLabPiKink.mcParticle_as(); - auto mcTrackSigma = mcLabSigma.mcParticle_as(); - auto mcTrackPi = mcLabPi.mcParticle_as(); + bool isSigmaMinusKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaMinusPdgCode, 211, particlesMC); + bool isSigmaPlusToPiKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaPlusPdgCode, 211, particlesMC); + bool isSigmaPlusToPrKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaPlusPdgCode, 2212, particlesMC); - bool isSigmaMinusKink = checkSigmaKinkMC(mcTrackSigma, mcTrackKink, 3122, 211, particlesMC); - bool isSigmaPlusToPiKink = checkSigmaKinkMC(mcTrackSigma, mcTrackKink, 3222, 211, particlesMC); - bool isSigmaPlusToPrKink = checkSigmaKinkMC(mcTrackSigma, mcTrackKink, 3222, 2212, particlesMC); + if (!isSigmaMinusKink && !isSigmaPlusToPiKink && !isSigmaPlusToPrKink) { + continue; // Skip if not a valid Sigma kink decay + } - if (!isSigmaMinusKink && !isSigmaPlusToPiKink && !isSigmaPlusToPrKink) { - continue; // Skip if not a valid Sigma kink decay - } - rLambda1405.fill(HIST("hRecoL1405"), 2., lambda1405Cand.pt()); // Has kink decay in MC + std::vector selectedCandidates; + constructCollCandidates(collision, sigmaCand, tracksPerCol, selectedCandidates); + for (auto& lambda1405Cand : selectedCandidates) { + rLambda1405.fill(HIST("hRecoL1405"), 0., lambda1405Cand.pt()); // All reconstructed - // Disentangle the Sigma+ --> npi+, treated as contamination in data - if (isSigmaPlusToPiKink) { - lambda1405Cand.isSigmaMinus = false; - lambda1405Cand.isSigmaPlus = true; + // Do MC association + auto labelBachPi = trackLabelsMC.rawIteratorAt(lambda1405Cand.bachPiId); + if (!labelBachPi.has_mcParticle()) { + continue; // Skip if no valid MC association } - if (std::abs(mcTrackPi.pdgCode()) != PDG_t::kPiPlus) { + auto genBachPi = labelBachPi.template mcParticle_as(); + if (std::abs(genBachPi.pdgCode()) != PDG_t::kPiPlus) { continue; // Skip if not a valid pion candidate } - rLambda1405.fill(HIST("hRecoL1405"), 3., lambda1405Cand.pt()); // Has bach pi + rLambda1405.fill(HIST("hRecoL1405"), 1., lambda1405Cand.pt()); // Has bach pi - if (!mcTrackSigma.has_mothers() || !mcTrackPi.has_mothers()) { + if (!genSigma.has_mothers() || !genBachPi.has_mothers()) { continue; // Skip if no mothers found } - rLambda1405.fill(HIST("hRecoL1405"), 4., lambda1405Cand.pt()); // Has mothers for Sigma and Pi + rLambda1405.fill(HIST("hRecoL1405"), 2., lambda1405Cand.pt()); // Has mothers for Sigma and Pi // check that labpi and labsigma have the same mother (a lambda1405 candidate) int lambda1405Id = -1; - for (const auto& piMother : mcTrackPi.mothers_as()) { - for (const auto& sigmaMother : mcTrackSigma.mothers_as()) { + for (const auto& piMother : genBachPi.template mothers_as()) { + for (const auto& sigmaMother : genSigma.template mothers_as()) { if (piMother.globalIndex() == sigmaMother.globalIndex() && std::abs(piMother.pdgCode()) == lambda1405PdgCode) { lambda1405Id = piMother.globalIndex(); break; // Found the mother, exit loop @@ -938,7 +1005,7 @@ struct lambda1405analysis { if (lambda1405Id == -1) { continue; // Skip if the Sigma and pion do not share the same lambda1405 candidate } - rLambda1405.fill(HIST("hRecoL1405"), 4., lambda1405Cand.pt()); // Has same mother + rLambda1405.fill(HIST("hRecoL1405"), 3., lambda1405Cand.pt()); // Has same mother auto lambda1405Mother = particlesMC.rawIteratorAt(lambda1405Id); float lambda1405Mass = std::sqrt(lambda1405Mother.e() * lambda1405Mother.e() - lambda1405Mother.p() * lambda1405Mother.p()); @@ -963,14 +1030,38 @@ struct lambda1405analysis { lambda1405Cand.kinkPrNSigTpc, lambda1405Cand.kinkPrNSigTof, lambda1405Cand.kinkDcaDauToPv, lambda1405Cand.bachPiNSigTpc, lambda1405Cand.bachPiNSigTof, - lambda1405Mother.pt(), lambda1405Mass, mcTrackSigma.pdgCode(), mcTrackKink.pdgCode()); + lambda1405Mother.pt(), lambda1405Mass, genSigma.pdgCode(), genBachPi.pdgCode()); } + fillHistosLambda1405(lambda1405Cand); } } } // Loop over generated particles to fill MC histograms for (const auto& mcPart : particlesMC) { + if (std::abs(mcPart.pdgCode()) != lambda1405PdgCode && + std::abs(mcPart.pdgCode()) != sigmaMinusPdgCode && + std::abs(mcPart.pdgCode()) != sigmaPlusPdgCode) { + continue; // Only consider Lambda(1405) and Sigma candidates + } + + // Compute generated PV contributors + const auto& recoCollsPerMcColl = recoCollisions.sliceBy(colPerMcCollision, mcPart.mcCollision().globalIndex()); + if (recoCollsPerMcColl.size() == 0) { + continue; // Skip if no reconstructed collisions associated with this MC collision + } + unsigned maxNumContrib = 0; + for (const auto& recCol : recoCollsPerMcColl) { + maxNumContrib = recCol.numContrib() > maxNumContrib ? recCol.numContrib() : maxNumContrib; + } + + // Needed for Sigma efficiency vs PV contributors + if (std::abs(mcPart.pdgCode()) == sigmaMinusPdgCode) { + rSigmaMinus.fill(HIST("h2GenSigmaMinusPvContribPt"), maxNumContrib, mcPart.pt()); + } + if (std::abs(mcPart.pdgCode()) == sigmaPlusPdgCode) { + rSigmaPlus.fill(HIST("h2GenSigmaPlusPvContribPt"), maxNumContrib, mcPart.pt()); + } if (std::abs(mcPart.pdgCode()) != lambda1405PdgCode) { continue; // Only consider Lambda(1405) candidates } @@ -989,36 +1080,46 @@ struct lambda1405analysis { float genSigmaQtAP = qtAP({sigmaDaug.px(), sigmaDaug.py(), sigmaDaug.pz()}, {sigmaKinkDaug.px(), sigmaKinkDaug.py(), sigmaKinkDaug.pz()}); float mcMass = std::sqrt(mcPart.e() * mcPart.e() - mcPart.p() * mcPart.p()); rLambda1405.fill(HIST("h2PtMassMC"), mcPart.pt(), mcMass); + rLambda1405.fill(HIST("h2GenL1405PvContribPt"), maxNumContrib, mcPart.pt()); if (decayChannel == kSigmaMinusPiToPiPiNeutron) { rLambda1405.fill(HIST("h2GenSigmaMinusArmPod"), genSigmaAlphaAP, genSigmaQtAP); - rLambda1405.fill(HIST("h2GenPtVsBachPtSigmaMinusPiToPiPiNeutron"), mcPart.pt(), bachPi.pt()); - rLambda1405.fill(HIST("h2GenPtVsSigmaPtSigmaMinusPiToPiPiNeutron"), mcPart.pt(), sigmaDaug.pt()); - rLambda1405.fill(HIST("h2GenSigmaPtVsKinkPtSigmaMinusPiToPiPiNeutron"), sigmaDaug.pt(), sigmaKinkDaug.pt()); + rLambda1405.fill(HIST("h2GenPtVsBachPtSigmaMinus"), mcPart.pt(), bachPi.pt()); + rLambda1405.fill(HIST("h2GenPtVsSigmaMinusPt"), mcPart.pt(), sigmaDaug.pt()); + rLambda1405.fill(HIST("h2GenSigmaPtVsKinkPtSigmaMinus"), sigmaDaug.pt(), sigmaKinkDaug.pt()); } if (decayChannel == kSigmaPlusPiToPiPiNeutron) { rLambda1405.fill(HIST("h2GenSigmaPlusArmPod"), genSigmaAlphaAP, genSigmaQtAP); - rLambda1405.fill(HIST("h2GenPtVsBachPtSigmaPlusPiToPiPiN"), mcPart.pt(), bachPi.pt()); - rLambda1405.fill(HIST("h2GenPtVsSigmaPtSigmaPlusPiToPiPiN"), mcPart.pt(), sigmaDaug.pt()); - rLambda1405.fill(HIST("h2GenSigmaPtVsKinkPtSigmaPlusPiToPiPiN"), sigmaDaug.pt(), sigmaKinkDaug.pt()); + rLambda1405.fill(HIST("h2GenPtVsBachPtSigmaPlusToPi"), mcPart.pt(), bachPi.pt()); + rLambda1405.fill(HIST("h2GenPtVsSigmaPlusToPiPt"), mcPart.pt(), sigmaDaug.pt()); + rLambda1405.fill(HIST("h2GenSigmaPtVsPiKinkPt"), sigmaDaug.pt(), sigmaKinkDaug.pt()); } if (decayChannel == kSigmaPlusPiToPiPiProton) { rLambda1405.fill(HIST("h2GenSigmaPlusArmPod"), genSigmaAlphaAP, genSigmaQtAP); - rLambda1405.fill(HIST("h2GenPtVsBachPtSigmaPlusPiToPiPiP"), mcPart.pt(), bachPi.pt()); - rLambda1405.fill(HIST("h2GenPtVsSigmaPtSigmaPlusPiToPiPiP"), mcPart.pt(), sigmaDaug.pt()); - rLambda1405.fill(HIST("h2GenSigmaPtVsKinkPtSigmaPlusPiToPiPiP"), sigmaDaug.pt(), sigmaKinkDaug.pt()); + rLambda1405.fill(HIST("h2GenPtVsBachPtSigmaPlusToPr"), mcPart.pt(), bachPi.pt()); + rLambda1405.fill(HIST("h2GenPtVsSigmaPlusToPrPt"), mcPart.pt(), sigmaDaug.pt()); + rLambda1405.fill(HIST("h2GenSigmaPtVsPrKinkPt"), sigmaDaug.pt(), sigmaKinkDaug.pt()); } } } - void processMc(CollisionsFullMc const& collisions, aod::KinkCands const& kinkCands, aod::McTrackLabels const& trackLabelsMC, aod::McParticles const& particlesMC, TracksFull const& tracks) + void processMc(CollisionsFullMc const& recoCollisions, + aod::KinkCands const& kinkCands, + aod::McTrackLabels const& trackLabelsMC, + aod::McParticles const& particlesMC, + TracksFull const& tracks, + aod::McCollisions const&) { - fillOutputMc(collisions, kinkCands, trackLabelsMC, tracks, particlesMC); + fillOutputMc(recoCollisions, kinkCands, trackLabelsMC, tracks, particlesMC); } PROCESS_SWITCH(lambda1405analysis, processMc, "MC processing", false); - void processMcWCentSel(McRecoCollisionsCentSel const& collisions, aod::KinkCands const& kinkCands, aod::McTrackLabels const& trackLabelsMC, aod::McParticles const& particlesMC, TracksFull const& tracks) + void processMcWCentSel(McRecoCollisionsCentSel const& recoCollisions, + aod::KinkCands const& kinkCands, + aod::McTrackLabels const& trackLabelsMC, + aod::McParticles const& particlesMC, + TracksFull const& tracks) { - fillOutputMc(collisions, kinkCands, trackLabelsMC, tracks, particlesMC); + fillOutputMc(recoCollisions, kinkCands, trackLabelsMC, tracks, particlesMC); } PROCESS_SWITCH(lambda1405analysis, processMcWCentSel, "MC processing with centrality selection", false); }; From 2670a503287f8713538a914656f17c772b3ce6a7 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 1 Jul 2026 08:10:22 +0000 Subject: [PATCH 2/4] Please consider the following formatting changes --- PWGLF/TableProducer/Common/kinkBuilder.cxx | 4 +- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 44 +++++++++---------- 2 files changed, 24 insertions(+), 24 deletions(-) diff --git a/PWGLF/TableProducer/Common/kinkBuilder.cxx b/PWGLF/TableProducer/Common/kinkBuilder.cxx index dbbd1cce5e6..d06f1d05099 100644 --- a/PWGLF/TableProducer/Common/kinkBuilder.cxx +++ b/PWGLF/TableProducer/Common/kinkBuilder.cxx @@ -835,8 +835,8 @@ struct kinkBuilder { if (decayChannel < 0) { continue; // Skip candidates that do not match the decay channels of interest } - hRecCandidatesRecoPt->Fill(decayChannel, trackMoth.pt()); // Decay channel match bin - hRecCandidatesGenPt->Fill(decayChannel, genMothPart.pt()); // Decay channel match bin + hRecCandidatesRecoPt->Fill(decayChannel, trackMoth.pt()); // Decay channel match bin + hRecCandidatesGenPt->Fill(decayChannel, genMothPart.pt()); // Decay channel match bin hRecCandidatesDeltaPt->Fill((trackMoth.pt() - genMothPart.pt()) / genMothPart.pt(), genMothPart.pt()); // Decay channel match bin } bool isAccepted = false; diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index 500c27f8046..797c03d282a 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -91,10 +91,10 @@ struct lambda1405candidate { float bachPiNSigTof = -1; // Number of sigmas for the pion candidate using Tof int kinkDauId = 0; // Id of the pion from Sigma decay in MC int sigmaId = 0; // Id of the Sigma candidate in MC - int bachPiId = 0; // Id of the pion candidate in MC + int bachPiId = 0; // Id of the pion candidate in MC - float cent = -1; // Centrality of the collision - float pvContrib = -1; // Number of contributors to the primary vertex + float cent = -1; // Centrality of the collision + float pvContrib = -1; // Number of contributors to the primary vertex float scalarProd = -1; // Scalar product for flow analysis }; @@ -623,18 +623,18 @@ struct lambda1405analysis { } auto kinkDauMom = std::array{sigmaCand.pxDaug(), sigmaCand.pyDaug(), sigmaCand.pzDaug()}; - auto sigmaMom = std::array{sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth()}; + auto sigmaMom = std::array{sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth()}; // Sigma properties - lambda1405Cand.sigmaId = sigmaCand.globalIndex(); + lambda1405Cand.sigmaId = sigmaCand.globalIndex(); lambda1405Cand.sigmaMinusMass = sigmaCand.mSigmaMinus(); - lambda1405Cand.sigmaPlusMass = sigmaCand.mSigmaPlus(); - lambda1405Cand.xiMinusMass = sigmaCand.mXiMinus(); - lambda1405Cand.sigmaSign = sigmaCand.mothSign(); - lambda1405Cand.sigmaAlphaAP = alphaAP(sigmaMom, kinkDauMom); - lambda1405Cand.sigmaQtAP = qtAP(sigmaMom, kinkDauMom); - lambda1405Cand.sigmaPt = sigmaCand.ptMoth(); - lambda1405Cand.sigmaRadius = sigmaRad; - lambda1405Cand.dcaSigmaToPv = sigmaCand.dcaMothPv(); + lambda1405Cand.sigmaPlusMass = sigmaCand.mSigmaPlus(); + lambda1405Cand.xiMinusMass = sigmaCand.mXiMinus(); + lambda1405Cand.sigmaSign = sigmaCand.mothSign(); + lambda1405Cand.sigmaAlphaAP = alphaAP(sigmaMom, kinkDauMom); + lambda1405Cand.sigmaQtAP = qtAP(sigmaMom, kinkDauMom); + lambda1405Cand.sigmaPt = sigmaCand.ptMoth(); + lambda1405Cand.sigmaRadius = sigmaRad; + lambda1405Cand.dcaSigmaToPv = sigmaCand.dcaMothPv(); if (lambda1405Cand.sigmaQtAP < funcMinQtAlphaAP.Eval(lambda1405Cand.sigmaAlphaAP) || lambda1405Cand.sigmaQtAP > funcMaxQtAlphaAP.Eval(lambda1405Cand.sigmaAlphaAP)) { @@ -659,7 +659,7 @@ struct lambda1405analysis { // Collision properties lambda1405Cand.pvContrib = collision.numContrib(); - if constexpr ( requires{collision.centFT0C();} ) { + if constexpr (requires { collision.centFT0C(); }) { lambda1405Cand.cent = collision.centFT0C(); } else { lambda1405Cand.cent = -1; // Not available @@ -720,7 +720,7 @@ struct lambda1405analysis { lambda1405Cand.px = sigmaMom[0] + piMom[0]; lambda1405Cand.py = sigmaMom[1] + piMom[1]; lambda1405Cand.pz = sigmaMom[2] + piMom[2]; - + lambda1405Cand.phi = std::atan2(lambda1405Cand.py, lambda1405Cand.px); lambda1405Cand.scalarProd = -1; if constexpr (requires { collision.qvecFT0CRe(); }) { @@ -736,13 +736,13 @@ struct lambda1405analysis { std::hypot(sigmaCand.pxMoth(), sigmaCand.pyMoth()) > funcMaxSigmaPtVsL1405Pt.Eval(lambda1405Cand.pt())) { continue; } - + if (piTrack.pt() < funcMinBachPiPtVsL1405Pt.Eval(lambda1405Cand.pt()) || - piTrack.pt() > funcMaxBachPiPtVsL1405Pt.Eval(lambda1405Cand.pt())) { + piTrack.pt() > funcMaxBachPiPtVsL1405Pt.Eval(lambda1405Cand.pt())) { continue; } rSelections.fill(HIST("hSelectionsL1405"), 4); // Pt correlations - + if (lambda1405Cand.pt() < cutMinPtL1405) { continue; } @@ -962,9 +962,9 @@ struct lambda1405analysis { auto genSigma = labelSigma.template mcParticle_as(); auto genKinkDaug = labelKinkDaug.template mcParticle_as(); - bool isSigmaMinusKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaMinusPdgCode, 211, particlesMC); - bool isSigmaPlusToPiKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaPlusPdgCode, 211, particlesMC); - bool isSigmaPlusToPrKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaPlusPdgCode, 2212, particlesMC); + bool isSigmaMinusKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaMinusPdgCode, 211, particlesMC); + bool isSigmaPlusToPiKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaPlusPdgCode, 211, particlesMC); + bool isSigmaPlusToPrKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaPlusPdgCode, 2212, particlesMC); if (!isSigmaMinusKink && !isSigmaPlusToPiKink && !isSigmaPlusToPrKink) { continue; // Skip if not a valid Sigma kink decay @@ -973,7 +973,7 @@ struct lambda1405analysis { std::vector selectedCandidates; constructCollCandidates(collision, sigmaCand, tracksPerCol, selectedCandidates); for (auto& lambda1405Cand : selectedCandidates) { - rLambda1405.fill(HIST("hRecoL1405"), 0., lambda1405Cand.pt()); // All reconstructed + rLambda1405.fill(HIST("hRecoL1405"), 0., lambda1405Cand.pt()); // All reconstructed // Do MC association auto labelBachPi = trackLabelsMC.rawIteratorAt(lambda1405Cand.bachPiId); From bff81223301c47372d47bf0e660e7f93e39ecaac Mon Sep 17 00:00:00 2001 From: marcellocosti Date: Wed, 1 Jul 2026 18:53:00 +0200 Subject: [PATCH 3/4] Linter fixes --- PWGLF/TableProducer/Common/kinkBuilder.cxx | 8 +++----- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 17 ++++++++--------- 2 files changed, 11 insertions(+), 14 deletions(-) diff --git a/PWGLF/TableProducer/Common/kinkBuilder.cxx b/PWGLF/TableProducer/Common/kinkBuilder.cxx index d06f1d05099..22cf9806426 100644 --- a/PWGLF/TableProducer/Common/kinkBuilder.cxx +++ b/PWGLF/TableProducer/Common/kinkBuilder.cxx @@ -662,7 +662,7 @@ struct kinkBuilder { LOG(info) << "Task initialized for run " << mRunNumber << " with magnetic field " << mBz << " kZG"; } - template + template void buildSvPool(const TColls& collisions, const TTracks& tracks, const TAmbiTracks& ambiguousTracks, const aod::BCs& bcs) { svCreator.clearPools(); @@ -676,11 +676,9 @@ struct kinkBuilder { bool canBeMoth = true; bool canBeDaug = true; - if constexpr (isMC) { + if constexpr (KeepOnlyKinks) { if (!track.has_mcParticle()) { LOG(debug) << "Track has no MC particle"; - canBeMoth = false; - canBeDaug = false; continue; } auto genPart = track.template mcParticle_as(); @@ -691,7 +689,7 @@ struct kinkBuilder { std::abs(genPart.pdgCode())) != mothMatchPdgCodes.end(); canBeDaug = false; - for (auto mother : genPart.template mothers_as()) { + for (const auto& mother : genPart.template mothers_as()) { if (std::find( mothMatchPdgCodes.begin(), mothMatchPdgCodes.end(), diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index 797c03d282a..f50b62561a5 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -101,8 +101,7 @@ struct lambda1405candidate { struct lambda1405analysis { int lambda1405PdgCode = 102132; // PDG code for Lambda(1405) - int sigmaMinusPdgCode = 3112; // PDG code for Lambda(1405) - int sigmaPlusPdgCode = 3222; // PDG code for Lambda(1405) + 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 @@ -962,9 +961,9 @@ struct lambda1405analysis { auto genSigma = labelSigma.template mcParticle_as(); auto genKinkDaug = labelKinkDaug.template mcParticle_as(); - bool isSigmaMinusKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaMinusPdgCode, 211, particlesMC); - bool isSigmaPlusToPiKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaPlusPdgCode, 211, particlesMC); - bool isSigmaPlusToPrKink = checkSigmaKinkMC(genSigma, genKinkDaug, sigmaPlusPdgCode, 2212, particlesMC); + 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 (!isSigmaMinusKink && !isSigmaPlusToPiKink && !isSigmaPlusToPrKink) { continue; // Skip if not a valid Sigma kink decay @@ -1040,8 +1039,8 @@ struct lambda1405analysis { // Loop over generated particles to fill MC histograms for (const auto& mcPart : particlesMC) { if (std::abs(mcPart.pdgCode()) != lambda1405PdgCode && - std::abs(mcPart.pdgCode()) != sigmaMinusPdgCode && - std::abs(mcPart.pdgCode()) != sigmaPlusPdgCode) { + std::abs(mcPart.pdgCode()) != PDG_t::kSigmaMinus && + std::abs(mcPart.pdgCode()) != PDG_t::kSigmaPlus) { continue; // Only consider Lambda(1405) and Sigma candidates } @@ -1056,10 +1055,10 @@ struct lambda1405analysis { } // Needed for Sigma efficiency vs PV contributors - if (std::abs(mcPart.pdgCode()) == sigmaMinusPdgCode) { + if (std::abs(mcPart.pdgCode()) == PDG_t::kSigmaMinus) { rSigmaMinus.fill(HIST("h2GenSigmaMinusPvContribPt"), maxNumContrib, mcPart.pt()); } - if (std::abs(mcPart.pdgCode()) == sigmaPlusPdgCode) { + if (std::abs(mcPart.pdgCode()) == PDG_t::kSigmaPlus) { rSigmaPlus.fill(HIST("h2GenSigmaPlusPvContribPt"), maxNumContrib, mcPart.pt()); } if (std::abs(mcPart.pdgCode()) != lambda1405PdgCode) { From e1be0c865dff3448c690a91061af694b8467f3a7 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 1 Jul 2026 16:54:33 +0000 Subject: [PATCH 4/4] Please consider the following formatting changes --- PWGLF/Tasks/Resonances/lambda1405analysis.cxx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx index f50b62561a5..e426973f215 100644 --- a/PWGLF/Tasks/Resonances/lambda1405analysis.cxx +++ b/PWGLF/Tasks/Resonances/lambda1405analysis.cxx @@ -961,9 +961,9 @@ struct lambda1405analysis { 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); + 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 (!isSigmaMinusKink && !isSigmaPlusToPiKink && !isSigmaPlusToPrKink) { continue; // Skip if not a valid Sigma kink decay