Skip to content

Commit dee284a

Browse files
ariedel-cernariedel-cern
committed
Feat: use strangeness TOF for daughter PID
1 parent b875773 commit dee284a

13 files changed

Lines changed: 260 additions & 123 deletions

‎PWGCF/Femto/Core/cascadeBuilder.h‎

Lines changed: 64 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -132,10 +132,10 @@ enum CascadeSels {
132132
kCascadeTransRadMin, ///< max. transverse radius
133133

134134
// selection for lambda daughter
135-
kLambdaCpaMin, ///< Min. DCA of the lambda daughers at primary vertex
136-
kLambdaDcaDauMax, ///< TPC PID for daughters (Pion/Proton)
137-
kLambdaTransRadMin, ///< Min. number of TPC clusters of daughter
138-
kLambdaDcaToPvMin, ///< Min. DCA to primary vertex of daughter lambda
135+
kLambdaCpaMin, ///< Min. CPA of the lambda
136+
kLambdaDcaDauMax, ///< Max. DCA between the lambda daughters at lambda decay vertex
137+
kLambdaTransRadMin, ///< Min. tranverse radius of the lambda
138+
kLambdaDcaToPvMin, ///< Min. DCA of the lambda to the primary vertex
139139

140140
// selection for bachelor/daugthers
141141
kDauAbsEtaMax, ///< Max. |eta| of daughter tracks
@@ -181,9 +181,7 @@ const std::unordered_map<CascadeSels, std::string> cascadeSelectionNames = {
181181
{kPosDauTpc, "Positive Daughter TPC PID"},
182182
{kNegDauTpc, "Negative Daughter TPC PID"},
183183
{kPosDauTof, "Positive Daughter TOF PID"},
184-
{kNegDauTof, "Negative Daughter TOF PID"},
185-
186-
{kCascadeSelsMax, "Cascade Selections Max"}};
184+
{kNegDauTof, "Negative Daughter TOF PID"}};
187185

