Skip to content

[PWGLF] Add sigma plus decay and extend mass range #11897

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
fmazzasc merged 2 commits into from
Jul 4, 2025
Merged

[PWGLF] Add sigma plus decay and extend mass range #11897

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
2ca57aa
Extend mass axis
Jul 3, 2025
1b9c766
Add sigma plus decay
Jul 4, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
159 changes: 112 additions & 47 deletions PWGLF/Tasks/Resonances/lambda1405analysis.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
// Copyright 2019-2020 CERN and copyright holders of ALICE O2.

Check failure on line 1 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[name/workflow-file] 

Name of a workflow file must match the name of the main struct in it (without the PWG prefix). (Class implementation files should be in "Core" directories.)
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
Expand Down Expand Up @@ -27,33 +27,36 @@
using namespace o2::framework;
using namespace o2::framework::expressions;

using TracksFull = soa::Join<aod::TracksIU, aod::TracksExtra, aod::TracksCovIU, aod::pidTPCPi, aod::pidTOFFullPi>;
using TracksFull = soa::Join<aod::TracksIU, aod::TracksExtra, aod::TracksCovIU, aod::pidTPCPi, aod::pidTPCPr, aod::pidTOFFullPi, aod::pidTOFFullPr>;
using CollisionsFull = soa::Join<aod::Collisions, aod::EvSel>;
using CollisionsFullMC = soa::Join<aod::Collisions, aod::McCollisionLabels, aod::EvSels>;

struct lambda1405candidate {

Check failure on line 34 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[name/struct] 

Use UpperCamelCase for names of structs.
// Columns for Lambda(1405) candidate
float mass = -1; // Invariant mass of the Lambda(1405) candidate
float sigmaMass = -1; // Invariant mass of the Sigma candidate
float pt = -1; // pT of the Lambda(1405) candidate
int sigmaSign = 0; // Sign of the Sigma candidate: 1 for matter, -1 for antimatter
float sigmaPt = -1; // pT of the Sigma daughter
float piPt = -1; // pT of the pion daughter
float nSigmaTPCPi = -1; // Number of sigmas for the pion candidate
float nSigmaTOFPi = -1; // Number of sigmas for the pion candidate using TOF
int piFromSigmaID = 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
bool isSigmaPlus = false; // True if compatible with Sigma+
bool isSigmaMinus = false; // True if compatible with Sigma-
float mass = -1; // Invariant mass of the Lambda(1405) candidate
float sigmaMinusMass = -1; // Invariant mass of the Sigma- candidate
float sigmaPlusMass = -1; // Invariant mass of the Sigma+ candidate
float pt = -1; // pT of the Lambda(1405) candidate
int sigmaSign = 0; // Sign of the Sigma candidate: 1 for matter, -1 for antimatter
float sigmaPt = -1; // pT of the Sigma daughter
float piPt = -1; // pT of the pion daughter
float nSigmaTPCPi = -1; // Number of sigmas for the pion candidate
float nSigmaTOFPi = -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
};

