Skip to content

Commit 364da38

Browse files
joonsukbaeJoonsuk Baeclaude
authored
[PWGJE] trackEfficiency: add track pT-eta-phi histogram; jetCrossSectionEfficiency review follow-up (#17539)
Co-authored-by: Joonsuk Bae <monkeybae@kiaf-ui.sdfarm.kr> Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
1 parent 1cb25ed commit 364da38

2 files changed

Lines changed: 151 additions & 110 deletions

File tree

‎PWGJE/Tasks/jetCrossSectionEfficiency.cxx‎

Lines changed: 149 additions & 110 deletions
Original file line numberDiff line numberDiff line change
@@ -90,34 +90,67 @@ struct JetCrossSectionEfficiency {
9090
SplitOkCheckFirstAssocCollOnly // 2
9191
};
9292

93-
static constexpr float configSwitchLow = -98.0f;
94-
static constexpr float configSwitchHigh = 9998.0f;
95-
static constexpr float kBrokenPtHardSentinel = 1.0f;
93+
static constexpr float ConfigSwitchLow = -98.0f;
94+
static constexpr float ConfigSwitchHigh = 9998.0f;
95+
static constexpr float BrokenPtHardSentinel = 1.0f;
9696

9797
// CollRecoFirst: reco collision required first; BC bits read from the reco-coll EvSels.
98-
static constexpr int kBinCRF_Inel = 1;
99-
static constexpr int kBinCRF_RctPass = 2;
100-
static constexpr int kBinCRF_HasColl = 3;
101-
static constexpr int kBinCRF_Zreco = 4;
102-
static constexpr int kBinCRF_NoSplit = 5;
103-
static constexpr int kBinCRF_TVX = 6;
104-
static constexpr int kBinCRF_TFB = 7;
105-
static constexpr int kBinCRF_ROFB = 8;
106-
static constexpr int kBinCRF_SBP = 9;
107-
static constexpr int kBinCRF_N = 9;
98+
enum BinCollRecoFirst {
99+
CollRecoFirstInel = 1,
100+
CollRecoFirstRct,
101+
CollRecoFirstHasCollision,
102+
CollRecoFirstVertexZ,
103+
CollRecoFirstNoSplit,
104+
CollRecoFirstTvx,
105+
CollRecoFirstNoTimeFrameBorder,
106+
CollRecoFirstNoItsRofBorder,
107+
CollRecoFirstNoSameBunchPileup,
108+
CollRecoFirstNBins = CollRecoFirstNoSameBunchPileup
109+
};
108110

109111
// BcBitsFirst: BC bits read from the MC truth BC; SBP from a Preslice count
110112
// (exactly one MC collision per truth BC) so it works before requiring reco.
111-
static constexpr int kBinBBF_Inel = 1;
112-
static constexpr int kBinBBF_RctPass = 2;
113-
static constexpr int kBinBBF_TVX = 3;
114-
static constexpr int kBinBBF_TFB = 4;
115-
static constexpr int kBinBBF_ROFB = 5;
116-
static constexpr int kBinBBF_TruthSBP = 6;
117-
static constexpr int kBinBBF_HasColl = 7;
118-
static constexpr int kBinBBF_Zreco = 8;
119-
static constexpr int kBinBBF_NoSplit = 9;
120-
static constexpr int kBinBBF_N = 9;
113+
enum BinBcBitsFirst {
114+
BcBitsFirstInel = 1,
115+
BcBitsFirstRct,
116+
BcBitsFirstTvx,
117+
BcBitsFirstNoTimeFrameBorder,
118+
BcBitsFirstNoItsRofBorder,
119+
BcBitsFirstNoSameBunchPileupTruth,
120+
BcBitsFirstHasCollision,
121+
BcBitsFirstVertexZ,
122+
BcBitsFirstNoSplit,
123+
BcBitsFirstNBins = BcBitsFirstNoSplit
124+
};
125+
126+
enum EventSelectionPreset {
127+
PresetSelTvx = 0,
128+
PresetSelMc,
129+
PresetSelMcFull,
130+
PresetSel8,
131+
PresetSel8Full,
132+
PresetInvalid
133+
};
134+
135+
static EventSelectionPreset getEventSelectionPreset(const std::string& preset)
136+
{
137+
if (preset == "selTVX") {
138+
return PresetSelTvx;
139+
}
140+
if (preset == "selMC") {
141+
return PresetSelMc;
142+
}
143+
if (preset == "selMCFull") {
144+
return PresetSelMcFull;
145+
}
146+
if (preset == "sel8") {
147+
return PresetSel8;
148+
}
149+
if (preset == "sel8Full") {
150+
return PresetSel8Full;
151+
}
152+
return PresetInvalid;
153+
}
121154

122155
Preslice<aod::JetMcCollisions> mcCollsPerBC = aod::jmccollision::bcId;
123156

@@ -130,93 +163,99 @@ struct JetCrossSectionEfficiency {
130163
rctChecker.init(static_cast<std::string>(rctSelectionsLabel));
131164
rctMask = rctChecker.value();
132165

133-
const std::string es = eventSelections;
134-
if (es == "selTVX") {
135-
applyTFB = false;
136-
applyROFB = false;
137-
applySBP = false;
138-
} else if (es == "selMC") {
139-
applyTFB = true;
140-
applyROFB = false;
141-
applySBP = false;
142-
} else if (es == "selMCFull") {
143-
applyTFB = true;
144-
applyROFB = false;
145-
applySBP = true;
146-
} else if (es == "sel8") {
147-
applyTFB = true;
148-
applyROFB = true;
149-
applySBP = false;
150-
} else if (es == "sel8Full") {
151-
applyTFB = true;
152-
applyROFB = true;
153-
applySBP = true;
154-
} else {
155-
LOGF(fatal, "Configurable eventSelections=%s not supported; use selTVX, selMC, selMCFull, sel8, or sel8Full", es.c_str());
166+
switch (getEventSelectionPreset(static_cast<std::string>(eventSelections))) {
167+
case PresetSelTvx:
168+
applyTFB = false;
169+
applyROFB = false;
170+
applySBP = false;
171+
break;
172+
case PresetSelMc:
173+
applyTFB = true;
174+
applyROFB = false;
175+
applySBP = false;
176+
break;
177+
case PresetSelMcFull:
178+
applyTFB = true;
179+
applyROFB = false;
180+
applySBP = true;
181+
break;
182+
case PresetSel8:
183+
applyTFB = true;
184+
applyROFB = true;
185+
applySBP = false;
186+
break;
187+
case PresetSel8Full:
188+
applyTFB = true;
189+
applyROFB = true;
190+
applySBP = true;
191+
break;
192+
default:
193+
LOGF(fatal, "Configurable eventSelections=%s not supported; use selTVX, selMC, selMCFull, sel8, or sel8Full", static_cast<std::string>(eventSelections).c_str());
194+
break;
156195
}
157196

158197
AxisSpec jetPtAxis = {200, 0., jetPtMax, "#it{p}_{T} (GeV/#it{c})"};
159198

160199
if (doprocessCrossSectionEfficiency) {
161-
AxisSpec axCRF = {kBinCRF_N, 0.5, static_cast<double>(kBinCRF_N) + 0.5, "event selection (CollRecoFirst)"};
200+
AxisSpec axisSelectionCollRecoFirst = {CollRecoFirstNBins, 0.5, static_cast<double>(CollRecoFirstNBins) + 0.5, "event selection (CollRecoFirst)"};
162201
registry.add("h2_jet_pt_part_eventselection_collRecoFirst",
163202
"part jet pT vs event selection (CollRecoFirst);#it{p}_{T,jet}^{part} (GeV/#it{c});event selection;counts",
164-
{HistType::kTH2F, {jetPtAxis, axCRF}});
165-
auto hCRF2 = registry.get<TH2>(HIST("h2_jet_pt_part_eventselection_collRecoFirst"));
166-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_Inel, "INEL");
167-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_RctPass, "+RCT_pass");
168-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_HasColl, "+hasRecoColl");
169-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_Zreco, "+|zReco|<10");
170-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_NoSplit, "+noSplit");
171-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_TVX, "+kTVX");
172-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_TFB, "+kNoTFB");
173-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_ROFB, "+kNoITSROFB");
174-
hCRF2->GetYaxis()->SetBinLabel(kBinCRF_SBP, "+kNoSBP");
203+
{HistType::kTH2F, {jetPtAxis, axisSelectionCollRecoFirst}});
204+
auto hJetPtCollRecoFirst = registry.get<TH2>(HIST("h2_jet_pt_part_eventselection_collRecoFirst"));
205+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstInel, "INEL");
206+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstRct, "+RCT_pass");
207+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstHasCollision, "+hasRecoColl");
208+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstVertexZ, "+|zReco|<10");
209+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstNoSplit, "+noSplit");
210+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstTvx, "+kTVX");
211+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstNoTimeFrameBorder, "+kNoTFB");
212+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstNoItsRofBorder, "+kNoITSROFB");
213+
hJetPtCollRecoFirst->GetYaxis()->SetBinLabel(CollRecoFirstNoSameBunchPileup, "+kNoSBP");
175214

