Skip to content

Commit 6c74353

Browse files
DonggukKim0DonggukKim0
authored
[PWGJE] update dijetFinderQA.cxx (#11302)
1 parent e487ef9 commit 6c74353

File tree

1 file changed

+164
-52
lines changed

1 file changed

+164
-52
lines changed

‎PWGJE/Tasks/dijetFinderQA.cxx‎

Lines changed: 164 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,7 @@ struct DijetFinderQATask {
5252
Configurable<float> centralityMax{"centralityMax", 999.0, "maximum centrality"};
5353
Configurable<std::string> eventSelections{"eventSelections", "sel8", "choose event selection"};
5454
Configurable<float> vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"};
55+
Configurable<bool> checkMcCollisionIsMatched{"checkMcCollisionIsMatched", false, "0: count whole MCcollisions, 1: select MCcollisions which only have their correspond collisions"};
5556
Configurable<std::string> trackSelections{"trackSelections", "globalTracks", "set track selections"};
5657
Configurable<float> trackPtMin{"trackPtMin", 0.15, "minimum pT acceptance for tracks"};
5758
Configurable<float> trackPtMax{"trackPtMax", 1000.0, "maximum pT acceptance for tracks"};
@@ -73,6 +74,28 @@ struct DijetFinderQATask {
7374

7475
std::vector<double> dijetMassBins;
7576

77+
void labelCollisionHistograms(HistogramRegistry& registry)
78+
{
79+
if (doprocessDijetMCP) {
80+
auto hColCounter_MCP = registry.get<TH1>(HIST("hColCounter_MCP"));
81+
hColCounter_MCP->GetXaxis()->SetBinLabel(1, "AllMcCollisions");
82+
hColCounter_MCP->GetXaxis()->SetBinLabel(2, "McCollisionsWithVertexZ");
83+
hColCounter_MCP->GetXaxis()->SetBinLabel(3, "MatchedMcCollisions");
84+
}
85+
if (doprocessDijetMCD) {
86+
auto hColCounter_MCD = registry.get<TH1>(HIST("hColCounter_MCD"));
87+
hColCounter_MCD->GetXaxis()->SetBinLabel(1, "AllDetCollisions");
88+
hColCounter_MCD->GetXaxis()->SetBinLabel(2, "DetCollisionsWithVertexZ");
89+
hColCounter_MCD->GetXaxis()->SetBinLabel(3, "AcceptedDetCollisions");
90+
}
91+
if (doprocessDijetData) {
92+
auto hColCounter_Data = registry.get<TH1>(HIST("hColCounter_Data"));
93+
hColCounter_Data->GetXaxis()->SetBinLabel(1, "AllDataCollisions");
94+
hColCounter_Data->GetXaxis()->SetBinLabel(2, "DataCollisionsWithVertexZ");
95+
hColCounter_Data->GetXaxis()->SetBinLabel(3, "AcceptedDataCollisions");
96+
}
97+
}
98+
7699
void init(o2::framework::InitContext&)
77100
{
78101
eventSelection = jetderiveddatautilities::initialiseEventSelectionBits(static_cast<std::string>(eventSelections));
@@ -86,32 +109,33 @@ struct DijetFinderQATask {
86109
}
87110

88111
AxisSpec dijetMassAxis = {dijetMassBins, "M_{jj} (GeV/#it{c}^2)"};
89-
AxisSpec eventCountAxis = {{0.5, 1.5}, "events"};
90112

91113
if (doprocessDijetMCP) {
92114
registry.add("h_part_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {dijetMassAxis}});
93-
registry.add("hColCounterFinal_MCP", "Event count;;entries", {HistType::kTH1F, {eventCountAxis}});
115+
registry.add("hColCounter_MCP", "event status; event status;entries", {HistType::kTH1F, {{10, 0., 10.0}}});
94116
}
95117

96118
if (doprocessDijetMCD) {
97119
registry.add("h_detec_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {dijetMassAxis}});
98-
registry.add("hColCounterFinal_MCD", "Event count;;entries", {HistType::kTH1F, {eventCountAxis}});
120+
registry.add("hColCounter_MCD", "event status; event status;entries", {HistType::kTH1F, {{10, 0., 10.0}}});
121+
// registry.add("hColCounter_MCD", "Event count;;entries", {HistType::kTH1F, {eventCountAxis}});
99122
}
100123

101124
if (doprocessDijetData) {
102125
registry.add("h_data_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {dijetMassAxis}});
103-
registry.add("hColCounterFinal_Data", "Event count;;entries", {HistType::kTH1F, {eventCountAxis}});
126+
registry.add("hColCounter_Data", "event status; event status;entries", {HistType::kTH1F, {{10, 0., 10.0}}});
127+
// registry.add("hColCounter_Data", "Event count;;entries", {HistType::kTH1F, {eventCountAxis}});
104128
}
105129

106-
if (doprocessDijetMCMatched) {
130+
if (doprocessDijetMCPMCDMatched) {
107131
registry.add("h_matched_dijet_mass", "M_{jj matched};M_{jj part}; M_{jj det}", {HistType::kTH2F, {dijetMassAxis, dijetMassAxis}});
108132
}
133+
134+
labelCollisionHistograms(registry);
109135
}
110136

111137
/****************************************************************************************************************************************************************/
112138
Filter trackCuts = (aod::jtrack::pt >= trackPtMin && aod::jtrack::pt < trackPtMax && aod::jtrack::eta > trackEtaMin && aod::jtrack::eta < trackEtaMax);
113-
Filter eventCuts = (nabs(aod::jcollision::posZ) < vertexZCut && aod::jcollision::centrality >= centralityMin && aod::jcollision::centrality < centralityMax);
114-
Filter mcCollisionsFilter = nabs(aod::jmccollision::posZ) < vertexZCut;
115139
Filter jetCuts = aod::jet::pt > jetPtMin&& aod::jet::r == nround(jetR.node() * 100.0f);
116140
/****************************************************************************************************************************************************************/
117141

@@ -170,7 +194,7 @@ struct DijetFinderQATask {
170194
}
171195

172196
template <typename T>
173-
void fillMassHistogramsMCMatched(T const& mass_P, T const& mass_D)
197+
void fillMassHistogramsMCPMCDMatched(T const& mass_P, T const& mass_D)
174198
{
175199
registry.fill(HIST("h_matched_dijet_mass"), mass_P, mass_D);
176200
}
@@ -180,25 +204,44 @@ struct DijetFinderQATask {
180204
}
181205
PROCESS_SWITCH(DijetFinderQATask, processDummy, "dummy", false);
182206

183-
void processDijetMCP(soa::Filtered<aod::JetMcCollisions>::iterator const&, soa::Filtered<aod::ChargedMCParticleLevelJets> const& jets, soa::SmallGroups<aod::JetCollisionsMCD> const& collisions)
207+
void processDijetMCP(aod::JetMcCollisions::iterator const& mccollision,
208+
soa::Filtered<soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents>> const& jets,
209+
soa::SmallGroups<aod::JetCollisionsMCD> const& collisions)
184210
{
185-
if (collisions.size() == 0) {
211+
registry.fill(HIST("hColCounter_MCP"), 0.5);
212+
if (fabs(mccollision.posZ()) > vertexZCut) {
186213
return;
187214
}
188-
for (auto& collision : collisions) {
189-
if (fabs(collision.posZ()) > vertexZCut || !jetderiveddatautilities::selectCollision(collision, eventSelection))
215+
registry.fill(HIST("hColCounter_MCP"), 1.5);
216+
if (checkMcCollisionIsMatched) {
217+
if (collisions.size() == 0) {
190218
return;
219+
}
220+
for (auto& collision : collisions) {
221+
if (fabs(collision.posZ()) > vertexZCut || !jetderiveddatautilities::selectCollision(collision, eventSelection)) {
222+
return;
223+
}
224+
}
225+
registry.fill(HIST("hColCounter_MCP"), 2.5);
191226
}
192227

193-
registry.fill(HIST("hColCounterFinal_MCP"), 1);
194-
195228
std::vector<std::array<double, 3>> jetPtcuts;
196229
for (auto& jet : jets) {
230+
if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) {
231+
continue;
232+
}
233+
if (!isAcceptedJet<aod::JetParticles>(jet)) {
234+
continue;
235+
}
236+
if (jet.pt() < setJetPtCut) {
237+
continue;
238+
}
197239
jetPtcuts.push_back({jet.pt(), jet.eta(), jet.phi()});
198240
}
199241

200242
if (jetPtcuts.size() >= 2) {
201243
auto& leading_jet = jetPtcuts[0];
244+
202245
bool found_pair = false;
203246

204247
for (size_t i = 1; i < jetPtcuts.size() && !found_pair; i++) {
@@ -219,21 +262,36 @@ struct DijetFinderQATask {
219262
}
220263
PROCESS_SWITCH(DijetFinderQATask, processDijetMCP, "QA for invariant mass of dijet in particle level MC", false);
221264

222-
void processDijetMCD(soa::Filtered<aod::JetCollisions>::iterator const& collision, soa::Filtered<aod::ChargedMCDetectorLevelJets> const& jets)
265+
void processDijetMCD(aod::JetCollisions::iterator const& collision,
266+
soa::Filtered<soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents>> const& jets)
223267
{
268+
registry.fill(HIST("hColCounter_MCD"), 0.5);
269+
if (fabs(collision.posZ()) > vertexZCut) {
270+
return;
271+
}
272+
registry.fill(HIST("hColCounter_MCD"), 1.5);
224273
if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) {
225274
return;
226275
}
227-
228-
registry.fill(HIST("hColCounterFinal_MCD"), 1);
276+
registry.fill(HIST("hColCounter_MCD"), 2.5);
229277

230278
std::vector<std::array<double, 3>> jetPtcuts;
231279
for (auto& jet : jets) {
280+
if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) {
281+
continue;
282+
}
283+
if (!isAcceptedJet<aod::JetParticles>(jet)) {
284+
continue;
285+
}
286+
if (jet.pt() < setJetPtCut) {
287+
continue;
288+
}
232289
jetPtcuts.push_back({jet.pt(), jet.eta(), jet.phi()});
233290
}
234291

235292
if (jetPtcuts.size() >= 2) {
236293
auto& leading_jet = jetPtcuts[0];
294+
237295
bool found_pair = false;
238296

239297
for (size_t i = 1; i < jetPtcuts.size() && !found_pair; i++) {
@@ -254,22 +312,36 @@ struct DijetFinderQATask {
254312
}
255313
PROCESS_SWITCH(DijetFinderQATask, processDijetMCD, "QA for invariant mass of dijet in detector level MC", false);
256314

257-
void processDijetData(soa::Filtered<aod::JetCollisions>::iterator const& collision, soa::Filtered<aod::ChargedJets> const& jets)
315+
void processDijetData(aod::JetCollisions::iterator const& collision,
316+
soa::Filtered<soa::Join<aod::ChargedJets, aod::ChargedJetConstituents>> const& jets)
258317
{
318+
registry.fill(HIST("hColCounter_Data"), 0.5);
319+
if (fabs(collision.posZ()) > vertexZCut) {
320+
return;
321+
}
322+
registry.fill(HIST("hColCounter_Data"), 1.5);
259323
if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) {
260324
return;
261325
}
262-
263-
// Fill event count histogram
264-
registry.fill(HIST("hColCounterFinal_Data"), 1);
326+
registry.fill(HIST("hColCounter_Data"), 2.5);
265327

266328
std::vector<std::array<double, 3>> jetPtcuts;
267329
for (auto& jet : jets) {
330+
if (!jetfindingutilities::isInEtaAcceptance(jet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) {
331+
continue;
332+
}
333+
if (!isAcceptedJet<aod::JetParticles>(jet)) {
334+
continue;
335+
}
336+
if (jet.pt() < setJetPtCut) {
337+
continue;
338+
}
268339
jetPtcuts.push_back({jet.pt(), jet.eta(), jet.phi()});
269340
}
270341

271342
if (jetPtcuts.size() >= 2) {
272343
auto& leading_jet = jetPtcuts[0];
344+
273345
bool found_pair = false;
274346

275347
for (size_t i = 1; i < jetPtcuts.size() && !found_pair; i++) {
@@ -290,61 +362,101 @@ struct DijetFinderQATask {
290362
}
291363
PROCESS_SWITCH(DijetFinderQATask, processDijetData, "QA for invariant mass of dijet in data", false);
292364

293-
using JetMCPTable = soa::Filtered<soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents, aod::ChargedMCParticleLevelJetsMatchedToChargedMCDetectorLevelJets>>;
294-
void processDijetMCMatched(soa::Filtered<aod::JetCollisionsMCD>::iterator const& collision,
295-
soa::Filtered<soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents, aod::ChargedMCDetectorLevelJetsMatchedToChargedMCParticleLevelJets>> const& mcdjets,
296-
JetMCPTable const&, aod::JetTracks const&, aod::JetParticles const&)
365+
using JetMCPTable = soa::Filtered<soa::Join<aod::ChargedMCParticleLevelJets,
366+
aod::ChargedMCParticleLevelJetConstituents,
367+
aod::ChargedMCParticleLevelJetsMatchedToChargedMCDetectorLevelJets>>;
368+
using JetMCDTable = soa::Filtered<soa::Join<aod::ChargedMCDetectorLevelJets,
369+
aod::ChargedMCDetectorLevelJetConstituents,
370+
aod::ChargedMCDetectorLevelJetsMatchedToChargedMCParticleLevelJets>>;
371+
372+
void processDijetMCPMCDMatched(aod::JetCollisionsMCD::iterator const& collision,
373+
JetMCDTable const& mcdjets,
374+
JetMCPTable const&,
375+
aod::JetTracks const&,
376+
aod::JetParticles const&)
297377
{
378+
if (fabs(collision.posZ()) > vertexZCut) {
379+
return;
380+
}
298381
if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) {
299382
return;
300383
}
301384

302385
std::vector<std::array<double, 3>> jetPtcuts_D;
303386
std::vector<std::array<double, 3>> jetPtcuts_P;
304387

305-
for (auto& jet : mcdjets) {
306-
if (jet.has_matchedJetGeo()) {
307-
for (auto& matchedJet : jet.template matchedJetPt_as<JetMCPTable>()) {
308-
if (matchedJet.pt() > setJetPtCut) {
309-
jetPtcuts_D.push_back({jet.pt(), jet.eta(), jet.phi()});
310-
jetPtcuts_P.push_back({matchedJet.pt(), matchedJet.eta(), matchedJet.phi()});
311-
break;
388+
for (auto& mcdjet : mcdjets) {
389+
if (!jetfindingutilities::isInEtaAcceptance(mcdjet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) {
390+
continue;
391+
}
392+
if (!isAcceptedJet<aod::JetParticles>(mcdjet)) {
393+
continue;
394+
}
395+
if (mcdjet.pt() < setJetPtCut) {
396+
continue;
397+
}
398+
if (mcdjet.has_matchedJetGeo()) {
399+
for (auto& matchedjet : mcdjet.template matchedJetPt_as<JetMCPTable>()) {
400+
if (matchedjet.pt() < setJetPtCut) {
401+
continue;
402+
}
403+
if (!jetfindingutilities::isInEtaAcceptance(matchedjet, jetEtaMin, jetEtaMax, trackEtaMin, trackEtaMax)) {
404+
continue;
405+
}
406+
if (!isAcceptedJet<aod::JetParticles>(matchedjet)) {
407+
continue;
312408
}
409+
jetPtcuts_D.push_back({mcdjet.pt(), mcdjet.eta(), mcdjet.phi()});
410+
jetPtcuts_P.push_back({matchedjet.pt(), matchedjet.eta(), matchedjet.phi()});
313411
}
314412
}
315413
}
316414

317415
if (jetPtcuts_D.size() >= 2 && jetPtcuts_P.size() >= 2) {
318416
auto& leading_jet_D = jetPtcuts_D[0];
319417
auto& leading_jet_P = jetPtcuts_P[0];
320-
bool found_pair = false;
321418

322-
for (size_t i = 1; i < jetPtcuts_D.size() && !found_pair; i++) {
323-
auto& candidate_jet_D = jetPtcuts_D[i];
324-
auto& candidate_jet_P = jetPtcuts_P[i];
419+
std::array<double, 3> candidate_jet_D{};
420+
std::array<double, 3> candidate_jet_P{};
325421

326-
Double_t dphi_D = fabs(leading_jet_D[2] - candidate_jet_D[2]);
327-
Double_t deta_D = fabs(leading_jet_D[1] - candidate_jet_D[1]);
328-
Double_t dphi_P = fabs(leading_jet_P[2] - candidate_jet_P[2]);
329-
Double_t deta_P = fabs(leading_jet_P[1] - candidate_jet_P[1]);
330-
Double_t condition = fabs(dphi_D - M_PI);
422+
auto dphi_D = 0.;
423+
auto dphi_P = 0.;
331424

332-
if (condition < setPhiCut * M_PI) {
333-
double pt1_D = leading_jet_D[0];
334-
double pt2_D = candidate_jet_D[0];
335-
double dijet_mass_D = sqrt(2 * pt1_D * pt2_D * (cosh(deta_D) - cos(dphi_D)));
336-
337-
double pt1_P = leading_jet_P[0];
338-
double pt2_P = candidate_jet_P[0];
339-
double dijet_mass_P = sqrt(2 * pt1_P * pt2_P * (cosh(deta_P) - cos(dphi_P)));
425+
bool found_pair_MCD = false;
426+
bool found_pair_MCP = false;
340427

341-
fillMassHistogramsMCMatched(dijet_mass_P, dijet_mass_D);
342-
found_pair = true;
428+
for (size_t i = 1; i < jetPtcuts_D.size() && !found_pair_MCD; i++) {
429+
candidate_jet_D = jetPtcuts_D[i];
430+
dphi_D = fabs(leading_jet_D[2] - candidate_jet_D[2]);
431+
Double_t condition = fabs(dphi_D - M_PI);
432+
if (condition > setPhiCut * M_PI) {
433+
continue;
434+
}
435+
found_pair_MCD = true;
436+
}
437+
for (size_t i = 1; i < jetPtcuts_P.size() && !found_pair_MCP; i++) {
438+
candidate_jet_P = jetPtcuts_P[i];
439+
dphi_P = fabs(leading_jet_P[2] - candidate_jet_P[2]);
440+
Double_t condition = fabs(dphi_P - M_PI);
441+
if (condition > setPhiCut * M_PI) {
442+
continue;
343443
}
444+
found_pair_MCP = true;
445+
}
446+
if (found_pair_MCD && found_pair_MCP) {
447+
Double_t deta_D = fabs(leading_jet_D[1] - candidate_jet_D[1]);
448+
Double_t deta_P = fabs(leading_jet_P[1] - candidate_jet_P[1]);
449+
double pt1_D = leading_jet_D[0];
450+
double pt2_D = candidate_jet_D[0];
451+
double pt1_P = leading_jet_P[0];
452+
double pt2_P = candidate_jet_P[0];
453+
double dijet_mass_D = sqrt(2 * pt1_D * pt2_D * (cosh(deta_D) - cos(dphi_D)));
454+
double dijet_mass_P = sqrt(2 * pt1_P * pt2_P * (cosh(deta_P) - cos(dphi_P)));
455+
fillMassHistogramsMCPMCDMatched(dijet_mass_P, dijet_mass_D);
344456
}
345457
}
346458
}
347-
PROCESS_SWITCH(DijetFinderQATask, processDijetMCMatched, "QA for invariant mass of dijet in mcmactched", false);
459+
PROCESS_SWITCH(DijetFinderQATask, processDijetMCPMCDMatched, "QA for invariant mass of dijet in mcmactched", false);
348460
};
349461

350462
WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)

0 commit comments

Comments
 (0)