struct lambda1405analysis {

Check failure on line 52 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[name/struct] 

Use UpperCamelCase for names of structs.
int lambda1405PdgCode = 102132; // PDG code for Lambda(1405)

Check failure on line 53 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[pdg/explicit-code] 

Avoid hard-coded PDG codes. Use named values from PDG_t or o2::constants::physics::Pdg instead.
lambda1405candidate lambda1405Cand; // Lambda(1405) candidate structure
// Histograms are defined with HistogramRegistry
HistogramRegistry rEventSelection{"eventSelection", {}, OutputObjHandlingPolicy::AnalysisObject, true, true};
HistogramRegistry rLambda1405{"lambda1405", {}, OutputObjHandlingPolicy::AnalysisObject, true, true};
// Configurable for event selection
Configurable<float> cutzvertex{"cutZVertex", 10.0f, "Accepted z-vertex range (cm)"};

Check failure on line 59 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[name/configurable] 

Use lowerCamelCase for names of configurables and use the same name for the struct member as for the JSON string. (Declare the type and names on the same line.)
Configurable<float> cutEtaDaught{"cutEtaDaughter", 0.8f, "Eta cut for daughter tracks"};
Configurable<float> cutDCAtoPVSigma{"cutDCAtoPVSigma", 0.1f, "Max DCA to primary vertex for Sigma candidates (cm)"};
Configurable<float> cutDCAtoPVPiFromSigma{"cutDCAtoPVPiFromSigma", 2., "Min DCA to primary vertex for pion from Sigma candidates (cm)"};
Expand All @@ -62,8 +65,8 @@
Configurable<float> cutSigmaMass{"cutSigmaMass", 0.1, "Sigma mass window (MeV/c^2)"};
Configurable<float> cutNITSClusPi{"cutNITSClusPi", 5, "Minimum number of ITS clusters for pion candidate"};
Configurable<float> cutNTPCClusPi{"cutNTPCClusPi", 90, "Minimum number of TPC clusters for pion candidate"};
Configurable<float> cutNSigmaPi{"cutNSigmaPi", 3, "NSigmaTPCPion"};
Configurable<float> cutNSigmaPiTOF{"cutNSigmaPiTOF", 3, "NSigmaTOFPion"};
Configurable<float> cutNSigmaTPC{"cutNSigmaTPC", 3, "NSigmaTPCPion"};
Configurable<float> cutNSigmaTOF{"cutNSigmaTOF", 3, "NSigmaTOFPion"};

Configurable<bool> doLSBkg{"doLikeSignBkg", false, "Use like-sign background"};
Configurable<bool> useTOF{"useTOF", false, "Use TOF for PID for pion candidates"};
Expand All @@ -77,31 +80,44 @@
const AxisSpec ptAxis{100, -10, 10, "#it{p}_{T} (GeV/#it{c})"};
const AxisSpec ptPiAxis{50, -2, 2, "#it{p}_{T}^{#pi} (GeV/#it{c})"};
const AxisSpec ptResolutionAxis{100, -0.5, 0.5, "#it{p}_{T}^{rec} - #it{p}_{T}^{gen} (GeV/#it{c})"};
const AxisSpec massAxis{100, 1.3, 1.5, "m (GeV/#it{c}^{2})"};
const AxisSpec massAxis{100, 1.3, 1.6, "m (GeV/#it{c}^{2})"};
const AxisSpec massResolutionAxis{100, -0.1, 0.1, "m_{rec} - m_{gen} (GeV/#it{c}^{2})"};
const AxisSpec nSigmaPiAxis{100, -5, 5, "n#sigma_{#pi}"};
const AxisSpec sigmaMassAxis{100, 1.1, 1.4, "m (GeV/#it{c}^{2})"};
const AxisSpec vertexZAxis{100, -15., 15., "vrtx_{Z} [cm]"};
rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}});
rLambda1405.add("h2PtMass", "h2PtMass", {HistType::kTH2F, {ptAxis, massAxis}});
rLambda1405.add("h2PtMassSigmaBeforeCuts", "h2PtMassSigmaBeforeCuts", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
rLambda1405.add("h2PtMassSigma", "h2PtMassSigma", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
rLambda1405.add("h2SigmaMassVsMass", "h2SigmaMassVsMass", {HistType::kTH2F, {massAxis, sigmaMassAxis}});
rLambda1405.add("h2PtPiNSigma", "h2PtPiNSigma", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
rLambda1405.add("h2PtPiNSigmaTOF", "h2PtPiNSigmaTOF", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});

// lambda1405 to sigmaminus
rLambda1405.add("h2PtMass_0", "h2PtMass_0", {HistType::kTH2F, {ptAxis, massAxis}});
rLambda1405.add("h2PtMassSigmaBeforeCuts_0", "h2PtMassSigmaBeforeCuts_0", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
rLambda1405.add("h2PtMassSigma_0", "h2PtMassSigma_0", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
rLambda1405.add("h2SigmaMassVsMass_0", "h2SigmaMassVsMass_0", {HistType::kTH2F, {massAxis, sigmaMassAxis}});
rLambda1405.add("h2PtPiNSigma_0", "h2PtPiNSigma_0", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
rLambda1405.add("h2PtPiNSigmaTOF_0", "h2PtPiNSigmaTOF_0", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
// lambda1405 to sigmaplus
rLambda1405.add("h2PtMass_1", "h2PtMass_1", {HistType::kTH2F, {ptAxis, massAxis}});
rLambda1405.add("h2PtMassSigmaBeforeCuts_1", "h2PtMassSigmaBeforeCuts_1", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
rLambda1405.add("h2PtMassSigma_1", "h2PtMassSigma_1", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
rLambda1405.add("h2SigmaMassVsMass_1", "h2SigmaMassVsMass_1", {HistType::kTH2F, {massAxis, sigmaMassAxis}});
rLambda1405.add("h2PtPiNSigma_1", "h2PtPiNSigma_1", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
rLambda1405.add("h2PtPiNSigmaTOF_1", "h2PtPiNSigmaTOF_1", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});

if (doprocessMC) {
// Add MC histograms if needed
rLambda1405.add("h2MassResolution", "h2MassResolution", {HistType::kTH2F, {massAxis, massResolutionAxis}});
rLambda1405.add("h2PtResolution", "h2PtResolution", {HistType::kTH2F, {ptAxis, ptResolutionAxis}});
rLambda1405.add("h2PtMassMC", "h2PtMassMC", {HistType::kTH2F, {ptAxis, massAxis}});
// Add MC histograms if needed, to sigmaminus
rLambda1405.add("h2MassResolution_0", "h2MassResolution_0", {HistType::kTH2F, {massAxis, massResolutionAxis}});
rLambda1405.add("h2PtResolution_0", "h2PtResolution_0", {HistType::kTH2F, {ptAxis, ptResolutionAxis}});
rLambda1405.add("h2PtMassMC_0", "h2PtMassMC_0", {HistType::kTH2F, {ptAxis, massAxis}});
// Add MC histograms if needed, to sigmaplus
rLambda1405.add("h2MassResolution_1", "h2MassResolution_1", {HistType::kTH2F, {massAxis, massResolutionAxis}});
rLambda1405.add("h2PtResolution_1", "h2PtResolution_1", {HistType::kTH2F, {ptAxis, ptResolutionAxis}});
rLambda1405.add("h2PtMassMC_1", "h2PtMassMC_1", {HistType::kTH2F, {ptAxis, massAxis}});
}
}

template <typename Ttrack>
bool selectPiTrack(const Ttrack& candidate, bool piFromSigma)
{
if (std::abs(candidate.tpcNSigmaPi()) > cutNSigmaPi || candidate.tpcNClsFound() < cutNTPCClusPi || std::abs(candidate.eta()) > cutEtaDaught) {
if (std::abs(candidate.tpcNSigmaPi()) > cutNSigmaTPC || candidate.tpcNClsFound() < cutNTPCClusPi || std::abs(candidate.eta()) > cutEtaDaught) {
return false;
}
if (piFromSigma) {
Expand All @@ -116,20 +132,46 @@
return false;
}

if (useTOF && std::abs(candidate.tofNSigmaPi()) > cutNSigmaPiTOF) {
if (useTOF && std::abs(candidate.tofNSigmaPi()) > cutNSigmaTOF) {
return false;
}

return true; // Track is selected
}

template <typename Ttrack>
bool selectProTrack(const Ttrack& candidate, bool prFromSigma)
{
if (std::abs(candidate.tpcNSigmaPr()) > cutNSigmaTPC || candidate.tpcNClsFound() < cutNTPCClusPi || std::abs(candidate.eta()) > cutEtaDaught) {
return false;
}
if (prFromSigma) {
return true;
}
if (candidate.itsNCls() < cutNITSClusPi) {
return false;
}
if (useTOF && !candidate.hasTOF()) {
return false;
}
if (useTOF && std::abs(candidate.tofNSigmaPr()) > cutNSigmaTOF) {
return false;
}
return true; // Track is selected
}

bool selectCandidate(aod::KinkCands::iterator const& sigmaCand, TracksFull const& tracks)
{
auto piKinkTrack = sigmaCand.trackDaug_as<TracksFull>();
if (!selectPiTrack(piKinkTrack, true)) {
auto kinkDauTrack = sigmaCand.trackDaug_as<TracksFull>();
bool isPiKink = selectPiTrack(kinkDauTrack, true);
bool isProKink = selectProTrack(kinkDauTrack, true);
if (!isPiKink || !isProKink) {
return false;
}
if (sigmaCand.mSigmaMinus() < o2::constants::physics::MassSigmaMinus - cutSigmaMass || sigmaCand.mSigmaMinus() > o2::constants::physics::MassSigmaMinus + cutSigmaMass) {

lambda1405Cand.isSigmaPlus = isProKink && (sigmaCand.mSigmaPlus() < o2::constants::physics::MassSigmaPlus - cutSigmaMass || sigmaCand.mSigmaPlus() > o2::constants::physics::MassSigmaPlus + cutSigmaMass);
lambda1405Cand.isSigmaMinus = isPiKink && (sigmaCand.mSigmaMinus() < o2::constants::physics::MassSigmaMinus - cutSigmaMass || sigmaCand.mSigmaMinus() > o2::constants::physics::MassSigmaMinus + cutSigmaMass);
if (!lambda1405Cand.isSigmaPlus && !lambda1405Cand.isSigmaMinus) {
return false;
}
float sigmaRad = std::hypot(sigmaCand.xDecVtx(), sigmaCand.yDecVtx());
Expand All @@ -153,15 +195,17 @@
auto sigmaMom = std::array{sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth()};
auto piMom = std::array{piTrack.px(), piTrack.py(), piTrack.pz()};
float pt = std::hypot(sigmaMom[0] + piMom[0], sigmaMom[1] + piMom[1]);
float invMass = RecoDecay::m(std::array{sigmaMom, piMom}, std::array{o2::constants::physics::MassSigmaMinus, o2::constants::physics::MassPiPlus});
double massSigma = lambda1405Cand.isSigmaMinus ? sigmaCand.mSigmaMinus() : sigmaCand.mSigmaPlus();
float invMass = RecoDecay::m(std::array{sigmaMom, piMom}, std::array{massSigma, o2::constants::physics::MassPiPlus});
if (invMass < 1.3 || invMass > 1.5) {

Check failure on line 200 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[magic-number] 

Avoid magic numbers in expressions. Assign the value to a clearly named variable or constant.
continue;
}
lambda1405Cand.piFromSigmaID = piKinkTrack.globalIndex();
lambda1405Cand.kinkDauID = kinkDauTrack.globalIndex();
lambda1405Cand.sigmaID = sigmaCand.globalIndex();
lambda1405Cand.piID = piTrack.globalIndex();
lambda1405Cand.mass = invMass;
lambda1405Cand.sigmaMass = sigmaCand.mSigmaMinus();
lambda1405Cand.sigmaMinusMass = sigmaCand.mSigmaMinus();
lambda1405Cand.sigmaPlusMass = sigmaCand.mSigmaPlus();
lambda1405Cand.sigmaSign = sigmaCand.mothSign();
lambda1405Cand.pt = pt;
lambda1405Cand.sigmaPt = sigmaCand.ptMoth();
Expand All @@ -185,11 +229,20 @@
rEventSelection.fill(HIST("hVertexZRec"), collision.posZ());
for (const auto& sigmaCand : kinkCands) {
if (selectCandidate(sigmaCand, tracks)) {
rLambda1405.fill(HIST("h2PtMass"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtMassSigma"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMass);
rLambda1405.fill(HIST("h2SigmaMassVsMass"), lambda1405Cand.mass, lambda1405Cand.sigmaMass);
rLambda1405.fill(HIST("h2PtPiNSigma"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
rLambda1405.fill(HIST("h2PtPiNSigmaTOF"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTOFPi);
if (lambda1405Cand.isSigmaMinus) {
rLambda1405.fill(HIST("h2PtMass_0"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtMassSigma_0"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMinusMass);
rLambda1405.fill(HIST("h2SigmaMassVsMass_0"), lambda1405Cand.mass, lambda1405Cand.sigmaMinusMass);
rLambda1405.fill(HIST("h2PtPiNSigma_0"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
rLambda1405.fill(HIST("h2PtPiNSigmaTOF_0"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTOFPi);
}
if (lambda1405Cand.isSigmaPlus) {
rLambda1405.fill(HIST("h2PtMass_1"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtMassSigma_1"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaPlusMass);
rLambda1405.fill(HIST("h2SigmaMassVsMass_1"), lambda1405Cand.mass, lambda1405Cand.sigmaPlusMass);
rLambda1405.fill(HIST("h2PtPiNSigma_1"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
rLambda1405.fill(HIST("h2PtPiNSigmaTOF_1"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTOFPi);
}
}
}
}
Expand All @@ -207,7 +260,7 @@
for (const auto& sigmaCand : sigmaCandsPerCol) {
if (selectCandidate(sigmaCand, tracksPerCol)) {
// Do MC association
auto mcLabPiKink = trackLabelsMC.rawIteratorAt(lambda1405Cand.piFromSigmaID);
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()) {
Expand All @@ -216,7 +269,7 @@
auto mcTrackPiKink = mcLabPiKink.mcParticle_as<aod::McParticles>();
auto mcTrackSigma = mcLabSigma.mcParticle_as<aod::McParticles>();
auto mcTrackPi = mcLabPi.mcParticle_as<aod::McParticles>();
if (std::abs(mcTrackPiKink.pdgCode()) != 211 || std::abs(mcTrackSigma.pdgCode()) != 3122 || std::abs(mcTrackPi.pdgCode()) != 211) {

Check failure on line 272 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[magic-number] 

Avoid magic numbers in expressions. Assign the value to a clearly named variable or constant.

Check failure on line 272 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[pdg/explicit-code] 

Avoid hard-coded PDG codes. Use named values from PDG_t or o2::constants::physics::Pdg instead.
continue; // Skip if not a valid pion or Sigma candidate
}
if (!mcTrackPiKink.has_mothers() || !mcTrackSigma.has_mothers() || !mcTrackPi.has_mothers()) {
Expand Down Expand Up @@ -249,12 +302,22 @@
auto lambda1405Mother = particlesMC.rawIteratorAt(lambda1405Id);
LOG(info) << "Particle selected!";
float lambda1405Mass = std::sqrt(lambda1405Mother.e() * lambda1405Mother.e() - lambda1405Mother.p() * lambda1405Mother.p());
rLambda1405.fill(HIST("h2PtMass"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtMassSigma"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMass);
rLambda1405.fill(HIST("h2SigmaMassVsMass"), lambda1405Cand.mass, lambda1405Cand.sigmaMass);
rLambda1405.fill(HIST("h2PtPiNSigma"), lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
rLambda1405.fill(HIST("h2MassResolution"), lambda1405Mass, lambda1405Mass - lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtResolution"), lambda1405Cand.pt, lambda1405Cand.pt - lambda1405Mother.pt());
if (lambda1405Cand.isSigmaMinus) {
rLambda1405.fill(HIST("h2PtMass_0"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtMassSigma_0"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMinusMass);
rLambda1405.fill(HIST("h2SigmaMassVsMass_0"), lambda1405Cand.mass, lambda1405Cand.sigmaMinusMass);
rLambda1405.fill(HIST("h2PtPiNSigma_0"), lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
rLambda1405.fill(HIST("h2MassResolution_0"), lambda1405Mass, lambda1405Mass - lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtResolution_0"), lambda1405Cand.pt, lambda1405Cand.pt - lambda1405Mother.pt());
}
if (lambda1405Cand.isSigmaPlus) {
rLambda1405.fill(HIST("h2PtMass_1"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtMassSigma_1"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaPlusMass);
rLambda1405.fill(HIST("h2SigmaMassVsMass_1"), lambda1405Cand.mass, lambda1405Cand.sigmaPlusMass);
rLambda1405.fill(HIST("h2PtPiNSigma_1"), lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
rLambda1405.fill(HIST("h2MassResolution_1"), lambda1405Mass, lambda1405Mass - lambda1405Cand.mass);
rLambda1405.fill(HIST("h2PtResolution_1"), lambda1405Cand.pt, lambda1405Cand.pt - lambda1405Mother.pt());
}
}
}
}
Expand All @@ -269,9 +332,11 @@
}
// Check if the Lambda(1405) has a Sigma daughter
bool hasSigmaDaughter = false;
int dauPdgCode = 0;
for (const auto& daughter : mcPart.daughters_as<aod::McParticles>()) {
if (std::abs(daughter.pdgCode()) == 3122) { // Sigma PDG code
if (std::abs(daughter.pdgCode()) == 3122 || std::abs(daughter.pdgCode()) == 3222) { // Sigma PDG code

Check failure on line 337 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[magic-number] 

Avoid magic numbers in expressions. Assign the value to a clearly named variable or constant.

Check failure on line 337 in PWGLF/Tasks/Resonances/lambda1405analysis.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[pdg/explicit-code] 

Avoid hard-coded PDG codes. Use named values from PDG_t or o2::constants::physics::Pdg instead.
hasSigmaDaughter = true;
dauPdgCode = daughter.pdgCode();
break; // Found a Sigma daughter, exit loop
}
}
Expand All @@ -280,7 +345,7 @@
}

float mcMass = std::sqrt(mcPart.e() * mcPart.e() - mcPart.p() * mcPart.p());
rLambda1405.fill(HIST("h2PtMassMC"), mcPart.pt(), mcMass);
dauPdgCode ? rLambda1405.fill(HIST("h2PtMassMC_0"), mcPart.pt(), mcMass) : rLambda1405.fill(HIST("h2PtMassMC_1"), mcPart.pt(), mcMass);
}
}
PROCESS_SWITCH(lambda1405analysis, processMC, "MC processing", false);
Expand Down
Loading