176215
registry.add("h_mccollisions_eventselection_collRecoFirst",
177216
"number of mc events vs event selection (CollRecoFirst);event selection;entries",
178-
{HistType::kTH1F, {{kBinCRF_N, 0.5, static_cast<double>(kBinCRF_N) + 0.5}}});
179-
auto hCRF1 = registry.get<TH1>(HIST("h_mccollisions_eventselection_collRecoFirst"));
180-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_Inel, "INEL");
181-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_RctPass, "+RCT_pass");
182-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_HasColl, "+hasRecoColl");
183-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_Zreco, "+|zReco|<10");
184-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_NoSplit, "+noSplit");
185-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_TVX, "+kTVX");
186-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_TFB, "+kNoTFB");
187-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_ROFB, "+kNoITSROFB");
188-
hCRF1->GetXaxis()->SetBinLabel(kBinCRF_SBP, "+kNoSBP");
217+
{HistType::kTH1F, {{CollRecoFirstNBins, 0.5, static_cast<double>(CollRecoFirstNBins) + 0.5}}});
218+
auto hMcCollisionsCollRecoFirst = registry.get<TH1>(HIST("h_mccollisions_eventselection_collRecoFirst"));
219+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstInel, "INEL");
220+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstRct, "+RCT_pass");
221+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstHasCollision, "+hasRecoColl");
222+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstVertexZ, "+|zReco|<10");
223+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstNoSplit, "+noSplit");
224+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstTvx, "+kTVX");
225+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstNoTimeFrameBorder, "+kNoTFB");
226+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstNoItsRofBorder, "+kNoITSROFB");
227+
hMcCollisionsCollRecoFirst->GetXaxis()->SetBinLabel(CollRecoFirstNoSameBunchPileup, "+kNoSBP");
189228
}
190229

