AliPhysics  97a96ce (97a96ce)
 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 
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 "AliAnalysisTaskEmcalDijetImbalance.h"
33 
35 ClassImp(AliAnalysisTaskEmcalDijetImbalance);
37 
41 AliAnalysisTaskEmcalDijetImbalance::AliAnalysisTaskEmcalDijetImbalance() :
42  AliAnalysisTaskEmcalJet(),
43  fHistManager()
44 {
45 }
46 
52 AliAnalysisTaskEmcalDijetImbalance::AliAnalysisTaskEmcalDijetImbalance(const char *name) :
53  AliAnalysisTaskEmcalJet(name, kTRUE),
54  fHistManager(name)
55 {
56  SetMakeGeneralHistograms(kTRUE);
57 }
58 
62 AliAnalysisTaskEmcalDijetImbalance::~AliAnalysisTaskEmcalDijetImbalance()
63 {
64 }
65 
70 void AliAnalysisTaskEmcalDijetImbalance::UserCreateOutputObjects()
71 {
72  AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
73 
74  AllocateClusterHistograms();
75  AllocateTrackHistograms();
76  AllocateJetHistograms();
77  AllocateCellHistograms();
78  AllocateDijetHistograms();
79 
80  TIter next(fHistManager.GetListOfHistograms());
81  TObject* obj = 0;
82  while ((obj = next())) {
83  fOutput->Add(obj);
84  }
85 
86  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
87 }
88 
89 /*
90  * This function allocates the histograms for basic EMCal cluster QA.
91  * A set of histograms (energy, eta, phi, number of cluster) is allocated
92  * per each cluster container and per each centrality bin.
93  */
94 void AliAnalysisTaskEmcalDijetImbalance::AllocateClusterHistograms()
95 {
96  TString histname;
97  TString histtitle;
98  TString groupname;
99  AliClusterContainer* clusCont = 0;
100  TIter next(&fClusterCollArray);
101  while ((clusCont = static_cast<AliClusterContainer*>(next()))) {
102  groupname = clusCont->GetName();
103  fHistManager.CreateHistoGroup(groupname);
104  for (Int_t cent = 0; cent < fNcentBins; cent++) {
105  histname = TString::Format("%s/histClusterEnergy_%d", groupname.Data(), cent);
106  histtitle = TString::Format("%s;#it{E}_{cluster} (GeV);counts", histname.Data());
107  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
108 
109  histname = TString::Format("%s/histClusterEnergyExotic_%d", groupname.Data(), cent);
110  histtitle = TString::Format("%s;#it{E}_{cluster}^{exotic} (GeV);counts", histname.Data());
111  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
112 
113  histname = TString::Format("%s/histClusterNonLinCorrEnergy_%d", groupname.Data(), cent);
114  histtitle = TString::Format("%s;#it{E}_{cluster}^{non-lin.corr.} (GeV);counts", histname.Data());
115  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
116 
117  histname = TString::Format("%s/histClusterHadCorrEnergy_%d", groupname.Data(), cent);
118  histtitle = TString::Format("%s;#it{E}_{cluster}^{had.corr.} (GeV);counts", histname.Data());
119  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
120 
121  histname = TString::Format("%s/histClusterPhi_%d", groupname.Data(), cent);
122  histtitle = TString::Format("%s;#it{#phi}_{custer};counts", histname.Data());
123  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, 0, TMath::TwoPi());
124 
125  histname = TString::Format("%s/histClusterEta_%d", groupname.Data(), cent);
126  histtitle = TString::Format("%s;#it{#eta}_{custer};counts", histname.Data());
127  fHistManager.CreateTH1(histname, histtitle, fNbins / 6, -1, 1);
128 
129  histname = TString::Format("%s/histNClusters_%d", groupname.Data(), cent);
130  histtitle = TString::Format("%s;number of clusters;events", histname.Data());
131  if (fForceBeamType != kpp) {
132  fHistManager.CreateTH1(histname, histtitle, 500, 0, 3000);
133  }
134  else {
135  fHistManager.CreateTH1(histname, histtitle, 200, 0, 200);
136  }
137  }
138  }
139 }
140 
141 /*
142  * This function allocates the histograms for basic EMCal QA.
143  * One 2D histogram with the cell energy spectra and the number of cells
144  * per event is allocated per each centrality bin.
145  */
146 void AliAnalysisTaskEmcalDijetImbalance::AllocateCellHistograms()
147 {
148  TString histname;
149  TString histtitle;
150  TString groupname(fCaloCellsName);
151 
152  fHistManager.CreateHistoGroup(groupname);
153  for (Int_t cent = 0; cent < fNcentBins; cent++) {
154  histname = TString::Format("%s/histCellEnergyvsAbsId_%d", groupname.Data(), cent);
155  histtitle = TString::Format("%s;cell abs. ID;#it{E}_{cell} (GeV);counts", histname.Data());
156  fHistManager.CreateTH2(histname, histtitle, 20000, 0, 20000, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
157 
158  histname = TString::Format("%s/histNCells_%d", groupname.Data(), cent);
159  histtitle = TString::Format("%s;number of cells;events", histname.Data());
160  if (fForceBeamType != kpp) {
161  fHistManager.CreateTH1(histname, histtitle, 500, 0, 6000);
162  }
163  else {
164  fHistManager.CreateTH1(histname, histtitle, 200, 0, 200);
165  }
166  }
167 }
168 
169 /*
170  * This function allocates the histograms for basic tracking QA.
171  * A set of histograms (pT, eta, phi, difference between kinematic properties
172  * at the vertex and at the EMCal surface, number of tracks) is allocated
173  * per each particle container and per each centrality bin.
174  */
175 void AliAnalysisTaskEmcalDijetImbalance::AllocateTrackHistograms()
176 {
177  TString histname;
178  TString histtitle;
179  TString groupname;
180  AliParticleContainer* partCont = 0;
181  TIter next(&fParticleCollArray);
182  while ((partCont = static_cast<AliParticleContainer*>(next()))) {
183  groupname = partCont->GetName();
184  fHistManager.CreateHistoGroup(groupname);
185  for (Int_t cent = 0; cent < fNcentBins; cent++) {
186  histname = TString::Format("%s/histTrackPt_%d", groupname.Data(), cent);
187  histtitle = TString::Format("%s;#it{p}_{T,track} (GeV/#it{c});counts", histname.Data());
188  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
189 
190  histname = TString::Format("%s/histTrackPhi_%d", groupname.Data(), cent);
191  histtitle = TString::Format("%s;#it{#phi}_{track};counts", histname.Data());
192  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, 0, TMath::TwoPi());
193 
194  histname = TString::Format("%s/histTrackEta_%d", groupname.Data(), cent);
195  histtitle = TString::Format("%s;#it{#eta}_{track};counts", histname.Data());
196  fHistManager.CreateTH1(histname, histtitle, fNbins / 6, -1, 1);
197 
198  if (TClass(partCont->GetClassName()).InheritsFrom("AliVTrack")) {
199  histname = TString::Format("%s/fHistDeltaEtaPt_%d", groupname.Data(), cent);
200  histtitle = TString::Format("%s;#it{p}_{T,track}^{vertex} (GeV/#it{c});#it{#eta}_{track}^{vertex} - #it{#eta}_{track}^{EMCal};counts", histname.Data());
201  fHistManager.CreateTH2(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt, 50, -0.5, 0.5);
202 
203  histname = TString::Format("%s/fHistDeltaPhiPt_%d", groupname.Data(), cent);
204  histtitle = TString::Format("%s;#it{p}_{T,track}^{vertex} (GeV/#it{c});#it{#phi}_{track}^{vertex} - #it{#phi}_{track}^{EMCal};counts", histname.Data());
205  fHistManager.CreateTH2(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt, 200, -2, 2);
206 
207  histname = TString::Format("%s/fHistDeltaPtvsPt_%d", groupname.Data(), cent);
208  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());
209  fHistManager.CreateTH2(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt, fNbins / 2, -fMaxBinPt/2, fMaxBinPt/2);
210 
211  histname = TString::Format("%s/fHistEoverPvsP_%d", groupname.Data(), cent);
212  histtitle = TString::Format("%s;#it{P}_{track} (GeV/#it{c});#it{E}_{cluster} / #it{P}_{track} #it{c};counts", histname.Data());
213  fHistManager.CreateTH2(histname, histtitle, fNbins / 2, fMinBinPt, fMaxBinPt, fNbins / 2, 0, 4);
214  }
215 
216  histname = TString::Format("%s/histNTracks_%d", groupname.Data(), cent);
217  histtitle = TString::Format("%s;number of tracks;events", histname.Data());
218  if (fForceBeamType != kpp) {
219  fHistManager.CreateTH1(histname, histtitle, 500, 0, 5000);
220  }
221  else {
222  fHistManager.CreateTH1(histname, histtitle, 200, 0, 200);
223  }
224  }
225  }
226 }
227 
228 /*
229  * This function allocates the histograms for basic jet QA.
230  * A set of histograms (pT, eta, phi, area, number of jets, corrected pT) is allocated
231  * per each jet container and per each centrality bin.
232  */
233 void AliAnalysisTaskEmcalDijetImbalance::AllocateJetHistograms()
234 {
235  TString histname;
236  TString histtitle;
237  TString groupname;
238  AliJetContainer* jetCont = 0;
239  TIter next(&fJetCollArray);
240  while ((jetCont = static_cast<AliJetContainer*>(next()))) {
241  groupname = jetCont->GetName();
242  fHistManager.CreateHistoGroup(groupname);
243  for (Int_t cent = 0; cent < fNcentBins; cent++) {
244  histname = TString::Format("%s/histJetPt_%d", groupname.Data(), cent);
245  histtitle = TString::Format("%s;#it{p}_{T,jet} (GeV/#it{c});counts", histname.Data());
246  fHistManager.CreateTH1(histname, histtitle, fNbins, fMinBinPt, fMaxBinPt);
247 
248  histname = TString::Format("%s/histJetArea_%d", groupname.Data(), cent);
249  histtitle = TString::Format("%s;#it{A}_{jet};counts", histname.Data());
250  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, 0, 3);
251 
252  histname = TString::Format("%s/histJetPhi_%d", groupname.Data(), cent);
253  histtitle = TString::Format("%s;#it{#phi}_{jet};counts", histname.Data());
254  fHistManager.CreateTH1(histname, histtitle, fNbins / 2, 0, TMath::TwoPi());
255 
256  histname = TString::Format("%s/histJetEta_%d", groupname.Data(), cent);
257  histtitle = TString::Format("%s;#it{#eta}_{jet};counts", histname.Data());
258  fHistManager.CreateTH1(histname, histtitle, fNbins / 6, -1, 1);
259 
260  histname = TString::Format("%s/histNJets_%d", groupname.Data(), cent);
261  histtitle = TString::Format("%s;number of jets;events", histname.Data());
262  if (fForceBeamType != kpp) {
263  fHistManager.CreateTH1(histname, histtitle, 500, 0, 500);
264  }
265  else {
266  fHistManager.CreateTH1(histname, histtitle, 100, 0, 100);
267  }
268 
269  if (!jetCont->GetRhoName().IsNull()) {
270  histname = TString::Format("%s/histJetCorrPt_%d", groupname.Data(), cent);
271  histtitle = TString::Format("%s;#it{p}_{T,jet}^{corr} (GeV/#it{c});counts", histname.Data());
272  fHistManager.CreateTH1(histname, histtitle, fNbins, -fMaxBinPt / 2, fMaxBinPt / 2);
273  }
274  }
275  }
276 }
277 
278 /*
279  * This function allocates the histograms for the dijet analysis.
280  * A set of histograms is allocated per each jet container and per each centrality bin.
281  */
282 void AliAnalysisTaskEmcalDijetImbalance::AllocateDijetHistograms()
283 {
284  TString histname;
285  TString histtitle;
286  TString groupname;
287  AliJetContainer* jetCont = 0;
288  TIter next(&fJetCollArray);
289  while ((jetCont = static_cast<AliJetContainer*>(next()))) {
290  groupname = jetCont->GetName();
291  //fHistManager.CreateHistoGroup(groupname);
292  for (Int_t cent = 0; cent < fNcentBins; cent++) {
293 
294  histname = TString::Format("%s/histDijetAJ_%d", groupname.Data(), cent);
295  histtitle = TString::Format("%s;AJ;counts", histname.Data());
296  fHistManager.CreateTH1(histname, histtitle, 100, 0, 1);
297 
298  }
299  }
300 }
301 
308 Bool_t AliAnalysisTaskEmcalDijetImbalance::FillHistograms()
309 {
310  DoJetLoop();
311  DoTrackLoop();
312  DoClusterLoop();
313  DoCellLoop();
314 
315  return kTRUE;
316 }
317 
322 void AliAnalysisTaskEmcalDijetImbalance::DoJetLoop()
323 {
324  TString histname;
325  TString groupname;
326  AliJetContainer* jetCont = 0;
327  TIter next(&fJetCollArray);
328  while ((jetCont = static_cast<AliJetContainer*>(next()))) {
329  groupname = jetCont->GetName();
330  UInt_t count = 0;
331  for(auto jet : jetCont->accepted()) {
332  if (!jet) continue;
333  count++;
334 
335  histname = TString::Format("%s/histJetPt_%d", groupname.Data(), fCentBin);
336  fHistManager.FillTH1(histname, jet->Pt());
337 
338  histname = TString::Format("%s/histJetArea_%d", groupname.Data(), fCentBin);
339  fHistManager.FillTH1(histname, jet->Area());
340 
341  histname = TString::Format("%s/histJetPhi_%d", groupname.Data(), fCentBin);
342  fHistManager.FillTH1(histname, jet->Phi());
343 
344  histname = TString::Format("%s/histJetEta_%d", groupname.Data(), fCentBin);
345  fHistManager.FillTH1(histname, jet->Eta());
346 
347  if (jetCont->GetRhoParameter()) {
348  histname = TString::Format("%s/histJetCorrPt_%d", groupname.Data(), fCentBin);
349  fHistManager.FillTH1(histname, jet->Pt() - jetCont->GetRhoVal() * jet->Area());
350  }
351  }
352  histname = TString::Format("%s/histNJets_%d", groupname.Data(), fCentBin);
353  fHistManager.FillTH1(histname, count);
354  }
355 }
356 
361 void AliAnalysisTaskEmcalDijetImbalance::DoTrackLoop()
362 {
363  AliClusterContainer* clusCont = GetClusterContainer(0);
364 
365  TString histname;
366  TString groupname;
367  AliParticleContainer* partCont = 0;
368  TIter next(&fParticleCollArray);
369  while ((partCont = static_cast<AliParticleContainer*>(next()))) {
370  groupname = partCont->GetName();
371  UInt_t count = 0;
372  for(auto part : partCont->accepted()) {
373  if (!part) continue;
374  count++;
375 
376  histname = TString::Format("%s/histTrackPt_%d", groupname.Data(), fCentBin);
377  fHistManager.FillTH1(histname, part->Pt());
378 
379  histname = TString::Format("%s/histTrackPhi_%d", groupname.Data(), fCentBin);
380  fHistManager.FillTH1(histname, part->Phi());
381 
382  histname = TString::Format("%s/histTrackEta_%d", groupname.Data(), fCentBin);
383  fHistManager.FillTH1(histname, part->Eta());
384 
385  if (partCont->GetLoadedClass()->InheritsFrom("AliVTrack")) {
386  const AliVTrack* track = static_cast<const AliVTrack*>(part);
387 
388  histname = TString::Format("%s/fHistDeltaEtaPt_%d", groupname.Data(), fCentBin);
389  fHistManager.FillTH1(histname, track->Pt(), track->Eta() - track->GetTrackEtaOnEMCal());
390 
391  histname = TString::Format("%s/fHistDeltaPhiPt_%d", groupname.Data(), fCentBin);
392  fHistManager.FillTH1(histname, track->Pt(), track->Phi() - track->GetTrackPhiOnEMCal());
393 
394  histname = TString::Format("%s/fHistDeltaPtvsPt_%d", groupname.Data(), fCentBin);
395  fHistManager.FillTH1(histname, track->Pt(), track->Pt() - track->GetTrackPtOnEMCal());
396 
397  if (clusCont) {
398  Int_t iCluster = track->GetEMCALcluster();
399  if (iCluster >= 0) {
400  AliVCluster* cluster = clusCont->GetAcceptCluster(iCluster);
401  if (cluster) {
402  histname = TString::Format("%s/fHistEoverPvsP_%d", groupname.Data(), fCentBin);
403  fHistManager.FillTH2(histname, track->P(), cluster->GetNonLinCorrEnergy() / track->P());
404  }
405  }
406  }
407  }
408  }
409 
410  histname = TString::Format("%s/histNTracks_%d", groupname.Data(), fCentBin);
411  fHistManager.FillTH1(histname, count);
412  }
413 }
414 
419 void AliAnalysisTaskEmcalDijetImbalance::DoClusterLoop()
420 {
421  TString histname;
422  TString groupname;
423  AliClusterContainer* clusCont = 0;
424  TIter next(&fClusterCollArray);
425  while ((clusCont = static_cast<AliClusterContainer*>(next()))) {
426  groupname = clusCont->GetName();
427 
428  for(auto cluster : clusCont->all()) {
429  if (!cluster) continue;
430 
431  if (cluster->GetIsExotic()) {
432  histname = TString::Format("%s/histClusterEnergyExotic_%d", groupname.Data(), fCentBin);
433  fHistManager.FillTH1(histname, cluster->E());
434  }
435  }
436 
437  UInt_t count = 0;
438  for(auto cluster : clusCont->accepted()) {
439  if (!cluster) continue;
440  count++;
441 
442  AliTLorentzVector nPart;
443  cluster->GetMomentum(nPart, fVertex);
444 
445  histname = TString::Format("%s/histClusterEnergy_%d", groupname.Data(), fCentBin);
446  fHistManager.FillTH1(histname, cluster->E());
447 
448  histname = TString::Format("%s/histClusterNonLinCorrEnergy_%d", groupname.Data(), fCentBin);
449  fHistManager.FillTH1(histname, cluster->GetNonLinCorrEnergy());
450 
451  histname = TString::Format("%s/histClusterHadCorrEnergy_%d", groupname.Data(), fCentBin);
452  fHistManager.FillTH1(histname, cluster->GetHadCorrEnergy());
453 
454  histname = TString::Format("%s/histClusterPhi_%d", groupname.Data(), fCentBin);
455  fHistManager.FillTH1(histname, nPart.Phi_0_2pi());
456 
457  histname = TString::Format("%s/histClusterEta_%d", groupname.Data(), fCentBin);
458  fHistManager.FillTH1(histname, nPart.Eta());
459  }
460 
461  histname = TString::Format("%s/histNClusters_%d", groupname.Data(), fCentBin);
462  fHistManager.FillTH1(histname, count);
463  }
464 }
465 
470 void AliAnalysisTaskEmcalDijetImbalance::DoCellLoop()
471 {
472  if (!fCaloCells) return;
473 
474  TString histname;
475 
476  const Short_t ncells = fCaloCells->GetNumberOfCells();
477 
478  histname = TString::Format("%s/histNCells_%d", fCaloCellsName.Data(), fCentBin);
479  fHistManager.FillTH1(histname, ncells);
480 
481  histname = TString::Format("%s/histCellEnergyvsAbsId_%d", fCaloCellsName.Data(), fCentBin);
482  for (Short_t pos = 0; pos < ncells; pos++) {
483  Double_t amp = fCaloCells->GetAmplitude(pos);
484  Short_t absId = fCaloCells->GetCellNumber(pos);
485 
486  fHistManager.FillTH2(histname, absId, amp);
487  }
488 }
489 
494 void AliAnalysisTaskEmcalDijetImbalance::ExecOnce()
495 {
496  AliAnalysisTaskEmcalJet::ExecOnce();
497 }
498 
506 Bool_t AliAnalysisTaskEmcalDijetImbalance::Run()
507 {
508 
509  TString histname;
510  TString groupname;
511 
512  AliJetContainer* jetCont = 0;
513  TIter next(&fJetCollArray);
514  while ((jetCont = static_cast<AliJetContainer*>(next()))) {
515  groupname = jetCont->GetName();
516 
517  // get trigger jet
518  AliEmcalJet *trigJet = jetCont->GetLeadingJet();
519  if(!trigJet) continue;
520  Double_t trigJetPt = trigJet->Pt();
521  Double_t trigJetPhi = trigJet->Phi();
522  if(trigJetPt < fTrigJetMinPt) continue;
523 
524  // look for associated jet
525  Double_t assJetPt = 0;
526  for(auto assJetCand : jetCont->accepted()) {
527  if (!assJetCand) continue;
528  Double_t assJetCandPt = assJetCand->Pt();
529  Double_t assJetCandPhi = assJetCand->Phi();
530 
531  if ( assJetCandPt < fAssJetMinPt ) continue;
532  if ( TMath::Abs(trigJetPhi - assJetCandPhi) < fDeltaPhiMin ) continue;
533  if ( assJetCandPt < assJetPt ) continue;
534  if ( assJetCand->Compare(trigJet) == 0 ) continue;
535 
536  assJetPt = assJetCandPt;
537 
538  }
539 
540  // if we find an acceptable associated jet, fill the AJ spectrum
541  if(assJetPt > 0){
542  Double_t AJ = (trigJetPt - assJetPt)/(trigJetPt + assJetPt);
543 
544  histname = TString::Format("%s/histDijetAJ_%d", groupname.Data(), fCentBin);
545  fHistManager.FillTH1(histname, AJ);
546  }
547 
548  }
549 
550  return kTRUE;
551 }
552 
556 void AliAnalysisTaskEmcalDijetImbalance::Terminate(Option_t *)
557 {
558 }
AliAnalysisTaskEmcal::fClusterCollArray
TObjArray fClusterCollArray
cluster collection array
Definition: AliAnalysisTaskEmcal.h:295
AliJetContainer::GetRhoVal
Double_t GetRhoVal() const
Definition: AliJetContainer.h:158
AliJetContainer::GetRhoName
const TString & GetRhoName() const
Definition: AliJetContainer.h:159
Double_t
double Double_t
Definition: External.C:58
AliAnalysisTaskEmcalDijetImbalance::fAssJetMinPt
Double_t fAssJetMinPt
Pt threshold for trigger (full) jet.
Definition: AliAnalysisTaskEmcalDijetImbalance.h:64
AliEmcalJet::Phi
Double_t Phi() const
Definition: AliEmcalJet.h:104
THistManager::FillTH2
void FillTH2(const char *hname, double x, double y, double weight=1., Option_t *opt="")
Definition: THistManager.cxx:456
AliTLorentzVector.h
Declaration of class AliTLorentzVector.
AliAnalysisTaskEmcal::fMinBinPt
Double_t fMinBinPt
min pt in histograms
Definition: AliAnalysisTaskEmcal.h:280
AliAnalysisTaskEmcal::fCentBin
Int_t fCentBin
!event centrality bin
Definition: AliAnalysisTaskEmcal.h:317
AliParticleContainer
Container for particles within the EMCAL framework.
Definition: AliParticleContainer.h:28
AliAnalysisTaskEmcal::fParticleCollArray
TObjArray fParticleCollArray
particle/track collection array
Definition: AliAnalysisTaskEmcal.h:294
AliClusterContainer::all
const AliClusterIterableContainer all() const
Definition: AliClusterContainer.cxx:409
THistManager::CreateHistoGroup
THashList * CreateHistoGroup(const char *groupname, const char *parent="/")
Definition: THistManager.cxx:60
AliJetContainer::GetLeadingJet
AliEmcalJet * GetLeadingJet(const char *opt="")
Definition: AliJetContainer.cxx:237
THistManager::CreateTH2
TH2 * CreateTH2(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, Option_t *opt="")
Definition: THistManager.cxx:142
Int_t
int Int_t
Definition: External.C:63
UInt_t
unsigned int UInt_t
Definition: External.C:33
THistManager::GetListOfHistograms
THashList * GetListOfHistograms() const
Definition: THistManager.h:504
AliAnalysisTaskEmcalDijetImbalance.h
Declaration of class AliAnalysisTaskEmcalDijetImbalance.
AliTLorentzVector::Phi_0_2pi
Double_t Phi_0_2pi() const
Definition: AliTLorentzVector.cxx:67
AliParticleContainer.h
THistManager::CreateTH1
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
Definition: THistManager.cxx:72
AliAnalysisTaskEmcal::fForceBeamType
BeamType fForceBeamType
forced beam type
Definition: AliAnalysisTaskEmcal.h:259
AliAnalysisTaskEmcal::fNcentBins
Int_t fNcentBins
how many centrality bins
Definition: AliAnalysisTaskEmcal.h:292
AliAnalysisTaskEmcal::GetClusterContainer
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Definition: AliAnalysisTaskEmcal.cxx:1564
AliJetContainer.h
AliClusterContainer::GetAcceptCluster
AliVCluster * GetAcceptCluster(Int_t i) const
Definition: AliClusterContainer.cxx:115
AliClusterContainer::accepted
const AliClusterIterableContainer accepted() const
Definition: AliClusterContainer.cxx:418
AliAnalysisTaskEmcal::fCaloCellsName
TString fCaloCellsName
name of calo cell collection
Definition: AliAnalysisTaskEmcal.h:263
AliRhoParameter.h
THistManager::FillTH1
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
Definition: THistManager.cxx:409
AliAnalysisTaskEmcalJet::fJetCollArray
TObjArray fJetCollArray
jet collection array
Definition: AliAnalysisTaskEmcalJet.h:96
AliAnalysisTaskEmcalDijetImbalance::fHistManager
THistManager fHistManager
Pt threshold for associated (charged) jet (note: unscaled)
Definition: AliAnalysisTaskEmcalDijetImbalance.h:66
Short_t
short Short_t
Definition: External.C:23
AliAnalysisTaskEmcal::fCaloCells
AliVCaloCells * fCaloCells
!cells
Definition: AliAnalysisTaskEmcal.h:313
AliJetContainer::GetRhoParameter
AliRhoParameter * GetRhoParameter()
Definition: AliJetContainer.h:157
AliEmcalJet::Pt
Double_t Pt() const
Definition: AliEmcalJet.h:96
AliAnalysisTaskEmcal::fOutput
AliEmcalList * fOutput
!output list
Definition: AliAnalysisTaskEmcal.h:334
AliAnalysisTaskEmcal::fMaxBinPt
Double_t fMaxBinPt
max pt in histograms
Definition: AliAnalysisTaskEmcal.h:281
AliAnalysisTaskEmcalDijetImbalance::fTrigJetMinPt
Double_t fTrigJetMinPt
minimum delta phi between di-jets
Definition: AliAnalysisTaskEmcalDijetImbalance.h:63
ClassImp
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Definition: AliAnalysisTaskCRC.cxx:44
AliAnalysisTaskEmcal::fVertex
Double_t fVertex[3]
!event vertex
Definition: AliAnalysisTaskEmcal.h:321
AliAnalysisTaskEmcal::SetMakeGeneralHistograms
void SetMakeGeneralHistograms(Bool_t g)
Definition: AliAnalysisTaskEmcal.h:148
AliAnalysisTaskEmcalJet
Base task in the EMCAL jet framework.
Definition: AliAnalysisTaskEmcalJet.h:30
AliAnalysisTaskEmcalDijetImbalance
Implementation of a sample jet analysis task.
Definition: AliAnalysisTaskEmcalDijetImbalance.h:32
AliEmcalJet
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
AliParticleContainer::accepted
const AliParticleIterableContainer accepted() const
Definition: AliParticleContainer.cxx:460
Option_t
const char Option_t
Definition: External.C:48
AliJetContainer::accepted
const AliJetIterableContainer accepted() const
Definition: AliJetContainer.cxx:959
Bool_t
bool Bool_t
Definition: External.C:53
AliClusterContainer
Container structure for EMCAL clusters.
Definition: AliClusterContainer.h:29
AliEmcalJet.h
AliJetContainer
Container for jet within the EMCAL jet framework.
Definition: AliJetContainer.h:37
AliAnalysisTaskEmcal::fNbins
Int_t fNbins
no. of pt bins
Definition: AliAnalysisTaskEmcal.h:279
AliClusterContainer.h