188186
/// enum for all cascade pre-filters (evaluated in checkFilters, before the selection bitmask)
189187
enum CascadeFilters {
@@ -237,6 +235,17 @@ class CascadeSelection : public baseselection::BaseSelection<float, o2::analysis
237235
{
238236
this->init(config.passThrough.value);
239237

238+
mPtMin = filter.ptMin.value;
239+
mPtMax = filter.ptMax.value;
240+
mEtaMin = filter.etaMin.value;
241+
mEtaMax = filter.etaMax.value;
242+
mPhiMin = filter.phiMin.value;
243+
mPhiMax = filter.phiMax.value;
244+
mLambdaMassMin = filter.massLambdaMin.value;
245+
mLambdaMassMax = filter.massLambdaMax.value;
246+
mRequireTof = config.requireTof.value;
247+
mKeepTracksWithoutTof = config.keepTracksWithoutTof.value;
248+
240249
if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) {
241250
mXiMassLowerLimit = filter.massXiMin.value;
242251
mXiMassUpperLimit = filter.massXiMax.value;
@@ -256,17 +265,6 @@ class CascadeSelection : public baseselection::BaseSelection<float, o2::analysis
256265
this->addSelection(kBachelorTofKaon, cascadeSelectionNames.at(kBachelorTofKaon), config.bachelorTofKaon.value, limits::kAbsUpperLimit, true, mRequireTof, false);
257266
}
258267

259-
mPtMin = filter.ptMin.value;
260-
mPtMax = filter.ptMax.value;
261-
mEtaMin = filter.etaMin.value;
262-
mEtaMax = filter.etaMax.value;
263-
mPhiMin = filter.phiMin.value;
264-
mPhiMax = filter.phiMax.value;
265-
mLambdaMassMin = filter.massLambdaMin.value;
266-
mLambdaMassMax = filter.massLambdaMax.value;
267-
mRequireTof = config.requireTof.value;
268-
mKeepTracksWithoutTof = config.keepTracksWithoutTof.value;
269-
270268
this->addSelection(kPosDauTpc, cascadeSelectionNames.at(kPosDauTpc), config.posDauTpc.value, limits::kAbsUpperLimit, true, true, false);
271269
this->addSelection(kNegDauTpc, cascadeSelectionNames.at(kNegDauTpc), config.negDauTpc.value, limits::kAbsUpperLimit, true, true, false);
272270
this->addSelection(kPosDauTof, cascadeSelectionNames.at(kPosDauTof), config.posDauTof.value, limits::kAbsUpperLimit, true, mRequireTof, false);
@@ -324,56 +322,64 @@ class CascadeSelection : public baseselection::BaseSelection<float, o2::analysis
324322
auto negDaughter = cascade.template negTrack_as<T2>();
325323

326324
// daughter selections
327-
std::array<float, 3> etaDaughters = {std::fabs(bachelor.eta()), std::fabs(posDaughter.eta()), std::fabs(negDaughter.eta())};
325+
std::array<float, 3> etaDaughters = {std::fabs(cascade.bacheloreta()), std::fabs(cascade.positiveeta()), std::fabs(cascade.negativeeta())};
328326
this->evaluateObservable(kDauAbsEtaMax, *std::max_element(etaDaughters.begin(), etaDaughters.end()));
329327

330-
std::array<float, 3> dcaDaughters = {std::fabs(bachelor.dcaXY()), std::fabs(posDaughter.dcaXY()), std::fabs(negDaughter.dcaXY())};
328+
std::array<float, 3> dcaDaughters = {std::fabs(cascade.dcabachtopv()), std::fabs(cascade.dcapostopv()), std::fabs(cascade.dcanegtopv())};
331329
this->evaluateObservable(kDauAbsDcaxyMin, *std::min_element(dcaDaughters.begin(), dcaDaughters.end()));
332330

333331
std::array<float, 3> clustersDaughters = {1.f * bachelor.tpcNClsFound(), 1.f * posDaughter.tpcNClsFound(), 1.f * negDaughter.tpcNClsFound()};
334332
this->evaluateObservable(kDauTpcClsMin, *std::min_element(clustersDaughters.begin(), clustersDaughters.end()));
335333

336-
// bachelor pid selection
337-
// check both pion and kaon PID for xi and omega
338-
this->evaluateObservable(kBachelorTpcPion, bachelor.tpcNSigmaPi());
339-
this->evaluateObservable(kBachelorTpcKaon, bachelor.tpcNSigmaKa());
340-
if (bachelor.hasTOF()) {
341-
this->evaluateObservable(kBachelorTofPion, bachelor.tofNSigmaPi());
342-
this->evaluateObservable(kBachelorTofKaon, bachelor.tofNSigmaKa());
343-
} else if (mKeepTracksWithoutTof) {
344-
this->evaluateObservable(kBachelorTofPion, 0);
345-
this->evaluateObservable(kBachelorTofKaon, 0);
346-
}
347-
348-
// depending on the charge, we check lambda or antilambda hypothesis
349-
if (cascade.sign() < 0) {
350-
this->evaluateObservable(kPosDauTpc, posDaughter.tpcNSigmaPr());
351-
this->evaluateObservable(kNegDauTpc, negDaughter.tpcNSigmaPi());
352-
if (posDaughter.hasTOF()) {
353-
this->evaluateObservable(kPosDauTof, posDaughter.tofNSigmaPr());
334+
// pid selections
335+
// TPC nSigma comes from the daughter track, TOF nSigma and the has-TOF flags from the cascade candidate
336+
// if a daughter has no TOF signal, feed 0 so the bit passes any limit (opt-in via keepTracksWithoutTof)
337+
auto evaluatePid = [this](CascadeSels tpcBit, float tpcNSigma,
338+
CascadeSels tofBit, float tofNSigma, bool hasTof) {
339+
this->evaluateObservable(tpcBit, tpcNSigma);
340+
if (hasTof) {
341+
this->evaluateObservable(tofBit, tofNSigma);
354342
} else if (mKeepTracksWithoutTof) {
355-
this->evaluateObservable(kPosDauTof, 0);
343+
this->evaluateObservable(tofBit, 0.f);
356344
}
357-
if (negDaughter.hasTOF()) {
358-
this->evaluateObservable(kNegDauTof, negDaughter.tofNSigmaPi());
359-
} else if (mKeepTracksWithoutTof) {
360-
this->evaluateObservable(kNegDauTof, 0);
361-
}
362-
} else if (cascade.sign() > 0) {
363-
this->evaluateObservable(kPosDauTpc, posDaughter.tpcNSigmaPi());
364-
this->evaluateObservable(kNegDauTpc, negDaughter.tpcNSigmaPr());
365-
if (posDaughter.hasTOF()) {
366-
this->evaluateObservable(kPosDauTof, posDaughter.tofNSigmaPi());
367-
} else if (mKeepTracksWithoutTof) {
368-
this->evaluateObservable(kPosDauTof, 0);
369-
}
370-
if (negDaughter.hasTOF()) {
371-
this->evaluateObservable(kNegDauTof, negDaughter.tofNSigmaPr());
372-
} else if (mKeepTracksWithoutTof) {
373-
this->evaluateObservable(kNegDauTof, 0);
374-
}
375-
} else {
345+
};
346+
347+
const bool bachHasTof = cascade.bachelorHasTOF();
348+
const bool posHasTof = cascade.positiveHasTOF();
349+
const bool negHasTof = cascade.negativeHasTOF();
350+
351+
// bachelor: pion for Xi, kaon for Omega
352+
if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) {
353+
evaluatePid(kBachelorTpcPion, bachelor.tpcNSigmaPi(),
354+
kBachelorTofPion, cascade.tofNSigmaXiPi(), bachHasTof);
355+
} else if constexpr (modes::isEqual(cascadeType, modes::Cascade::kOmega)) {
356+
evaluatePid(kBachelorTpcKaon, bachelor.tpcNSigmaKa(),
357+
kBachelorTofKaon, cascade.tofNSigmaOmKa(), bachHasTof);
358+
}
359+
360+
// v0 daughters: charge of the cascade fixes the Lambda vs. AntiLambda hypothesis
361+
if (cascade.sign() == 0) {
376362
LOG(warn) << "Encountered Cascade candidate with 0 charge";
363+
} else {
364+
// sign < 0: Xi-/Omega- -> Lambda -> p pi- (pos = proton, neg = pion)
365+
// sign > 0: Xi+/Omega+ -> AntiLambda (pos = pion, neg = antiproton)
366+
const bool isMatter = cascade.sign() < 0;
367+
368+
const float tpcPosDau = isMatter ? posDaughter.tpcNSigmaPr() : posDaughter.tpcNSigmaPi();
369+
const float tpcNegDau = isMatter ? negDaughter.tpcNSigmaPi() : negDaughter.tpcNSigmaPr();
370+
371+
float tofPosDau = 0.f;
372+
float tofNegDau = 0.f;
373+
if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) {
374+
tofPosDau = isMatter ? cascade.tofNSigmaXiLaPr() : cascade.tofNSigmaXiLaPi();
375+
tofNegDau = isMatter ? cascade.tofNSigmaXiLaPi() : cascade.tofNSigmaXiLaPr();
376+
} else if constexpr (modes::isEqual(cascadeType, modes::Cascade::kOmega)) {
377+
tofPosDau = isMatter ? cascade.tofNSigmaOmLaPr() : cascade.tofNSigmaOmLaPi();
378+
tofNegDau = isMatter ? cascade.tofNSigmaOmLaPi() : cascade.tofNSigmaOmLaPr();
379+
}
380+
381+
evaluatePid(kPosDauTpc, tpcPosDau, kPosDauTof, tofPosDau, posHasTof);
382+
evaluatePid(kNegDauTpc, tpcNegDau, kNegDauTof, tofNegDau, negHasTof);
377383
}
378384

379385
this->assembleBitmask<SelectionHistName>();

‎PWGCF/Femto/Core/dataTypes.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -63,6 +63,10 @@ using TransverseMassType = uint16_t;
6363
using CharmHadronMaskType = uint32_t;
6464
using CharmHadronType = uint16_t;
6565

66+
// datatypes for event shape enums
67+
using QvecDetectorType= uint8_t;
68+
using QvecHarmonicType= uint8_t;
69+
6670
} // namespace o2::analysis::femto::datatypes
6771