191230
if (doprocessCrossSectionEfficiencyBcBitsFirst) {
192-
AxisSpec axBBF = {kBinBBF_N, 0.5, static_cast<double>(kBinBBF_N) + 0.5, "event selection (BcBitsFirst)"};
231+
AxisSpec axisSelectionBcBitsFirst = {BcBitsFirstNBins, 0.5, static_cast<double>(BcBitsFirstNBins) + 0.5, "event selection (BcBitsFirst)"};
193232
registry.add("h2_jet_pt_part_eventselection_bcBitsFirst",
194233
"part jet pT vs event selection (BcBitsFirst);#it{p}_{T,jet}^{part} (GeV/#it{c});event selection;counts",
195-
{HistType::kTH2F, {jetPtAxis, axBBF}});
196-
auto hBBF2 = registry.get<TH2>(HIST("h2_jet_pt_part_eventselection_bcBitsFirst"));
197-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_Inel, "INEL");
198-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_RctPass, "+RCT_pass");
199-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_TVX, "+kTVX(truth)");
200-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_TFB, "+kNoTFB(truth)");
201-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_ROFB, "+kNoITSROFB(truth)");
202-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_TruthSBP, "+kNoSBP(truth)");
203-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_HasColl, "+hasColl");
204-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_Zreco, "+|zReco|<10");
205-
hBBF2->GetYaxis()->SetBinLabel(kBinBBF_NoSplit, "+noSplit");
234+
{HistType::kTH2F, {jetPtAxis, axisSelectionBcBitsFirst}});
235+
auto hJetPtBcBitsFirst = registry.get<TH2>(HIST("h2_jet_pt_part_eventselection_bcBitsFirst"));
236+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstInel, "INEL");
237+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstRct, "+RCT_pass");
238+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstTvx, "+kTVX(truth)");
239+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstNoTimeFrameBorder, "+kNoTFB(truth)");
240+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstNoItsRofBorder, "+kNoITSROFB(truth)");
241+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstNoSameBunchPileupTruth, "+kNoSBP(truth)");
242+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstHasCollision, "+hasColl");
243+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstVertexZ, "+|zReco|<10");
244+
hJetPtBcBitsFirst->GetYaxis()->SetBinLabel(BcBitsFirstNoSplit, "+noSplit");
206245

