AliPhysics  b3a51e4 (b3a51e4)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalJetSample.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 
21 #include <AliVCluster.h>
22 #include <AliVParticle.h>
23 #include <AliLog.h>
24 
25 #include "AliTLorentzVector.h"
26 #include "AliEmcalJet.h"
27 #include "AliRhoParameter.h"
28 #include "AliJetContainer.h"
29 #include "AliParticleContainer.h"
30 #include "AliClusterContainer.h"
31 
32 #include "AliAnalysisTaskEmcalJetSample.h"
33 
35 ClassImp(AliAnalysisTaskEmcalJetSample);
37 
41 AliAnalysisTaskEmcalJetSample::AliAnalysisTaskEmcalJetSample() :
42  AliAnalysisTaskEmcalJet(),
43  fHistManager()
44 {
45 }
46 
52 AliAnalysisTaskEmcalJetSample::AliAnalysisTaskEmcalJetSample(const char *name) :
53  AliAnalysisTaskEmcalJet(name, kTRUE),
54  fHistManager(name)
55 {
56  SetMakeGeneralHistograms(kTRUE);
57 }
58 
62 AliAnalysisTaskEmcalJetSample::~AliAnalysisTaskEmcalJetSample()
63 {
64 }
65 
70 void AliAnalysisTaskEmcalJetSample::UserCreateOutputObjects()
71 {
72  AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
73 
74  AllocateClusterHistograms();
75  AllocateTrackHistograms();
76  AllocateJetHistograms();
77  AllocateCellHistograms();
78 
79  TIter next(fHistManager.GetListOfHistograms());
80  TObject* obj = 0;
81  while ((obj = next())) {
82  fOutput->Add(obj);
83  }
84 
85  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
86 }
87 
88 /*
89  * This function allocates the histograms for basic EMCal cluster QA.
90  * A set of histograms (energy, eta, phi, number of cluster) is allocated
91  * per each cluster container and per each centrality bin.
92  */
93 void AliAnalysisTaskEmcalJetSample::AllocateClusterHistograms()
94 {
95  TString histname;
96  TString histtitle;
97  TString groupname;
98  AliClusterContainer* clusCont = 0;
99  TIter next(&fClusterCollArray);
100  while ((clusCont = static_cast<AliClusterContainer*>(next()))) {
101  groupname = clusCont->GetName();
102  fHistManager.CreateHistoGroup(groupname);
103  for (Int_t cent = 0; cent < fNcentBins; cent++) {
104  histname = TString::Format("%s/histClusterEnergy_%d", groupname.Data(), cent);
105  histtitle = TString::Format("%s;#it{E}_{cluster} (GeV);counts", histname.Data());
106  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
107 
108  histname = TString::Format("%s/histClusterEnergyExotic_%d", groupname.Data(), cent);
109  histtitle = TString::Format("%s;#it{E}_{cluster}^{exotic} (GeV);counts", histname.Data());
110  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
111 
112  histname = TString::Format("%s/histClusterNonLinCorrEnergy_%d", groupname.Data(), cent);
113  histtitle = TString::Format("%s;#it{E}_{cluster}^{non-lin.corr.} (GeV);counts", histname.Data());
114  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
115 
116  histname = TString::Format("%s/histClusterHadCorrEnergy_%d", groupname.Data(), cent);
117  histtitle = TString::Format("%s;#it{E}_{cluster}^{had.corr.} (GeV);counts", histname.Data());
118  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
119 
120  histname = TString::Format("%s/histClusterPhi_%d", groupname.Data(), cent);
121  histtitle = TString::Format("%s;#it{#phi}_{custer};counts", histname.Data());
122  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, 0, TMath::TwoPi());
123 
124  histname = TString::Format("%s/histClusterEta_%d", groupname.Data(), cent);
125  histtitle = TString::Format("%s;#it{#eta}_{custer};counts", histname.Data());
126  fHistManager.CreateTH1(histname, histtitle, fNbins / 6, -1, 1);
127 
128  histname = TString::Format("%s/histNClusters_%d", groupname.Data(), cent);
129  histtitle = TString::Format("%s;number of clusters;events", histname.Data());
130  if (fForceBeamType != kpp) {
131  fHistManager.CreateTH1(histname, histtitle, 500, 0, 3000);
132  }
133  else {
134  fHistManager.CreateTH1(histname, histtitle, 200, 0, 200);
135  }
136  }
137  }
138 }
139 
140 /*
141  * This function allocates the histograms for basic EMCal QA.
142  * One 2D histogram with the cell energy spectra and the number of cells
143  * per event is allocated per each centrality bin.
144  */
145 void AliAnalysisTaskEmcalJetSample::AllocateCellHistograms()
146 {
147  TString histname;
148  TString histtitle;
149  TString groupname(fCaloCellsName);
150 
151  fHistManager.CreateHistoGroup(groupname);
152  for (Int_t cent = 0; cent < fNcentBins; cent++) {
153  histname = TString::Format("%s/histCellEnergyvsAbsId_%d", groupname.Data(), cent);
154  histtitle = TString::Format("%s;cell abs. ID;#it{E}_{cell} (GeV);counts", histname.Data());
155  fHistManager.CreateTH2(histname, histtitle, 20000, 0, 20000, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
156 
157  histname = TString::Format("%s/histNCells_%d", groupname.Data(), cent);
158  histtitle = TString::Format("%s;number of cells;events", histname.Data());
159  if (fForceBeamType != kpp) {
160  fHistManager.CreateTH1(histname, histtitle, 500, 0, 6000);
161  }
162  else {
163  fHistManager.CreateTH1(histname, histtitle, 200, 0, 200);
164  }
165  }
166 }
167 
168 /*
169  * This function allocates the histograms for basic tracking QA.
170  * A set of histograms (pT, eta, phi, difference between kinematic properties
171  * at the vertex and at the EMCal surface, number of tracks) is allocated
172  * per each particle container and per each centrality bin.
173  */
174 void AliAnalysisTaskEmcalJetSample::AllocateTrackHistograms()
175 {
176  TString histname;
177  TString histtitle;
178  TString groupname;
179  AliParticleContainer* partCont = 0;
180  TIter next(&fParticleCollArray);
181  while ((partCont = static_cast<AliParticleContainer*>(next()))) {
182  groupname = partCont->GetName();
183  fHistManager.CreateHistoGroup(groupname);
184  for (Int_t cent = 0; cent < fNcentBins; cent++) {
185  histname = TString::Format("%s/histTrackPt_%d", groupname.Data(), cent);
186  histtitle = TString::Format("%s;#it{p}_{T,track} (GeV/#it{c});counts", histname.Data());
187  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
188 
189  histname = TString::Format("%s/histTrackPhi_%d", groupname.Data(), cent);
190  histtitle = TString::Format("%s;#it{#phi}_{track};counts", histname.Data());
191  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, 0, TMath::TwoPi());
192 
193  histname = TString::Format("%s/histTrackEta_%d", groupname.Data(), cent);
194  histtitle = TString::Format("%s;#it{#eta}_{track};counts", histname.Data());
195  fHistManager.CreateTH1(histname, histtitle, fNbins / 6, -1, 1);
196 
197  if (TClass(partCont->GetClassName()).InheritsFrom("AliVTrack")) {
198  histname = TString::Format("%s/fHistDeltaEtaPt_%d", groupname.Data(), cent);
199  histtitle = TString::Format("%s;#it{p}_{T,track}^{vertex} (GeV/#it{c});#it{#eta}_{track}^{vertex} - #it{#eta}_{track}^{EMCal};counts", histname.Data());
200  fHistManager.CreateTH2(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt, 50, -0.5, 0.5);
201 
202  histname = TString::Format("%s/fHistDeltaPhiPt_%d", groupname.Data(), cent);
203  histtitle = TString::Format("%s;#it{p}_{T,track}^{vertex} (GeV/#it{c});#it{#phi}_{track}^{vertex} - #it{#phi}_{track}^{EMCal};counts", histname.Data());
204  fHistManager.CreateTH2(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt, 200, -2, 2);
205 
206  histname = TString::Format("%s/fHistDeltaPtvsPt_%d", groupname.Data(), cent);
207  histtitle = TString::Format("%s;#it{p}_{T,track}^{vertex} (GeV/#it{c});#it{p}_{T,track}^{vertex} - #it{p}_{T,track}^{EMCal} (GeV/#it{c});counts", histname.Data());
208  fHistManager.CreateTH2(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt, fNbins / 2, -fMaxBinPt/2, fMaxBinPt/2);
209 
210  histname = TString::Format("%s/fHistEoverPvsP_%d", groupname.Data(), cent);
211  histtitle = TString::Format("%s;#it{P}_{track} (GeV/#it{c});#it{E}_{cluster} / #it{P}_{track} #it{c};counts", histname.Data());
212  fHistManager.CreateTH2(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt, fNbins / 2, 0, 4);
213  }
214 
215  histname = TString::Format("%s/histNTracks_%d", groupname.Data(), cent);
216  histtitle = TString::Format("%s;number of tracks;events", histname.Data());
217  if (fForceBeamType != kpp) {
218  fHistManager.CreateTH1(histname, histtitle, 500, 0, 5000);
219  }
220  else {
221  fHistManager.CreateTH1(histname, histtitle, 200, 0, 200);
222  }
223  }
224  }
225 }
226 
227 /*
228  * This function allocates the histograms for basic jet QA.
229  * A set of histograms (pT, eta, phi, area, number of jets, corrected pT) is allocated
230  * per each jet container and per each centrality bin.
231  */
232 void AliAnalysisTaskEmcalJetSample::AllocateJetHistograms()
233 {
234  TString histname;
235  TString histtitle;
236  TString groupname;
237  AliJetContainer* jetCont = 0;
238  TIter next(&fJetCollArray);
239  while ((jetCont = static_cast<AliJetContainer*>(next()))) {
240  groupname = jetCont->GetName();
241  fHistManager.CreateHistoGroup(groupname);
242  for (Int_t cent = 0; cent < fNcentBins; cent++) {
243  histname = TString::Format("%s/histJetPt_%d", groupname.Data(), cent);
244  histtitle = TString::Format("%s;#it{p}_{T,jet} (GeV/#it{c});counts", histname.Data());
245  fHistManager.CreateTH1(histname, histtitle, fNbins, fMinBinPt, fMaxBinPt);
246 
247  histname = TString::Format("%s/histJetArea_%d", groupname.Data(), cent);
248  histtitle = TString::Format("%s;#it{A}_{jet};counts", histname.Data());
249  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, 0, 3);
250 
251  histname = TString::Format("%s/histJetPhi_%d", groupname.Data(), cent);
252  histtitle = TString::Format("%s;#it{#phi}_{jet};counts", histname.Data());
253  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, 0, TMath::TwoPi());
254 
255  histname = TString::Format("%s/histJetEta_%d", groupname.Data(), cent);
256  histtitle = TString::Format("%s;#it{#eta}_{jet};counts", histname.Data());
257  fHistManager.CreateTH1(histname, histtitle, fNbins / 6, -1, 1);
258 
259  histname = TString::Format("%s/histNJets_%d", groupname.Data(), cent);
260  histtitle = TString::Format("%s;number of jets;events", histname.Data());
261  if (fForceBeamType != kpp) {
262  fHistManager.CreateTH1(histname, histtitle, 500, 0, 500);
263  }
264  else {
265  fHistManager.CreateTH1(histname, histtitle, 100, 0, 100);
266  }
267 
268  if (!jetCont->GetRhoName().IsNull()) {
269  histname = TString::Format("%s/histJetCorrPt_%d", groupname.Data(), cent);
270  histtitle = TString::Format("%s;#it{p}_{T,jet}^{corr} (GeV/#it{c});counts", histname.Data());
271  fHistManager.CreateTH1(histname, histtitle, fNbins, -fMaxBinPt / 2, fMaxBinPt / 2);
272  }
273  }
274  }
275 }
276 
283 Bool_t AliAnalysisTaskEmcalJetSample::FillHistograms()
284 {
285  DoJetLoop();
286  DoTrackLoop();
287  DoClusterLoop();
288  DoCellLoop();
289 
290  return kTRUE;
291 }
292 
297 void AliAnalysisTaskEmcalJetSample::DoJetLoop()
298 {
299  TString histname;
300  TString groupname;
301  AliJetContainer* jetCont = 0;
302  TIter next(&fJetCollArray);
303  while ((jetCont = static_cast<AliJetContainer*>(next()))) {
304  groupname = jetCont->GetName();
305  UInt_t count = 0;
306  for(auto it : jetCont->accepted()) {
307  count++;
308  const AliEmcalJet* jet = static_cast<const AliEmcalJet*>(it);
309 
310  histname = TString::Format("%s/histJetPt_%d", groupname.Data(), fCentBin);
311  fHistManager.FillTH1(histname, jet->Pt());
312 
313  histname = TString::Format("%s/histJetArea_%d", groupname.Data(), fCentBin);
314  fHistManager.FillTH1(histname, jet->Area());
315 
316  histname = TString::Format("%s/histJetPhi_%d", groupname.Data(), fCentBin);
317  fHistManager.FillTH1(histname, jet->Phi());
318 
319  histname = TString::Format("%s/histJetEta_%d", groupname.Data(), fCentBin);
320  fHistManager.FillTH1(histname, jet->Eta());
321 
322  if (jetCont->GetRhoParameter()) {
323  histname = TString::Format("%s/histJetCorrPt_%d", groupname.Data(), fCentBin);
324  fHistManager.FillTH1(histname, jet->Pt() - jetCont->GetRhoVal() * jet->Area());
325  }
326  }
327  histname = TString::Format("%s/histNJets_%d", groupname.Data(), fCentBin);
328  fHistManager.FillTH1(histname, count);
329  }
330 }
331 
336 void AliAnalysisTaskEmcalJetSample::DoTrackLoop()
337 {
338  AliClusterContainer* clusCont = GetClusterContainer(0);
339 
340  TString histname;
341  TString groupname;
342  AliParticleContainer* partCont = 0;
343  TIter next(&fParticleCollArray);
344  while ((partCont = static_cast<AliParticleContainer*>(next()))) {
345  groupname = partCont->GetName();
346  UInt_t count = 0;
347  for(auto it : partCont->accepted()) {
348  count++;
349  const AliVParticle* part = static_cast<const AliVParticle*>(it);
350 
351  histname = TString::Format("%s/histTrackPt_%d", groupname.Data(), fCentBin);
352  fHistManager.FillTH1(histname, part->Pt());
353 
354  histname = TString::Format("%s/histTrackPhi_%d", groupname.Data(), fCentBin);
355  fHistManager.FillTH1(histname, part->Phi());
356 
357  histname = TString::Format("%s/histTrackEta_%d", groupname.Data(), fCentBin);
358  fHistManager.FillTH1(histname, part->Eta());
359 
360  if (partCont->GetLoadedClass()->InheritsFrom("AliVTrack")) {
361  const AliVTrack* track = static_cast<const AliVTrack*>(part);
362 
363  histname = TString::Format("%s/fHistDeltaEtaPt_%d", groupname.Data(), fCentBin);
364  fHistManager.FillTH1(histname, track->Pt(), track->Eta() - track->GetTrackEtaOnEMCal());
365 
366  histname = TString::Format("%s/fHistDeltaPhiPt_%d", groupname.Data(), fCentBin);
367  fHistManager.FillTH1(histname, track->Pt(), track->Phi() - track->GetTrackPhiOnEMCal());
368 
369  histname = TString::Format("%s/fHistDeltaPtvsPt_%d", groupname.Data(), fCentBin);
370  fHistManager.FillTH1(histname, track->Pt(), track->Pt() - track->GetTrackPtOnEMCal());
371 
372  if (clusCont) {
373  Int_t iCluster = track->GetEMCALcluster();
374  if (iCluster >= 0) {
375  AliVCluster* cluster = clusCont->GetAcceptCluster(iCluster);
376  if (cluster) {
377  histname = TString::Format("%s/fHistEoverPvsP_%d", groupname.Data(), fCentBin);
378  fHistManager.FillTH2(histname, track->P(), cluster->GetNonLinCorrEnergy() / track->P());
379  }
380  }
381  }
382  }
383  }
384 
385  histname = TString::Format("%s/histNTracks_%d", groupname.Data(), fCentBin);
386  fHistManager.FillTH1(histname, count);
387  }
388 }
389 
394 void AliAnalysisTaskEmcalJetSample::DoClusterLoop()
395 {
396  TString histname;
397  TString groupname;
398  AliClusterContainer* clusCont = 0;
399  TIter next(&fClusterCollArray);
400  while ((clusCont = static_cast<AliClusterContainer*>(next()))) {
401  groupname = clusCont->GetName();
402 
403  for(auto it : clusCont->all()) {
404  const AliVCluster* cluster = static_cast<const AliVCluster*>(it);
405 
406  if (cluster->GetIsExotic()) {
407  histname = TString::Format("%s/histClusterEnergyExotic_%d", groupname.Data(), fCentBin);
408  fHistManager.FillTH1(histname, cluster->E());
409  }
410  }
411 
412  UInt_t count = 0;
413  for(auto it : clusCont->accepted()) {
414  count++;
415  const AliVCluster* cluster = static_cast<const AliVCluster*>(it);
416  AliTLorentzVector nPart;
417  cluster->GetMomentum(nPart, fVertex);
418 
419  histname = TString::Format("%s/histClusterEnergy_%d", groupname.Data(), fCentBin);
420  fHistManager.FillTH1(histname, cluster->E());
421 
422  histname = TString::Format("%s/histClusterNonLinCorrEnergy_%d", groupname.Data(), fCentBin);
423  fHistManager.FillTH1(histname, cluster->GetNonLinCorrEnergy());
424 
425  histname = TString::Format("%s/histClusterHadCorrEnergy_%d", groupname.Data(), fCentBin);
426  fHistManager.FillTH1(histname, cluster->GetHadCorrEnergy());
427 
428  histname = TString::Format("%s/histClusterPhi_%d", groupname.Data(), fCentBin);
429  fHistManager.FillTH1(histname, nPart.Phi_0_2pi());
430 
431  histname = TString::Format("%s/histClusterEta_%d", groupname.Data(), fCentBin);
432  fHistManager.FillTH1(histname, nPart.Eta());
433  }
434 
435  histname = TString::Format("%s/histNClusters_%d", groupname.Data(), fCentBin);
436  fHistManager.FillTH1(histname, count);
437  }
438 }
439 
444 void AliAnalysisTaskEmcalJetSample::DoCellLoop()
445 {
446  if (!fCaloCells) return;
447 
448  TString histname;
449 
450  const Short_t ncells = fCaloCells->GetNumberOfCells();
451 
452  histname = TString::Format("%s/histNCells_%d", fCaloCellsName.Data(), fCentBin);
453  fHistManager.FillTH1(histname, ncells);
454 
455  histname = TString::Format("%s/histCellEnergyvsAbsId_%d", fCaloCellsName.Data(), fCentBin);
456  for (Short_t pos = 0; pos < ncells; pos++) {
457  Double_t amp = fCaloCells->GetAmplitude(pos);
458  Short_t absId = fCaloCells->GetCellNumber(pos);
459 
460  fHistManager.FillTH2(histname, absId, amp);
461  }
462 }
463 
468 void AliAnalysisTaskEmcalJetSample::ExecOnce()
469 {
470  AliAnalysisTaskEmcalJet::ExecOnce();
471 }
472 
480 Bool_t AliAnalysisTaskEmcalJetSample::Run()
481 {
482  return kTRUE;
483 }
484 
488 void AliAnalysisTaskEmcalJetSample::Terminate(Option_t *)
489 {
490 }
ClassImp
ClassImp(AliAnalysisTaskTriggerRates) AliAnalysisTaskTriggerRates
Definition: AliAnalysisTaskTriggerRates.cxx:34
AliEmcalJet::Area
Double_t Area() const
Definition: AliEmcalJet.h:97
AliAnalysisTaskEmcal::fClusterCollArray
TObjArray fClusterCollArray
cluster collection array
Definition: AliAnalysisTaskEmcal.h:279
AliJetContainer::GetRhoVal
Double_t GetRhoVal() const
Definition: AliJetContainer.h:153
AliJetContainer::GetRhoName
const TString & GetRhoName() const
Definition: AliJetContainer.h:154
AliEmcalJet::Eta
Double_t Eta() const
Definition: AliEmcalJet.h:88
AliAnalysisTaskEmcalJetSample.h
Declaration of class AliAnalysisTaskEmcalJetSample.
AliEmcalJet::Phi
Double_t Phi() const
Definition: AliEmcalJet.h:84
AliAnalysisTaskEmcal::fMinBinPt
Double_t fMinBinPt
min pt in histograms
Definition: AliAnalysisTaskEmcal.h:264
AliAnalysisTaskEmcal::fCentBin
Int_t fCentBin
!event centrality bin
Definition: AliAnalysisTaskEmcal.h:300
AliAnalysisTaskEmcalJetSample
Implementation of a sample jet analysis task.
Definition: AliAnalysisTaskEmcalJetSample.h:34
AliParticleContainer
Container for particles within the EMCAL framework.
Definition: AliParticleContainer.h:25
AliAnalysisTaskEmcal::fParticleCollArray
TObjArray fParticleCollArray
particle/track collection array
Definition: AliAnalysisTaskEmcal.h:278
AliClusterContainer::all
const AliClusterIterableContainer all() const
Definition: AliClusterContainer.cxx:419
AliParticleContainer.h
AliAnalysisTaskEmcal::fForceBeamType
BeamType fForceBeamType
forced beam type
Definition: AliAnalysisTaskEmcal.h:243
AliAnalysisTaskEmcal::fNcentBins
Int_t fNcentBins
how many centrality bins
Definition: AliAnalysisTaskEmcal.h:276
AliAnalysisTaskEmcal::GetClusterContainer
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Definition: AliAnalysisTaskEmcal.cxx:1571
AliJetContainer.h
AliClusterContainer::GetAcceptCluster
AliVCluster * GetAcceptCluster(Int_t i) const
Definition: AliClusterContainer.cxx:125
AliClusterContainer::accepted
const AliClusterIterableContainer accepted() const
Definition: AliClusterContainer.cxx:428
AliAnalysisTaskEmcal::fCaloCellsName
TString fCaloCellsName
name of calo cell collection
Definition: AliAnalysisTaskEmcal.h:247
AliRhoParameter.h
AliAnalysisTaskEmcalJet::fJetCollArray
TObjArray fJetCollArray
jet collection array
Definition: AliAnalysisTaskEmcalJet.h:97
AliAnalysisTaskEmcal::fCaloCells
AliVCaloCells * fCaloCells
!cells
Definition: AliAnalysisTaskEmcal.h:296
AliJetContainer::GetRhoParameter
AliRhoParameter * GetRhoParameter()
Definition: AliJetContainer.h:152
AliEmcalJet::Pt
Double_t Pt() const
Definition: AliEmcalJet.h:76
AliAnalysisTaskEmcal::fOutput
AliEmcalList * fOutput
!output list
Definition: AliAnalysisTaskEmcal.h:317
AliAnalysisTaskEmcal::fMaxBinPt
Double_t fMaxBinPt
max pt in histograms
Definition: AliAnalysisTaskEmcal.h:265
AliAnalysisTaskEmcalJetSample::fHistManager
THistManager fHistManager
Histogram manager.
Definition: AliAnalysisTaskEmcalJetSample.h:59
AliAnalysisTaskEmcal::fVertex
Double_t fVertex[3]
!event vertex
Definition: AliAnalysisTaskEmcal.h:304
AliAnalysisTaskEmcal::SetMakeGeneralHistograms
void SetMakeGeneralHistograms(Bool_t g)
Definition: AliAnalysisTaskEmcal.h:148
AliAnalysisTaskEmcalJet
Base task in the EMCAL jet framework.
Definition: AliAnalysisTaskEmcalJet.h:30
AliEmcalJet
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
AliParticleContainer::accepted
const AliParticleIterableContainer accepted() const
Definition: AliParticleContainer.cxx:432
AliJetContainer::accepted
const AliJetIterableContainer accepted() const
Definition: AliJetContainer.cxx:1063
AliClusterContainer
Container structure for EMCAL clusters.
Definition: AliClusterContainer.h:26
AliEmcalJet.h
AliJetContainer
Container for jet within the EMCAL jet framework.
Definition: AliJetContainer.h:34
AliAnalysisTaskEmcal::fNbins
Int_t fNbins
no. of pt bins
Definition: AliAnalysisTaskEmcal.h:263
AliClusterContainer.h