6872
#endif // PWGCF_FEMTO_CORE_DATATYPES_H_

‎PWGCF/Femto/Core/femtoUtils.h‎

Lines changed: 14 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -130,11 +130,20 @@ inline double getPdgMass(int pdgCode)
130130
}
131131

132132
template <typename T>
133-
float qn(T const& col)
134-
{
135-
float qn = std::sqrt(col.qvecFT0CReVec()[0] * col.qvecFT0CReVec()[0] + col.qvecFT0CImVec()[0] * col.qvecFT0CImVec()[0]) * std::sqrt(col.sumAmplFT0C());
136-
return qn;
137-
}
133+
concept HasQvectors = requires(T col) {
134+
col.qvecFT0CReVec();
135+
col.qvecFT0CImVec();
136+
col.sumAmplFT0C();
137+
col.qvecFT0AReVec();
138+
col.qvecFT0AImVec();
139+
col.sumAmplFT0A();
140+
};
141+
142+
template <typename T>
143+
concept HasEventShape = requires(T col) {
144+
col.qvec();
145+
col.eventPlaneAngle();
146+
};
138147

139148
/// Recalculate pT for Kinks (Sigmas) using kinematic constraints
140149
inline float calcPtnew(float pxMother, float pyMother, float pzMother, float pxDaughter, float pyDaughter, float pzDaughter)