207246
registry.add("h_mccollisions_eventselection_bcBitsFirst",
208247
"number of mc events vs event selection (BcBitsFirst);event selection;entries",
209-
{HistType::kTH1F, {{kBinBBF_N, 0.5, static_cast<double>(kBinBBF_N) + 0.5}}});
210-
auto hBBF1 = registry.get<TH1>(HIST("h_mccollisions_eventselection_bcBitsFirst"));
211-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_Inel, "INEL");
212-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_RctPass, "+RCT_pass");
213-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_TVX, "+kTVX(truth)");
214-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_TFB, "+kNoTFB(truth)");
215-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_ROFB, "+kNoITSROFB(truth)");
216-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_TruthSBP, "+kNoSBP(truth)");
217-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_HasColl, "+hasColl");
218-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_Zreco, "+|zReco|<10");
219-
hBBF1->GetXaxis()->SetBinLabel(kBinBBF_NoSplit, "+noSplit");
248+
{HistType::kTH1F, {{BcBitsFirstNBins, 0.5, static_cast<double>(BcBitsFirstNBins) + 0.5}}});
249+
auto hMcCollisionsBcBitsFirst = registry.get<TH1>(HIST("h_mccollisions_eventselection_bcBitsFirst"));
250+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstInel, "INEL");
251+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstRct, "+RCT_pass");
252+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstTvx, "+kTVX(truth)");
253+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstNoTimeFrameBorder, "+kNoTFB(truth)");
254+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstNoItsRofBorder, "+kNoITSROFB(truth)");
255+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstNoSameBunchPileupTruth, "+kNoSBP(truth)");
256+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstHasCollision, "+hasColl");
257+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstVertexZ, "+|zReco|<10");
258+
hMcCollisionsBcBitsFirst->GetXaxis()->SetBinLabel(BcBitsFirstNoSplit, "+noSplit");
220259
}
221260
}
222261

