Skip to content

Commit 23bd0e5

Browse files
fmazzascFrancesco Mazzaschi
fmazzasc
and
Francesco Mazzaschi
authored
[PWGLF] Extend mass axis (#11897)
Co-authored-by: Francesco Mazzaschi <fmazzasc@alipap1.cern.ch>
1 parent 6ce4172 commit 23bd0e5

File tree

1 file changed

+112
-47
lines changed

1 file changed

+112
-47
lines changed

‎PWGLF/Tasks/Resonances/lambda1405analysis.cxx‎

Lines changed: 112 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -27,23 +27,26 @@ using namespace o2;
2727
using namespace o2::framework;
2828
using namespace o2::framework::expressions;
2929

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

3434
struct lambda1405candidate {
3535
// Columns for Lambda(1405) candidate
36-
float mass = -1; // Invariant mass of the Lambda(1405) candidate
37-
float sigmaMass = -1; // Invariant mass of the Sigma candidate
38-
float pt = -1; // pT of the Lambda(1405) candidate
39-
int sigmaSign = 0; // Sign of the Sigma candidate: 1 for matter, -1 for antimatter
40-
float sigmaPt = -1; // pT of the Sigma daughter
41-
float piPt = -1; // pT of the pion daughter
42-
float nSigmaTPCPi = -1; // Number of sigmas for the pion candidate
43-
float nSigmaTOFPi = -1; // Number of sigmas for the pion candidate using TOF
44-
int piFromSigmaID = 0; // ID of the pion from Sigma decay in MC
45-
int sigmaID = 0; // ID of the Sigma candidate in MC
46-
int piID = 0; // ID of the pion candidate in MC
36+
bool isSigmaPlus = false; // True if compatible with Sigma+
37+
bool isSigmaMinus = false; // True if compatible with Sigma-
38+
float mass = -1; // Invariant mass of the Lambda(1405) candidate
39+
float sigmaMinusMass = -1; // Invariant mass of the Sigma- candidate
40+
float sigmaPlusMass = -1; // Invariant mass of the Sigma+ candidate
41+
float pt = -1; // pT of the Lambda(1405) candidate
42+
int sigmaSign = 0; // Sign of the Sigma candidate: 1 for matter, -1 for antimatter
43+
float sigmaPt = -1; // pT of the Sigma daughter
44+
float piPt = -1; // pT of the pion daughter
45+
float nSigmaTPCPi = -1; // Number of sigmas for the pion candidate
46+
float nSigmaTOFPi = -1; // Number of sigmas for the pion candidate using TOF
47+
int kinkDauID = 0; // ID of the pion from Sigma decay in MC
48+
int sigmaID = 0; // ID of the Sigma candidate in MC
49+
int piID = 0; // ID of the pion candidate in MC
4750
};
4851

4952
struct lambda1405analysis {
@@ -62,8 +65,8 @@ struct lambda1405analysis {
6265
Configurable<float> cutSigmaMass{"cutSigmaMass", 0.1, "Sigma mass window (MeV/c^2)"};
6366
Configurable<float> cutNITSClusPi{"cutNITSClusPi", 5, "Minimum number of ITS clusters for pion candidate"};
6467
Configurable<float> cutNTPCClusPi{"cutNTPCClusPi", 90, "Minimum number of TPC clusters for pion candidate"};
65-
Configurable<float> cutNSigmaPi{"cutNSigmaPi", 3, "NSigmaTPCPion"};
66-
Configurable<float> cutNSigmaPiTOF{"cutNSigmaPiTOF", 3, "NSigmaTOFPion"};
68+
Configurable<float> cutNSigmaTPC{"cutNSigmaTPC", 3, "NSigmaTPCPion"};
69+
Configurable<float> cutNSigmaTOF{"cutNSigmaTOF", 3, "NSigmaTOFPion"};
6770

6871
Configurable<bool> doLSBkg{"doLikeSignBkg", false, "Use like-sign background"};
6972
Configurable<bool> useTOF{"useTOF", false, "Use TOF for PID for pion candidates"};
@@ -77,31 +80,44 @@ struct lambda1405analysis {
7780
const AxisSpec ptAxis{100, -10, 10, "#it{p}_{T} (GeV/#it{c})"};
7881
const AxisSpec ptPiAxis{50, -2, 2, "#it{p}_{T}^{#pi} (GeV/#it{c})"};
7982
const AxisSpec ptResolutionAxis{100, -0.5, 0.5, "#it{p}_{T}^{rec} - #it{p}_{T}^{gen} (GeV/#it{c})"};
80-
const AxisSpec massAxis{100, 1.3, 1.5, "m (GeV/#it{c}^{2})"};
83+
const AxisSpec massAxis{100, 1.3, 1.6, "m (GeV/#it{c}^{2})"};
8184
const AxisSpec massResolutionAxis{100, -0.1, 0.1, "m_{rec} - m_{gen} (GeV/#it{c}^{2})"};
8285
const AxisSpec nSigmaPiAxis{100, -5, 5, "n#sigma_{#pi}"};
8386
const AxisSpec sigmaMassAxis{100, 1.1, 1.4, "m (GeV/#it{c}^{2})"};
8487
const AxisSpec vertexZAxis{100, -15., 15., "vrtx_{Z} [cm]"};
8588
rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}});
86-
rLambda1405.add("h2PtMass", "h2PtMass", {HistType::kTH2F, {ptAxis, massAxis}});
87-
rLambda1405.add("h2PtMassSigmaBeforeCuts", "h2PtMassSigmaBeforeCuts", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
88-
rLambda1405.add("h2PtMassSigma", "h2PtMassSigma", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
89-
rLambda1405.add("h2SigmaMassVsMass", "h2SigmaMassVsMass", {HistType::kTH2F, {massAxis, sigmaMassAxis}});
90-
rLambda1405.add("h2PtPiNSigma", "h2PtPiNSigma", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
91-
rLambda1405.add("h2PtPiNSigmaTOF", "h2PtPiNSigmaTOF", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
89+
90+
// lambda1405 to sigmaminus
91+
rLambda1405.add("h2PtMass_0", "h2PtMass_0", {HistType::kTH2F, {ptAxis, massAxis}});
92+
rLambda1405.add("h2PtMassSigmaBeforeCuts_0", "h2PtMassSigmaBeforeCuts_0", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
93+
rLambda1405.add("h2PtMassSigma_0", "h2PtMassSigma_0", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
94+
rLambda1405.add("h2SigmaMassVsMass_0", "h2SigmaMassVsMass_0", {HistType::kTH2F, {massAxis, sigmaMassAxis}});
95+
rLambda1405.add("h2PtPiNSigma_0", "h2PtPiNSigma_0", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
96+
rLambda1405.add("h2PtPiNSigmaTOF_0", "h2PtPiNSigmaTOF_0", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
97+
// lambda1405 to sigmaplus
98+
rLambda1405.add("h2PtMass_1", "h2PtMass_1", {HistType::kTH2F, {ptAxis, massAxis}});
99+
rLambda1405.add("h2PtMassSigmaBeforeCuts_1", "h2PtMassSigmaBeforeCuts_1", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
100+
rLambda1405.add("h2PtMassSigma_1", "h2PtMassSigma_1", {HistType::kTH2F, {ptAxis, sigmaMassAxis}});
101+
rLambda1405.add("h2SigmaMassVsMass_1", "h2SigmaMassVsMass_1", {HistType::kTH2F, {massAxis, sigmaMassAxis}});
102+
rLambda1405.add("h2PtPiNSigma_1", "h2PtPiNSigma_1", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
103+
rLambda1405.add("h2PtPiNSigmaTOF_1", "h2PtPiNSigmaTOF_1", {HistType::kTH2F, {ptPiAxis, nSigmaPiAxis}});
92104

93105
if (doprocessMC) {
94-
// Add MC histograms if needed
95-
rLambda1405.add("h2MassResolution", "h2MassResolution", {HistType::kTH2F, {massAxis, massResolutionAxis}});
96-
rLambda1405.add("h2PtResolution", "h2PtResolution", {HistType::kTH2F, {ptAxis, ptResolutionAxis}});
97-
rLambda1405.add("h2PtMassMC", "h2PtMassMC", {HistType::kTH2F, {ptAxis, massAxis}});
106+
// Add MC histograms if needed, to sigmaminus
107+
rLambda1405.add("h2MassResolution_0", "h2MassResolution_0", {HistType::kTH2F, {massAxis, massResolutionAxis}});
108+
rLambda1405.add("h2PtResolution_0", "h2PtResolution_0", {HistType::kTH2F, {ptAxis, ptResolutionAxis}});
109+
rLambda1405.add("h2PtMassMC_0", "h2PtMassMC_0", {HistType::kTH2F, {ptAxis, massAxis}});
110+
// Add MC histograms if needed, to sigmaplus
111+
rLambda1405.add("h2MassResolution_1", "h2MassResolution_1", {HistType::kTH2F, {massAxis, massResolutionAxis}});
112+
rLambda1405.add("h2PtResolution_1", "h2PtResolution_1", {HistType::kTH2F, {ptAxis, ptResolutionAxis}});
113+
rLambda1405.add("h2PtMassMC_1", "h2PtMassMC_1", {HistType::kTH2F, {ptAxis, massAxis}});
98114
}
99115
}
100116

101117
template <typename Ttrack>
102118
bool selectPiTrack(const Ttrack& candidate, bool piFromSigma)
103119
{
104-
if (std::abs(candidate.tpcNSigmaPi()) > cutNSigmaPi || candidate.tpcNClsFound() < cutNTPCClusPi || std::abs(candidate.eta()) > cutEtaDaught) {
120+
if (std::abs(candidate.tpcNSigmaPi()) > cutNSigmaTPC || candidate.tpcNClsFound() < cutNTPCClusPi || std::abs(candidate.eta()) > cutEtaDaught) {
105121
return false;
106122
}
107123
if (piFromSigma) {
@@ -116,20 +132,46 @@ struct lambda1405analysis {
116132
return false;
117133
}
118134

119-
if (useTOF && std::abs(candidate.tofNSigmaPi()) > cutNSigmaPiTOF) {
135+
if (useTOF && std::abs(candidate.tofNSigmaPi()) > cutNSigmaTOF) {
120136
return false;
121137
}
122138

123139
return true; // Track is selected
124140
}
125141

142+
template <typename Ttrack>
143+
bool selectProTrack(const Ttrack& candidate, bool prFromSigma)
144+
{
145+
if (std::abs(candidate.tpcNSigmaPr()) > cutNSigmaTPC || candidate.tpcNClsFound() < cutNTPCClusPi || std::abs(candidate.eta()) > cutEtaDaught) {
146+
return false;
147+
}
148+
if (prFromSigma) {
149+
return true;
150+
}
151+
if (candidate.itsNCls() < cutNITSClusPi) {
152+
return false;
153+
}
154+
if (useTOF && !candidate.hasTOF()) {
155+
return false;
156+
}
157+
if (useTOF && std::abs(candidate.tofNSigmaPr()) > cutNSigmaTOF) {
158+
return false;
159+
}
160+
return true; // Track is selected
161+
}
162+
126163
bool selectCandidate(aod::KinkCands::iterator const& sigmaCand, TracksFull const& tracks)
127164
{
128-
auto piKinkTrack = sigmaCand.trackDaug_as<TracksFull>();
129-
if (!selectPiTrack(piKinkTrack, true)) {
165+
auto kinkDauTrack = sigmaCand.trackDaug_as<TracksFull>();
166+
bool isPiKink = selectPiTrack(kinkDauTrack, true);
167+
bool isProKink = selectProTrack(kinkDauTrack, true);
168+
if (!isPiKink || !isProKink) {
130169
return false;
131170
}
132-
if (sigmaCand.mSigmaMinus() < o2::constants::physics::MassSigmaMinus - cutSigmaMass || sigmaCand.mSigmaMinus() > o2::constants::physics::MassSigmaMinus + cutSigmaMass) {
171+
172+
lambda1405Cand.isSigmaPlus = isProKink && (sigmaCand.mSigmaPlus() < o2::constants::physics::MassSigmaPlus - cutSigmaMass || sigmaCand.mSigmaPlus() > o2::constants::physics::MassSigmaPlus + cutSigmaMass);
173+
lambda1405Cand.isSigmaMinus = isPiKink && (sigmaCand.mSigmaMinus() < o2::constants::physics::MassSigmaMinus - cutSigmaMass || sigmaCand.mSigmaMinus() > o2::constants::physics::MassSigmaMinus + cutSigmaMass);
174+
if (!lambda1405Cand.isSigmaPlus && !lambda1405Cand.isSigmaMinus) {
133175
return false;
134176
}
135177
float sigmaRad = std::hypot(sigmaCand.xDecVtx(), sigmaCand.yDecVtx());
@@ -153,15 +195,17 @@ struct lambda1405analysis {
153195
auto sigmaMom = std::array{sigmaCand.pxMoth(), sigmaCand.pyMoth(), sigmaCand.pzMoth()};
154196
auto piMom = std::array{piTrack.px(), piTrack.py(), piTrack.pz()};
155197
float pt = std::hypot(sigmaMom[0] + piMom[0], sigmaMom[1] + piMom[1]);
156-
float invMass = RecoDecay::m(std::array{sigmaMom, piMom}, std::array{o2::constants::physics::MassSigmaMinus, o2::constants::physics::MassPiPlus});
198+
double massSigma = lambda1405Cand.isSigmaMinus ? sigmaCand.mSigmaMinus() : sigmaCand.mSigmaPlus();
199+
float invMass = RecoDecay::m(std::array{sigmaMom, piMom}, std::array{massSigma, o2::constants::physics::MassPiPlus});
157200
if (invMass < 1.3 || invMass > 1.5) {
158201
continue;
159202
}
160-
lambda1405Cand.piFromSigmaID = piKinkTrack.globalIndex();
203+
lambda1405Cand.kinkDauID = kinkDauTrack.globalIndex();
161204
lambda1405Cand.sigmaID = sigmaCand.globalIndex();
162205
lambda1405Cand.piID = piTrack.globalIndex();
163206
lambda1405Cand.mass = invMass;
164-
lambda1405Cand.sigmaMass = sigmaCand.mSigmaMinus();
207+
lambda1405Cand.sigmaMinusMass = sigmaCand.mSigmaMinus();
208+
lambda1405Cand.sigmaPlusMass = sigmaCand.mSigmaPlus();
165209
lambda1405Cand.sigmaSign = sigmaCand.mothSign();
166210
lambda1405Cand.pt = pt;
167211
lambda1405Cand.sigmaPt = sigmaCand.ptMoth();
@@ -185,11 +229,20 @@ struct lambda1405analysis {
185229
rEventSelection.fill(HIST("hVertexZRec"), collision.posZ());
186230
for (const auto& sigmaCand : kinkCands) {
187231
if (selectCandidate(sigmaCand, tracks)) {
188-
rLambda1405.fill(HIST("h2PtMass"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
189-
rLambda1405.fill(HIST("h2PtMassSigma"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMass);
190-
rLambda1405.fill(HIST("h2SigmaMassVsMass"), lambda1405Cand.mass, lambda1405Cand.sigmaMass);
191-
rLambda1405.fill(HIST("h2PtPiNSigma"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
192-
rLambda1405.fill(HIST("h2PtPiNSigmaTOF"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTOFPi);
232+
if (lambda1405Cand.isSigmaMinus) {
233+
rLambda1405.fill(HIST("h2PtMass_0"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
234+
rLambda1405.fill(HIST("h2PtMassSigma_0"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMinusMass);
235+
rLambda1405.fill(HIST("h2SigmaMassVsMass_0"), lambda1405Cand.mass, lambda1405Cand.sigmaMinusMass);
236+
rLambda1405.fill(HIST("h2PtPiNSigma_0"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
237+
rLambda1405.fill(HIST("h2PtPiNSigmaTOF_0"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTOFPi);
238+
}
239+
if (lambda1405Cand.isSigmaPlus) {
240+
rLambda1405.fill(HIST("h2PtMass_1"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
241+
rLambda1405.fill(HIST("h2PtMassSigma_1"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaPlusMass);
242+
rLambda1405.fill(HIST("h2SigmaMassVsMass_1"), lambda1405Cand.mass, lambda1405Cand.sigmaPlusMass);
243+
rLambda1405.fill(HIST("h2PtPiNSigma_1"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
244+
rLambda1405.fill(HIST("h2PtPiNSigmaTOF_1"), lambda1405Cand.sigmaSign * lambda1405Cand.piPt, lambda1405Cand.nSigmaTOFPi);
245+
}
193246
}
194247
}
195248
}
@@ -207,7 +260,7 @@ struct lambda1405analysis {
207260
for (const auto& sigmaCand : sigmaCandsPerCol) {
208261
if (selectCandidate(sigmaCand, tracksPerCol)) {
209262
// Do MC association
210-
auto mcLabPiKink = trackLabelsMC.rawIteratorAt(lambda1405Cand.piFromSigmaID);
263+
auto mcLabPiKink = trackLabelsMC.rawIteratorAt(lambda1405Cand.kinkDauID);
211264
auto mcLabSigma = trackLabelsMC.rawIteratorAt(lambda1405Cand.sigmaID);
212265
auto mcLabPi = trackLabelsMC.rawIteratorAt(lambda1405Cand.piID);
213266
if (!mcLabSigma.has_mcParticle() || mcLabPiKink.has_mcParticle() || mcLabPi.has_mcParticle()) {
@@ -249,12 +302,22 @@ struct lambda1405analysis {
249302
auto lambda1405Mother = particlesMC.rawIteratorAt(lambda1405Id);
250303
LOG(info) << "Particle selected!";
251304
float lambda1405Mass = std::sqrt(lambda1405Mother.e() * lambda1405Mother.e() - lambda1405Mother.p() * lambda1405Mother.p());
252-
rLambda1405.fill(HIST("h2PtMass"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
253-
rLambda1405.fill(HIST("h2PtMassSigma"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMass);
254-
rLambda1405.fill(HIST("h2SigmaMassVsMass"), lambda1405Cand.mass, lambda1405Cand.sigmaMass);
255-
rLambda1405.fill(HIST("h2PtPiNSigma"), lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
256-
rLambda1405.fill(HIST("h2MassResolution"), lambda1405Mass, lambda1405Mass - lambda1405Cand.mass);
257-
rLambda1405.fill(HIST("h2PtResolution"), lambda1405Cand.pt, lambda1405Cand.pt - lambda1405Mother.pt());
305+
if (lambda1405Cand.isSigmaMinus) {
306+
rLambda1405.fill(HIST("h2PtMass_0"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
307+
rLambda1405.fill(HIST("h2PtMassSigma_0"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaMinusMass);
308+
rLambda1405.fill(HIST("h2SigmaMassVsMass_0"), lambda1405Cand.mass, lambda1405Cand.sigmaMinusMass);
309+
rLambda1405.fill(HIST("h2PtPiNSigma_0"), lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
310+
rLambda1405.fill(HIST("h2MassResolution_0"), lambda1405Mass, lambda1405Mass - lambda1405Cand.mass);
311+
rLambda1405.fill(HIST("h2PtResolution_0"), lambda1405Cand.pt, lambda1405Cand.pt - lambda1405Mother.pt());
312+
}
313+
if (lambda1405Cand.isSigmaPlus) {
314+
rLambda1405.fill(HIST("h2PtMass_1"), lambda1405Cand.sigmaSign * lambda1405Cand.pt, lambda1405Cand.mass);
315+
rLambda1405.fill(HIST("h2PtMassSigma_1"), lambda1405Cand.sigmaSign * lambda1405Cand.sigmaPt, lambda1405Cand.sigmaPlusMass);
316+
rLambda1405.fill(HIST("h2SigmaMassVsMass_1"), lambda1405Cand.mass, lambda1405Cand.sigmaPlusMass);
317+
rLambda1405.fill(HIST("h2PtPiNSigma_1"), lambda1405Cand.piPt, lambda1405Cand.nSigmaTPCPi);
318+
rLambda1405.fill(HIST("h2MassResolution_1"), lambda1405Mass, lambda1405Mass - lambda1405Cand.mass);
319+
rLambda1405.fill(HIST("h2PtResolution_1"), lambda1405Cand.pt, lambda1405Cand.pt - lambda1405Mother.pt());
320+
}
258321
}
259322
}
260323
}
@@ -269,9 +332,11 @@ struct lambda1405analysis {
269332
}
270333
// Check if the Lambda(1405) has a Sigma daughter
271334
bool hasSigmaDaughter = false;
335+
int dauPdgCode = 0;
272336
for (const auto& daughter : mcPart.daughters_as<aod::McParticles>()) {
273-
if (std::abs(daughter.pdgCode()) == 3122) { // Sigma PDG code
337+
if (std::abs(daughter.pdgCode()) == 3122 || std::abs(daughter.pdgCode()) == 3222) { // Sigma PDG code
274338
hasSigmaDaughter = true;
339+
dauPdgCode = daughter.pdgCode();
275340
break; // Found a Sigma daughter, exit loop
276341
}
277342
}
@@ -280,7 +345,7 @@ struct lambda1405analysis {
280345
}
281346

282347
float mcMass = std::sqrt(mcPart.e() * mcPart.e() - mcPart.p() * mcPart.p());
283-
rLambda1405.fill(HIST("h2PtMassMC"), mcPart.pt(), mcMass);
348+
dauPdgCode ? rLambda1405.fill(HIST("h2PtMassMC_0"), mcPart.pt(), mcMass) : rLambda1405.fill(HIST("h2PtMassMC_1"), mcPart.pt(), mcMass);
284349
}
285350
}
286351
PROCESS_SWITCH(lambda1405analysis, processMC, "MC processing", false);

0 commit comments

Comments
 (0)