AliPhysics  6a0d37d (6a0d37d)
 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  fEventCuts(0),
46  fEventCutList(0),
47  fUseManualEventCuts(kFALSE),
48  fDeltaPhiMin(0),
49  fNDijetPtThresholds(1),
50  fMinTrigJetPt(0),
51  fMinAssJetPt(0),
52  fDijetLeadingHadronPt(0),
53  fMaxPt(250),
54  fNCentHistBins(0),
55  fCentHistBins(0),
56  fPlotJetHistograms(kFALSE),
57  fPlotDijetJetHistograms(kFALSE),
58  fPlotDijetImbalanceHistograms(kFALSE),
59  fDoMomentumBalance(kFALSE),
60  fDoGeometricalMatching(kFALSE),
61  fMatchingJetR(0.2),
62  fTrackConstituentThreshold(0),
63  fClusterConstituentThreshold(0)
64 {
68 }
69 
76  AliAnalysisTaskEmcalJet(name, kTRUE),
77  fHistManager(name),
78  fEventCuts(0),
79  fEventCutList(0),
80  fUseManualEventCuts(kFALSE),
81  fDeltaPhiMin(0),
82  fNDijetPtThresholds(1),
83  fMinTrigJetPt(0),
84  fMinAssJetPt(0),
85  fDijetLeadingHadronPt(0),
86  fMaxPt(250),
87  fNCentHistBins(0),
88  fCentHistBins(0),
89  fPlotJetHistograms(kFALSE),
90  fPlotDijetJetHistograms(kFALSE),
91  fPlotDijetImbalanceHistograms(kFALSE),
92  fDoMomentumBalance(kFALSE),
93  fDoGeometricalMatching(kFALSE),
94  fMatchingJetR(0.2),
95  fTrackConstituentThreshold(0),
96  fClusterConstituentThreshold(0)
97 {
101 }
102 
107 {
108 }
109 
114 {
115  fNCentHistBins = 4;
117  fCentHistBins[0] = 0;
118  fCentHistBins[1] = 10;
119  fCentHistBins[2] = 30;
120  fCentHistBins[3] = 50;
121  fCentHistBins[4] = 90;
122 }
123 
129 {
131 
137 
138  TIter next(fHistManager.GetListOfHistograms());
139  TObject* obj = 0;
140  while ((obj = next())) {
141  fOutput->Add(obj);
142  }
143 
144  // Intialize AliEventCuts
145  fEventCutList = new TList();
146  fEventCutList ->SetOwner();
147  fEventCutList ->SetName("EventCutOutput");
148 
149  fEventCuts.OverrideAutomaticTriggerSelection(fOffTrigger);
150  if(fUseManualEventCuts==1)
151  {
152  fEventCuts.SetManualMode();
153  // Configure manual settings here
154  // ...
155  }
156  fEventCuts.AddQAplotsToList(fEventCutList);
157  fOutput->Add(fEventCutList);
158 
159  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
160 }
161 
162 /*
163  * This function allocates the histograms for single jets.
164  * A set of histograms is allocated per each jet container and per each centrality bin.
165  */
167 {
168 
169  AliJetContainer* jets = 0;
170  TIter nextJetColl(&fJetCollArray);
171  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
172 
173  // Allocate THnSparse
174  TString axisTitle[30]= {""};
175  Int_t nbins[30] = {0};
176  Double_t min[30] = {0.};
177  Double_t max[30] = {0.};
178  Double_t *binEdges[20] = {0};
179  Int_t dim = 0;
180 
181  if (fForceBeamType != kpp) {
182  axisTitle[dim] = "Centrality (%)";
183  nbins[dim] = fNCentHistBins;
184  binEdges[dim] = fCentHistBins;
185  min[dim] = fCentHistBins[0];
186  max[dim] = fCentHistBins[fNCentHistBins];
187  dim++;
188  }
189 
190  axisTitle[dim] = "#eta_{jet}";
191  nbins[dim] = 100;
192  min[dim] = -1;
193  max[dim] = 1;
194  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
195  dim++;
196 
197  axisTitle[dim] = "#phi_{jet} (rad)";
198  nbins[dim] = 101;
199  min[dim] = 0;
200  max[dim] = TMath::Pi() * 2.02;
201  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
202  dim++;
203 
204  axisTitle[dim] = "#it{p}_{T} (GeV/#it{c})";
205  nbins[dim] = TMath::CeilNint(fMaxPt/2);
206  min[dim] = 0;
207  max[dim] = fMaxPt;
208  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
209  dim++;
210 
211  if (fForceBeamType != kpp) {
212  axisTitle[dim] = "#it{p}_{T}^{corr} (GeV/#it{c})";
213  nbins[dim] = TMath::CeilNint(fMaxPt/2);
214  min[dim] = -fMaxPt/2 + 25;
215  max[dim] = fMaxPt/2 + 25;
216  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
217  dim++;
218  }
219 
220  axisTitle[dim] = "#it{p}_{T,particle}^{leading} (GeV/#it{c})";
221  nbins[dim] = 56;
222  Double_t* pTLeadingBins = new Double_t[nbins[dim]+1];
223  GenerateFixedBinArray(20, 0, 10, pTLeadingBins);
224  GenerateFixedBinArray(10, 10, 20, pTLeadingBins+20);
225  GenerateFixedBinArray(26, 20, 150, pTLeadingBins+30);
226  min[dim] = 0;
227  max[dim] = pTLeadingBins[nbins[dim]];
228  binEdges[dim] = pTLeadingBins;
229  dim++;
230 
231  axisTitle[dim] = "#it{A}_{jet}";
232  nbins[dim] = fMaxPt/3;
233  min[dim] = 0;
234  max[dim] = 1.5;
235  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
236  dim++;
237 
238  if (fClusterCollArray.GetEntriesFast() > 0 && fParticleCollArray.GetEntriesFast() > 0) {
239  axisTitle[dim] = "NEF";
240  nbins[dim] = fMaxPt/5;
241  min[dim] = 0;
242  max[dim] = 1.0;
243  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
244  dim++;
245  }
246 
247  axisTitle[dim] = "#it{z}_{leading}";
248  nbins[dim] = fMaxPt/5;
249  min[dim] = 0;
250  max[dim] = 1.0;
251  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
252  dim++;
253 
254  if (fForceBeamType != kpp) {
255  axisTitle[dim] = "No. of constituents";
256  nbins[dim] = fMaxPt/5;
257  min[dim] = 0;
258  max[dim] = fMaxPt;
259  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
260  dim++;
261  }
262  else {
263  axisTitle[dim] = "No. of constituents";
264  nbins[dim] = 50;
265  min[dim] = -0.5;
266  max[dim] = 49.5;
267  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
268  dim++;
269  }
270 
271  TString thnname = TString::Format("%s/JetObservables", jets->GetArrayName().Data());
272  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
273  for (Int_t i = 0; i < dim; i++) {
274  hn->GetAxis(i)->SetTitle(axisTitle[i]);
275  hn->SetBinEdges(i, binEdges[i]);
276  }
277 
278  // Allocate other jet histograms
279  TString histname;
280  TString title;
281  histname = TString::Format("%s/fHistJetRejectionReason", jets->GetArrayName().Data());
282  title = histname + ";Rejection reason;#it{p}_{T,jet} (GeV/#it{c});counts";
283  TH2* hist = fHistManager.CreateTH2(histname.Data(), title.Data(), 32, 0, 32, 50, 0, 250);
284  SetRejectionReasonLabels(hist->GetXaxis());
285 
286  if (!jets->GetRhoName().IsNull()) {
287  histname = TString::Format("%s/fHistRhoVsCent", jets->GetArrayName().Data());
288  title = histname + ";Centrality (%);#rho (GeV/#it{c});counts";
289  fHistManager.CreateTH2(histname.Data(), title.Data(), 101, 0, 101, 100, 0, 500);
290  }
291 
292  }
293 }
294 
295 /*
296  * This function allocates the histograms for single jets that comprise dijet pairs.
297  */
299 {
300  // Allocate dijet THnSparse
301  AliJetContainer* jets = 0;
302  TIter nextJetColl(&fJetCollArray);
303  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
304  TString axisTitle[30]= {""};
305  Int_t nbins[30] = {0};
306  Double_t min[30] = {0.};
307  Double_t max[30] = {0.};
308  Double_t *binEdges[20] = {0};
309  Int_t dim = 0;
310 
311  if (fForceBeamType != kpp) {
312  axisTitle[dim] = "Centrality (%)";
313  nbins[dim] = fNCentHistBins;
314  binEdges[dim] = fCentHistBins;
315  min[dim] = fCentHistBins[0];
316  max[dim] = fCentHistBins[fNCentHistBins];
317  dim++;
318  }
319 
320  axisTitle[dim] = "LeadingHadronRequired";
321  nbins[dim] = 2;
322  min[dim] = -0.5;
323  max[dim] = 1.5;
324  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
325  dim++;
326 
327  axisTitle[dim] = "#it{p}_{T,min}^{trig}";
328  nbins[dim] = fNDijetPtThresholds;
329  min[dim] = -0.5;
330  max[dim] = fNDijetPtThresholds - 0.5;
331  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
332  dim++;
333 
334  axisTitle[dim] = "#it{p}_{T,min}^{ass}";
335  nbins[dim] = fNDijetPtThresholds;
336  min[dim] = -0.5;
337  max[dim] = fNDijetPtThresholds - 0.5;
338  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
339  dim++;
340 
341  axisTitle[dim] = "isAccepted";
342  nbins[dim] = 2;
343  min[dim] = -0.5;
344  max[dim] = 1.5;
345  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
346  dim++;
347 
348  axisTitle[dim] = "LeadingSubleading";
349  nbins[dim] = 2;
350  min[dim] = -0.5;
351  max[dim] = 1.5;
352  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
353  dim++;
354 
355  axisTitle[dim] = "#it{p}_{T,jet} (GeV/#it{c})";
356  nbins[dim] = fMaxPt/3;
357  min[dim] = -fMaxPt/2 + 25;
358  max[dim] = fMaxPt/2 + 25;
359  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
360  dim++;
361 
362  axisTitle[dim] = "#phi_{jet}";
363  nbins[dim] = fMaxPt/3;
364  min[dim] = 0;
365  max[dim] = TMath::TwoPi();
366  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
367  dim++;
368 
369  axisTitle[dim] = "#eta_{jet}";
370  nbins[dim] = fMaxPt/3;
371  min[dim] = -1;
372  max[dim] = 1;
373  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
374  dim++;
375 
376  axisTitle[dim] = "N_{tracks}";
377  nbins[dim] = fMaxPt/5;
378  min[dim] = 0;
379  max[dim] = 100;
380  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
381  dim++;
382 
383  axisTitle[dim] = "A_{jet}";
384  nbins[dim] = fMaxPt/3;
385  min[dim] = 0;
386  max[dim] = 1.5;
387  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
388  dim++;
389 
390  TString thnname = TString::Format("%s/DijetObservables", jets->GetArrayName().Data());
391  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
392  for (Int_t i = 0; i < dim; i++) {
393  hn->GetAxis(i)->SetTitle(axisTitle[i]);
394  hn->SetBinEdges(i, binEdges[i]);
395  }
396  }
397 }
398 
399 /*
400  * This function allocates the histograms for dijet imbalance.
401  */
403 {
404  // Allocate dijet imbalance THnSparse
405  AliJetContainer* jets = 0;
406  TIter nextJetColl(&fJetCollArray);
407  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
408  TString axisTitle[30]= {""};
409  Int_t nbins[30] = {0};
410  Double_t min[30] = {0.};
411  Double_t max[30] = {0.};
412  Double_t *binEdges[20] = {0};
413  Int_t dim = 0;
414 
415  if (fForceBeamType != kpp) {
416  axisTitle[dim] = "Centrality (%)";
417  nbins[dim] = fNCentHistBins;
418  binEdges[dim] = fCentHistBins;
419  min[dim] = fCentHistBins[0];
420  max[dim] = fCentHistBins[fNCentHistBins];
421  dim++;
422  }
423 
424  axisTitle[dim] = "LeadingHadronRequired";
425  nbins[dim] = 2;
426  min[dim] = -0.5;
427  max[dim] = 1.5;
428  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
429  dim++;
430 
431  axisTitle[dim] = "#it{p}_{T,min}^{trig}";
432  nbins[dim] = fNDijetPtThresholds;
433  min[dim] = -0.5;
434  max[dim] = fNDijetPtThresholds - 0.5;
435  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
436  dim++;
437 
438  axisTitle[dim] = "#it{p}_{T,min}^{ass}";
439  nbins[dim] = fNDijetPtThresholds;
440  min[dim] = -0.5;
441  max[dim] = fNDijetPtThresholds - 0.5;
442  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
443  dim++;
444 
445  axisTitle[dim] = "#Delta#phi";
446  nbins[dim] = 100;
447  min[dim] = 0;
448  max[dim] = 4;
449  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
450  dim++;
451 
452  axisTitle[dim] = "#Delta#eta";
453  nbins[dim] = 100;
454  min[dim] = -2;
455  max[dim] = 2;
456  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
457  dim++;
458 
459  axisTitle[dim] = "A_{J}";
460  nbins[dim] = 100;
461  min[dim] = 0;
462  max[dim] = 1;
463  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
464  dim++;
465 
466  axisTitle[dim] = "x_{J}";
467  nbins[dim] = 100;
468  min[dim] = 0;
469  max[dim] = 1;
470  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
471  dim++;
472 
473  axisTitle[dim] = "k_{Ty} (GeV)";
474  nbins[dim] = 100;
475  min[dim] = 0;
476  max[dim] = 100;
477  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
478  dim++;
479 
480  TString thnname = TString::Format("%s/DijetImbalanceObservables", jets->GetArrayName().Data());
481  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
482  for (Int_t i = 0; i < dim; i++) {
483  hn->GetAxis(i)->SetTitle(axisTitle[i]);
484  hn->SetBinEdges(i, binEdges[i]);
485  }
486  }
487 }
488 
489 /*
490  * This function allocates the histograms for the momentum balance study.
491  */
493 {
494  AliJetContainer* jets = 0;
495  TIter nextJetColl(&fJetCollArray);
496  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
497 
498  // Allocate THnSparse
499  TString axisTitle[30]= {""};
500  Int_t nbins[30] = {0};
501  Double_t min[30] = {0.};
502  Double_t max[30] = {0.};
503  Double_t *binEdges[20] = {0};
504  Int_t dim = 0;
505 
506  axisTitle[dim] = "LeadingHadronRequired";
507  nbins[dim] = 2;
508  min[dim] = -0.5;
509  max[dim] = 1.5;
510  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
511  dim++;
512 
513  axisTitle[dim] = "#it{p}_{T,min}^{trig}";
514  nbins[dim] = fNDijetPtThresholds;
515  min[dim] = -0.5;
516  max[dim] = fNDijetPtThresholds - 0.5;
517  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
518  dim++;
519 
520  axisTitle[dim] = "#it{p}_{T,min}^{ass}";
521  nbins[dim] = fNDijetPtThresholds;
522  min[dim] = -0.5;
523  max[dim] = fNDijetPtThresholds - 0.5;
524  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
525  dim++;
526 
527  axisTitle[dim] = "A_{J}";
528  nbins[dim] = 100;
529  min[dim] = 0;
530  max[dim] = 1;
531  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
532  dim++;
533 
534  axisTitle[dim] = "#Delta#phi";
535  nbins[dim] = 100;
536  min[dim] = -4;
537  max[dim] = 4;
538  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
539  dim++;
540 
541  axisTitle[dim] = "#it{p}_{T,particle} (GeV/#it{c})";
542  nbins[dim] = 9;
543  Double_t* pTParticleBins = new Double_t[nbins[dim]+1];
544  GenerateFixedBinArray(1, 0.15, 0.3, pTParticleBins);
545  GenerateFixedBinArray(1, 0.3, 0.5, pTParticleBins+1);
546  GenerateFixedBinArray(1, 0.5, 1, pTParticleBins+2);
547  GenerateFixedBinArray(2, 1, 5, pTParticleBins+3);
548  GenerateFixedBinArray(3, 5, 20, pTParticleBins+5);
549  GenerateFixedBinArray(1, 20, 150, pTParticleBins+8);
550  min[dim] = 0;
551  max[dim] = pTParticleBins[nbins[dim]];
552  binEdges[dim] = pTParticleBins;
553  dim++;
554 
555  axisTitle[dim] = "#it{p}_{T}#parallel (GeV/#it{c})";
556  nbins[dim] = 80;
557  Double_t* pTParallelBins = new Double_t[nbins[dim]+1];
558  GenerateFixedBinArray(20, 0, 2, pTParallelBins);
559  GenerateFixedBinArray(16, 2, 10, pTParallelBins+20);
560  GenerateFixedBinArray(10, 10, 20, pTParallelBins+36);
561  GenerateFixedBinArray(10, 20, 40, pTParallelBins+46);
562  GenerateFixedBinArray(24, 40, 150, pTParallelBins+56);
563  min[dim] = 0;
564  max[dim] = pTParallelBins[nbins[dim]];
565  binEdges[dim] = pTParallelBins;
566  dim++;
567 
568  TString thnname = TString::Format("%s/MomentumBalance", jets->GetArrayName().Data());
569  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
570  for (Int_t i = 0; i < dim; i++) {
571  hn->GetAxis(i)->SetTitle(axisTitle[i]);
572  hn->SetBinEdges(i, binEdges[i]);
573  }
574  }
575 }
576 
577 /*
578  * This function allocates the histograms for the constituent dijet study.
579  */
581 {
582  // Allocate geometrical matching THnSparse
583  TString axisTitle[30]= {""};
584  Int_t nbins[30] = {0};
585  Double_t min[30] = {0.};
586  Double_t max[30] = {0.};
587  Double_t *binEdges[20] = {0};
588  Int_t dim = 0;
589 
590  if (fForceBeamType != kpp) {
591  axisTitle[dim] = "Centrality (%)";
592  nbins[dim] = fNCentHistBins;
593  binEdges[dim] = fCentHistBins;
594  min[dim] = fCentHistBins[0];
595  max[dim] = fCentHistBins[fNCentHistBins];
596  dim++;
597  }
598 
599  axisTitle[dim] = "#it{p}_{T,min}^{trig}";
600  nbins[dim] = fNDijetPtThresholds;
601  min[dim] = -0.5;
602  max[dim] = fNDijetPtThresholds - 0.5;
603  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
604  dim++;
605 
606  axisTitle[dim] = "#it{p}_{T,min}^{ass}";
607  nbins[dim] = fNDijetPtThresholds;
608  min[dim] = -0.5;
609  max[dim] = fNDijetPtThresholds - 0.5;
610  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
611  dim++;
612 
613  axisTitle[dim] = "isSwitched";
614  nbins[dim] = 2;
615  min[dim] = -0.5;
616  max[dim] = 1.5;
617  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
618  dim++;
619 
620  axisTitle[dim] = "#DeltaR_{trig}";
621  nbins[dim] = 50;
622  min[dim] = 0;
623  max[dim] = 0.5;
624  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
625  dim++;
626 
627  axisTitle[dim] = "#DeltaR_{ass}";
628  nbins[dim] = 50;
629  min[dim] = 0;
630  max[dim] = 0.5;
631  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
632  dim++;
633 
634  axisTitle[dim] = "trig #it{p}_{T,low-thresh} - #it{p}_{T,hard-core}";
635  nbins[dim] = 100;
636  min[dim] = -50;
637  max[dim] = 50;
638  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
639  dim++;
640 
641  axisTitle[dim] = "ass #it{p}_{T,low-thresh} - #it{p}_{T,hard-core}";
642  nbins[dim] = 100;
643  min[dim] = -50;
644  max[dim] = 50;
645  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
646  dim++;
647 
648  axisTitle[dim] = "A_{J} low-threshold";
649  nbins[dim] = 100;
650  min[dim] = 0;
651  max[dim] = 1;
652  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
653  dim++;
654 
655  axisTitle[dim] = "A_{J} hard-core";
656  nbins[dim] = 100;
657  min[dim] = 0;
658  max[dim] = 1;
659  binEdges[dim] = GenerateFixedBinArray(nbins[dim], min[dim], max[dim]);
660  dim++;
661 
662  TString thnname = "GeometricalMatching";
663  THnSparse* hn = fHistManager.CreateTHnSparse(thnname.Data(), thnname.Data(), dim, nbins, min, max);
664  for (Int_t i = 0; i < dim; i++) {
665  hn->GetAxis(i)->SetTitle(axisTitle[i]);
666  hn->SetBinEdges(i, binEdges[i]);
667  }
668 
669  // Allocate other histograms
670  TString histname;
671  TString title;
672  histname = "GeometricalMatchingEfficiency";
673  title = histname + ";isMatched;counts";
674  TH1* hist = fHistManager.CreateTH1(histname.Data(), title.Data(), 2, -0.5, 1.5);
675 }
676 
682 {
684 
685  AliInfo(Form("Number of pT thresholds: %d", fNDijetPtThresholds));
686  for (Int_t i = 0; i < fNDijetPtThresholds; i++) {
687  AliInfo(Form("Trigger jet threshold %d = %f, Associated jet threshold %d = %f", i, fMinTrigJetPt[i], i, fMinAssJetPt[i]));
688  }
689  AliInfo(Form("Leading hadron threshold (for dijet leading jet): %f GeV", fDijetLeadingHadronPt));
690  AliInfo(Form("Momentum balance study: %d", fDoMomentumBalance));
691  AliInfo(Form("Geometrical matching study: %d", fDoGeometricalMatching));
692 
693 }
694 
699 {
700  if (!fEventCuts.AcceptEvent(InputEvent()))
701  {
702  PostData(1, fOutput);
703  return kFALSE;
704  }
705  return kTRUE;
706 }
707 
716 {
717  TString histname;
718  AliJetContainer* jetCont = 0;
719  TIter next(&fJetCollArray);
720  while ((jetCont = static_cast<AliJetContainer*>(next()))) {
721  TString jetContName = jetCont->GetName();
722  if (jetContName.Contains("HardCore")) continue;
723 
724  // Loop over leading hadron cut or not
725  for (Int_t leadingHadronCutType=0; leadingHadronCutType<2; leadingHadronCutType++) {
726 
727  // Loop through leading jet pT thresholds
728  for (Int_t trigJetMinPtType = 0; trigJetMinPtType < fNDijetPtThresholds; trigJetMinPtType++) {
729 
730  // Loop through subleading jet pT thresholds
731  for (Int_t assJetMinPtType=0; assJetMinPtType < fNDijetPtThresholds; assJetMinPtType++) {
732 
733  // Find the dijet candidate of the event and store its info in struct fDijet
734  FindDijet(jetCont, leadingHadronCutType, trigJetMinPtType, assJetMinPtType);
735 
736  // If we find a dijet candidate (i.e. acceptable trig jet; ass jet accepted or not), fill the di-jet jet histograms
738  TString histname = TString::Format("%s/DijetObservables", jetCont->GetArrayName().Data());
741  if (fDijet.assJet)
744  }
745 
746  // If we find an accepted dijet, fill the dijet imbalance histogram
748  TString histname = TString::Format("%s/DijetImbalanceObservables", jetCont->GetArrayName().Data());
750  }
751 
752  // If we find an accepted dijet, perform momentum-balance study (if requested)
754  histname = TString::Format("%s/MomentumBalance", jetCont->GetArrayName().Data());
755  DoMomentumBalance(histname);
756  }
757  }
758  }
759  }
760  }
761 
762  // Do the constituent threshold and geometrical matching study (if requested)
765 
766  return kTRUE;
767 }
768 
773 void AliAnalysisTaskEmcalDijetImbalance::FindDijet(AliJetContainer* jetCont, Int_t leadingHadronCutBin, Int_t trigJetMinPtBin, Int_t assJetMinPtBin)
774 {
775  fDijet.clear();
776  fDijet.leadingHadronCutType = leadingHadronCutBin;
777  fDijet.trigJetMinPtType = trigJetMinPtBin;
778  fDijet.assJetMinPtType = assJetMinPtBin;
779 
780  // Get trigger jet
781  AliEmcalJet* trigJet = 0;
782  if (jetCont->GetRhoParameter())
783  trigJet = jetCont->GetLeadingJet("rho");
784  else
785  trigJet = jetCont->GetLeadingJet();
786  if(!trigJet) return;
787 
788  // Skip the event if the leading jet doesn't satisfy the pT threshold
789  Double_t trigJetPt = GetJetPt(jetCont, trigJet);
790  if ( trigJetPt < fMinTrigJetPt[trigJetMinPtBin] ) return;
791 
792  // Skip the event if the leading jet doesn't satisfy the leading hadron threshold
793  if (jetCont->GetLeadingHadronPt(trigJet) < fDijetLeadingHadronPt*leadingHadronCutBin) return;
794 
795  // Fill the dijet struct
796  fDijet.trigJet = trigJet;
797  fDijet.trigJetPt = trigJetPt;
798  fDijet.trigJetEta = trigJet->Eta();
799  fDijet.trigJetPhi = trigJet->Phi();
800 
801  // Find the subleading jet in the opposite hemisphere
802  AliEmcalJet *assJet = 0;
803  for(auto assJetCand : jetCont->accepted()) {
804  if (!assJetCand) continue;
805  Double_t assJetCandPt = GetJetPt(jetCont, assJetCand);
806  if ( TMath::Abs(trigJet->Phi() - assJetCand->Phi()) < fDeltaPhiMin ) continue;
807  if (assJet) {
808  Double_t assJetPt = GetJetPt(jetCont, assJet);
809  if ( assJetCandPt < assJetPt ) continue;
810  }
811  assJet = assJetCand;
812  }
813  if (!assJet) return;
814 
815  // Fill the dijet struct
816  fDijet.assJet = assJet;
817  fDijet.assJetPt = GetJetPt(jetCont, assJet);
818  fDijet.assJetPhi = assJet->Phi();
819  fDijet.assJetEta = assJet->Eta();
820  fDijet.isAccepted = fDijet.assJetPt > fMinAssJetPt[assJetMinPtBin];
821 
822  fDijet.deltaPhi = TMath::Abs(trigJet->Phi() - assJet->Phi());
823  fDijet.deltaEta = trigJet->Eta() - assJet->Eta();
826  fDijet.kTy = TMath::Abs( fDijet.trigJetPt * TMath::Sin(fDijet.deltaPhi) );
827 }
828 
834 {
835 
836  AliTrackContainer* trackCont = dynamic_cast<AliTrackContainer*>(GetParticleContainer("tracks"));
837 
838  AliVTrack* track;
839  for (auto trackIterator : trackCont->accepted_momentum() ) {
840 
841  track = trackIterator.second;
842 
843  // Compute the delta phi between the track and its nearest jet (of the two jets in the dijet),
844  // as well as its pT-parallel projection onto the nearest jet's axis.
845 
846  Double_t trackPt = track->Pt();
847  Double_t trackPhi = track->Phi();
848  Double_t trigJetPhi = fDijet.trigJet->Phi();
849  Double_t assJetPhi = fDijet.assJet->Phi();
850 
851  Double_t deltaPhiTrigJet = TMath::Abs(trackPhi - trigJetPhi);
852  Double_t deltaPhiAssJet = TMath::Abs(trackPhi - assJetPhi);
853  Bool_t isNearside = deltaPhiTrigJet < deltaPhiAssJet;
854 
855  Double_t deltaPhi;
856  Double_t balancePt;
857  if (isNearside) {
858  deltaPhi = trackPhi - trigJetPhi;
859  balancePt = trackPt * TMath::Cos(deltaPhi);
860  }
861  else {
862  deltaPhi = trackPhi - assJetPhi;
863  balancePt = -trackPt * TMath::Cos(deltaPhi);
864  }
865 
866  FillMomentumBalanceHistograms(histname, deltaPhi, trackPt, balancePt);
867 
868  }
869 }
870 
875 {
876  // Get jet container with minimum constituent pT,E thresholds
877  TString jetContAllName = Form("Jet_AKTFullR0%d0_tracks_pT0150_caloClusters_E0300_pt_scheme", (int) (fMatchingJetR*10) );
878  AliJetContainer* jetContAll = GetJetContainer(jetContAllName.Data());
879 
880  // Get jet container with X GeV constituent pT,E thresholds
881  Int_t trackThreshold = (int) (fTrackConstituentThreshold*1000); // in MeV
882  Int_t clusThreshold = (int) (fClusterConstituentThreshold*1000); // in MeV
883  TString jetContHardCoreName = Form("JetHardCore_AKTFullR0%d0_tracks_pT%d_caloClusters_E%d_pt_scheme", (int) (fMatchingJetR*10), trackThreshold, clusThreshold);
884  AliJetContainer* jetContHardCore = GetJetContainer(jetContHardCoreName.Data());
885 
886  // Find the di-jet in the hard-core jet sample, then find the matching di-jet and fill histograms
887  FindDijet(jetContHardCore, 0, 0, 0);
888  if (fDijet.isAccepted) {
889  FindMatchingDijet(jetContAll, 0);
891  }
892 }
893 
899 {
901  fMatchingDijet.assJetMinPtType = assJetMinPtBin;
902 
903  // Loop over jets and find leading jet within R of fDijet.trigJet
904  AliEmcalJet *matchingTrigJet = 0;
905  for(auto matchingTrigJetCand : jetCont->accepted()) {
906  if (!matchingTrigJetCand) continue;
907  if ( GetDeltaR(matchingTrigJetCand, fDijet.trigJet) > fMatchingJetR ) continue;
908  if (matchingTrigJet) {
909  if ( GetJetPt(jetCont, matchingTrigJetCand) < GetJetPt(jetCont, matchingTrigJet) ) continue;
910  }
911  matchingTrigJet = matchingTrigJetCand;
912  }
913  if (!matchingTrigJet) return;
914 
915  // Loop over jets and find leading jet within R of fDijet.assJet
916  AliEmcalJet *matchingAssJet = 0;
917  for(auto matchingAssJetCand : jetCont->accepted()) {
918  if (!matchingAssJetCand) continue;
919  if ( GetDeltaR(matchingAssJetCand, fDijet.assJet) > fMatchingJetR ) continue;
920  if (matchingAssJet) {
921  if ( GetJetPt(jetCont, matchingAssJetCand) < GetJetPt(jetCont, matchingAssJet) ) continue;
922  }
923  matchingAssJet = matchingAssJetCand;
924  }
925 
926  // Determine which matching jet is the leading jet (i.e. allow them to flip)
927  if (matchingAssJet) {
928  AliEmcalJet* trigJet = matchingTrigJet;
929  AliEmcalJet* assJet = matchingAssJet;
930  if ( GetJetPt(jetCont, matchingTrigJet) < GetJetPt(jetCont, matchingAssJet) ) {
931  AliEmcalJet* trigJet = matchingAssJet;
932  AliEmcalJet* assJet = matchingTrigJet;
933  }
934 
935  // Fill the dijet struct
936  fMatchingDijet.trigJet = trigJet;
937  fMatchingDijet.trigJetPt = GetJetPt(jetCont, trigJet);
938  fMatchingDijet.trigJetEta = trigJet->Eta();
939  fMatchingDijet.trigJetPhi = trigJet->Phi();
940 
941  fMatchingDijet.assJet = assJet;
942  fMatchingDijet.assJetPt = GetJetPt(jetCont, assJet);
943  fMatchingDijet.assJetPhi = assJet->Phi();
944  fMatchingDijet.assJetEta = assJet->Eta();
946 
947  fMatchingDijet.deltaPhi = TMath::Abs(trigJet->Phi() - assJet->Phi());
948  fMatchingDijet.deltaEta = trigJet->Eta() - assJet->Eta();
951  fMatchingDijet.kTy = TMath::Abs( fMatchingDijet.trigJetPt * TMath::Sin(fMatchingDijet.deltaPhi) );
952  }
953 }
954 
959 {
960  Double_t pT = jet->Pt() - jetCont->GetRhoVal() * jet->Area();
961  TString jetContName = jetCont->GetName();
962  if (jetContName.Contains("HardCore")) pT = jet->Pt();
963  return pT;
964 }
965 
970 {
971  Double_t deltaPhi = TMath::Abs(jet1->Phi() - jet2->Phi());
972  Double_t deltaEta = TMath::Abs(jet1->Eta() - jet2->Eta());
973  Double_t deltaR = TMath::Sqrt( deltaPhi*deltaPhi + deltaEta*deltaEta );
974  return deltaR;
975 }
976 
984 {
986 
987  return kTRUE;
988 }
989 
995 {
996  TString histname;
997  AliJetContainer* jets = 0;
998  TIter nextJetColl(&fJetCollArray);
999  while ((jets = static_cast<AliJetContainer*>(nextJetColl()))) {
1000  TString jetContName = jets->GetName();
1001  if (jetContName.Contains("HardCore")) continue;
1002  Double_t rhoVal = 0;
1003  if (jets->GetRhoParameter()) {
1004  rhoVal = jets->GetRhoVal();
1005  histname = TString::Format("%s/fHistRhoVsCent", jets->GetArrayName().Data());
1006  fHistManager.FillTH2(histname.Data(), fCent, rhoVal);
1007  }
1008 
1009  for (auto jet : jets->all()) {
1010 
1011  UInt_t rejectionReason = 0;
1012  if (!jets->AcceptJet(jet, rejectionReason)) {
1013  histname = TString::Format("%s/fHistJetRejectionReason", jets->GetArrayName().Data());
1014  fHistManager.FillTH2(histname.Data(), jets->GetRejectionReasonBitPosition(rejectionReason), jet->Pt());
1015  continue;
1016  }
1017 
1018  Float_t ptLeading = jets->GetLeadingHadronPt(jet);
1019  Float_t corrPt = jet->Pt() - rhoVal * jet->Area();
1020 
1021  TLorentzVector leadPart;
1022  jets->GetLeadingHadronMomentum(leadPart, jet);
1023  Double_t z = GetParallelFraction(leadPart.Vect(), jet);
1024  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
1025 
1026  Double_t contents[30]={0};
1027  histname = TString::Format("%s/JetObservables", jets->GetArrayName().Data());
1028  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(histname));
1029  if (!histJetObservables) return;
1030  for (Int_t i = 0; i < histJetObservables->GetNdimensions(); i++) {
1031  TString title(histJetObservables->GetAxis(i)->GetTitle());
1032  if (title=="Centrality (%)")
1033  contents[i] = fCent;
1034  else if (title=="#eta_{jet}")
1035  contents[i] = jet->Eta();
1036  else if (title=="#phi_{jet} (rad)")
1037  contents[i] = jet->Phi_0_2pi();
1038  else if (title=="#it{p}_{T} (GeV/#it{c})")
1039  contents[i] = jet->Pt();
1040  else if (title=="#it{p}_{T}^{corr} (GeV/#it{c})")
1041  contents[i] = corrPt;
1042  else if (title=="#it{p}_{T,particle}^{leading} (GeV/#it{c})")
1043  contents[i] = ptLeading;
1044  else if (title=="#it{A}_{jet}")
1045  contents[i] = jet->Area();
1046  else if (title=="NEF")
1047  contents[i] = jet->NEF();
1048  else if (title=="#it{z}_{leading}")
1049  contents[i] = z;
1050  else if (title=="No. of constituents")
1051  contents[i] = jet->GetNumberOfConstituents();
1052  else
1053  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1054  }
1055  histJetObservables->Fill(contents);
1056 
1057  } //jet loop
1058  }
1059 }
1060 
1064 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)
1065 {
1066  Double_t contents[30]={0};
1067  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(histname));
1068  if (!histJetObservables) return;
1069  for (Int_t n = 0; n < histJetObservables->GetNdimensions(); n++) {
1070  TString title(histJetObservables->GetAxis(n)->GetTitle());
1071  if (title=="Centrality (%)")
1072  contents[n] = fCent;
1073  else if (title=="LeadingHadronRequired")
1074  contents[n] = fDijet.leadingHadronCutType;
1075  else if (title=="#it{p}_{T,min}^{trig}")
1076  contents[n] = fDijet.trigJetMinPtType;
1077  else if (title=="#it{p}_{T,min}^{ass}")
1078  contents[n] = fDijet.assJetMinPtType;
1079  else if (title=="isAccepted")
1080  contents[n] = isAccepted;
1081  else if (title=="LeadingSubleading")
1082  contents[n] = IsAssJet;
1083  else if (title=="#it{p}_{T,jet} (GeV/#it{c})")
1084  contents[n] = jetPt;
1085  else if (title=="#phi_{jet}")
1086  contents[n] = jetPhi;
1087  else if (title=="#eta_{jet}")
1088  contents[n] = jetEta;
1089  else if (title=="N_{tracks}")
1090  contents[n] = nTracksJet;
1091  else if (title=="A_{jet}")
1092  contents[n] = jetArea;
1093  else
1094  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1095  }
1096  histJetObservables->Fill(contents);
1097 }
1098 
1103 {
1104  Double_t contents[30]={0};
1105  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(histname));
1106  if (!histJetObservables) return;
1107  for (Int_t n = 0; n < histJetObservables->GetNdimensions(); n++) {
1108  TString title(histJetObservables->GetAxis(n)->GetTitle());
1109  if (title=="Centrality (%)")
1110  contents[n] = fCent;
1111  else 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=="#Delta#phi")
1118  contents[n] = fDijet.deltaPhi;
1119  else if (title=="#Delta#eta")
1120  contents[n] = fDijet.deltaEta;
1121  else if (title=="A_{J}")
1122  contents[n] = fDijet.AJ;
1123  else if (title=="x_{J}")
1124  contents[n] = fDijet.xJ;
1125  else if (title=="k_{Ty} (GeV)")
1126  contents[n] = fDijet.kTy;
1127  else
1128  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1129  }
1130  histJetObservables->Fill(contents);
1131 }
1132 
1137 {
1138  Double_t contents[30]={0};
1139  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(histname));
1140  if (!histJetObservables) return;
1141  for (Int_t n = 0; n < histJetObservables->GetNdimensions(); n++) {
1142  TString title(histJetObservables->GetAxis(n)->GetTitle());
1143  if (title=="LeadingHadronRequired")
1144  contents[n] = fDijet.leadingHadronCutType;
1145  else if (title=="#it{p}_{T,min}^{trig}")
1146  contents[n] = fDijet.trigJetMinPtType;
1147  else if (title=="#it{p}_{T,min}^{ass}")
1148  contents[n] = fDijet.assJetMinPtType;
1149  else if (title=="A_{J}")
1150  contents[n] = fDijet.AJ;
1151  else if (title=="#Delta#phi")
1152  contents[n] = deltaPhi;
1153  else if (title=="#it{p}_{T,particle} (GeV/#it{c})")
1154  contents[n] = trackPt;
1155  else if (title=="#it{p}_{T}#parallel (GeV/#it{c})")
1156  contents[n] = balancePt;
1157  else
1158  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1159  }
1160  histJetObservables->Fill(contents);
1161 }
1162 
1167 {
1168  // Matching efficiency histogram
1169  TString histname = "GeometricalMatchingEfficiency";
1170 
1171  // If we have a matching di-jet, fill the geometrical matching histogram
1172  if (fMatchingDijet.assJet) {
1173  fHistManager.FillTH1(histname.Data(), 1);
1174 
1177  Bool_t isSwitched = trigDeltaR > fMatchingJetR;
1178 
1179  TString thnname = "GeometricalMatching";
1180  Double_t contents[30]={0};
1181  THnSparse* histJetObservables = static_cast<THnSparse*>(fHistManager.FindObject(thnname.Data()));
1182  if (!histJetObservables) return;
1183  for (Int_t n = 0; n < histJetObservables->GetNdimensions(); n++) {
1184  TString title(histJetObservables->GetAxis(n)->GetTitle());
1185  if (title=="Centrality (%)")
1186  contents[n] = fCent;
1187  else if (title=="#it{p}_{T,min}^{trig}")
1188  contents[n] = fDijet.trigJetMinPtType;
1189  else if (title=="#it{p}_{T,min}^{ass}")
1190  contents[n] = fDijet.assJetMinPtType;
1191  else if (title=="isSwitched")
1192  contents[n] = isSwitched;
1193  else if (title=="#DeltaR_{trig}")
1194  contents[n] = trigDeltaR;
1195  else if (title=="#DeltaR_{ass}")
1196  contents[n] = assDeltaR;
1197  else if (title=="trig #it{p}_{T,low-thresh} - #it{p}_{T,hard-core}")
1198  contents[n] = fMatchingDijet.trigJetPt - fDijet.trigJetPt;
1199  else if (title=="ass #it{p}_{T,low-thresh} - #it{p}_{T,hard-core}")
1200  contents[n] = fMatchingDijet.assJetPt - fDijet.assJetPt;
1201  else if (title=="A_{J} low-threshold")
1202  contents[n] = fMatchingDijet.AJ;
1203  else if (title=="A_{J} hard-core")
1204  contents[n] = fDijet.AJ;
1205  else
1206  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
1207  }
1208  histJetObservables->Fill(contents);
1209  }
1210  else {
1211  fHistManager.FillTH1(histname.Data(), 0.);
1212  }
1213 }
1214 
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
Bool_t fUseManualEventCuts
Flag to use manual event cuts.
UInt_t fOffTrigger
offline trigger for event selection
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="")
Fill a 2D histogram within the container.
Declaration of class AliTLorentzVector.
TList * fEventCutList
! Output list for event cut histograms
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.
AliEventCuts fEventCuts
event selection utility
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="")
Create a new TH2 within the container.
TObject * FindObject(const char *name) const
Find an object inside the container.
int Int_t
Definition: External.C:63
unsigned int UInt_t
Definition: External.C:33
THashList * GetListOfHistograms() const
Get the list of histograms.
Definition: THistManager.h:658
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="")
Create a new TH1 within the container.
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="")
Fill a 1D histogram within the container.
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
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="")
Create a new THnSparse within the container.
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