AliPhysics  58f3d52 (58f3d52)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalJetQA.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 <cstring>
17 
18 #include <TClonesArray.h>
19 #include <TH1F.h>
20 #include <TH2F.h>
21 #include <TH3F.h>
22 #include <THnSparse.h>
23 #include <THashList.h>
24 
25 #include <AliVEventHandler.h>
26 #include <AliAnalysisManager.h>
27 
28 #include "AliParticleContainer.h"
29 #include "AliClusterContainer.h"
30 #include "AliTrackContainer.h"
31 #include "AliCentrality.h"
32 #include "AliVCluster.h"
33 #include "AliVParticle.h"
34 #include "AliVTrack.h"
35 #include "AliLog.h"
36 #include "AliEMCALGeometry.h"
37 #include "AliEMCALGeoParams.h"
38 #include "AliPicoTrack.h"
39 #include "AliVVZERO.h"
40 #include "AliESDUtils.h"
41 
43 
45 
46 //________________________________________________________________________
49  fCellEnergyCut(0.05),
50  fParticleLevel(kFALSE),
51  fIsMC(kFALSE),
52  fCentMethod2(""),
53  fCentMethod3(""),
54  fDoV0QA(0),
55  fDoEPQA(0),
56  fDoLeadingObjectPosition(0),
57  fMaxCellsInCluster(50),
58  fPtBinWidth(0.5),
59  fMaxPt(150),
60  fSeparateEMCalDCal(kTRUE),
61  fIsEmbedded(kFALSE),
62  fCent2(0),
63  fCent3(0),
64  fVZERO(0),
65  fV0ATotMult(0),
66  fV0CTotMult(0),
67  fNTotTracks(0),
68  fLeadingTrack(),
69  fHistManager("AliAnalysisTaskEmcalJetQA")
70 {
71  // Default constructor.
72 
73  memset(fNTotClusters, 0, sizeof(Int_t)*3);
74 
75  SetMakeGeneralHistograms(kTRUE);
76 }
77 
78 //________________________________________________________________________
80  AliAnalysisTaskEmcalLight(name, kTRUE),
81  fCellEnergyCut(0.05),
82  fParticleLevel(kFALSE),
83  fIsMC(kFALSE),
84  fCentMethod2(""),
85  fCentMethod3(""),
86  fDoV0QA(0),
87  fDoEPQA(0),
88  fDoLeadingObjectPosition(0),
89  fMaxCellsInCluster(50),
90  fPtBinWidth(0.5),
91  fMaxPt(150),
92  fSeparateEMCalDCal(kTRUE),
93  fIsEmbedded(kFALSE),
94  fCent2(0),
95  fCent3(0),
96  fVZERO(0),
97  fV0ATotMult(0),
98  fV0CTotMult(0),
99  fNTotTracks(0),
100  fLeadingTrack(),
101  fHistManager(name)
102 {
103  // Standard
104 
105  memset(fNTotClusters, 0, sizeof(Int_t)*3);
106 
108 }
109 
110 //________________________________________________________________________
112 {
113  // Destructor
114 }
115 
116 //________________________________________________________________________
118 {
119  // Create histograms
120 
122 
123  TString histname;
124  TString title;
125 
126  Int_t nPtBins = TMath::CeilNint(fMaxPt / fPtBinWidth);
127 
128  for (auto cont_it : fParticleCollArray) {
129  AliParticleContainer* cont = cont_it.second;
130  if (!fParticleLevel && fIsMC) {
131  for (Int_t i = 0; i < GetNCentBins(); i++) {
132  histname = TString::Format("%s/fHistTrNegativeLabels_%d", cont->GetArrayName().Data(), i);
133  title = histname + ";% of negative labels;counts";
134  fHistManager.CreateTH1(histname.Data(), title.Data(), 500, 0, 1);
135 
136  histname = TString::Format("%s/fHistTrZeroLabels_%d", cont->GetArrayName().Data(), i);
137  title = histname + ";% of zero labels;counts";
138  fHistManager.CreateTH1(histname.Data(), title.Data(), 500, 0, 1);
139  }
140  }
141 
142  Int_t nlabels = 4;
143  if (fParticleLevel) nlabels = 1;
144 
145  for (Int_t i = 0; i < GetNCentBins(); i++) {
146  histname = TString::Format("%s/fHistRejectionReason_%d", cont->GetArrayName().Data(), i);
147  title = histname + ";Rejection reason;#it{p}_{T,track} (GeV/#it{c});counts";
148  TH2* hist = fHistManager.CreateTH2(histname.Data(), title.Data(), 32, 0, 32, 40, 0, 100);
149  SetRejectionReasonLabels(hist->GetXaxis());
150 
151  for (Int_t j = 0; j < nlabels; j++) {
152  histname = TString::Format("%s/fHistTrPhiEtaPt_%d_%d", cont->GetArrayName().Data(), i, j);
153  title = histname + ";#eta;#phi;#it{p}_{T} (GeV/#it{c})";
154  fHistManager.CreateTH3(histname.Data(), title.Data(), 100, -1, 1, 100, 0, TMath::TwoPi(), nPtBins, 0, fMaxPt);
155  }
156 
157  if (!fParticleLevel) {
158  if (fIsMC) {
159  histname = TString::Format("%s/fHistTrPhiEtaZeroLab_%d", cont->GetArrayName().Data(), i);
160  title = histname + ";#eta;#phi;counts";
161  fHistManager.CreateTH2(histname.Data(), title.Data(), 100, -1, 1, 100, 0, TMath::TwoPi());
162 
163  histname = TString::Format("%s/fHistTrPtZeroLab_%d", cont->GetArrayName().Data(), i);
164  title = histname + ";#it{p}_{T} (GeV/#it{c});counts";
165  fHistManager.CreateTH1(histname.Data(), title.Data(), nPtBins, 0, fMaxPt);
166  }
167 
168  histname = TString::Format("%s/fHistTrEmcPhiEta_%d", cont->GetArrayName().Data(), i);
169  title = histname + ";#eta;#phi;counts";
170  fHistManager.CreateTH2(histname.Data(), title.Data(), 100, -1, 1, 100, 0, TMath::TwoPi());
171 
172  histname = TString::Format("%s/fHistTrEmcPt_%d", cont->GetArrayName().Data(), i);
173  title = histname + ";#it{p}_{T} (GeV/#it{c});counts";
174  fHistManager.CreateTH1(histname.Data(), title.Data(), nPtBins, 0, fMaxPt);
175 
176  histname = TString::Format("%s/fHistTrPhiEtaNonProp_%d", cont->GetArrayName().Data(), i);
177  title = histname + ";#eta;#phi;counts";
178  fHistManager.CreateTH2(histname.Data(), title.Data(), 100, -1, 1, 100, 0, TMath::TwoPi());
179 
180  histname = TString::Format("%s/fHistTrPtNonProp_%d", cont->GetArrayName().Data(), i);
181  title = histname + ";#it{p}_{T} (GeV/#it{c});counts";
182  fHistManager.CreateTH1(histname.Data(), title.Data(), nPtBins, 0, fMaxPt);
183 
184  histname = TString::Format("%s/fHistDeltaEtaPt_%d", cont->GetArrayName().Data(), i);
185  title = histname + ";#it{p}_{T} (GeV/#it{c});#delta#eta;counts";
186  fHistManager.CreateTH2(histname.Data(), title.Data(), nPtBins, 0, fMaxPt, 50, -0.5, 0.5);
187 
188  histname = TString::Format("%s/fHistDeltaPhiPt_%d", cont->GetArrayName().Data(), i);
189  title = histname + ";#it{p}_{T} (GeV/#it{c});#delta#phi;counts";
190  fHistManager.CreateTH2(histname.Data(), title.Data(), nPtBins, 0, fMaxPt, 200, -2, 2);
191 
192  histname = TString::Format("%s/fHistDeltaPtvsPt_%d", cont->GetArrayName().Data(), i);
193  title = histname + ";#it{p}_{T} (GeV/#it{c});#delta#it{p}_{T} (GeV/#it{c});counts";
194  fHistManager.CreateTH2(histname.Data(), title.Data(), nPtBins, 0, fMaxPt, nPtBins, -fMaxPt/2, fMaxPt/2);
195  }
196  }
197  }
198 
199  for (auto cont_it : fClusterCollArray) {
200  AliClusterContainer* cont = cont_it.second;
201  for (Int_t i = 0; i < GetNCentBins(); i++) {
202  const Int_t nSM = 20;
203 
204  for (Int_t sm = 0; sm < nSM; sm++) {
205  histname = TString::Format("%s/BySM/fHistClusEnergy_SM%d_%d", cont->GetArrayName().Data(), sm, i);
206  title = histname + ";#it{E}_{cluster} (GeV);counts";
207  fHistManager.CreateTH1(histname.Data(), title.Data(), nPtBins, 0, fMaxPt);
208  }
209 
210  histname = TString::Format("%s/fHistRejectionReason_%d", cont->GetArrayName().Data(), i);
211  title = histname + ";Rejection reason;#it{E}_{cluster} (GeV);counts";
212  TH2* hist = fHistManager.CreateTH2(histname.Data(), title.Data(), 32, 0, 32, 40, 0, 100);
213  SetRejectionReasonLabels(hist->GetXaxis());
214 
215  histname = TString::Format("%s/fHistClusPosition_%d", cont->GetArrayName().Data(), i);
216  title = histname + ";#it{x} (cm);#it{y} (cm);#it{z} (cm)";
217  fHistManager.CreateTH3(histname.Data(), title.Data(), 50, -500, 500, 50, -500, 500, 50, -500, 500);
218 
219  histname = TString::Format("%s/fHistClusPhiEtaEnergy_%d", cont->GetArrayName().Data(), i);
220  title = histname + ";#eta;#phi;#it{E}_{cluster} (GeV)";
221  fHistManager.CreateTH3(histname.Data(), title.Data(), 100, -1, 1, 100, 0, TMath::TwoPi(), nPtBins, 0, fMaxPt);
222 
223  if (fForceBeamType != kpp) {
224  histname = TString::Format("%s/fHistClusDeltaPhiEPEnergy_%d", cont->GetArrayName().Data(), i);
225  title = histname + ";#it{E}_{cluster} (GeV);#phi_{cluster} - #psi_{EP};counts";
226  fHistManager.CreateTH2(histname.Data(), title.Data(), nPtBins, 0, fMaxPt, 100, 0, TMath::Pi());
227  }
228 
229  if (fIsEmbedded) {
230  histname = TString::Format("%s/fHistClusMCEnergyFraction_%d", cont->GetArrayName().Data(), i);
231  title = histname + ";MC fraction;counts";
232  fHistManager.CreateTH1(histname.Data(), title.Data(), nPtBins, 0, 1.2);
233  }
234 
235  histname = TString::Format("%s/fHistClusTimeEnergy_%d", cont->GetArrayName().Data(), i);
236  title = histname + ";#it{E}_{cluster} (GeV);time (s);counts";
237  fHistManager.CreateTH2(histname.Data(), title.Data(), nPtBins, 0, fMaxPt, nPtBins, -5e-6, 5e-6);
238 
240  while (nbins > nPtBins) nbins /= 2;
241  histname = TString::Format("%s/fHistNCellsEnergy_%d", cont->GetArrayName().Data(), i);
242  title = histname + ";#it{E}_{cluster} (GeV);#it{N}_{cells};counts";
243  fHistManager.CreateTH2(histname.Data(), title.Data(), nPtBins, 0, fMaxPt, nbins, -0.5, fMaxCellsInCluster-0.5);
244 
245  histname = TString::Format("%s/fHistFcrossEnergy_%d", cont->GetArrayName().Data(), i);
246  title = histname + ";#it{E}_{cluster} (GeV);#it{F}_{cross};counts";
247  fHistManager.CreateTH2(histname.Data(), title.Data(), nPtBins, 0, fMaxPt, 200, -3.5, 1.5);
248 
249  histname = TString::Format("%s/fHistClusEnergy_%d", cont->GetArrayName().Data(), i);
250  title = histname + ";#it{E}_{cluster} (GeV);counts";
251  fHistManager.CreateTH1(histname.Data(), title.Data(), nPtBins, 0, fMaxPt);
252 
253  histname = TString::Format("%s/fHistClusNonLinCorrEnergy_%d", cont->GetArrayName().Data(), i);
254  title = histname + ";#it{E}_{cluster} (GeV);counts";
255  fHistManager.CreateTH1(histname.Data(), title.Data(), nPtBins, 0, fMaxPt);
256 
257  histname = TString::Format("%s/fHistClusHadCorrEnergy_%d", cont->GetArrayName().Data(), i);
258  title = histname + ";#it{E}_{cluster} (GeV);counts";
259  fHistManager.CreateTH1(histname.Data(), title.Data(), nPtBins, 0, fMaxPt);
260  }
261  }
262 
263  if (!fCaloCellsName.IsNull()) {
264  for (Int_t i = 0; i < GetNCentBins(); i++) {
265  histname = TString::Format("%s/fHistCellsAbsIdEnergy_%d", fCaloCellsName.Data(), i);
266  title = histname + ";cell abs. Id;#it{E}_{cell} (GeV);counts";
267  fHistManager.CreateTH2(histname.Data(), title.Data(), 20000,0,20000,(Int_t)(nPtBins / 2), 0, fMaxPt / 2);
268 
269  histname = TString::Format("%s/fHistCellsAbsIdTime_%d", fCaloCellsName.Data(), i);
270  title = histname + ";cell abs. Id;#it{time}_{cell} (s);counts";
271  fHistManager.CreateTH2(histname.Data(), title.Data(), 20000,0,20000,(Int_t)(nPtBins / 2), -5e-6, 5e-6);
272  }
273  }
274 
275  Int_t dim = 0;
276  TString axistitle[40];
277  Int_t nbins[40] = {0};
278  Double_t min[40] = {0};
279  Double_t max[40] = {0};
280 
282  axistitle[dim] = "Centrality %";
283  nbins[dim] = 100;
284  min[dim] = 0;
285  max[dim] = 100;
286  dim++;
287 
288  if (!fCentMethod2.IsNull()) {
289  axistitle[dim] = Form("Centrality %s %%", fCentMethod2.Data());
290  nbins[dim] = 100;
291  min[dim] = 0;
292  max[dim] = 100;
293  dim++;
294  }
295 
296  if (!fCentMethod3.IsNull()) {
297  axistitle[dim] = Form("Centrality %s %%", fCentMethod3.Data());
298  nbins[dim] = 100;
299  min[dim] = 0;
300  max[dim] = 100;
301  dim++;
302  }
303 
304  if (fDoV0QA==1) {
305  axistitle[dim] = "V0A total multiplicity";
306  nbins[dim] = 200;
307  min[dim] = 0;
308  max[dim] = 20000;
309  dim++;
310 
311  axistitle[dim] = "V0C total multiplicity";
312  nbins[dim] = 200;
313  min[dim] = 0;
314  max[dim] = 20000;
315  dim++;
316  }
317  else if (fDoV0QA==2) {
318  axistitle[dim] = "V0A+V0C total multiplicity";
319  nbins[dim] = 300;
320  min[dim] = 0;
321  max[dim] = 30000;
322  dim++;
323  }
324 
325  if (fDoEPQA) {
326  axistitle[dim] = "#psi_{EP}";
327  nbins[dim] = 200;
328  min[dim] = -TMath::Pi();
329  max[dim] = TMath::Pi();
330  dim++;
331  }
332  }
333 
334  if (fParticleCollArray.size() > 0) {
335  axistitle[dim] = "No. of tracks";
337  nbins[dim] = 3000;
338  min[dim] = -0.5;
339  max[dim] = 6000-0.5;
340  }
341  else {
342  nbins[dim] = 200;
343  min[dim] = 0;
344  max[dim] = 200;
345  }
346  dim++;
347 
348  axistitle[dim] = "#it{p}_{T,track}^{leading} (GeV/c)";
349  nbins[dim] = nPtBins;
350  min[dim] = 0;
351  max[dim] = fMaxPt;
352  dim++;
353 
355  axistitle[dim] = "#eta_{track}^{leading}";
356  nbins[dim] = 100;
357  min[dim] = -1;
358  max[dim] = 1;
359  dim++;
360 
361  axistitle[dim] = "#phi_{track}^{leading}";
362  nbins[dim] = 100;
363  min[dim] = 0;
364  max[dim] = TMath::TwoPi();
365  dim++;
366  }
367  }
368 
369  if (fClusterCollArray.size() > 0) {
370  axistitle[dim] = "No. of clusters";
371 
373  nbins[dim] = 2000;
374  min[dim] = -0.5;
375  max[dim] = 4000-0.5;
376  }
377  else {
378  nbins[dim] = 200;
379  min[dim] = 0;
380  max[dim] = 200;
381  }
382  dim++;
383 
384  if (fSeparateEMCalDCal) {
385  axistitle[dim] = "#it{E}_{EMCal cluster}^{leading} (GeV)";
386  nbins[dim] = nPtBins;
387  min[dim] = 0;
388  max[dim] = fMaxPt;
389  dim++;
390 
391  axistitle[dim] = "#it{E}_{DCal cluster}^{leading} (GeV)";
392  nbins[dim] = nPtBins;
393  min[dim] = 0;
394  max[dim] = fMaxPt;
395  dim++;
396 
397  axistitle[dim] = "#it{E}_{PHOS cluster}^{leading} (GeV)";
398  nbins[dim] = nPtBins;
399  min[dim] = 0;
400  max[dim] = fMaxPt;
401  dim++;
402 
404  axistitle[dim] = "#eta_{EMCal cluster}^{leading}";
405  nbins[dim] = 100;
406  min[dim] = -1;
407  max[dim] = 1;
408  dim++;
409 
410  axistitle[dim] = "#phi_{EMCal cluster}^{leading}";
411  nbins[dim] = 100;
412  min[dim] = 0;
413  max[dim] = TMath::TwoPi();
414  dim++;
415 
416  axistitle[dim] = "#eta_{DCal cluster}^{leading}";
417  nbins[dim] = 100;
418  min[dim] = -1;
419  max[dim] = 1;
420  dim++;
421 
422  axistitle[dim] = "#phi_{DCal cluster}^{leading}";
423  nbins[dim] = 100;
424  min[dim] = 0;
425  max[dim] = TMath::TwoPi();
426  dim++;
427 
428  axistitle[dim] = "#eta_{PHOS cluster}^{leading}";
429  nbins[dim] = 100;
430  min[dim] = -1;
431  max[dim] = 1;
432  dim++;
433 
434  axistitle[dim] = "#phi_{PHOS cluster}^{leading}";
435  nbins[dim] = 100;
436  min[dim] = 0;
437  max[dim] = TMath::TwoPi();
438  dim++;
439  }
440  }
441  else {
442  axistitle[dim] = "#it{E}_{cluster}^{leading} (GeV)";
443  nbins[dim] = nPtBins;
444  min[dim] = 0;
445  max[dim] = fMaxPt;
446  dim++;
447 
449  axistitle[dim] = "#eta_{cluster}^{leading}";
450  nbins[dim] = 100;
451  min[dim] = -1;
452  max[dim] = 1;
453  dim++;
454 
455  axistitle[dim] = "#phi_{cluster}^{leading}";
456  nbins[dim] = 100;
457  min[dim] = 0;
458  max[dim] = TMath::TwoPi();
459  dim++;
460  }
461  }
462  }
463 
464  if (!fCaloCellsName.IsNull()) {
465  axistitle[dim] = "No. of cells";
466 
468  nbins[dim] = 5000;
469  min[dim] = -0.5;
470  max[dim] = 10000-0.5;
471  }
472  else {
473  nbins[dim] = 500;
474  min[dim] = -0.5;
475  max[dim] = 500-0.5;
476  }
477 
478  dim++;
479  }
480 
481  THnSparse* hn = fHistManager.CreateTHnSparse("fHistEventQA","fHistEventQA",dim,nbins,min,max);
482  for (Int_t i = 0; i < dim; i++)
483  hn->GetAxis(i)->SetTitle(axistitle[i]);
484 
486 
487  PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram
488 }
489 
490 //________________________________________________________________________
492 {
493  if (fClusterCollArray.size() == 0 && fCaloCellsName.IsNull()) {
494  fNeedEmcalGeom = kFALSE;
495  }
496  else {
497  fNeedEmcalGeom = kTRUE;
498  }
499 
501 
502  if (fDoV0QA) {
503  fVZERO = InputEvent()->GetVZEROData();
504  if (!fVZERO) {
505  AliError("AliVVZERO not available");
506  }
507  }
508 }
509 
510 //________________________________________________________________________
512 {
513  // Retrieve event objects.
514 
516 
517  if (!fCentMethod2.IsNull() || !fCentMethod3.IsNull()) {
518  if (fBeamType == kAA || fBeamType == kpA ) {
519  AliCentrality *aliCent = InputEvent()->GetCentrality();
520  if (aliCent) {
521  if (!fCentMethod2.IsNull())
522  fCent2 = aliCent->GetCentralityPercentile(fCentMethod2);
523  if (!fCentMethod3.IsNull())
524  fCent3 = aliCent->GetCentralityPercentile(fCentMethod3);
525  }
526  }
527  }
528 
529  if (fVZERO) {
530  fV0ATotMult = AliESDUtils::GetCorrV0A(fVZERO->GetMTotV0A(),fVertex[2]);
531  fV0CTotMult = AliESDUtils::GetCorrV0C(fVZERO->GetMTotV0C(),fVertex[2]);
532  }
533 
534  return kTRUE;
535 }
536 
537 //________________________________________________________________________
539 {
540  // Fill histograms.
541 
542  if (fCentBin < 0) {
543  AliError(Form("fCentBin is %d! fCent = %.3f. Fix the centrality bins to include all possible values of centrality.", fCentBin, fCent));
544  return kFALSE;
545  }
546 
547  EventQA_t eventQA;
548 
549  DoTrackLoop();
550  AliDebug(2,Form("%d tracks found in the event", fNTotTracks));
551  eventQA.fMaxTrack = fLeadingTrack;
552 
553  DoClusterLoop();
554  AliDebug(2,Form("%d clusters found in EMCal, %d in DCal and %d in PHOS", fNTotClusters[0], fNTotClusters[1], fNTotClusters[2]));
555  for (Int_t i = 0; i < 3; i++) {
556  eventQA.fMaxCluster[i] = fLeadingCluster[i];
557  }
558 
559  if (fCaloCells) {
560  eventQA.fNCells = DoCellLoop();
561  AliDebug(2,Form("%d cells found in the event", eventQA.fNCells));
562  }
563 
564  eventQA.fCent = fCent;
565  eventQA.fCent2 = fCent2;
566  eventQA.fCent3 = fCent3;
567  eventQA.fV0A = fV0ATotMult;
568  eventQA.fV0C = fV0CTotMult;
569  eventQA.fEP = fEPV0;
570  eventQA.fNTracks = fNTotTracks;
571  eventQA.fNClusters[0] = fNTotClusters[0];
572  eventQA.fNClusters[1] = fNTotClusters[1];
573  eventQA.fNClusters[2] = fNTotClusters[2];
574 
575  FillEventQAHisto(eventQA);
576 
577  return kTRUE;
578 }
579 
580 //________________________________________________________________________
582 {
583  Double_t contents[40]={0};
584 
585  Int_t globalNclusters = eventQA.fNClusters[0] + eventQA.fNClusters[1] + eventQA.fNClusters[2];
586 
587  AliTLorentzVector globalMaxCluster;
588  for (Int_t i = 0; i < 3; i++) {
589  if (globalMaxCluster.E() < eventQA.fMaxCluster[i].E()) globalMaxCluster = eventQA.fMaxCluster[i];
590  }
591 
592  THnSparse* histEventQA = static_cast<THnSparse*>(fHistManager.FindObject("fHistEventQA"));
593 
594  for (Int_t i = 0; i < histEventQA->GetNdimensions(); i++) {
595  TString title(histEventQA->GetAxis(i)->GetTitle());
596  if (title=="Centrality %")
597  contents[i] = eventQA.fCent;
598  else if (title==Form("Centrality %s %%", fCentMethod2.Data()))
599  contents[i] = eventQA.fCent2;
600  else if (title==Form("Centrality %s %%", fCentMethod3.Data()))
601  contents[i] = eventQA.fCent3;
602  else if (title=="V0A total multiplicity")
603  contents[i] = eventQA.fV0A;
604  else if (title=="V0C total multiplicity")
605  contents[i] = eventQA.fV0C;
606  else if (title=="V0A+V0C total multiplicity")
607  contents[i] = eventQA.fV0A+eventQA.fV0C;
608  else if (title=="#psi_{RP}")
609  contents[i] = eventQA.fEP;
610  else if (title=="No. of tracks")
611  contents[i] = eventQA.fNTracks;
612  else if (title=="No. of clusters")
613  contents[i] = globalNclusters;
614  else if (title=="No. of cells")
615  contents[i] = eventQA.fNCells;
616  else if (title=="#it{p}_{T,track}^{leading} (GeV/c)")
617  contents[i] = eventQA.fMaxTrack.Pt();
618  else if (title=="#eta_{track}^{leading}")
619  contents[i] = eventQA.fMaxTrack.Eta();
620  else if (title=="#phi_{track}^{leading}")
621  contents[i] = eventQA.fMaxTrack.Phi_0_2pi();
622  else if (title=="#it{E}_{cluster}^{leading} (GeV)")
623  contents[i] = globalMaxCluster.E();
624  else if (title=="#eta_{cluster}^{leading}")
625  contents[i] = globalMaxCluster.Eta();
626  else if (title=="#phi_{cluster}^{leading}")
627  contents[i] = globalMaxCluster.Phi();
628  else if (title=="#it{E}_{EMCal cluster}^{leading} (GeV)")
629  contents[i] = eventQA.fMaxCluster[0].E();
630  else if (title=="#eta_{EMCal cluster}^{leading}")
631  contents[i] = eventQA.fMaxCluster[0].Phi_0_2pi();
632  else if (title=="#phi_{EMCal cluster}^{leading}")
633  contents[i] = eventQA.fMaxCluster[0].Eta();
634  else if (title=="#it{E}_{DCal cluster}^{leading} (GeV)")
635  contents[i] = eventQA.fMaxCluster[1].E();
636  else if (title=="#phi_{DCal cluster}^{leading}")
637  contents[i] = eventQA.fMaxCluster[1].Phi_0_2pi();
638  else if (title=="#eta_{DCal cluster}^{leading}")
639  contents[i] = eventQA.fMaxCluster[1].Eta();
640  else if (title=="#it{E}_{PHOS cluster}^{leading} (GeV)")
641  contents[i] = eventQA.fMaxCluster[2].E();
642  else if (title=="#phi_{PHOS cluster}^{leading}")
643  contents[i] = eventQA.fMaxCluster[2].Phi_0_2pi();
644  else if (title=="#eta_{PHOS cluster}^{leading}")
645  contents[i] = eventQA.fMaxCluster[2].Eta();
646  else
647  AliWarning(Form("Unable to fill dimension %s!",title.Data()));
648  }
649 
650  histEventQA->Fill(contents);
651 }
652 
653 //________________________________________________________________________
655 {
656  // Do cell loop.
657 
658  if (!fCaloCells) return 0;
659 
660  TString histname_en = TString::Format("%s/fHistCellsAbsIdEnergy_%d", fCaloCellsName.Data(), fCentBin);
661  TString histname_tm = TString::Format("%s/fHistCellsAbsIdTime_%d", fCaloCellsName.Data(), fCentBin);
662 
663  const Int_t ncells = fCaloCells->GetNumberOfCells();
664  Int_t nAccCells = 0;
665 
666  for (Int_t pos = 0; pos < ncells; pos++) {
667  Float_t amp = fCaloCells->GetAmplitude(pos);
668  Float_t time = fCaloCells->GetTime(pos);
669  Int_t absId = fCaloCells->GetCellNumber(pos);
670 
671  if (amp < fCellEnergyCut) continue;
672 
673  fHistManager.FillTH2(histname_en, absId, amp);
674  fHistManager.FillTH2(histname_tm, absId, time);
675  nAccCells++;
676  }
677 
678  return nAccCells;
679 }
680 
681 //________________________________________________________________________
682 Double_t AliAnalysisTaskEmcalJetQA::GetFcross(AliVCluster *cluster, AliVCaloCells *cells)
683 {
684  Int_t AbsIdseed = -1;
685  Double_t Eseed = 0;
686  for (Int_t i = 0; i < cluster->GetNCells(); i++) {
687  if (cells->GetCellAmplitude(cluster->GetCellAbsId(i)) > Eseed) {
688  Eseed = cells->GetCellAmplitude(cluster->GetCellAbsId(i));
689  AbsIdseed = cluster->GetCellAbsId(i);
690  }
691  }
692 
693  if (Eseed < 1e-9)
694  return 100;
695 
696  Int_t imod = -1, iphi =-1, ieta=-1,iTower = -1, iIphi = -1, iIeta = -1;
697  fGeom->GetCellIndex(AbsIdseed,imod,iTower,iIphi,iIeta);
698  fGeom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi,iIeta,iphi,ieta);
699 
700  //Get close cells index and energy, not in corners
701 
702  Int_t absID1 = -1;
703  Int_t absID2 = -1;
704 
705  if (iphi < AliEMCALGeoParams::fgkEMCALRows-1) absID1 = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi+1, ieta);
706  if (iphi > 0) absID2 = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi-1, ieta);
707 
708  // In case of cell in eta = 0 border, depending on SM shift the cross cell index
709 
710  Int_t absID3 = -1;
711  Int_t absID4 = -1;
712 
713  if (ieta == AliEMCALGeoParams::fgkEMCALCols-1 && !(imod%2)) {
714  absID3 = fGeom->GetAbsCellIdFromCellIndexes(imod+1, iphi, 0);
715  absID4 = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi, ieta-1);
716  }
717  else if (ieta == 0 && imod%2) {
718  absID3 = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi, ieta+1);
719  absID4 = fGeom->GetAbsCellIdFromCellIndexes(imod-1, iphi, AliEMCALGeoParams::fgkEMCALCols-1);
720  }
721  else {
722  if (ieta < AliEMCALGeoParams::fgkEMCALCols-1)
723  absID3 = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi, ieta+1);
724  if (ieta > 0)
725  absID4 = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi, ieta-1);
726  }
727 
728  Double_t ecell1 = cells->GetCellAmplitude(absID1);
729  Double_t ecell2 = cells->GetCellAmplitude(absID2);
730  Double_t ecell3 = cells->GetCellAmplitude(absID3);
731  Double_t ecell4 = cells->GetCellAmplitude(absID4);
732 
733  Double_t Ecross = ecell1 + ecell2 + ecell3 + ecell4;
734 
735  Double_t Fcross = 1 - Ecross/Eseed;
736 
737  return Fcross;
738 }
739 
740 //________________________________________________________________________
742 {
743  // Do cluster loop.
744 
745  TString histname;
746 
747  memset(fNTotClusters, 0, sizeof(Int_t)*3);
748  for (Int_t i = 0; i < 3; i++) fLeadingCluster[i].SetPxPyPzE(0,0,0,0);
749 
750  for (auto cont_it : fClusterCollArray) {
751  AliClusterContainer* clusters = cont_it.second;
752  // Cluster loop (EMCal, DCal, PHOS)
754  for (AliClusterIterableMomentumContainer::iterator it = itcont.begin(); it != itcont.end(); it++) {
755  UInt_t rejectionReason = 0;
756  if (!clusters->AcceptCluster(it.current_index(), rejectionReason)) {
757  histname = TString::Format("%s/fHistRejectionReason_%d", clusters->GetArrayName().Data(), fCentBin);
758  fHistManager.FillTH2(histname, clusters->GetRejectionReasonBitPosition(rejectionReason), it->first.E());
759  continue;
760  }
761 
762  Float_t pos[3]={0};
763  it->second->GetPosition(pos);
764  histname = TString::Format("%s/fHistClusPosition_%d", clusters->GetArrayName().Data(), fCentBin);
765  fHistManager.FillTH3(histname, pos[0], pos[1], pos[2]);
766 
767  histname = TString::Format("%s/fHistClusPhiEtaEnergy_%d", clusters->GetArrayName().Data(), fCentBin);
768  fHistManager.FillTH3(histname, it->first.Eta(), it->first.Phi_0_2pi(), it->first.E());
769 
770  histname = TString::Format("%s/fHistClusDeltaPhiEPEnergy_%d", clusters->GetArrayName().Data(), fCentBin);
771  if (fHistManager.FindObject(histname)) {
772  Double_t ep = it->first.Phi_0_2pi() - fEPV0;
773  while (ep < 0) ep += TMath::Pi();
774  while (ep >= TMath::Pi()) ep -= TMath::Pi();
775  fHistManager.FillTH2(histname, it->first.E(), ep);
776  }
777 
778  histname = TString::Format("%s/fHistNCellsEnergy_%d", clusters->GetArrayName().Data(), fCentBin);
779  fHistManager.FillTH2(histname, it->first.E(), it->second->GetNCells());
780 
781  histname = TString::Format("%s/fHistClusTimeEnergy_%d", clusters->GetArrayName().Data(), fCentBin);
782  fHistManager.FillTH2(histname, it->first.E(), it->second->GetTOF());
783 
784  histname = TString::Format("%s/fHistClusMCEnergyFraction_%d", clusters->GetArrayName().Data(), fCentBin);
785  if (fHistManager.FindObject(histname)) {
786  fHistManager.FillTH1(histname, it->second->GetMCEnergyFraction());
787  }
788 
789  histname = TString::Format("%s/fHistClusEnergy_%d", clusters->GetArrayName().Data(), fCentBin);
790  fHistManager.FillTH1(histname, it->second->E());
791 
792  if (it->second->GetNonLinCorrEnergy() > 0.) {
793  histname = TString::Format("%s/fHistClusNonLinCorrEnergy_%d", clusters->GetArrayName().Data(), fCentBin);
794  fHistManager.FillTH1(histname, it->second->GetNonLinCorrEnergy());
795  }
796 
797  if (it->second->GetHadCorrEnergy() > 0.) {
798  histname = TString::Format("%s/fHistClusHadCorrEnergy_%d", clusters->GetArrayName().Data(), fCentBin);
799  fHistManager.FillTH1(histname, it->second->GetHadCorrEnergy());
800  }
801 
802  // The following histograms are filled only for EMCal/DCal
803  if (it->second->IsEMCAL()) {
804  Double_t phi = it->first.Phi_0_2pi();
805  Int_t isDcal = Int_t(phi > fgkEMCalDCalPhiDivide);
806  if (fLeadingCluster[isDcal].E() < it->first.E()) fLeadingCluster[isDcal] = it->first;
807  fNTotClusters[isDcal]++;
808 
809  if (fCaloCells) {
810  histname = TString::Format("%s/fHistFcrossEnergy_%d", clusters->GetArrayName().Data(), fCentBin);
811  fHistManager.FillTH2(histname, it->first.E(), GetFcross(it->second, fCaloCells));
812  }
813 
814  Int_t sm = fGeom->GetSuperModuleNumber(it->second->GetCellAbsId(0));
815  if (sm >=0 && sm < 20) {
816  histname = TString::Format("%s/BySM/fHistClusEnergy_SM%d_%d", clusters->GetArrayName().Data(), sm, fCentBin);
817  fHistManager.FillTH1(histname, it->second->E());
818  }
819  else {
820  AliError(Form("Supermodule %d does not exist!", sm));
821  }
822  }
823  else if (it->second->IsPHOS()) {
824  fNTotClusters[2]++;
825  if (fLeadingCluster[2].E() < it->first.E()) fLeadingCluster[2] = it->first;
826  }
827  }
828  }
829 }
830 
831 //________________________________________________________________________
833 {
834  // Do track loop.
835 
836  Int_t neg = 0;
837  Int_t zero = 0;
838 
839  fNTotTracks = 0;
840  fLeadingTrack.SetPxPyPzE(0,0,0,0);
841 
842  TString histname;
843 
844  for (auto cont_it : fParticleCollArray) {
845  AliParticleContainer* particles = cont_it.second;
847  for (AliParticleIterableMomentumContainer::iterator it = itcont.begin(); it != itcont.end(); it++) {
848 
849  UInt_t rejectionReason = 0;
850  if (!particles->AcceptParticle(it.current_index(), rejectionReason)) {
851  histname = TString::Format("%s/fHistRejectionReason_%d", particles->GetArrayName().Data(), fCentBin);
852  fHistManager.FillTH2(histname, particles->GetRejectionReasonBitPosition(rejectionReason), it->first.Pt());
853  continue;
854  }
855 
856  fNTotTracks++;
857 
858  if (fLeadingTrack.Pt() < it->first.Pt()) fLeadingTrack = it->first;
859 
860  if (fParticleLevel) {
861  histname = TString::Format("%s/fHistTrPhiEtaPt_%d_0", particles->GetArrayName().Data(), fCentBin);
862  fHistManager.FillTH3(histname, it->first.Eta(), it->first.Phi_0_2pi(), it->first.Pt());
863  }
864  else {
865  if (it->second->GetLabel() == 0) {
866  zero++;
867  histname = TString::Format("%s/fHistTrPhiEtaZeroLab_%d", particles->GetArrayName().Data(), fCentBin);
868  if (fHistManager.FindObject(histname)) {
869 
870  fHistManager.FillTH2(histname, it->first.Eta(), it->first.Phi_0_2pi());
871 
872  }
873  histname = TString::Format("%s/fHistTrPtZeroLab_%d", particles->GetArrayName().Data(), fCentBin);
874  if (fHistManager.FindObject(histname)) {
875  fHistManager.FillTH1(histname, it->first.Pt());
876  }
877  }
878 
879  if (it->second->GetLabel() < 0) neg++;
880 
881  Int_t type = 0;
882  AliTrackContainer* tracks = dynamic_cast<AliTrackContainer*>(particles);
883  if (tracks) {
884  // Track type (hybrid)
886  type = tracks->GetTrackType(it.current_index());
887  }
888  }
889 
890  // Track propagation to EMCal surface
891  AliVTrack* vtrack = dynamic_cast<AliVTrack*>(it->second);
892  if (vtrack) {
893  if (vtrack->GetTrackEtaOnEMCal() == -999 || vtrack->GetTrackPhiOnEMCal() == -999) {
894  histname = TString::Format("%s/fHistTrPhiEtaNonProp_%d", particles->GetArrayName().Data(), fCentBin);
895  if (fHistManager.FindObject(histname)) {
896  fHistManager.FillTH2(histname, it->first.Eta(), it->first.Phi_0_2pi());
897  }
898  histname = TString::Format("%s/fHistTrPtNonProp_%d", particles->GetArrayName().Data(), fCentBin);
899  if (fHistManager.FindObject(histname)) {
900  fHistManager.FillTH1(histname, it->first.Pt());
901  }
902  }
903  else {
904  histname = TString::Format("%s/fHistTrEmcPhiEta_%d", particles->GetArrayName().Data(), fCentBin);
905  if (fHistManager.FindObject(histname))
906  fHistManager.FillTH2(histname, vtrack->GetTrackEtaOnEMCal(), vtrack->GetTrackPhiOnEMCal());
907 
908  histname = TString::Format("%s/fHistTrEmcPt_%d", particles->GetArrayName().Data(), fCentBin);
909  if (fHistManager.FindObject(histname))
910  fHistManager.FillTH1(histname, vtrack->GetTrackPtOnEMCal());
911 
912  histname = TString::Format("%s/fHistDeltaEtaPt_%d", particles->GetArrayName().Data(), fCentBin);
913  if (fHistManager.FindObject(histname))
914  fHistManager.FillTH2(histname, it->first.Pt(), it->first.Eta() - vtrack->GetTrackEtaOnEMCal());
915 
916  histname = TString::Format("%s/fHistDeltaPhiPt_%d", particles->GetArrayName().Data(), fCentBin);
917  if (fHistManager.FindObject(histname))
918  fHistManager.FillTH2(histname, it->first.Pt(), it->first.Phi_0_2pi() - vtrack->GetTrackPhiOnEMCal());
919 
920  histname = TString::Format("%s/fHistDeltaPtvsPt_%d", particles->GetArrayName().Data(), fCentBin);
921  if (fHistManager.FindObject(histname))
922  fHistManager.FillTH2(histname, it->first.Pt(), it->first.Pt() - vtrack->GetTrackPtOnEMCal());
923  }
924  }
925 
926  if (type >= 0 && type <= 3) {
927  histname = TString::Format("%s/fHistTrPhiEtaPt_%d_%d", particles->GetArrayName().Data(), fCentBin, type);
928  fHistManager.FillTH3(histname, it->first.Eta(), it->first.Phi_0_2pi(), it->first.Pt());
929  }
930  else {
931  AliWarning(Form("%s: track type %d not recognized!", GetName(), type));
932  }
933  }
934  }
935 
936  histname = TString::Format("%s/fHistTrNegativeLabels_%d", particles->GetArrayName().Data(), fCentBin);
937  if (fHistManager.FindObject(histname))
938  fHistManager.FillTH1(histname, 1. * neg / fNTotTracks);
939 
940  histname = TString::Format("%s/fHistTrZeroLabels_%d", particles->GetArrayName().Data(), fCentBin);
941  if (fHistManager.FindObject(histname))
942  fHistManager.FillTH1(histname, 1. * zero / fNTotTracks);
943  }
944 }
945 
946 //________________________________________________________________________
948 {
949  // Get the pointer to the existing analysis manager via the static access method
950  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
951  if (!mgr) {
952  ::Error("AddTaskEmcalJetQA", "No analysis manager to connect to.");
953  return NULL;
954  }
955 
956  // Check the analysis type using the event handlers connected to the analysis manager
957  AliVEventHandler* handler = mgr->GetInputEventHandler();
958  if (!handler) {
959  ::Error("AddTaskEmcalJetQA", "This task requires an input event handler");
960  return NULL;
961  }
962 
963  EDataType_t dataType = kUnknownDataType;
964 
965  if (handler->InheritsFrom("AliESDInputHandler")) {
966  dataType = kESD;
967  }
968  else if (handler->InheritsFrom("AliAODInputHandler")) {
969  dataType = kAOD;
970  }
971 
972  // Init the task and do settings
973 
974  if (ntracks == "usedefault") {
975  if (dataType == kESD) {
976  ntracks = "Tracks";
977  }
978  else if (dataType == kAOD) {
979  ntracks = "tracks";
980  }
981  else {
982  ntracks = "";
983  }
984  }
985 
986  if (nclusters == "usedefault") {
987  if (dataType == kESD) {
988  nclusters = "CaloClusters";
989  }
990  else if (dataType == kAOD) {
991  nclusters = "caloClusters";
992  }
993  else {
994  nclusters = "";
995  }
996  }
997 
998  if (ncells == "usedefault") {
999  if (dataType == kESD) {
1000  ncells = "EMCALCells";
1001  }
1002  else if (dataType == kAOD) {
1003  ncells = "emcalCells";
1004  }
1005  else {
1006  ncells = "";
1007  }
1008  }
1009 
1010  TString name("AliAnalysisTaskEmcalJetQA");
1011  if (!ntracks.IsNull()) {
1012  name += "_";
1013  name += ntracks;
1014  }
1015  if (!nclusters.IsNull()) {
1016  name += "_";
1017  name += nclusters;
1018  }
1019  if (!ncells.IsNull()) {
1020  name += "_";
1021  name += ncells;
1022  }
1023  if (!suffix.IsNull() != 0) {
1024  name += "_";
1025  name += suffix;
1026  }
1027 
1029  qaTask->SetCaloCellsName(ncells);
1030  qaTask->SetVzRange(-10,10);
1031  qaTask->AddParticleContainer(ntracks.Data());
1032  qaTask->AddClusterContainer(nclusters.Data());
1033 
1034  // Final settings, pass to manager and set the containers
1035  mgr->AddTask(qaTask);
1036 
1037  // Create containers for input/output
1038  AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer() ;
1039 
1040  TString contName = TString::Format("%s_histos", name.Data());
1041  TString commonoutput;
1042  if (subdir.IsNull()) {
1043  commonoutput = mgr->GetCommonFileName();
1044  }
1045  else {
1046  commonoutput = TString::Format("%s:%s", mgr->GetCommonFileName(), subdir.Data());
1047  }
1048 
1049  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(),
1050  TList::Class(),AliAnalysisManager::kOutputContainer,
1051  commonoutput);
1052  mgr->ConnectInput (qaTask, 0, cinput1 );
1053  mgr->ConnectOutput (qaTask, 1, coutput1 );
1054 
1055  return qaTask;
1056 }
1057 
1063 {
1064  EBeamType_t beam = BeamTypeFromRunNumber(runnumber);
1065  Int_t nCentBins = 0;
1066  if (beam == kpA || beam == kAA) nCentBins = 4;
1067  std::vector<std::string> triggerClasses = {"CINT7", "CEMC7", "CDMC7", "EG1", "EG2", "EJ1", "EJ2", "DG1", "DG2", "DJ1", "DJ2" };
1068  for (auto triggerClass : triggerClasses) {
1069  TString suffix(triggerClass.c_str());
1070  suffix.ReplaceAll("-", "_");
1071  AliAnalysisTaskEmcalJetQA* task = AddTaskEmcalJetQA("", "usedefault", "usedefault", "CaloQA_default", suffix);
1072  task->AddAcceptedTriggerClass(triggerClass.c_str());
1073  task->SetForceBeamType(beam);
1074  if (runnumber == 0 || (runnumber >= 265077 && runnumber <= 999999)) { // Run-2 p-Pb (LHC16q): disabling vertex cut
1075  task->SetVzRange(-999,999);
1076  }
1077  }
1078 }
AliClusterContainer * AddClusterContainer(std::string branchName, std::string contName="")
AliEMCALGeometry * fGeom
!emcal geometry
Float_t fMaxPt
Histogram pt limit.
EBeamType_t fBeamType
!event beam type
double Double_t
Definition: External.C:58
EDataType_t
Switch for the data type.
void FillEventQAHisto(const EventQA_t &eventQA)
Double_t fCent3
!Event centrality with method 3
const char * title
Definition: MakeQAPdf.C:27
Bool_t fSeparateEMCalDCal
Separate EMCal from DCal in QA plots.
TString fCentMethod3
Centrality method 3.
Int_t fNTotTracks
!Total number of accepted tracks in current event
Double_t fEPV0
!event plane V0
bidirectional stl iterator over the EMCAL iterable container
Container with name, TClonesArray and cuts for particles.
Double_t GetFcross(AliVCluster *cluster, AliVCaloCells *cells)
void FillTH2(const char *hname, double x, double y, double weight=1., Option_t *opt="")
Fill a 2D histogram within the container.
void FillTH3(const char *hname, double x, double y, double z, double weight=1., Option_t *opt="")
Fill a 3D histogram within the container.
Implementation of a task to perform basic QA on tracks and clusters.
Int_t fDoLeadingObjectPosition
Add axis for leading object position (eta-phi)
Double_t fV0CTotMult
!Event V0C total multiplicity
Int_t nCentBins
TString fCaloCellsName
name of calo cell collection
Int_t fNTotClusters[3]
!Total number of accepted clusters in current event (DCal/EMCal)
Bool_t fIsEmbedded
Embedded data present.
Container for particles within the EMCAL framework.
Int_t fMaxCellsInCluster
Maximum number (approx) of cells in a cluster.
Bool_t fParticleLevel
Set particle level analysis.
static AliAnalysisTaskEmcalJetQA * AddTaskEmcalJetQA(TString ntracks="usedefault", TString nclusters="usedefault", TString ncells="usedefault", TString subdir="", TString suffix="")
static Double_t fgkEMCalDCalPhiDivide
phi value used to distinguish between DCal and EMCal
EBeamType_t fForceBeamType
forced beam type
static void AddTaskEmcalJetQA_QAtrain(Int_t runnumber)
const Int_t nPtBins
THistManager fHistManager
Histogram manager.
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
void AddAcceptedTriggerClass(const char *trigClass)
unsigned int UInt_t
Definition: External.C:33
THashList * GetListOfHistograms() const
Get the list of histograms.
Definition: THistManager.h:671
float Float_t
Definition: External.C:68
Int_t fDoV0QA
Add V0 QA histograms.
Base task in the EMCAL framework (lighter version of AliAnalysisTaskEmcal)
Double_t Phi_0_2pi() const
Double_t fVertex[3]
!event vertex
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
Create a new TH1 within the container.
TString fCentMethod2
Centrality method 2.
virtual Bool_t AcceptCluster(Int_t i, UInt_t &rejectionReason) const
Declaration of class AliAnalysisTaskEmcalJetQA.
ETrackFilterType_t GetTrackFilterType() const
Int_t fCentBin
!event centrality bin
virtual Bool_t AcceptParticle(const AliVParticle *vp, UInt_t &rejectionReason) const
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
Fill a 1D histogram within the container.
AliTLorentzVector fLeadingCluster[3]
!Leading cluster in current event (EMCal/DCal)
Int_t fDoEPQA
Add event plane QA histograms.
const AliClusterIterableMomentumContainer all_momentum() const
static EBeamType_t BeamTypeFromRunNumber(Int_t runnumber)
AliParticleContainer * AddParticleContainer(std::string branchName, std::string contName="")
Char_t GetTrackType(const AliVTrack *track) const
Definition: External.C:220
std::map< std::string, AliParticleContainer * > fParticleCollArray
particle/track collection array
void SetVzRange(Double_t min, Double_t max)
Double_t fCent2
!Event centrality with method 2
Float_t fPtBinWidth
Histogram pt bin width.
Float_t fCellEnergyCut
Energy cell cut.
const Int_t nbins
bool Bool_t
Definition: External.C:53
std::map< std::string, AliClusterContainer * > fClusterCollArray
cluster collection array
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.
EBeamType_t
Switch for the beam type.
AliTLorentzVector fLeadingTrack
!Leading track in current event
Double_t fV0ATotMult
!Event V0A total multiplicity
Container structure for EMCAL clusters.
AliVVZERO * fVZERO
!Event V0 object
const AliParticleIterableMomentumContainer all_momentum() const
Double_t fCent
!event centrality
TH3 * CreateTH3(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, int nbinsz, double zmin, double zmax, Option_t *opt="")
Create a new TH2 within the container.
Bool_t fNeedEmcalGeom
whether or not the task needs the emcal geometry