@@ -225,7 +264,7 @@ struct JetCrossSectionEfficiency {
225264
{
226265
float ptHardFromMc = ptHardCalcMethodSwitch;
227266
float storedPtHard = mccollision.ptHard();
228-
if (storedPtHard > kBrokenPtHardSentinel && storedPtHard < ptHardCalcMethodSwitch) {
267+
if (storedPtHard > BrokenPtHardSentinel && storedPtHard < ptHardCalcMethodSwitch) {
229268
ptHardFromMc = storedPtHard;
230269
}
231270
float weight = mccollision.weight();
@@ -237,13 +276,13 @@ struct JetCrossSectionEfficiency {
237276
template <typename TTracks, typename TJets>
238277
bool isAcceptedJet(TJets const& jet)
239278
{
240-
if (jetAreaFractionMin > configSwitchLow) {
279+
if (jetAreaFractionMin > ConfigSwitchLow) {
241280
if (jet.area() < jetAreaFractionMin * o2::constants::math::PI * (jet.r() / 100.0) * (jet.r() / 100.0)) {
242281
return false;
243282
}
244283
}
245-
bool checkConstituentMinPt = (leadingConstituentPtMinMCP > configSwitchLow);
246-
bool checkConstituentMaxPt = (leadingConstituentPtMaxMCP < configSwitchHigh);
284+
bool checkConstituentMinPt = (leadingConstituentPtMinMCP > ConfigSwitchLow);
285+
bool checkConstituentMaxPt = (leadingConstituentPtMaxMCP < ConfigSwitchHigh);
247286
bool checkConstituentPt = checkConstituentMinPt || checkConstituentMaxPt;
248287

249288
if (checkConstituentPt) {
@@ -303,17 +342,17 @@ struct JetCrossSectionEfficiency {
303342
}
304343

305344
bool passesRct = applyRCT ? (mccollision.bc_as<aod::JBCs>().rct_raw() & rctMask) == 0 : true;
306-
bool pass[kBinCRF_N + 1] = {false, true, passesRct, hasRecoColl, passesZvtxCutReco,
307-
hasRecoColl && noSplitPass, passesTVX,
308-
applyTFB ? passesNoTFB : true,
309-
applyROFB ? passesNoITSROFB : true,
310-
applySBP ? passesNoSBP : true};
345+
bool pass[CollRecoFirstNBins + 1] = {false, true, passesRct, hasRecoColl, passesZvtxCutReco,
346+
hasRecoColl && noSplitPass, passesTVX,
347+
applyTFB ? passesNoTFB : true,
348+
applyROFB ? passesNoITSROFB : true,
349+
applySBP ? passesNoSBP : true};
311350

312351
// Unified weight handling: MB MC -> weight=1 (no-op), JJ MC -> per-event sigma fraction.
313352
float weight = mccollision.weight();
314353

315354
int sMax = 0;
316-
for (int s = kBinCRF_Inel; s <= kBinCRF_N; ++s) {
355+
for (int s = CollRecoFirstInel; s <= CollRecoFirstNBins; ++s) {
317356
if (!pass[s])
318357
break;
319358
registry.fill(HIST("h_mccollisions_eventselection_collRecoFirst"), static_cast<double>(s), weight);
@@ -334,7 +373,7 @@ struct JetCrossSectionEfficiency {
334373
!isAcceptedJet<aod::JetParticles>(jet)) {
335374
continue;
336375
}
337-
for (int s = kBinCRF_Inel; s <= sMax; ++s) {
376+
for (int s = CollRecoFirstInel; s <= sMax; ++s) {
338377
registry.fill(HIST("h2_jet_pt_part_eventselection_collRecoFirst"), jet.pt(), static_cast<double>(s), weight);
339378
}
340379
}
@@ -379,16 +418,16 @@ struct JetCrossSectionEfficiency {
379418
bool noSplitPass = (acceptSplitCollisions == NonSplitOnly) ? (collisions.size() == 1) : true;
380419

381420
bool passesRct = applyRCT ? (truthBC.rct_raw() & rctMask) == 0 : true;
382-
bool pass[kBinBBF_N + 1] = {false, true, passesRct, passesTVXTruth,
383-
applyTFB ? passesNoTFBTruth : true,
384-
applyROFB ? passesNoITSROFBTruth : true,
385-
applySBP ? truthNoSBP : true,
386-
hasRecoColl, passesZvtxCutReco, hasRecoColl && noSplitPass};
421+
bool pass[BcBitsFirstNBins + 1] = {false, true, passesRct, passesTVXTruth,
422+
applyTFB ? passesNoTFBTruth : true,
423+
applyROFB ? passesNoITSROFBTruth : true,
424+
applySBP ? truthNoSBP : true,
425+
hasRecoColl, passesZvtxCutReco, hasRecoColl && noSplitPass};
387426

388427
float weight = mccollision.weight();
389428

390429
int sMax = 0;
391-
for (int s = kBinBBF_Inel; s <= kBinBBF_N; ++s) {
430+
for (int s = BcBitsFirstInel; s <= BcBitsFirstNBins; ++s) {
392431
if (!pass[s])
393432
break;
394433
registry.fill(HIST("h_mccollisions_eventselection_bcBitsFirst"), static_cast<double>(s), weight);
@@ -409,7 +448,7 @@ struct JetCrossSectionEfficiency {
409448
!isAcceptedJet<aod::JetParticles>(jet)) {
410449
continue;
411450
}
412-
for (int s = kBinBBF_Inel; s <= sMax; ++s) {
451+
for (int s = BcBitsFirstInel; s <= sMax; ++s) {
413452
registry.fill(HIST("h2_jet_pt_part_eventselection_bcBitsFirst"), jet.pt(), static_cast<double>(s), weight);
414453
}
415454
}

‎PWGJE/Tasks/trackEfficiency.cxx‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -168,6 +168,7 @@ struct TrackEfficiency {
168168
registry.fill(HIST("h2_track_pt_high_track_sigma1overpt"), track.pt(), track.sigma1Pt(), weight);
169169
registry.fill(HIST("h2_track_pt_high_track_sigmapt"), track.pt(), track.sigma1Pt() * track.pt(), weight);
170170
registry.fill(HIST("h3_intrate_centrality_track_pt"), collision.hadronicRate(), centrality, track.pt(), weight);
171+
registry.fill(HIST("h3_track_pt_track_eta_track_phi"), track.pt(), track.eta(), track.phi(), weight);
171172
}
172173
}
173174

@@ -335,6 +336,7 @@ struct TrackEfficiency {
335336
registry.add("h2_track_pt_track_sigma1overpt", "#sigma(1/#it{p}_{T}); #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{100, 0., 10.}, {10000, 0.0, 1.0}}});
336337
registry.add("h2_track_pt_high_track_sigma1overpt", "#sigma(1/#it{p}_{T}); #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{90, 10., 100.}, {10000, 0.0, 1.0}}});
337338
registry.add("h3_intrate_centrality_track_pt", "interaction rate vs centrality vs track pT; int. rate; centrality; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH3F, {intRateAxis, centAxis, {200, 0., 200.}}});
339+
registry.add("h3_track_pt_track_eta_track_phi", "track pT vs track #eta vs track #varphi; #it{p}_{T,track} (GeV/#it{c}); #eta_{track}; #varphi_{track}", {HistType::kTH3F, {{200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}}});
338340
}
339341

340342
if (doprocessParticles || doprocessParticlesWeighted) {

0 commit comments

Comments
 (0)