AliPhysics  97344c9 (97344c9)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalDijetImbalance.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2016, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 
16 #include <TClonesArray.h>
17 #include <TH1F.h>
18 #include <TH2F.h>
19 #include <TList.h>
20 #include <THnSparse.h>
21 
22 #include <AliVCluster.h>
23 #include <AliVParticle.h>
24 #include <AliLog.h>
25 
26 #include "AliTLorentzVector.h"
27 #include "AliEmcalJet.h"
28 #include "AliRhoParameter.h"
29 #include "AliJetContainer.h"
30 #include "AliParticleContainer.h"
31 #include "AliClusterContainer.h"
32 
34 
38 
44  fHistManager(),
45  fDeltaPhiMin(0),
46  fNDijetPtThresholds(1),
47  fMinTrigJetPt(0),
48  fMinAssJetPt(0),
49  fDijetLeadingHadronPt(0),
50  fMaxPt(250),
51  fNCentHistBins(0),
52  fCentHistBins(0),
53  fPlotJetHistograms(kFALSE),
54  fPlotDijetJetHistograms(kFALSE),
55  fPlotDijetImbalanceHistograms(kFALSE),
56  fDoMomentumBalance(kFALSE),
57  fDoGeometricalMatching(kFALSE),
58  fMatchingJetR(0.2),
59  fTrackConstituentThreshold(0),
60  fClusterConstituentThreshold(0)
61 {
66 }
67 
74  AliAnalysisTaskEmcalJet(name, kTRUE),
75  fHistManager(name),
76  fDeltaPhiMin(0),
77  fNDijetPtThresholds(1),
78  fMinTrigJetPt(0),
79  fMinAssJetPt(0),
80  fDijetLeadingHadronPt(0),
81  fMaxPt(250),
82  fNCentHistBins(0),
83  fCentHistBins(0),
84  fPlotJetHistograms(kFALSE),
85  fPlotDijetJetHistograms(kFALSE),
86  fPlotDijetImbalanceHistograms(kFALSE),
87  fDoMomentumBalance(kFALSE),
88  fDoGeometricalMatching(kFALSE),
89  fMatchingJetR(0.2),
90  fTrackConstituentThreshold(0),
91  fClusterConstituentThreshold(0)
92 {
97 }
98 
103 {
104 }
105 
110 {
111  fNCentHistBins = 4;
113  fCentHistBins[0] = 0;
114  fCentHistBins[1] = 10;
115  fCentHistBins[2] = 30;
116  fCentHistBins[3] = 50;
117  fCentHistBins[4] = 90;
118 }
119 
125 {
127 
133 
134  TIter next(fHistManager.GetListOfHistograms());
135  TObject* obj = 0;
136  while ((obj = next())) {
137  fOutput->Add(obj);
138  }
139 
140  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
141 }
142 
143 /*
144  * This function allocates the histograms for single jets.
145  * A set of histograms is allocated per each jet container and per each centrality bin.
146  */
148 {
149 
150  AliJetContainer* jets = 0;
151  TIter nextJetColl(&fJetCollArray);
152  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
153 
154  // Allocate THnSparse
155  TString axisTitle[30]= {""};
156  Int_t nbins[30] = {0};
157  Double_t min[30] = {0.};
158  Double_t max[30] = {0.};
159  Double_t *binEdges[20] = {0};
160  Int_t dim = 0;
161 
162  if (fForceBeamType != kpp) {
163  axisTitle[dim] = "Centrality (%)";
164  nbins[dim] = fNCentHistBins;
165  binEdges[dim] = fCentHistBins;
166  min[dim] = fCentHistBins[0];
167  max[dim] = fCentHistBins[fNCentHistBins];
168  dim++;
169  }
170 
171  axisTitle[dim] = "#eta_{jet}";
172  nbins[dim] = 100;
173  min[dim] = -1;
174  max[dim] = 1;
175  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
176  dim++;
177 
178  axisTitle[dim] = "#phi_{jet} (rad)";
179  nbins[dim] = 101;
180  min[dim] = 0;
181  max[dim] = TMath::Pi() * 2.02;
182  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
183  dim++;
184 
185  axisTitle[dim] = "#it{p}_{T} (GeV/#it{c})";
186  nbins[dim] = TMath::CeilNint(fMaxPt/2);
187  min[dim] = 0;
188  max[dim] = fMaxPt;
189  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
190  dim++;
191 
192  if (fForceBeamType != kpp) {
193  axisTitle[dim] = "#it{p}_{T}^{corr} (GeV/#it{c})";
194  nbins[dim] = TMath::CeilNint(fMaxPt/2);
195  min[dim] = -fMaxPt/2 + 25;
196  max[dim] = fMaxPt/2 + 25;
197  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
198  dim++;
199  }
200 
201  axisTitle[dim] = "#it{p}_{T,particle}^{leading} (GeV/#it{c})";
202  nbins[dim] = 56;
203  Double_t* pTLeadingBins = new Double_t[nbins[dim]+1];
204  GenerateFixedBinArray(20, 0, 10, pTLeadingBins);
205  GenerateFixedBinArray(10, 10, 20, pTLeadingBins+20);
206  GenerateFixedBinArray(26, 20, 150, pTLeadingBins+30);
207  min[dim] = 0;
208  max[dim] = pTLeadingBins[nbins[dim]];
209  binEdges[dim] = pTLeadingBins;
210  dim++;
211 
212  axisTitle[dim] = "#it{A}_{jet}";
213  nbins[dim] = fMaxPt/3;
214  min[dim] = 0;
215  max[dim] = 1.5;
216  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
217  dim++;
218 
219  if (fClusterCollArray.GetEntriesFast() > 0 && fParticleCollArray.GetEntriesFast() > 0) {
220  axisTitle[dim] = "NEF";
221  nbins[dim] = fMaxPt/5;
222  min[dim] = 0;
223  max[dim] = 1.0;
224  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
225  dim++;
226  }
227 
228  axisTitle[dim] = "#it{z}_{leading}";
229  nbins[dim] = fMaxPt/5;
230  min[dim] = 0;
231  max[dim] = 1.0;
232  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
233  dim++;
234 
235  if (fForceBeamType != kpp) {
236  axisTitle[dim] = "No. of constituents";
237  nbins[dim] = fMaxPt/5;
238  min[dim] = 0;
239  max[dim] = fMaxPt;
240  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
241  dim++;
242  }
243  else {
244  axisTitle[dim] = "No. of constituents";
245  nbins[dim] = 50;
246  min[dim] = -0.5;
247  max[dim] = 49.5;
248  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
249  dim++;
250  }
251 
252  TString thnname = TString::Format("%s/JetObservables", jets->GetArrayName().Data());
253  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
254  for (Int_t i = 0; i < dim; i++) {
255  hn->GetAxis(i)->SetTitle(axisTitle[i]);
256  hn->SetBinEdges(i, binEdges[i]);
257  }
258 
259  // Allocate other jet histograms
260  TString histname;
261  TString title;
262  histname = TString::Format("%s/fHistJetRejectionReason", jets->GetArrayName().Data());
263  title = histname + ";Rejection reason;#it{p}_{T,jet} (GeV/#it{c});counts";
264  TH2* hist = fHistManager.CreateTH2(histname.Data(), title.Data(), 32, 0, 32, 50, 0, 250);
265  SetRejectionReasonLabels(hist->GetXaxis());
266 
267  if (!jets->GetRhoName().IsNull()) {
268  histname = TString::Format("%s/fHistRhoVsCent", jets->GetArrayName().Data());
269  title = histname + ";Centrality (%);#rho (GeV/#it{c});counts";
270  fHistManager.CreateTH2(histname.Data(), title.Data(), 101, 0, 101, 100, 0, 500);
271  }
272 
273  }
274 }
275 
276 /*
277  * This function allocates the histograms for single jets that comprise dijet pairs.
278  */
280 {
281  // Allocate dijet THnSparse
282  AliJetContainer* jets = 0;
283  TIter nextJetColl(&fJetCollArray);
284  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
285  TString axisTitle[30]= {""};
286  Int_t nbins[30] = {0};
287  Double_t min[30] = {0.};
288  Double_t max[30] = {0.};
289  Double_t *binEdges[20] = {0};
290  Int_t dim = 0;
291 
292  if (fForceBeamType != kpp) {
293  axisTitle[dim] = "Centrality (%)";
294  nbins[dim] = fNCentHistBins;
295  binEdges[dim] = fCentHistBins;
296  min[dim] = fCentHistBins[0];
297  max[dim] = fCentHistBins[fNCentHistBins];
298  dim++;
299  }
300 
301  axisTitle[dim] = "LeadingHadronRequired";
302  nbins[dim] = 2;
303  min[dim] = -0.5;
304  max[dim] = 1.5;
305  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
306  dim++;
307 
308  axisTitle[dim] = "#it{p}_{T,min}^{trig}";
309  nbins[dim] = fNDijetPtThresholds;
310  min[dim] = -0.5;
311  max[dim] = fNDijetPtThresholds - 0.5;
312  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
313  dim++;
314 
315  axisTitle[dim] = "#it{p}_{T,min}^{ass}";
316  nbins[dim] = fNDijetPtThresholds;
317  min[dim] = -0.5;
318  max[dim] = fNDijetPtThresholds - 0.5;
319  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
320  dim++;
321 
322  axisTitle[dim] = "isAccepted";
323  nbins[dim] = 2;
324  min[dim] = -0.5;
325  max[dim] = 1.5;
326  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
327  dim++;
328 
329  axisTitle[dim] = "LeadingSubleading";
330  nbins[dim] = 2;
331  min[dim] = -0.5;
332  max[dim] = 1.5;
333  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
334  dim++;
335 
336  axisTitle[dim] = "#it{p}_{T,jet} (GeV/#it{c})";
337  nbins[dim] = fMaxPt/3;
338  min[dim] = -fMaxPt/2 + 25;
339  max[dim] = fMaxPt/2 + 25;
340  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
341  dim++;
342 
343  axisTitle[dim] = "#phi_{jet}";
344  nbins[dim] = fMaxPt/3;
345  min[dim] = 0;
346  max[dim] = TMath::TwoPi();
347  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
348  dim++;
349 
350  axisTitle[dim] = "#eta_{jet}";
351  nbins[dim] = fMaxPt/3;
352  min[dim] = -1;
353  max[dim] = 1;
354  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
355  dim++;
356 
357  axisTitle[dim] = "N_{tracks}";
358  nbins[dim] = fMaxPt/5;
359  min[dim] = 0;
360  max[dim] = 100;
361  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
362  dim++;
363 
364  axisTitle[dim] = "A_{jet}";
365  nbins[dim] = fMaxPt/3;
366  min[dim] = 0;
367  max[dim] = 1.5;
368  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
369  dim++;
370 
371  TString thnname = TString::Format("%s/DijetObservables", jets->GetArrayName().Data());
372  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
373  for (Int_t i = 0; i < dim; i++) {
374  hn->GetAxis(i)->SetTitle(axisTitle[i]);
375  hn->SetBinEdges(i, binEdges[i]);
376  }
377  }
378 }
379 
380 /*
381  * This function allocates the histograms for dijet imbalance.
382  */
384 {
385  // Allocate dijet imbalance THnSparse
386  AliJetContainer* jets = 0;
387  TIter nextJetColl(&fJetCollArray);
388  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
389  TString axisTitle[30]= {""};
390  Int_t nbins[30] = {0};
391  Double_t min[30] = {0.};
392  Double_t max[30] = {0.};
393  Double_t *binEdges[20] = {0};
394  Int_t dim = 0;
395 
396  if (fForceBeamType != kpp) {
397  axisTitle[dim] = "Centrality (%)";
398  nbins[dim] = fNCentHistBins;
399  binEdges[dim] = fCentHistBins;
400  min[dim] = fCentHistBins[0];
401  max[dim] = fCentHistBins[fNCentHistBins];
402  dim++;
403  }
404 
405  axisTitle[dim] = "LeadingHadronRequired";
406  nbins[dim] = 2;
407  min[dim] = -0.5;
408  max[dim] = 1.5;
409  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
410  dim++;
411 
412  axisTitle[dim] = "#it{p}_{T,min}^{trig}";
413  nbins[dim] = fNDijetPtThresholds;
414  min[dim] = -0.5;
415  max[dim] = fNDijetPtThresholds - 0.5;
416  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
417  dim++;
418 
419  axisTitle[dim] = "#it{p}_{T,min}^{ass}";
420  nbins[dim] = fNDijetPtThresholds;
421  min[dim] = -0.5;
422  max[dim] = fNDijetPtThresholds - 0.5;
423  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
424  dim++;
425 
426  axisTitle[dim] = "#Delta#phi";
427  nbins[dim] = 100;
428  min[dim] = 0;
429  max[dim] = 4;
430  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
431  dim++;
432 
433  axisTitle[dim] = "#Delta#eta";
434  nbins[dim] = 100;
435  min[dim] = -2;
436  max[dim] = 2;
437  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
438  dim++;
439 
440  axisTitle[dim] = "A_{J}";
441  nbins[dim] = 100;
442  min[dim] = 0;
443  max[dim] = 1;
444  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
445  dim++;
446 
447  axisTitle[dim] = "x_{J}";
448  nbins[dim] = 100;
449  min[dim] = 0;
450  max[dim] = 1;
451  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
452  dim++;
453 
454  axisTitle[dim] = "k_{Ty} (GeV)";
455  nbins[dim] = 100;
456  min[dim] = 0;
457  max[dim] = 100;
458  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
459  dim++;
460 
461  TString thnname = TString::Format("%s/DijetImbalanceObservables", jets->GetArrayName().Data());
462  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
463  for (Int_t i = 0; i < dim; i++) {
464  hn->GetAxis(i)->SetTitle(axisTitle[i]);
465  hn->SetBinEdges(i, binEdges[i]);
466  }
467  }
468 }
469 
470 /*
471  * This function allocates the histograms for the momentum balance study.
472  */
474 {
475  AliJetContainer* jets = 0;
476  TIter nextJetColl(&fJetCollArray);
477  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
478 
479  // Allocate THnSparse
480  TString axisTitle[30]= {""};
481  Int_t nbins[30] = {0};
482  Double_t min[30] = {0.};
483  Double_t max[30] = {0.};
484  Double_t *binEdges[20] = {0};
485  Int_t dim = 0;
486 
487  axisTitle[dim] = "LeadingHadronRequired";
488  nbins[dim] = 2;
489  min[dim] = -0.5;
490  max[dim] = 1.5;
491  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
492  dim++;
493 
494  axisTitle[dim] = "#it{p}_{T,min}^{trig}";
495  nbins[dim] = fNDijetPtThresholds;
496  min[dim] = -0.5;
497  max[dim] = fNDijetPtThresholds - 0.5;
498  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
499  dim++;
500 
501  axisTitle[dim] = "#it{p}_{T,min}^{ass}";
502  nbins[dim] = fNDijetPtThresholds;
503  min[dim] = -0.5;
504  max[dim] = fNDijetPtThresholds - 0.5;
505  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
506  dim++;
507 
508  axisTitle[dim] = "A_{J}";
509  nbins[dim] = 100;
510  min[dim] = 0;
511  max[dim] = 1;
512  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
513  dim++;
514 
515  axisTitle[dim] = "#Delta#phi";
516  nbins[dim] = 100;
517  min[dim] = -4;
518  max[dim] = 4;
519  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
520  dim++;
521 
522  axisTitle[dim] = "#it{p}_{T,particle} (GeV/#it{c})";
523  nbins[dim] = 9;
524  Double_t* pTParticleBins = new Double_t[nbins[dim]+1];
525  GenerateFixedBinArray(1, 0.15, 0.3, pTParticleBins);
526  GenerateFixedBinArray(1, 0.3, 0.5, pTParticleBins+1);
527  GenerateFixedBinArray(1, 0.5, 1, pTParticleBins+2);
528  GenerateFixedBinArray(2, 1, 5, pTParticleBins+3);
529  GenerateFixedBinArray(3, 5, 20, pTParticleBins+5);
530  GenerateFixedBinArray(1, 20, 150, pTParticleBins+8);
531  min[dim] = 0;
532  max[dim] = pTParticleBins[nbins[dim]];
533  binEdges[dim] = pTParticleBins;
534  dim++;
535 
536  axisTitle[dim] = "#it{p}_{T}#parallel (GeV/#it{c})";
537  nbins[dim] = 80;
538  Double_t* pTParallelBins = new Double_t[nbins[dim]+1];
539  GenerateFixedBinArray(20, 0, 2, pTParallelBins);
540  GenerateFixedBinArray(16, 2, 10, pTParallelBins+20);
541  GenerateFixedBinArray(10, 10, 20, pTParallelBins+36);
542  GenerateFixedBinArray(10, 20, 40, pTParallelBins+46);
543  GenerateFixedBinArray(24, 40, 150, pTParallelBins+56);
544  min[dim] = 0;
545  max[dim] = pTParallelBins[nbins[dim]];
546  binEdges[dim] = pTParallelBins;
547  dim++;
548 
549  TString thnname = TString::Format("%s/MomentumBalance", jets->GetArrayName().Data());
550  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
551  for (Int_t i = 0; i < dim; i++) {
552  hn->GetAxis(i)->SetTitle(axisTitle[i]);
553  hn->SetBinEdges(i, binEdges[i]);
554  }
555  }
556 }
557 
558 /*
559  * This function allocates the histograms for the constituent dijet study.
560  */
562 {
563  // Allocate geometrical matching THnSparse
564  TString axisTitle[30]= {""};
565  Int_t nbins[30] = {0};
566  Double_t min[30] = {0.};
567  Double_t max[30] = {0.};
568  Double_t *binEdges[20] = {0};
569  Int_t dim = 0;
570 
571  if (fForceBeamType != kpp) {
572  axisTitle[dim] = "Centrality (%)";
573  nbins[dim] = fNCentHistBins;
574  binEdges[dim] = fCentHistBins;
575  min[dim] = fCentHistBins[0];
576  max[dim] = fCentHistBins[fNCentHistBins];
577  dim++;
578  }
579 
580  axisTitle[dim] = "#it{p}_{T,min}^{trig}";
581  nbins[dim] = fNDijetPtThresholds;
582  min[dim] = -0.5;
583  max[dim] = fNDijetPtThresholds - 0.5;
584  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
585  dim++;
586 
587  axisTitle[dim] = "#it{p}_{T,min}^{ass}";
588  nbins[dim] = fNDijetPtThresholds;
589  min[dim] = -0.5;
590  max[dim] = fNDijetPtThresholds - 0.5;
591  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
592  dim++;
593 
594  axisTitle[dim] = "isSwitched";
595  nbins[dim] = 2;
596  min[dim] = -0.5;
597  max[dim] = 1.5;
598  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
599  dim++;
600 
601  axisTitle[dim] = "#DeltaR_{trig}";
602  nbins[dim] = 50;
603  min[dim] = 0;
604  max[dim] = 0.5;
605  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
606  dim++;
607 
608  axisTitle[dim] = "#DeltaR_{ass}";
609  nbins[dim] = 50;
610  min[dim] = 0;
611  max[dim] = 0.5;
612  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
613  dim++;
614 
615  axisTitle[dim] = "trig #it{p}_{T,low-thresh} - #it{p}_{T,hard-core}";
616  nbins[dim] = 100;
617  min[dim] = -50;
618  max[dim] = 50;
619  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
620  dim++;
621 
622  axisTitle[dim] = "ass #it{p}_{T,low-thresh} - #it{p}_{T,hard-core}";
623  nbins[dim] = 100;
624  min[dim] = -50;
625  max[dim] = 50;
626  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
627  dim++;
628 
629  axisTitle[dim] = "A_{J} low-threshold";
630  nbins[dim] = 100;
631  min[dim] = 0;
632  max[dim] = 1;
633  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
634  dim++;
635 
636  axisTitle[dim] = "A_{J} hard-core";
637  nbins[dim] = 100;
638  min[dim] = 0;
639  max[dim] = 1;
640  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
641  dim++;
642 
643  TString thnname = "GeometricalMatching";
644  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
645  for (Int_t i = 0; i < dim; i++) {
646  hn->GetAxis(i)->SetTitle(axisTitle[i]);
647  hn->SetBinEdges(i, binEdges[i]);
648  }
649 
650  // Allocate other histograms
651  TString histname;
652  TString title;
653  histname = "GeometricalMatchingEfficiency";
654  title = histname + ";isMatched;counts";
655  TH1* hist = fHistManager.CreateTH1(histname.Data(), title.Data(), 2, -0.5, 1.5);
656 }
657 
663 {
665 
666  AliInfo(Form("Number of pT thresholds: %d", fNDijetPtThresholds));
667  for (Int_t i = 0; i < fNDijetPtThresholds; i++) {
668  AliInfo(Form("Trigger jet threshold %d = %f, Associated jet threshold %d = %f", i, fMinTrigJetPt[i], i, fMinAssJetPt[i]));
669  }
670  AliInfo(Form("Leading hadron threshold (for dijet leading jet): %f GeV", fDijetLeadingHadronPt));
671  AliInfo(Form("Momentum balance study: %d", fDoMomentumBalance));
672  AliInfo(Form("Geometrical matching study: %d", fDoGeometricalMatching));
673 
674 }
675 
684 {
685  TString histname;
686  AliJetContainer* jetCont = 0;
687  TIter next(&fJetCollArray);
688  while ((jetCont = static_cast<AliJetContainer*>(next()))) {
689  TString jetContName = jetCont->GetName();
690  if (jetContName.Contains("HardCore")) continue;
691 
692  // Loop over leading hadron cut or not
693  for (Int_t leadingHadronCutType=0; leadingHadronCutType<2; leadingHadronCutType++) {
694 
695  // Loop through leading jet pT thresholds
696  for (Int_t trigJetMinPtType = 0; trigJetMinPtType < fNDijetPtThresholds; trigJetMinPtType++) {
697 
698  // Loop through subleading jet pT thresholds
699  for (Int_t assJetMinPtType=0; assJetMinPtType < fNDijetPtThresholds; assJetMinPtType++) {
700 
701  // Find the dijet candidate of the event and store its info in struct fDijet
702  FindDijet(jetCont, leadingHadronCutType, trigJetMinPtType, assJetMinPtType);
703 
704  // If we find a dijet candidate (i.e. acceptable trig jet; ass jet accepted or not), fill the di-jet jet histograms
706  TString histname = TString::Format("%s/DijetObservables", jetCont->GetArrayName().Data());
709  if (fDijet.assJet)
712  }
713 
714  // If we find an accepted dijet, fill the dijet imbalance histogram
716  TString histname = TString::Format("%s/DijetImbalanceObservables", jetCont->GetArrayName().Data());
718  }
719 
720  // If we find an accepted dijet, perform momentum-balance study (if requested)
722  histname = TString::Format("%s/MomentumBalance", jetCont->GetArrayName().Data());
723  DoMomentumBalance(histname);
724  }
725  }
726  }
727  }
728  }
729 
730  // Do the constituent threshold and geometrical matching study (if requested)
733 
734  return kTRUE;
735 }
736 
741 void AliAnalysisTaskEmcalDijetImbalance::FindDijet(AliJetContainer* jetCont, Int_t leadingHadronCutBin, Int_t trigJetMinPtBin, Int_t assJetMinPtBin)
742 {
743  fDijet.clear();
744  fDijet.leadingHadronCutType = leadingHadronCutBin;
745  fDijet.trigJetMinPtType = trigJetMinPtBin;
746  fDijet.assJetMinPtType = assJetMinPtBin;
747 
748  // Get trigger jet
749  AliEmcalJet* trigJet = 0;
750  if (jetCont->GetRhoParameter())
751  trigJet = jetCont->GetLeadingJet("rho");
752  else
753  trigJet = jetCont->GetLeadingJet();
754  if(!trigJet) return;
755 
756  // Skip the event if the leading jet doesn't satisfy the pT threshold
757  Double_t trigJetPt = GetJetPt(jetCont, trigJet);
758  if ( trigJetPt < fMinTrigJetPt[trigJetMinPtBin] ) return;
759 
760  // Skip the event if the leading jet doesn't satisfy the leading hadron threshold
761  if (jetCont->GetLeadingHadronPt(trigJet) < fDijetLeadingHadronPt*leadingHadronCutBin) return;
762 
763  // Fill the dijet struct
764  fDijet.trigJet = trigJet;
765  fDijet.trigJetPt = trigJetPt;
766  fDijet.trigJetEta = trigJet->Eta();
767  fDijet.trigJetPhi = trigJet->Phi();
768 
769  // Find the subleading jet in the opposite hemisphere
770  AliEmcalJet *assJet = 0;
771  for(auto assJetCand : jetCont->accepted()) {
772  if (!assJetCand) continue;
773  Double_t assJetCandPt = GetJetPt(jetCont, assJetCand);
774  if ( TMath::Abs(trigJet->Phi() - assJetCand->Phi()) < fDeltaPhiMin ) continue;
775  if (assJet) {
776  Double_t assJetPt = GetJetPt(jetCont, assJet);
777  if ( assJetCandPt < assJetPt ) continue;
778  }
779  assJet = assJetCand;
780  }
781  if (!assJet) return;
782 
783  // Fill the dijet struct
784  fDijet.assJet = assJet;
785  fDijet.assJetPt = GetJetPt(jetCont, assJet);
786  fDijet.assJetPhi = assJet->Phi();
787  fDijet.assJetEta = assJet->Eta();
788  fDijet.isAccepted = fDijet.assJetPt > fMinAssJetPt[assJetMinPtBin];
789 
790  fDijet.deltaPhi = TMath::Abs(trigJet->Phi() - assJet->Phi());
791  fDijet.deltaEta = trigJet->Eta() - assJet->Eta();
794  fDijet.kTy = TMath::Abs( fDijet.trigJetPt * TMath::Sin(fDijet.deltaPhi) );
795 }
796 
802 {
803 
804  AliTrackContainer* trackCont = dynamic_cast<AliTrackContainer*>(GetParticleContainer("tracks"));
805 
806  AliVTrack* track;
807  for (auto trackIterator : trackCont->accepted_momentum() ) {
808 
809  track = trackIterator.second;
810 
811  // Compute the delta phi between the track and its nearest jet (of the two jets in the dijet),
812  // as well as its pT-parallel projection onto the nearest jet's axis.
813 
814  Double_t trackPt = track->Pt();
815  Double_t trackPhi = track->Phi();
816  Double_t trigJetPhi = fDijet.trigJet->Phi();
817  Double_t assJetPhi = fDijet.assJet->Phi();
818 
819  Double_t deltaPhiTrigJet = TMath::Abs(trackPhi - trigJetPhi);
820  Double_t deltaPhiAssJet = TMath::Abs(trackPhi - assJetPhi);
821  Bool_t isNearside = deltaPhiTrigJet < deltaPhiAssJet;
822 
823  Double_t deltaPhi;
824  Double_t balancePt;
825  if (isNearside) {
826  deltaPhi = trackPhi - trigJetPhi;
827  balancePt = trackPt * TMath::Cos(deltaPhi);
828  }
829  else {
830  deltaPhi = trackPhi - assJetPhi;
831  balancePt = -trackPt * TMath::Cos(deltaPhi);
832  }
833 
834  FillMomentumBalanceHistograms(histname, deltaPhi, trackPt, balancePt);
835 
836  }
837 }
838 
843 {
844  // Get jet container with minimum constituent pT,E thresholds
845  TString jetContAllName = Form("Jet_AKTFullR0%d0_tracks_pT0150_caloClusters_E0300_pt_scheme", (int) (fMatchingJetR*10) );
846  AliJetContainer* jetContAll = GetJetContainer(jetContAllName.Data());
847 
848  // Get jet container with X GeV constituent pT,E thresholds
849  Int_t trackThreshold = (int) (fTrackConstituentThreshold*1000); // in MeV
850  Int_t clusThreshold = (int) (fClusterConstituentThreshold*1000); // in MeV
851  TString jetContHardCoreName = Form("JetHardCore_AKTFullR0%d0_tracks_pT%d_caloClusters_E%d_pt_scheme", (int) (fMatchingJetR*10), trackThreshold, clusThreshold);
852  AliJetContainer* jetContHardCore = GetJetContainer(jetContHardCoreName.Data());
853 
854  // Find the di-jet in the hard-core jet sample, then find the matching di-jet and fill histograms
855  FindDijet(jetContHardCore, 0, 0, 0);
856  if (fDijet.isAccepted) {
857  FindMatchingDijet(jetContAll, 0);
859  }
860 }
861 
867 {
869  fMatchingDijet.assJetMinPtType = assJetMinPtBin;
870 
871  // Loop over jets and find leading jet within R of fDijet.trigJet
872  AliEmcalJet *matchingTrigJet = 0;
873  for(auto matchingTrigJetCand : jetCont->accepted()) {
874  if (!matchingTrigJetCand) continue;
875  if ( GetDeltaR(matchingTrigJetCand, fDijet.trigJet) > fMatchingJetR ) continue;
876  if (matchingTrigJet) {
877  if ( GetJetPt(jetCont, matchingTrigJetCand) < GetJetPt(jetCont, matchingTrigJet) ) continue;
878  }
879  matchingTrigJet = matchingTrigJetCand;
880  }
881  if (!matchingTrigJet) return;
882 
883  // Loop over jets and find leading jet within R of fDijet.assJet
884  AliEmcalJet *matchingAssJet = 0;
885  for(auto matchingAssJetCand : jetCont->accepted()) {
886  if (!matchingAssJetCand) continue;
887  if ( GetDeltaR(matchingAssJetCand, fDijet.assJet) > fMatchingJetR ) continue;
888  if (matchingAssJet) {
889  if ( GetJetPt(jetCont, matchingAssJetCand) < GetJetPt(jetCont, matchingAssJet) ) continue;
890  }
891  matchingAssJet = matchingAssJetCand;
892  }
893 
894  // Determine which matching jet is the leading jet (i.e. allow them to flip)
895  if (matchingAssJet) {
896  AliEmcalJet* trigJet = matchingTrigJet;
897  AliEmcalJet* assJet = matchingAssJet;
898  if ( GetJetPt(jetCont, matchingTrigJet) < GetJetPt(jetCont, matchingAssJet) ) {
899  AliEmcalJet* trigJet = matchingAssJet;
900  AliEmcalJet* assJet = matchingTrigJet;
901  }
902 
903  // Fill the dijet struct
904  fMatchingDijet.trigJet = trigJet;
905  fMatchingDijet.trigJetPt = GetJetPt(jetCont, trigJet);
906  fMatchingDijet.trigJetEta = trigJet->Eta();
907  fMatchingDijet.trigJetPhi = trigJet->Phi();
908 
909  fMatchingDijet.assJet = assJet;
910  fMatchingDijet.assJetPt = GetJetPt(jetCont, assJet);
911  fMatchingDijet.assJetPhi = assJet->Phi();
912  fMatchingDijet.assJetEta = assJet->Eta();
914 
915  fMatchingDijet.deltaPhi = TMath::Abs(trigJet->Phi() - assJet->Phi());
916  fMatchingDijet.deltaEta = trigJet->Eta() - assJet->Eta();
919  fMatchingDijet.kTy = TMath::Abs( fMatchingDijet.trigJetPt * TMath::Sin(fMatchingDijet.deltaPhi) );
920  }
921 }
922 
927 {
928  Double_t pT = jet->Pt() - jetCont->GetRhoVal() * jet->Area();
929  TString jetContName = jetCont->GetName();
930  if (jetContName.Contains("HardCore")) pT = jet->Pt();
931  return pT;
932 }
933 
938 {
939  Double_t deltaPhi = TMath::Abs(jet1->Phi() - jet2->Phi());
940  Double_t deltaEta = TMath::Abs(jet1->Eta() - jet2->Eta());
941  Double_t deltaR = TMath::Sqrt( deltaPhi*deltaPhi + deltaEta*deltaEta );
942  return deltaR;
943 }
944 
952 {
954 
955  return kTRUE;
956 }
957 
963 {
964  TString histname;
965  AliJetContainer* jets = 0;
966  TIter nextJetColl(&fJetCollArray);
967  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
968  TString jetContName = jets->GetName();
969  if (jetContName.Contains("HardCore")) continue;
970  Double_t rhoVal = 0;
971  if (jets->GetRhoParameter()) {
972  rhoVal = jets->GetRhoVal();
973  histname = TString::Format("%s/fHistRhoVsCent", jets->GetArrayName().Data());
974  fHistManager.FillTH2(histname.Data(), fCent, rhoVal);
975  }
976 
977  for (auto jet : jets->all()) {
978 
979  UInt_t rejectionReason = 0;
980  if (!jets->AcceptJet(jet, rejectionReason)) {
981  histname = TString::Format("%s/fHistJetRejectionReason", jets->GetArrayName().Data());
982  fHistManager.FillTH2(histname.Data(), jets->GetRejectionReasonBitPosition(rejectionReason), jet->Pt());
983  continue;
984  }
985 
986  Float_t ptLeading = jets->GetLeadingHadronPt(jet);
987  Float_t corrPt = jet->Pt() - rhoVal * jet->Area();
988 
989  TLorentzVector leadPart;
990  jets->GetLeadingHadronMomentum(leadPart, jet);
991  Double_t z = GetParallelFraction(leadPart.Vect(), jet);
992  if (z == 1 || (z > 1 && z - 1 < 1e-3)) z = 0.999; // so that it will contribute to the bin 0.9-1 rather than 1-1.1
993 
994  Double_t contents[30]={0};
995  histname = TString::Format("%s/JetObservables", jets->GetArrayName().Data());
996  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(histname));
997  if (!histJetObservables) return;
998  for (Int_t i = 0; i < histJetObservables->GetNdimensions(); i++) {
999  TString title(histJetObservables->GetAxis(i)->GetTitle());
1000  if (title=="Centrality (%)")
1001  contents[i] = fCent;
1002  else if (title=="#eta_{jet}")
1003  contents[i] = jet->Eta();
1004  else if (title=="#phi_{jet} (rad)")
1005  contents[i] = jet->Phi_0_2pi();
1006  else if (title=="#it{p}_{T} (GeV/#it{c})")
1007  contents[i] = jet->Pt();
1008  else if (title=="#it{p}_{T}^{corr} (GeV/#it{c})")
1009  contents[i] = corrPt;
1010  else if (title=="#it{p}_{T,particle}^{leading} (GeV/#it{c})")
1011  contents[i] = ptLeading;
1012  else if (title=="#it{A}_{jet}")
1013  contents[i] = jet->Area();
1014  else if (title=="NEF")
1015  contents[i] = jet->NEF();
1016  else if (title=="#it{z}_{leading}")
1017  contents[i] = z;
1018  else if (title=="No. of constituents")
1019  contents[i] = jet->GetNumberOfConstituents();
1020  else
1021  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1022  }
1023  histJetObservables->Fill(contents);
1024 
1025  } //jet loop
1026  }
1027 }
1028 
1032 void AliAnalysisTaskEmcalDijetImbalance::FillDijetJetHistograms(TString histname, Int_t isAccepted, Int_t IsAssJet, Double_t jetPt, Double_t jetPhi, Double_t jetEta, Int_t nTracksJet, Double_t jetArea)
1033 {
1034  Double_t contents[30]={0};
1035  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(histname));
1036  if (!histJetObservables) return;
1037  for (Int_t n = 0; n < histJetObservables->GetNdimensions(); n++) {
1038  TString title(histJetObservables->GetAxis(n)->GetTitle());
1039  if (title=="Centrality (%)")
1040  contents[n] = fCent;
1041  else if (title=="LeadingHadronRequired")
1042  contents[n] = fDijet.leadingHadronCutType;
1043  else if (title=="#it{p}_{T,min}^{trig}")
1044  contents[n] = fDijet.trigJetMinPtType;
1045  else if (title=="#it{p}_{T,min}^{ass}")
1046  contents[n] = fDijet.assJetMinPtType;
1047  else if (title=="isAccepted")
1048  contents[n] = isAccepted;
1049  else if (title=="LeadingSubleading")
1050  contents[n] = IsAssJet;
1051  else if (title=="#it{p}_{T,jet} (GeV/#it{c})")
1052  contents[n] = jetPt;
1053  else if (title=="#phi_{jet}")
1054  contents[n] = jetPhi;
1055  else if (title=="#eta_{jet}")
1056  contents[n] = jetEta;
1057  else if (title=="N_{tracks}")
1058  contents[n] = nTracksJet;
1059  else if (title=="A_{jet}")
1060  contents[n] = jetArea;
1061  else
1062  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1063  }
1064  histJetObservables->Fill(contents);
1065 }
1066 
1071 {
1072  Double_t contents[30]={0};
1073  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(histname));
1074  if (!histJetObservables) return;
1075  for (Int_t n = 0; n < histJetObservables->GetNdimensions(); n++) {
1076  TString title(histJetObservables->GetAxis(n)->GetTitle());
1077  if (title=="Centrality (%)")
1078  contents[n] = fCent;
1079  else if (title=="LeadingHadronRequired")
1080  contents[n] = fDijet.leadingHadronCutType;
1081  else if (title=="#it{p}_{T,min}^{trig}")
1082  contents[n] = fDijet.trigJetMinPtType;
1083  else if (title=="#it{p}_{T,min}^{ass}")
1084  contents[n] = fDijet.assJetMinPtType;
1085  else if (title=="#Delta#phi")
1086  contents[n] = fDijet.deltaPhi;
1087  else if (title=="#Delta#eta")
1088  contents[n] = fDijet.deltaEta;
1089  else if (title=="A_{J}")
1090  contents[n] = fDijet.AJ;
1091  else if (title=="x_{J}")
1092  contents[n] = fDijet.xJ;
1093  else if (title=="k_{Ty} (GeV)")
1094  contents[n] = fDijet.kTy;
1095  else
1096  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1097  }
1098  histJetObservables->Fill(contents);
1099 }
1100 
1105 {
1106  Double_t contents[30]={0};
1107  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(histname));
1108  if (!histJetObservables) return;
1109  for (Int_t n = 0; n < histJetObservables->GetNdimensions(); n++) {
1110  TString title(histJetObservables->GetAxis(n)->GetTitle());
1111  if (title=="LeadingHadronRequired")
1112  contents[n] = fDijet.leadingHadronCutType;
1113  else if (title=="#it{p}_{T,min}^{trig}")
1114  contents[n] = fDijet.trigJetMinPtType;
1115  else if (title=="#it{p}_{T,min}^{ass}")
1116  contents[n] = fDijet.assJetMinPtType;
1117  else if (title=="A_{J}")
1118  contents[n] = fDijet.AJ;
1119  else if (title=="#Delta#phi")
1120  contents[n] = deltaPhi;
1121  else if (title=="#it{p}_{T,particle} (GeV/#it{c})")
1122  contents[n] = trackPt;
1123  else if (title=="#it{p}_{T}#parallel (GeV/#it{c})")
1124  contents[n] = balancePt;
1125  else
1126  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1127  }
1128  histJetObservables->Fill(contents);
1129 }
1130 
1135 {
1136  // Matching efficiency histogram
1137  TString histname = "GeometricalMatchingEfficiency";
1138 
1139  // If we have a matching di-jet, fill the geometrical matching histogram
1140  if (fMatchingDijet.assJet) {
1141  fHistManager.FillTH1(histname.Data(), 1);
1142 
1145  Bool_t isSwitched = trigDeltaR > fMatchingJetR;
1146 
1147  TString thnname = "GeometricalMatching";
1148  Double_t contents[30]={0};
1149  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(thnname.Data()));
1150  if (!histJetObservables) return;
1151  for (Int_t n = 0; n < histJetObservables->GetNdimensions(); n++) {
1152  TString title(histJetObservables->GetAxis(n)->GetTitle());
1153  if (title=="Centrality (%)")
1154  contents[n] = fCent;
1155  else if (title=="#it{p}_{T,min}^{trig}")
1156  contents[n] = fDijet.trigJetMinPtType;
1157  else if (title=="#it{p}_{T,min}^{ass}")
1158  contents[n] = fDijet.assJetMinPtType;
1159  else if (title=="isSwitched")
1160  contents[n] = isSwitched;
1161  else if (title=="#DeltaR_{trig}")
1162  contents[n] = trigDeltaR;
1163  else if (title=="#DeltaR_{ass}")
1164  contents[n] = assDeltaR;
1165  else if (title=="trig #it{p}_{T,low-thresh} - #it{p}_{T,hard-core}")
1166  contents[n] = fMatchingDijet.trigJetPt - fDijet.trigJetPt;
1167  else if (title=="ass #it{p}_{T,low-thresh} - #it{p}_{T,hard-core}")
1168  contents[n] = fMatchingDijet.assJetPt - fDijet.assJetPt;
1169  else if (title=="A_{J} low-threshold")
1170  contents[n] = fMatchingDijet.AJ;
1171  else if (title=="A_{J} hard-core")
1172  contents[n] = fDijet.AJ;
1173  else
1174  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1175  }
1176  histJetObservables->Fill(contents);
1177  }
1178  else {
1179  fHistManager.FillTH1(histname.Data(), 0.);
1180  }
1181 }
1182 
Double_t Area() const
Definition: AliEmcalJet.h:123
TObjArray fClusterCollArray
cluster collection array
Double_t GetRhoVal() const
const TString & GetRhoName() const
double Double_t
Definition: External.C:58
void FindMatchingDijet(AliJetContainer *jetCont, Int_t assJetMinPtBin)
const char * title
Definition: MakeQAPdf.C:26
AliJetContainer * GetJetContainer(Int_t i=0) const
Double_t Eta() const
Definition: AliEmcalJet.h:114
Double_t Phi() const
Definition: AliEmcalJet.h:110
Container with name, TClonesArray and cuts for particles.
Bool_t fPlotJetHistograms
Set whether to enable inclusive jet histograms.
void FillTH2(const char *hname, double x, double y, double weight=1., Option_t *opt="")
Declaration of class AliTLorentzVector.
Double_t fDijetLeadingHadronPt
leading hadron pT threshold for leading jet in dijet
virtual Bool_t AcceptJet(Int_t i, UInt_t &rejectionReason) const
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:132
Bool_t fDoMomentumBalance
Set whether to enable momentum balance study.
TObjArray fParticleCollArray
particle/track collection array
Bool_t fPlotDijetImbalanceHistograms
Set whether to enable dijet imbalance histograms.
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Int_t fNDijetPtThresholds
number of pT thresholds on leading/subleading jets
AliEmcalJet * GetLeadingJet(const char *opt="")
void GetLeadingHadronMomentum(TLorentzVector &mom, const AliEmcalJet *jet) const
Dijet_t fDijet
! dijet candidate (per event)
TH2 * CreateTH2(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, Option_t *opt="")
TObject * FindObject(const char *name) const
int Int_t
Definition: External.C:63
unsigned int UInt_t
Definition: External.C:33
THashList * GetListOfHistograms() const
Definition: THistManager.h:504
Double_t GetDeltaR(AliEmcalJet *jet1, AliEmcalJet *jet2)
Double_t GetLeadingHadronPt(const AliEmcalJet *jet) const
float Float_t
Definition: External.C:68
Double_t fClusterConstituentThreshold
constituent threshold for matching study
Di-jet imbalance analysis with full jets.
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
BeamType fForceBeamType
forced beam type
Double_t fDeltaPhiMin
minimum delta phi between di-jets
Double_t fCent
!event centrality
Double_t GetJetPt(AliJetContainer *jetCont, AliEmcalJet *jet)
static Double_t GetParallelFraction(AliVParticle *part1, AliVParticle *part2)
void FillMomentumBalanceHistograms(TString histname, Double_t deltaPhi, Double_t trackPt, Double_t balancePt)
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
TObjArray fJetCollArray
jet collection array
AliRhoParameter * GetRhoParameter()
Double_t Pt() const
Definition: AliEmcalJet.h:102
Bool_t fPlotDijetJetHistograms
Set whether to enable dijet pair histograms.
static Double_t * GenerateFixedBinArray(Int_t n, Double_t min, Double_t max)
AliEmcalList * fOutput
!output list
Definition: External.C:220
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
void SetMakeGeneralHistograms(Bool_t g)
Base task in the EMCAL jet framework.
Bool_t fDoGeometricalMatching
Set whether to enable constituent study with geometrical matching.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
void FillDijetJetHistograms(TString histname, Int_t isAccepted, Int_t IsAssJet, Double_t jetPt, Double_t jetPhi, Double_t jetEta, Int_t nTracksJet, Double_t jetArea)
const AliTrackIterableMomentumContainer accepted_momentum() const
Dijet_t fMatchingDijet
! low-threshold matching dijet, for matching study
void SetRejectionReasonLabels(TAxis *axis)
const Int_t nbins
const AliJetIterableContainer accepted() const
bool Bool_t
Definition: External.C:53
Double_t fTrackConstituentThreshold
constituent threshold for matching study
THnSparse * CreateTHnSparse(const char *name, const char *title, int ndim, const int *nbins, const double *min, const double *max, Option_t *opt="")
Container for jet within the EMCAL jet framework.
Definition: External.C:196
void FindDijet(AliJetContainer *jetCont, Int_t leadingHadronCutBin, Int_t trigJetMinPtBin, Int_t assJetMinPtBin)
const AliJetIterableContainer all() const