‎PWGCF/Femto/Core/modes.h‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -178,5 +178,17 @@ enum class CharmHadron : o2::analysis::femto::datatypes::CharmHadronType {
178178
kLc
179179
};
180180

181+
enum class QvecDetector : o2::analysis::femto::datatypes::QvecDetectorType {
182+
kFT0C = 0,
183+
kFT0A = 1
184+
};
185+
186+
enum class QvecHarmonic : o2::analysis::femto::datatypes::QvecHarmonicType {
187+
kN0 = 0,
188+
kN1 = 1,
189+
kN2 = 2,
190+
kN3 = 3
191+
};
192+
181193
}; // namespace o2::analysis::femto::modes
182194
#endif // PWGCF_FEMTO_CORE_MODES_H_

‎PWGCF/Femto/Core/v0Builder.h‎

Lines changed: 51 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -51,8 +51,8 @@ struct ConfV0Filters : o2::framework::ConfigurableGroup {
5151
o2::framework::Configurable<float> massMinLambda{"massMinLambda", 1.f, "Minimum mass for Lambda hypothesis"};
5252
o2::framework::Configurable<float> massMaxLambda{"massMaxLambda", 1.2f, "Maximum mass for Lambda hypothesis"};
5353
o2::framework::Configurable<bool> rejectHypothesisK0short{"rejectHypothesisK0short", true, "Rejection of K0short hypothesis for Lambda candidates"};
54-
o2::framework::Configurable<float> rejectMassMinK0short{"rejectMassMinK0short", 0.48f, "Minimum mass to rejection K0short hypothesis for Lambda candidates"};
55-
o2::framework::Configurable<float> rejectMassMaxK0short{"rejectMassMaxK0short", 0.5f, "Maximum mass to rejection K0short hypothesis for Lambda candidates"};
54+
o2::framework::Configurable<float> rejectMassMinK0short{"rejectMassMinK0short", 0.475f, "Minimum mass to rejection K0short hypothesis for Lambda candidates"};
55+
o2::framework::Configurable<float> rejectMassMaxK0short{"rejectMassMaxK0short", 0.515f, "Maximum mass to rejection K0short hypothesis for Lambda candidates"};
5656
o2::framework::Configurable<float> massMinK0short{"massMinK0short", 0.45f, "Minimum mass for K0Short hypothesis"};
5757
o2::framework::Configurable<float> massMaxK0short{"massMaxK0short", 0.53f, "Maximum mass for K0Short hypothesis"};
5858
o2::framework::Configurable<bool> rejectHypothesisLambda{"rejectHypothesisLambda", true, "Rejection of Lambda hypothesis for K0short candidates"};
@@ -71,7 +71,9 @@ struct ConfV0Filters : o2::framework::ConfigurableGroup {
7171
o2::framework::Configurable<std::vector<float>> decayVtxMax{"decayVtxMax", {100.f}, "Maximum distance in x,y,z of the decay vertex from primary vertex (cm)"}; \
7272
o2::framework::Configurable<std::vector<float>> dauAbsEtaMax{"dauAbsEtaMax", {0.8f}, "Maximum |eta| for daughter tracks"}; \
7373
o2::framework::Configurable<std::vector<float>> dauAbsDcaxyMin{"dauAbsDcaxyMin", {0.05f}, "Minimum DCAxy of the daughters from primary vertex (cm)"}; \
74-
o2::framework::Configurable<std::vector<float>> dauTpcClustersMin{"dauTpcClustersMin", {80.f}, "Minimum number of TPC clusters for daughter tracks"};
74+
o2::framework::Configurable<std::vector<float>> dauTpcClustersMin{"dauTpcClustersMin", {80.f}, "Minimum number of TPC clusters for daughter tracks"}; \
75+
o2::framework::Configurable<bool> requireTof{"requireTof", false, "If true, TOF PID is a minimal selection. If false, TOF PID is an optional"}; \
76+
o2::framework::Configurable<bool> keepTracksWithoutTof{"keepTracksWithoutTof", true, "If true, the bit mask for the TOF selection will be ture for all limits if the daugher track has no TOF"};
7577

7678
// derived selection bits for lambda
7779
struct ConfLambdaBits : o2::framework::ConfigurableGroup {
@@ -85,8 +87,6 @@ struct ConfLambdaBits : o2::framework::ConfigurableGroup {
8587
o2::framework::Configurable<std::vector<float>> posDauTofProton{"posDauTofProton", {}, "Maximum |nsigma_Proton| TOF for positive daughter tracks"};
8688
o2::framework::Configurable<std::vector<float>> negDauTofPion{"negDauTofPion", {}, "Maximum |nsigma_Pion| TOF for negative daughter tracks"};
8789
o2::framework::Configurable<std::vector<float>> negDauTofProton{"negDauTofProton", {}, "Maximum |nsigma_Proton| TOF for negative daughter tracks"};
88-
o2::framework::Configurable<bool> requireTof{"requireTof", false, "If true, TOF PID is a mandatory selection"};
89-
o2::framework::Configurable<bool> keepTracksWithoutTof{"keepTracksWithoutTof", true, "If true, candidates whose daughters have no TOF signal are kept"};
9090
};
9191

9292
// derived selection bits for K0Short
@@ -97,8 +97,6 @@ struct ConfK0shortBits : o2::framework::ConfigurableGroup {
9797
o2::framework::Configurable<std::vector<float>> negDauTpcPion{"negDauTpcPion", {5.f}, "Maximum |nsimga_Pion| TPC for negative daughter tracks"};
9898
o2::framework::Configurable<std::vector<float>> posDauTofPion{"posDauTofPion", {}, "Maximum |nsigma_Pion| TOF for positive daughter tracks"};
9999
o2::framework::Configurable<std::vector<float>> negDauTofPion{"negDauTofPion", {}, "Maximum |nsigma_Pion| TOF for negative daughter tracks"};
100-
o2::framework::Configurable<bool> requireTof{"requireTof", false, "If true, TOF PID is a mandatory selection"};
101-
o2::framework::Configurable<bool> keepTracksWithoutTof{"keepTracksWithoutTof", true, "If true, candidates whose daughters have no TOF signal are kept"};
102100
};
103101

104102
#undef V0_DEFAULT_BITS
@@ -335,32 +333,49 @@ class V0Selection : public baseselection::BaseSelection<float, datatypes::V0Mask
335333
auto posDaughter = v0candidate.template posTrack_as<T2>();
336334
auto negDaughter = v0candidate.template negTrack_as<T2>();
337335

338-
std::array<float, 2> etaAbsDaughters = {std::fabs(posDaughter.eta()), std::fabs(negDaughter.eta())};
336+
std::array<float, 2> etaAbsDaughters = {std::fabs(v0candidate.positiveeta()), std::fabs(v0candidate.negativeeta())};
339337
this->evaluateObservable(kDauAbsEtaMax, *std::max_element(etaAbsDaughters.begin(), etaAbsDaughters.end()));
340338

341-
std::array<float, 2> dcaxyAbsDaughters = {std::fabs(posDaughter.dcaXY()), std::fabs(negDaughter.dcaXY())};
339+
std::array<float, 2> dcaxyAbsDaughters = {std::fabs(v0candidate.dcapostopv()), std::fabs(v0candidate.dcanegtopv())};
342340
this->evaluateObservable(kDauAbsDcaxyMin, *std::min_element(dcaxyAbsDaughters.begin(), dcaxyAbsDaughters.end()));
343341

344342
std::array<float, 2> clustersDaughters = {1.f * posDaughter.tpcNClsFound(), 1.f * negDaughter.tpcNClsFound()};
345343
this->evaluateObservable(kDauTpcClsMin, *std::min_element(clustersDaughters.begin(), clustersDaughters.end()));
346344

347-
this->evaluateObservable(kPosDaughTpcPion, posDaughter.tpcNSigmaPi());
348-
this->evaluateObservable(kPosDaughTpcProton, posDaughter.tpcNSigmaPr());
349-
this->evaluateObservable(kNegDaughTpcPion, negDaughter.tpcNSigmaPi());
350-
this->evaluateObservable(kNegDaughTpcProton, negDaughter.tpcNSigmaPr());
351-
if (posDaughter.hasTOF()) {
352-
this->evaluateObservable(kPosDaughTofPion, posDaughter.tofNSigmaPi());
353-
this->evaluateObservable(kPosDaughTofProton, posDaughter.tofNSigmaPr());
354-
} else if (mKeepTracksWithoutTof) {
355-
this->evaluateObservable(kPosDaughTofPion, 0);
356-
this->evaluateObservable(kPosDaughTofProton, 0);
357-
}
358-
if (negDaughter.hasTOF()) {
359-
this->evaluateObservable(kNegDaughTofPion, negDaughter.tofNSigmaPi());
360-
this->evaluateObservable(kNegDaughTofProton, negDaughter.tofNSigmaPr());
361-
} else if (mKeepTracksWithoutTof) {
362-
this->evaluateObservable(kNegDaughTofPion, 0);
363-
this->evaluateObservable(kNegDaughTofProton, 0);
345+
// PID of the daughters under the mass hypothesis of this v0 type
346+
// TPC nSigma comes from the daughter track, TOF nSigma from the strangeness-tagged v0 candidate
347+
// if the daughter has no TOF signal, feed 0 so the bit passes any limit (opt-in via keepTracksWithoutTof)
348+
auto evaluateDaughterPid = [this](V0Sels tpcBit, float tpcNSigma,
349+
V0Sels tofBit, float tofNSigma, bool hasTof) {
350+
this->evaluateObservable(tpcBit, tpcNSigma);
351+
if (hasTof) {
352+
this->evaluateObservable(tofBit, tofNSigma);
353+
} else if (mKeepTracksWithoutTof) {
354+
this->evaluateObservable(tofBit, 0.f);
355+
}
356+
};
357+
358+
const bool posHasTof = v0candidate.positiveHasTOF();
359+
const bool negHasTof = v0candidate.negativeHasTOF();
360+
361+
if constexpr (modes::isEqual(v0Type, modes::V0::kLambda)) {
362+
// Lambda -> p pi-
363+
evaluateDaughterPid(kPosDaughTpcProton, posDaughter.tpcNSigmaPr(),
364+
kPosDaughTofProton, v0candidate.tofNSigmaLaPr(), posHasTof);
365+
evaluateDaughterPid(kNegDaughTpcPion, negDaughter.tpcNSigmaPi(),
366+
kNegDaughTofPion, v0candidate.tofNSigmaLaPi(), negHasTof);
367+
} else if constexpr (modes::isEqual(v0Type, modes::V0::kAntiLambda)) {
368+
// AntiLambda -> pbar pi+
369+
evaluateDaughterPid(kPosDaughTpcPion, posDaughter.tpcNSigmaPi(),
370+
kPosDaughTofPion, v0candidate.tofNSigmaALaPi(), posHasTof);
371+
evaluateDaughterPid(kNegDaughTpcProton, negDaughter.tpcNSigmaPr(),
372+
kNegDaughTofProton, v0candidate.tofNSigmaALaPr(), negHasTof);
373+
} else if constexpr (modes::isEqual(v0Type, modes::V0::kK0short)) {
374+
// K0short -> pi+ pi-
375+
evaluateDaughterPid(kPosDaughTpcPion, posDaughter.tpcNSigmaPi(),
376+
kPosDaughTofPion, v0candidate.tofNSigmaK0PiPlus(), posHasTof);
377+
evaluateDaughterPid(kNegDaughTpcPion, negDaughter.tpcNSigmaPi(),
378+
kNegDaughTofPion, v0candidate.tofNSigmaK0PiMinus(), negHasTof);
364379
}
365380

366381
this->assembleBitmask<SelectionHistName>();
@@ -649,12 +664,18 @@ class V0Builder
649664
{
650665
float mass = 0;
651666
float massAnti = 0;
667+
float strangeTofPosDau = 0;
668+
float strangeTofNegDau = 0;
652669
if (sign > 0.f) {
653670
mass = v0.mLambda();
654671
massAnti = v0.mAntiLambda();
672+
strangeTofPosDau = v0.tofNSigmaLaPr();
673+
strangeTofNegDau = v0.tofNSigmaLaPi();
655674
} else {
656675
mass = v0.mAntiLambda();
657676
massAnti = v0.mLambda();
677+
strangeTofPosDau = v0.tofNSigmaALaPi();
678+
strangeTofNegDau = v0.tofNSigmaALaPr();
658679
}
659680
if (mProduceLambdas) {
660681
v0Products.producedLambdas(collisionBuilder.collisionIndex(),
@@ -683,6 +704,8 @@ class V0Builder
683704
v0.mK0Short(),
684705
v0.v0cosPA(),
685706
v0.dcaV0daughters(),
707+
strangeTofPosDau,
708+
strangeTofNegDau,
686709
v0.v0radius(),
687710
v0.x(),
688711
v0.y(),
@@ -720,6 +743,8 @@ class V0Builder
720743
v0.mAntiLambda(),
721744
v0.v0cosPA(),
722745
v0.dcaV0daughters(),
746+
v0.tofNSigmaK0PiPlus(),
747+
v0.tofNSigmaK0PiMinus(),
723748
v0.v0radius(),
724749
v0.x(),
725750
v0.y(),

0 commit comments

Comments
 (0)