Skip to content

Commit e65783a

Browse files
alcalivaalcaliva
authored
optimized binning and removed histos for cascades (#5840)
* optimized binning * fixed formatting error
1 parent 9e5aafd commit e65783a

1 file changed

Lines changed: 68 additions & 83 deletions

File tree

‎PWGLF/Tasks/Strangeness/vzero_cascade_absorption.cxx‎

Lines changed: 68 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -30,15 +30,16 @@
3030
#include "Common/Core/TrackSelection.h"
3131
#include "Common/DataModel/TrackSelectionTables.h"
3232
#include "Common/DataModel/EventSelection.h"
33-
#include "Common/DataModel/Centrality.h"
3433
#include "Common/DataModel/PIDResponse.h"
3534

3635
using namespace o2;
3736
using namespace o2::framework;
3837
using namespace o2::framework::expressions;
38+
using namespace o2::constants::physics;
3939
using std::array;
4040

4141
using SelectedCollisions = soa::Join<aod::Collisions, aod::EvSels>;
42+
4243
using SimCollisions = soa::Join<aod::Collisions, aod::EvSels, aod::McCollisionLabels>;
4344

4445
using FullTracks = soa::Join<aod::Tracks, aod::TracksExtra, aod::TrackSelection, aod::TrackSelectionExtension, aod::pidTPCFullPi, aod::pidTPCFullKa, aod::pidTPCFullPr, aod::pidTOFFullPi, aod::pidTOFFullKa, aod::pidTOFFullPr>;
@@ -73,99 +74,86 @@ struct vzero_cascade_absorption {
7374

7475
// Configurable Parameters
7576
Configurable<float> minTPCnClsFound{"minTPCnClsFound", 80.0f, "min number of found TPC clusters"};
76-
Configurable<float> minNCrossedRowsTPC{"minNCrossedRowsTPC", 80.0f, "min number of found TPC crossed rows"};
77+
Configurable<float> minNCrossedRowsTPC{"minNCrossedRowsTPC", 80.0f, "min number of TPC crossed rows"};
7778
Configurable<float> maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"};
78-
Configurable<float> etaMin{"etaMin", -0.5f, "etaMin"};
79-
Configurable<float> etaMax{"etaMax", +0.5f, "etaMax"};
79+
Configurable<float> etaMin{"etaMin", -0.5f, "eta min"};
80+
Configurable<float> etaMax{"etaMax", +0.5f, "eta max"};
8081
Configurable<float> pMin_k0postrack{"pMin_k0postrack", 0.3f, "Min Momentum K0 pos track"};
8182
Configurable<float> pMax_k0postrack{"pMax_k0postrack", 5.0f, "Max Momentum K0 pos track"};
8283
Configurable<float> pMin_k0negtrack{"pMin_k0negtrack", 0.3f, "Min Momentum K0 neg track"};
8384
Configurable<float> pMax_k0negtrack{"pMax_k0negtrack", 5.0f, "Max Momentum K0 neg track"};
84-
Configurable<float> pMin_Lambda_proton{"pMin_Lambda_proton", 0.3f, "Min Momentum proton from Lambda"};
85-
Configurable<float> pMax_Lambda_proton{"pMax_Lambda_proton", 5.0f, "Max Momentum proton from Lambda"};
86-
Configurable<float> pMin_Lambda_pion{"pMin_Lambda_pion", 0.2f, "Min Momentum pion from Lambda"};
87-
Configurable<float> pMax_Lambda_pion{"pMax_Lambda_pion", 1.0f, "Max Momentum pion from Lambda"};
88-
Configurable<bool> requirehitsITS{"requirehitsITS", true, "require ITS hits for daughters"};
89-
Configurable<std::vector<float>> hit_requirement_before_target{"hit_requirement_before_target", {0, 0, 0, 1, 1, 1, 1}, "ITS Hits before target"};
90-
Configurable<std::vector<float>> hit_requirement_after_target{"hit_requirement_after_target", {0, 0, 0, 0, 0, 1, 1}, "ITS Hits after target"};
91-
Configurable<bool> useTOF{"useTOF", true, "use TOF for PID"};
85+
Configurable<float> pMin_Lambda_proton{"pMin_Lambda_proton", 0.3f, "Min Momentum proton from (Anti)Lambda"};
86+
Configurable<float> pMax_Lambda_proton{"pMax_Lambda_proton", 5.0f, "Max Momentum proton from (Anti)Lambda"};
87+
Configurable<float> pMin_Lambda_pion{"pMin_Lambda_pion", 0.2f, "Min Momentum pion from (Anti)Lambda"};
88+
Configurable<float> pMax_Lambda_pion{"pMax_Lambda_pion", 1.2f, "Max Momentum pion from (Anti)Lambda"};
9289
Configurable<float> nsigmaTPCmin{"nsigmaTPCmin", -3.0f, "Minimum nsigma TPC"};
9390
Configurable<float> nsigmaTPCmax{"nsigmaTPCmax", +3.0f, "Maximum nsigma TPC"};
9491
Configurable<float> nsigmaTOFmin{"nsigmaTOFmin", -3.0f, "Minimum nsigma TOF"};
9592
Configurable<float> nsigmaTOFmax{"nsigmaTOFmax", +3.0f, "Maximum nsigma TOF"};
9693
Configurable<float> minimumV0Radius{"minimumV0Radius", 0.5f, "Minimum V0 Radius"};
9794
Configurable<float> maximumV0Radius{"maximumV0Radius", 40.0f, "Maximum V0 Radius"};
98-
Configurable<float> minimumCascRadius{"minimumCascRadius", 0.5f, "Minimum Cascade Radius"};
99-
Configurable<float> maximumCascRadius{"maximumCascRadius", 40.0f, "Maximum Cascade Radius"};
10095
Configurable<float> dcanegtoPVmin{"dcanegtoPVmin", 0.1f, "Minimum DCA Neg To PV"};
10196
Configurable<float> dcapostoPVmin{"dcapostoPVmin", 0.1f, "Minimum DCA Pos To PV"};
102-
Configurable<float> dcaBachelorToPVmin{"dcaBachelorToPVmin", 0.1f, "Minimum DCA bachelor To PV"};
103-
Configurable<float> dcaV0ToPVmin{"dcaV0ToPVmin", 0.1f, "Minimum DCA V0 To PV for cascades"};
10497
Configurable<float> v0cospaMin{"v0cospaMin", 0.99f, "Minimum V0 CosPA"};
105-
Configurable<float> casccospaMin{"casccospaMin", 0.99f, "Minimum Cascade CosPA"};
10698
Configurable<float> dcaV0DaughtersMax{"dcaV0DaughtersMax", 0.5f, "Maximum DCA Daughters"};
107-
Configurable<float> dcaCascDaughtersMax{"dcaCascDaughtersMax", 0.5f, "Maximum DCA Cascade Daughters"};
10899
Configurable<float> Rmin_beforeAbs{"Rmin_beforeAbs", 10.0f, "Rmin before target"};
109100
Configurable<float> Rmax_beforeAbs{"Rmax_beforeAbs", 15.0f, "Rmax before target"};
110101
Configurable<float> Rmin_afterAbs{"Rmin_afterAbs", 26.0f, "Rmin after target"};
111102
Configurable<float> Rmax_afterAbs{"Rmax_afterAbs", 31.0f, "Rmax after target"};
103+
Configurable<bool> useTOF{"useTOF", true, "use TOF for PID"};
104+
Configurable<bool> requirehitsITS{"requirehitsITS", true, "require ITS hits for daughters"};
105+
Configurable<std::vector<float>> hit_req_before_target{"hit_req_before_target", {0, 0, 0, 1, 1, 1, 1}, "ITS Hits before target"};
106+
Configurable<std::vector<float>> hit_req_after_target{"hit_req_after_target", {0, 0, 0, 0, 0, 1, 1}, "ITS Hits after target"};
112107

113108
void init(InitContext const&)
114109
{
115-
// Histograms
116-
registryQC.add("event_counter_data", "event counter data", HistType::kTH1F, {{5, 0, 5, "number of events"}});
117-
registryQC.add("event_counter_mc", "event counter mc", HistType::kTH1F, {{5, 0, 5, "number of events"}});
110+
// QC Histograms (event counters)
111+
registryQC.add("event_counter_data", "event counter data", HistType::kTH1F, {{5, 0, 5, "number of events data"}});
112+
registryQC.add("event_counter_mc", "event counter mc", HistType::kTH1F, {{5, 0, 5, "number of events mc"}});
118113

119114
// K0 short
120-
registryData.add("K0_before_target_data", "K0 before target data", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {240, 0.44, 0.56, "m (GeV/c^{2})"}});
121-
registryData.add("K0_after_target_data", "K0 after target data", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {240, 0.44, 0.56, "m (GeV/c^{2})"}});
122-
registryMC.add("K0_before_target_mc", "K0 before target mc", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {240, 0.44, 0.56, "m (GeV/c^{2})"}});
123-
registryMC.add("K0_after_target_mc", "K0 after target mc", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {240, 0.44, 0.56, "m (GeV/c^{2})"}});
124-
125-
// Lambda and Antilambda
126-
registryData.add("Lambda_before_target_data", "Lambda before target data", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
127-
registryData.add("Lambda_after_target_data", "Lambda after target data", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
128-
registryData.add("AntiLambda_before_target_data", "AntiLambda before target data", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
129-
registryData.add("AntiLambda_after_target_data", "AntiLambda after target data", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
130-
registryMC.add("Lambda_before_target_mc", "Lambda before target mc", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
131-
registryMC.add("Lambda_after_target_mc", "Lambda after target mc", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
132-
registryMC.add("AntiLambda_before_target_mc", "AntiLambda before target mc", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
133-
registryMC.add("AntiLambda_after_target_mc", "AntiLambda after target mc", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
115+
registryData.add("K0_before_target_data", "K0 before target data", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {240, 0.44, 0.56, "m (GeV/c^{2})"}});
116+
registryData.add("K0_after_target_data", "K0 after target data", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {240, 0.44, 0.56, "m (GeV/c^{2})"}});
117+
registryMC.add("K0_before_target_mc", "K0 before target mc", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {240, 0.44, 0.56, "m (GeV/c^{2})"}});
118+
registryMC.add("K0_after_target_mc", "K0 after target mc", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {240, 0.44, 0.56, "m (GeV/c^{2})"}});
119+
120+
// Lambda
121+
registryData.add("Lambda_before_target_data", "Lambda before target data", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
122+
registryData.add("Lambda_after_target_data", "Lambda after target data", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
123+
registryMC.add("Lambda_before_target_mc", "Lambda before target mc", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
124+
registryMC.add("Lambda_after_target_mc", "Lambda after target mc", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
125+
126+
// Antilambda
127+
registryData.add("AntiLambda_before_target_data", "AntiLambda before target data", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
128+
registryData.add("AntiLambda_after_target_data", "AntiLambda after target data", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
129+
registryMC.add("AntiLambda_before_target_mc", "AntiLambda before target mc", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
130+
registryMC.add("AntiLambda_after_target_mc", "AntiLambda after target mc", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, 1.09, 1.14, "m (GeV/c^{2})"}});
134131

135132
// Generated Distributions
136-
registryMC.add("Lambda_before_target_mc_gen", "Lambda before target mc gen", HistType::kTH1F, {{200, 0.0, 10.0, "p (GeV/c)"}});
137-
registryMC.add("Lambda_after_target_mc_gen", "Lambda after target mc gen", HistType::kTH1F, {{200, 0.0, 10.0, "p (GeV/c)"}});
138-
registryMC.add("AntiLambda_before_target_mc_gen", "AntiLambda before target mc gen", HistType::kTH1F, {{200, 0.0, 10.0, "p (GeV/c)"}});
139-
registryMC.add("AntiLambda_after_target_mc_gen", "AntiLambda after target mc gen", HistType::kTH1F, {{200, 0.0, 10.0, "p (GeV/c)"}});
133+
registryMC.add("Lambda_before_target_mc_gen", "Lambda before target mc gen", HistType::kTH1F, {{100, 0.0, 10.0, "p (GeV/c)"}});
134+
registryMC.add("Lambda_after_target_mc_gen", "Lambda after target mc gen", HistType::kTH1F, {{100, 0.0, 10.0, "p (GeV/c)"}});
135+
registryMC.add("AntiLambda_before_target_mc_gen", "AntiLambda before target mc gen", HistType::kTH1F, {{100, 0.0, 10.0, "p (GeV/c)"}});
136+
registryMC.add("AntiLambda_after_target_mc_gen", "AntiLambda after target mc gen", HistType::kTH1F, {{100, 0.0, 10.0, "p (GeV/c)"}});
140137

141138
// Resolution
142-
registryMC.add("K0_Rresolution_before_target", "K0 Rresolution before target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {500, -5, 5, "#Delta R (cm)"}});
143-
registryMC.add("K0_Rresolution_after_target", "K0 Rresolution after target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {500, -5, 5, "#Delta R (cm)"}});
144-
registryMC.add("Lambda_Rresolution_before_target", "Lambda Rresolution before target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {500, -5, 5, "#Delta R (cm)"}});
145-
registryMC.add("Lambda_Rresolution_after_target", "Lambda Rresolution after target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {500, -5, 5, "#Delta R (cm)"}});
146-
registryMC.add("AntiLambda_Rresolution_before_target", "AntiLambda Rresolution before target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {500, -5, 5, "#Delta R (cm)"}});
147-
registryMC.add("AntiLambda_Rresolution_after_target", "AntiLambda Rresolution after target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {500, -5, 5, "#Delta R (cm)"}});
148-
149-
/*
150-
registryData.add("Csi_before_target", "Csi_before_target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.305, 1.34, "m (GeV/c)"}});
151-
registryData.add("Csi_after_target", "Csi_after_target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.305, 1.34, "m (GeV/c)"}});
152-
registryData.add("AntiCsi_before_target", "AntiCsi_before_target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.3, 1.35, "m (GeV/c)"}});
153-
registryData.add("AntiCsi_after_target", "AntiCsi_after_target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.3, 1.35, "m (GeV/c)"}});
154-
registryData.add("Omega_before_target", "Omega_before_target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.6, 1.75, "m (GeV/c)"}});
155-
registryData.add("Omega_after_target", "Omega_after_target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.6, 1.75, "m (GeV/c)"}});
156-
registryData.add("AntiOmega_before_target", "AntiOmega_before_target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.6, 1.75, "m (GeV/c)"}});
157-
registryData.add("AntiOmega_after_target", "AntiOmega_after_target", HistType::kTH2F, {{200, 0.0, 10.0, "p (GeV/c)"}, {200, 1.6, 1.75, "m (GeV/c)"}});*/
139+
registryMC.add("K0_Rresolution_before_target", "K0 Rresolution before target", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, -5, 5, "#Delta R (cm)"}});
140+
registryMC.add("K0_Rresolution_after_target", "K0 Rresolution after target", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, -5, 5, "#Delta R (cm)"}});
141+
registryMC.add("Lambda_Rresolution_before_target", "Lambda Rresolution before target", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, -5, 5, "#Delta R (cm)"}});
142+
registryMC.add("Lambda_Rresolution_after_target", "Lambda Rresolution after target", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, -5, 5, "#Delta R (cm)"}});
143+
registryMC.add("AntiLambda_Rresolution_before_target", "AntiLambda Rresolution before target", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, -5, 5, "#Delta R (cm)"}});
144+
registryMC.add("AntiLambda_Rresolution_after_target", "AntiLambda Rresolution after target", HistType::kTH2F, {{100, 0.0, 10.0, "p (GeV/c)"}, {200, -5, 5, "#Delta R (cm)"}});
158145
}
159146

147+
// Hits on ITS Layer
160148
bool hasHitOnITSlayer(uint8_t itsClsmap, int layer)
161149
{
162150
unsigned char test_bit = 1 << layer;
163151
return (itsClsmap & test_bit);
164152
}
165153

166154
// Single-Track Selection
167-
template <typename T1, typename C>
168-
bool passedSingleTrackSelection(const T1& track, const C&)
155+
template <typename T1>
156+
bool passedSingleTrackSelection(const T1& track)
169157
{
170158
// Single-Track Selections
171159
if (requirehitsITS && (!track.hasITS()))
@@ -186,14 +174,13 @@ struct vzero_cascade_absorption {
186174
}
187175

188176
// K0s Selections
189-
template <typename T1, typename T2, typename C>
190-
bool passedK0Selection(const T1& v0, const T2& ntrack, const T2& ptrack,
191-
const C& collision)
177+
template <typename V, typename T1, typename T2, typename C>
178+
bool passedK0Selection(const V& v0, const T1& ntrack, const T2& ptrack, const C& collision)
192179
{
193180
// Single-Track Selections
194-
if (!passedSingleTrackSelection(ptrack, collision))
181+
if (!passedSingleTrackSelection(ptrack))
195182
return false;
196-
if (!passedSingleTrackSelection(ntrack, collision))
183+
if (!passedSingleTrackSelection(ntrack))
197184
return false;
198185

199186
// Momentum K0 Daughters
@@ -236,14 +223,13 @@ struct vzero_cascade_absorption {
236223
}
237224

238225
// Lambda Selections
239-
template <typename T1, typename T2, typename C>
240-
bool passedLambdaSelection(const T1& v0, const T2& ntrack, const T2& ptrack,
241-
const C& collision)
226+
template <typename V, typename T1, typename T2, typename C>
227+
bool passedLambdaSelection(const V& v0, const T1& ntrack, const T2& ptrack, const C& collision)
242228
{
243229
// Single-Track Selections
244-
if (!passedSingleTrackSelection(ptrack, collision))
230+
if (!passedSingleTrackSelection(ptrack))
245231
return false;
246-
if (!passedSingleTrackSelection(ntrack, collision))
232+
if (!passedSingleTrackSelection(ntrack))
247233
return false;
248234

249235
// Momentum Lambda Daughters
@@ -286,14 +272,13 @@ struct vzero_cascade_absorption {
286272
}
287273

288274
// AntiLambda Selections
289-
template <typename T1, typename T2, typename C>
290-
bool passedAntiLambdaSelection(const T1& v0, const T2& ntrack, const T2& ptrack,
291-
const C& collision)
275+
template <typename V, typename T1, typename T2, typename C>
276+
bool passedAntiLambdaSelection(const V& v0, const T1& ntrack, const T2& ptrack, const C& collision)
292277
{
293278
// Single-Track Selections
294-
if (!passedSingleTrackSelection(ptrack, collision))
279+
if (!passedSingleTrackSelection(ptrack))
295280
return false;
296-
if (!passedSingleTrackSelection(ntrack, collision))
281+
if (!passedSingleTrackSelection(ntrack))
297282
return false;
298283

299284
// Momentum Lambda Daughters
@@ -355,8 +340,9 @@ struct vzero_cascade_absorption {
355340
// Event Counter (after cut on z_vtx)
356341
registryQC.fill(HIST("event_counter_data"), 2.5);
357342

358-
auto hit_ITS_before_target = static_cast<std::vector<float>>(hit_requirement_before_target);
359-
auto hit_ITS_after_target = static_cast<std::vector<float>>(hit_requirement_after_target);
343+
// Hits in ITS Layers
344+
auto hit_ITS_before_target = static_cast<std::vector<float>>(hit_req_before_target);
345+
auto hit_ITS_after_target = static_cast<std::vector<float>>(hit_req_after_target);
360346

361347
// Loop over Reconstructed V0s
362348
for (auto& v0 : fullV0s) {
@@ -424,15 +410,15 @@ struct vzero_cascade_absorption {
424410
if (v0.v0radius() > Rmin_afterAbs && v0.v0radius() < Rmax_afterAbs)
425411
registryData.fill(HIST("AntiLambda_after_target_data"), v0.p(), v0.mAntiLambda());
426412
}
427-
} // end loop on V0s
428-
} // end processData
413+
}
414+
}
429415
PROCESS_SWITCH(vzero_cascade_absorption, processData, "Process data", true);
430416

431417
Preslice<aod::V0Datas> perCollision = o2::aod::v0data::collisionId;
432418
Preslice<aod::McParticles> perMCCollision = o2::aod::mcparticle::mcCollisionId;
433419

434420
// Process MC Rec
435-
void processMCrec(SimCollisions const& collisions, MCTracks const&, aod::V0Datas const& fullV0s, aod::McCollisions const&, const aod::McParticles&)
421+
void processMCrec(SimCollisions const& collisions, MCTracks const& mcTracks, aod::V0Datas const& fullV0s, aod::McCollisions const& mcCollisions, const aod::McParticles& mcParticles)
436422
{
437423

438424
for (const auto& collision : collisions) {
@@ -469,8 +455,8 @@ struct vzero_cascade_absorption {
469455
if (!negTrack.passedTPCRefit())
470456
continue;
471457

472-
auto hit_ITS_before_target = static_cast<std::vector<float>>(hit_requirement_before_target);
473-
auto hit_ITS_after_target = static_cast<std::vector<float>>(hit_requirement_after_target);
458+
auto hit_ITS_before_target = static_cast<std::vector<float>>(hit_req_before_target);
459+
auto hit_ITS_after_target = static_cast<std::vector<float>>(hit_req_after_target);
474460

475461
// ITS Requirement
476462
bool satisfyITSreq = true;
@@ -502,6 +488,7 @@ struct vzero_cascade_absorption {
502488
continue;
503489
}
504490

491+
// Identification based on PDG
505492
bool isK0s = false;
506493
bool isLambda = false;
507494
bool isAntiLambda = false;
@@ -510,7 +497,6 @@ struct vzero_cascade_absorption {
510497
for (auto& particleMotherOfPos : posParticle.mothers_as<aod::McParticles>()) {
511498
if (particleMotherOfNeg == particleMotherOfPos && particleMotherOfNeg.pdgCode() == 310)
512499
isK0s = true;
513-
514500
if (particleMotherOfNeg == particleMotherOfPos && particleMotherOfNeg.pdgCode() == +3122)
515501
isLambda = true;
516502
if (particleMotherOfNeg == particleMotherOfPos && particleMotherOfNeg.pdgCode() == -3122)
@@ -570,10 +556,9 @@ struct vzero_cascade_absorption {
570556
registryMC.fill(HIST("AntiLambda_Rresolution_after_target"), v0.p(), deltaR);
571557
}
572558
}
573-
574-
} // end loop on V0s
559+
}
575560
}
576-
} // end processMC
561+
}
577562

578563
void processMCgen(o2::aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
579564
{

0 commit comments

Comments
 (0)