From b6f17539c015f9e0a492617c536ed0f8c4fdfad5 Mon Sep 17 00:00:00 2001 From: SCHOTTER Romain <47983209+romainschotter@users.noreply.github.com> Date: Tue, 1 Sep 2026 23:39:39 +0200 Subject: [PATCH 1/3] Add special treatment for decays into two positive PDG code particles --- PWGLF/Utils/strangenessBuilderModule.h | 79 +++++++++++++++++++++++++- 1 file changed, 78 insertions(+), 1 deletion(-) diff --git a/PWGLF/Utils/strangenessBuilderModule.h b/PWGLF/Utils/strangenessBuilderModule.h index 563b75e6d95..16a6b7a36cb 100644 --- a/PWGLF/Utils/strangenessBuilderModule.h +++ b/PWGLF/Utils/strangenessBuilderModule.h @@ -1892,11 +1892,31 @@ class BuilderModule if (mcParticle.has_daughters()) { auto const& daughters = mcParticle.template daughters_as(); + // For the K0s (main channel of interest): + // K0s --> pi+ pi- (69.20%) + // K0s --> pi0 pi0 (30.69%) + // For the Lambda (main channel of interest): + // Lambda --> p pi- (64.1%) + // Lambda --> n pi0 (35.9%) for (const auto& dau : daughters) { if (dau.getProcess() != TMCProcess::kPDecay) continue; + // proton, neutron, pi+, e+, pi0 if (dau.pdgCode() > 0) { + // special treatment of Lambda --> neutron pi0 (both PDG codes > 0) + // and K0s --> pi0 pi0 (both PDG codes > 0) + // take neutron as positive daughter and pi0 as negative daughter + // if the first daughter was the pi0 (already assigned as positive), + // then transfer the information to the negative and fill the information + // of the positive daughter with those of the neutrons + if (thisInfo.pdgCodePositive > -1 && thisInfo.pdgCodePositive == PDG_t::kPi0) { + thisInfo.pdgCodeNegative = thisInfo.pdgCodePositive; + thisInfo.processNegative = thisInfo.processPositive; + thisInfo.negP[0] = thisInfo.posP[0]; + thisInfo.negP[1] = thisInfo.posP[1]; + thisInfo.negP[2] = thisInfo.posP[2]; + } thisInfo.pdgCodePositive = dau.pdgCode(); thisInfo.processPositive = dau.getProcess(); thisInfo.posP[0] = dau.px(); @@ -1906,6 +1926,7 @@ class BuilderModule thisInfo.xyz[1] = dau.vy(); thisInfo.xyz[2] = dau.vz(); } + // antiproton, antineutron, pi-, e- (pi0 cannot have negative PDG code) if (dau.pdgCode() < 0) { thisInfo.pdgCodeNegative = dau.pdgCode(); thisInfo.processNegative = dau.getProcess(); @@ -2442,7 +2463,16 @@ class BuilderModule if (dau.getProcess() != TMCProcess::kPDecay) // check whether the daughter comes from a decay continue; - if (std::abs(dau.pdgCode()) == PDG_t::kPiPlus || std::abs(dau.pdgCode()) == PDG_t::kKPlus) { + // Dominant decay channels for charged Xi and Omega are: + // Xi- --> Lambda pi- ; Xi+ --> Lambda pi+ (99.887%) --> recover information of all daughters + // Omega- --> Lambda K- ; Omega+ --> Lambda K+ (67.7%) --> recover information of all daughters + // Omega- --> Xi0 pi- ; Omega+ --> Xi0 pi+ (24.3%) --> recover information of only Xi0 and pions + // Omega- --> Xi- pi0 ; Omega+ --> Xi+ pi0 (8.55%) --> recover information of only Xi and pions + // + // For the Lambda (main channel of interest): + // Lambda --> p pi- (64.1%) + // Lambda --> n pi0 (35.9%) + if (std::abs(dau.pdgCode()) == PDG_t::kPiPlus || std::abs(dau.pdgCode()) == PDG_t::kPi0 || std::abs(dau.pdgCode()) == PDG_t::kKPlus) { thisCascInfo.pdgCodeBachelor = dau.pdgCode(); thisCascInfo.bachP[0] = dau.px(); thisCascInfo.bachP[1] = dau.py(); @@ -2452,6 +2482,7 @@ class BuilderModule thisCascInfo.xyz[2] = dau.vz(); thisCascInfo.mcParticleBachelor = dau.globalIndex(); } + // Treatment of Lambda --> p pi ; Lambda --> n pi if (std::abs(dau.pdgCode()) == PDG_t::kLambda0) { thisCascInfo.pdgCodeV0 = dau.pdgCode(); @@ -2459,7 +2490,21 @@ class BuilderModule if (v0Dau.getProcess() != TMCProcess::kPDecay) continue; + // proton, neutron, pi+, pi0 if (v0Dau.pdgCode() > 0) { + // special treatment of Lambda --> neutron pi0 (both PDG codes > 0) + // take neutron as positive daughter and pi0 as negative daughter + // if the first daughter was the pi0 (already assigned as positive), + // then transfer the information to the negative and fill the information + // of the positive daughter with those of the neutrons + if (thisCascInfo.pdgCodePositive > -1 && thisCascInfo.pdgCodePositive == PDG_t::kPi0) { + thisCascInfo.pdgCodeNegative = thisCascInfo.pdgCodePositive; + thisCascInfo.processNegative = thisCascInfo.processPositive; + thisCascInfo.negP[0] = thisCascInfo.posP[0]; + thisCascInfo.negP[1] = thisCascInfo.posP[1]; + thisCascInfo.negP[2] = thisCascInfo.posP[2]; + thisCascInfo.mcParticleNegative = thisCascInfo.mcParticlePositive; + } thisCascInfo.pdgCodePositive = v0Dau.pdgCode(); thisCascInfo.processPositive = v0Dau.getProcess(); thisCascInfo.posP[0] = v0Dau.px(); @@ -2470,6 +2515,7 @@ class BuilderModule thisCascInfo.lxyz[2] = v0Dau.vz(); thisCascInfo.mcParticlePositive = v0Dau.globalIndex(); } + // antiproton, antineutron, pi- (pi0 cannot have negative PDG code) if (v0Dau.pdgCode() < 0) { thisCascInfo.pdgCodeNegative = v0Dau.pdgCode(); thisCascInfo.processNegative = v0Dau.getProcess(); @@ -2480,6 +2526,37 @@ class BuilderModule } } } + // Special treatment of Xi0 and Xi from Omega --> Xi0 pi ; Omega --> Xi pi0 + if (std::abs(dau.pdgCode()) == PDG_t::kXiMinus || std::abs(dau.pdgCode()) == o2::constants::physics::Pdg::kXi0) { + thisCascInfo.pdgCodeV0 = dau.pdgCode(); + + for (const auto& xiDau : dau.template daughters_as()) { + if (xiDau.getProcess() != TMCProcess::kPDecay) + continue; + + // always put the Lambda in the positive + if (std::abs(xiDau.pdgCode()) == PDG_t::kLambda0) { + thisCascInfo.pdgCodePositive = xiDau.pdgCode(); + thisCascInfo.processPositive = xiDau.getProcess(); + thisCascInfo.posP[0] = xiDau.px(); + thisCascInfo.posP[1] = xiDau.py(); + thisCascInfo.posP[2] = xiDau.pz(); + thisCascInfo.lxyz[0] = xiDau.vx(); + thisCascInfo.lxyz[1] = xiDau.vy(); + thisCascInfo.lxyz[2] = xiDau.vz(); + thisCascInfo.mcParticlePositive = xiDau.globalIndex(); + } + // always put the bachelor or the photon or the pi0 in the negative + if (std::abs(xiDau.pdgCode()) == PDG_t::kPiPlus || std::abs(xiDau.pdgCode()) == PDG_t::kPi0 || std::abs(xiDau.pdgCode()) == PDG_t::kGamma) { + thisCascInfo.pdgCodeNegative = xiDau.pdgCode(); + thisCascInfo.processNegative = xiDau.getProcess(); + thisCascInfo.negP[0] = xiDau.px(); + thisCascInfo.negP[1] = xiDau.py(); + thisCascInfo.negP[2] = xiDau.pz(); + thisCascInfo.mcParticleNegative = xiDau.globalIndex(); + } + } + } } } From 613e368f592ffad62377e9d3a8cfc51ca75f55c8 Mon Sep 17 00:00:00 2001 From: SCHOTTER Romain <47983209+romainschotter@users.noreply.github.com> Date: Tue, 1 Sep 2026 23:42:23 +0200 Subject: [PATCH 2/3] Add new strategy to look at generated secondary V0s Changed doSecondaryV0s from a boolean to an integer to allow for more options. Updated the associated logic to handle new values for doSecondaryV0s. --- .../derivedlambdakzeroanalysis.cxx | 123 +++++++++++++++++- 1 file changed, 120 insertions(+), 3 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx index af53ded1fb5..93659300c3c 100644 --- a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx @@ -132,7 +132,7 @@ struct derivedlambdakzeroanalysis { Configurable doMCAssociation{"doMCAssociation", true, "if MC, do MC association"}; Configurable doTreatPiToMuon{"doTreatPiToMuon", false, "Take pi decay into muon into account in MC"}; Configurable doCollisionAssociationQA{"doCollisionAssociationQA", true, "check collision association"}; - Configurable doSecondaryV0s{"doSecondaryV0s", false, "Look at secondary V0s?"}; + Configurable doSecondaryV0s{"doSecondaryV0s", 0, "Look at secondary V0s? 0: No; 1: yes via a loop on V0MCCores; 2: yes via a loop on CascMCCores"}; struct : ConfigurableGroup { std::string prefix = "eventSelections"; // JSON group name @@ -1254,24 +1254,33 @@ struct derivedlambdakzeroanalysis { } if (doSecondaryV0s) { + histos.add("h2dGenSecK0Short", "h2dGenSecK0Short", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); histos.add("h2dGenSecLambda", "h2dGenSecLambda", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambda", "h2dGenSecAntiLambda", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); histos.add("h2dGenSecLambdaFromXi", "h2dGenSecLambdaFromXi", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambdaFromXi", "h2dGenSecAntiLambdaFromXi", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); + histos.add("h2dGenSecLambdaFromXiAndXi0", "h2dGenSecLambdaFromXiAndXi0", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); + histos.add("h2dGenSecAntiLambdaFromXiAndXi0", "h2dGenSecAntiLambdaFromXiAndXi0", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); histos.add("h2dGenSecLambdaFromOmega", "h2dGenSecLambdaFromOmega", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambdaFromOmega", "h2dGenSecAntiLambdaFromOmega", kTH2D, {axisConfigurations.axisCentrality, axisConfigurations.axisPt}); + histos.add("h2dGenSecK0ShortVsMultMC_RecoedEvt", "h2dGenSecK0ShortVsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecLambdaVsMultMC_RecoedEvt", "h2dGenSecLambdaVsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambdaVsMultMC_RecoedEvt", "h2dGenSecAntiLambdaVsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecLambdaFromXiVsMultMC_RecoedEvt", "h2dGenSecLambdaFromXiVsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambdaFromXiVsMultMC_RecoedEvt", "h2dGenSecAntiLambdaFromXiVsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); + histos.add("h2dGenSecLambdaFromXiAndXi0VsMultMC_RecoedEvt", "h2dGenSecLambdaFromXiAndXi0VsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); + histos.add("h2dGenSecAntiLambdaFromXiAndXi0VsMultMC_RecoedEvt", "h2dGenSecAntiLambdaFromXiAndXi0VsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecLambdaFromOmegaVsMultMC_RecoedEvt", "h2dGenSecLambdaFromOmegaVsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambdaFromOmegaVsMultMC_RecoedEvt", "h2dGenSecAntiLambdaFromOmegaVsMultMC_RecoedEvt", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); + histos.add("h2dGenSecK0ShortVsMultMC", "h2dGenSecK0ShortVsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecLambdaVsMultMC", "h2dGenSecLambdaVsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambdaVsMultMC", "h2dGenSecAntiLambdaVsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecLambdaFromXiVsMultMC", "h2dGenSecLambdaFromXiVsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambdaFromXiVsMultMC", "h2dGenSecAntiLambdaFromXiVsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); + histos.add("h2dGenSecLambdaFromXiAndXi0VsMultMC", "h2dGenSecLambdaFromXiAndXi0VsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); + histos.add("h2dGenSecAntiLambdaFromXiAndXi0VsMultMC", "h2dGenSecAntiLambdaFromXiAndXi0VsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecLambdaFromOmegaVsMultMC", "h2dGenSecLambdaFromOmegaVsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); histos.add("h2dGenSecAntiLambdaFromOmegaVsMultMC", "h2dGenSecAntiLambdaFromOmegaVsMultMC", kTH2D, {axisConfigurations.axisNch, axisConfigurations.axisPt}); } @@ -3156,6 +3165,114 @@ struct derivedlambdakzeroanalysis { } } + if (doSecondaryV0s == 1) { + for (auto const& v0MC : V0MCCores) { + if (!v0MC.has_straMCCollision()) + continue; + + if (v0MC.isPhysicalPrimary()) // select only secondary Lambda + continue; + + float ptmc = v0MC.ptMC(); + float ymc = 1e3; + if (v0MC.pdgCode() == PDG_t::kK0Short) + ymc = v0MC.rapidityMC(0); + else if (std::abs(v0MC.pdgCode()) == PDG_t::kLambda0) + ymc = v0MC.rapidityMC(1); + + if (ymc < v0Selections.rapidityMinCut || + ymc > v0Selections.rapidityMaxCut) + continue; + + auto mcCollision = v0MC.template straMCCollision_as(); + if (eventSelections.applyZVtxSelOnMCPV && std::abs(mcCollision.posZ()) > eventSelections.maxZVtxPosition) { + continue; + } + if (eventSelections.requireINEL0 && mcCollision.multMCNParticlesEta10() < 1) { + continue; + } + + if (eventSelections.requireINEL1 && mcCollision.multMCNParticlesEta10() < 2) { + continue; + } + + float centrality = 100.5f; + if (listBestCollisionIdx[mcCollision.globalIndex()] > -1) { + auto collision = collisions.iteratorAt(listBestCollisionIdx[mcCollision.globalIndex()]); + if constexpr (requires { collision.centFT0C(); }) { // check if we are in Run 3 + centrality = getCentralityRun3(collision, useMcCentrality); + } else { // no, we are in Run 2 + centrality = eventSelections.useSPDTrackletsCent ? collision.centRun2SPDTracklets() : collision.centRun2V0M(); + } + + if (v0MC.pdgCode() == PDG_t::kK0Short) { + histos.fill(HIST("h2dGenSecK0ShortVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCode() == PDG_t::kLambda0) { + histos.fill(HIST("h2dGenSecLambdaVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + if (v0MC.pdgCodeMother() == PDG_t::kXiMinus) { + histos.fill(HIST("h2dGenSecLambdaFromXiVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCodeMother() == PDG_t::kXiMinus || v0MC.pdgCodeMother() == o2::constants::physics::Pdg::kXi0) { + histos.fill(HIST("h2dGenSecLambdaFromXiAndXi0VsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCodeMother() == PDG_t::kOmegaMinus) { + histos.fill(HIST("h2dGenSecLambdaFromOmegaVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + } + if (v0MC.pdgCode() == PDG_t::kLambda0Bar) { + histos.fill(HIST("h2dGenSecAntiLambdaVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + if (v0MC.pdgCodeMother() == PDG_t::kXiPlusBar) { + histos.fill(HIST("h2dGenSecAntiLambdaFromXiVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCodeMother() == PDG_t::kXiPlusBar || v0MC.pdgCodeMother() == -o2::constants::physics::Pdg::kXi0) { + histos.fill(HIST("h2dGenSecAntiLambdaFromXiAndXi0VsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCodeMother() == PDG_t::kOmegaPlusBar) { + histos.fill(HIST("h2dGenSecAntiLambdaFromOmegaVsMultMC_RecoedEvt"), mcCollision.multMCNParticlesEta05(), ptmc); + } + } + } + + if (v0MC.pdgCode() == PDG_t::kK0Short) { + histos.fill(HIST("h2dGenSecK0Short"), centrality, ptmc); + histos.fill(HIST("h2dGenSecK0ShortVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCode() == PDG_t::kLambda0) { + histos.fill(HIST("h2dGenSecLambda"), centrality, ptmc); + histos.fill(HIST("h2dGenSecLambdaVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + if (v0MC.pdgCodeMother() == PDG_t::kXiMinus) { + histos.fill(HIST("h2dGenSecLambdaFromXi"), centrality, ptmc); + histos.fill(HIST("h2dGenSecLambdaFromXiVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCodeMother() == PDG_t::kXiMinus || v0MC.pdgCodeMother() == o2::constants::physics::Pdg::kXi0) { + histos.fill(HIST("h2dGenSecLambdaFromXiAndXi0"), centrality, ptmc); + histos.fill(HIST("h2dGenSecLambdaFromXiAndXi0VsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCodeMother() == PDG_t::kOmegaMinus) { + histos.fill(HIST("h2dGenSecLambdaFromOmega"), centrality, ptmc); + histos.fill(HIST("h2dGenSecLambdaFromOmegaVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + } + if (v0MC.pdgCode() == PDG_t::kLambda0Bar) { + histos.fill(HIST("h2dGenSecAntiLambda"), centrality, ptmc); + histos.fill(HIST("h2dGenSecAntiLambdaVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + if (v0MC.pdgCodeMother() == PDG_t::kXiPlusBar) { + histos.fill(HIST("h2dGenSecAntiLambdaFromXi"), centrality, ptmc); + histos.fill(HIST("h2dGenSecAntiLambdaFromXiVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCodeMother() == PDG_t::kXiPlusBar || v0MC.pdgCodeMother() == -o2::constants::physics::Pdg::kXi0) { + histos.fill(HIST("h2dGenSecAntiLambdaFromXiAndXi0"), centrality, ptmc); + histos.fill(HIST("h2dGenSecAntiLambdaFromXiAndXi0VsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + if (v0MC.pdgCodeMother() == PDG_t::kOmegaPlusBar) { + histos.fill(HIST("h2dGenSecAntiLambdaFromOmega"), centrality, ptmc); + histos.fill(HIST("h2dGenSecAntiLambdaFromOmegaVsMultMC"), mcCollision.multMCNParticlesEta05(), ptmc); + } + } + } + } + for (auto const& cascMC : CascMCCores) { if (!cascMC.has_straMCCollision()) continue; @@ -3240,7 +3357,7 @@ struct derivedlambdakzeroanalysis { } } - if (doSecondaryV0s && std::abs(cascMC.pdgCodeV0()) == kLambda0) { + if (doSecondaryV0s == 2 && std::abs(cascMC.pdgCodeV0()) == kLambda0) { float v0PtMc = std::hypot(cascMC.pxPosMC() + cascMC.pxNegMC(), cascMC.pyPosMC() + cascMC.pyNegMC()); float v0RapMc = RecoDecay::y(std::array{cascMC.pxPosMC() + cascMC.pxNegMC(), cascMC.pyPosMC() + cascMC.pyNegMC(), cascMC.pzPosMC() + cascMC.pzNegMC()}, o2::constants::physics::MassLambda); if (v0Selections.rapidityMinCut < v0RapMc && v0RapMc < v0Selections.rapidityMaxCut) { @@ -3315,7 +3432,7 @@ struct derivedlambdakzeroanalysis { } } - if (doSecondaryV0s && std::abs(cascMC.pdgCodeV0()) == kLambda0) { + if (doSecondaryV0s == 2 && std::abs(cascMC.pdgCodeV0()) == kLambda0) { float v0PtMc = std::hypot(cascMC.pxPosMC() + cascMC.pxNegMC(), cascMC.pyPosMC() + cascMC.pyNegMC()); float v0RapMc = RecoDecay::y(std::array{cascMC.pxPosMC() + cascMC.pxNegMC(), cascMC.pyPosMC() + cascMC.pyNegMC(), cascMC.pzPosMC() + cascMC.pzNegMC()}, o2::constants::physics::MassLambda); if (v0Selections.rapidityMinCut < v0RapMc && v0RapMc < v0Selections.rapidityMaxCut) { From d64aad07fe3f051b0bb70b377eeb2d3abb6d0297 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 1 Sep 2026 21:43:41 +0000 Subject: [PATCH 3/3] Please consider the following formatting changes --- PWGLF/Utils/strangenessBuilderModule.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGLF/Utils/strangenessBuilderModule.h b/PWGLF/Utils/strangenessBuilderModule.h index 16a6b7a36cb..59e94a379d8 100644 --- a/PWGLF/Utils/strangenessBuilderModule.h +++ b/PWGLF/Utils/strangenessBuilderModule.h @@ -1907,7 +1907,7 @@ class BuilderModule // special treatment of Lambda --> neutron pi0 (both PDG codes > 0) // and K0s --> pi0 pi0 (both PDG codes > 0) // take neutron as positive daughter and pi0 as negative daughter - // if the first daughter was the pi0 (already assigned as positive), + // if the first daughter was the pi0 (already assigned as positive), // then transfer the information to the negative and fill the information // of the positive daughter with those of the neutrons if (thisInfo.pdgCodePositive > -1 && thisInfo.pdgCodePositive == PDG_t::kPi0) { @@ -2482,7 +2482,7 @@ class BuilderModule thisCascInfo.xyz[2] = dau.vz(); thisCascInfo.mcParticleBachelor = dau.globalIndex(); } - // Treatment of Lambda --> p pi ; Lambda --> n pi + // Treatment of Lambda --> p pi ; Lambda --> n pi if (std::abs(dau.pdgCode()) == PDG_t::kLambda0) { thisCascInfo.pdgCodeV0 = dau.pdgCode(); @@ -2494,7 +2494,7 @@ class BuilderModule if (v0Dau.pdgCode() > 0) { // special treatment of Lambda --> neutron pi0 (both PDG codes > 0) // take neutron as positive daughter and pi0 as negative daughter - // if the first daughter was the pi0 (already assigned as positive), + // if the first daughter was the pi0 (already assigned as positive), // then transfer the information to the negative and fill the information // of the positive daughter with those of the neutrons if (thisCascInfo.pdgCodePositive > -1 && thisCascInfo.pdgCodePositive == PDG_t::kPi0) { @@ -2526,7 +2526,7 @@ class BuilderModule } } } - // Special treatment of Xi0 and Xi from Omega --> Xi0 pi ; Omega --> Xi pi0 + // Special treatment of Xi0 and Xi from Omega --> Xi0 pi ; Omega --> Xi pi0 if (std::abs(dau.pdgCode()) == PDG_t::kXiMinus || std::abs(dau.pdgCode()) == o2::constants::physics::Pdg::kXi0) { thisCascInfo.pdgCodeV0 = dau.pdgCode();