AliPhysics  3337bb0 (3337bb0)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskRhoBase.cxx
Go to the documentation of this file.
1 // $Id$
2 //
3 // Base class for rho calculation.
4 // Calculates parameterized rho for given centrality independent of input.
5 //
6 // Author: S.Aiola
7 
8 #include <TFile.h>
9 #include <TF1.h>
10 #include <TH1F.h>
11 #include <TH2F.h>
12 #include <TH3F.h>
13 #include <TClonesArray.h>
14 #include <TGrid.h>
15 
16 #include "AliLog.h"
17 #include "AliRhoParameter.h"
18 #include "AliEmcalJet.h"
19 #include "AliParticleContainer.h"
20 #include "AliClusterContainer.h"
21 #include "AliVVZERO.h"
22 
23 #include "AliAnalysisTaskRhoBase.h"
24 
25 ClassImp(AliAnalysisTaskRhoBase)
26 
27 //________________________________________________________________________
30  fOutRhoName(),
31  fOutRhoScaledName(),
32  fCompareRhoName(),
33  fCompareRhoScaledName(),
34  fRhoFunction(0),
35  fScaleFunction(0),
36  fInEventSigmaRho(35.83),
37  fAttachToEvent(kTRUE),
38  fIsPbPb(kTRUE),
39  fOutRho(0),
40  fOutRhoScaled(0),
41  fCompareRho(0),
42  fCompareRhoScaled(0),
43  fHistJetPtvsCent(0),
44  fHistJetAreavsCent(0),
45  fHistJetRhovsCent(0),
46  fHistNjetvsCent(0),
47  fHistJetPtvsNtrack(0),
48  fHistJetAreavsNtrack(0),
49  fHistNjetvsNtrack(0),
50  fHistRhovsCent(0),
51  fHistRhoScaledvsCent(0),
52  fHistDeltaRhovsCent(0),
53  fHistDeltaRhoScalevsCent(0),
54  fHistRhovsNtrackvsV0Mult(0),
55  fHistRhoScaledvsNtrackvsV0Mult(0),
56  fHistDeltaRhovsNtrack(0),
57  fHistDeltaRhoScalevsNtrack(0),
58  fHistRhovsNcluster(0),
59  fHistRhoScaledvsNcluster(0)
60 {
61  // Constructor.
62 
63  for (Int_t i = 0; i < 4; i++) {
64  fHistJetNconstVsPt[i] = 0;
65  fHistJetRhovsEta[i] = 0;
66  }
67  for (Int_t i = 0; i < 12; i++) {
68  fHistNjUEoverNjVsNj[i] = 0;
69  }
70 }
71 
72 //________________________________________________________________________
74  AliAnalysisTaskEmcalJet(name, histo),
75  fOutRhoName(),
76  fOutRhoScaledName(),
77  fCompareRhoName(),
78  fCompareRhoScaledName(),
79  fRhoFunction(0),
80  fScaleFunction(0),
81  fInEventSigmaRho(35.83),
82  fAttachToEvent(kTRUE),
83  fIsPbPb(kTRUE),
84  fOutRho(0),
85  fOutRhoScaled(0),
86  fCompareRho(0),
87  fCompareRhoScaled(0),
88  fHistJetPtvsCent(0),
89  fHistJetAreavsCent(0),
90  fHistJetRhovsCent(0),
91  fHistNjetvsCent(0),
92  fHistJetPtvsNtrack(0),
93  fHistJetAreavsNtrack(0),
94  fHistNjetvsNtrack(0),
95  fHistRhovsCent(0),
96  fHistRhoScaledvsCent(0),
97  fHistDeltaRhovsCent(0),
98  fHistDeltaRhoScalevsCent(0),
99  fHistRhovsNtrackvsV0Mult(0),
100  fHistRhoScaledvsNtrackvsV0Mult(0),
101  fHistDeltaRhovsNtrack(0),
102  fHistDeltaRhoScalevsNtrack(0),
103  fHistRhovsNcluster(0),
104  fHistRhoScaledvsNcluster(0)
105 {
106  // Constructor.
107 
108  for (Int_t i = 0; i < 4; i++) {
109  fHistJetNconstVsPt[i] = 0;
110  fHistJetRhovsEta[i] = 0;
111  }
112  for (Int_t i = 0; i < 12; i++) {
113  fHistNjUEoverNjVsNj[i] = 0;
114  }
116 }
117 
118 //________________________________________________________________________
120 {
121  // User create output objects, called at the beginning of the analysis.
122 
123  if (!fCreateHisto)
124  return;
125 
127  //ranges for PbPb
128  Float_t Ntrackrange[2] = {0, 6000};
129  Float_t V0Mult[2] = {0.,25000.};
130  if(!fIsPbPb){
131  //set multiplicity related axes to a smaller max value
132  Ntrackrange[1] = 200.;
133  V0Mult[1] = 2000.;
134  }
135 
136  fHistRhovsCent = new TH2F("fHistRhovsCent", "fHistRhovsCent", 101, -1, 100, fNbins, fMinBinPt, fMaxBinPt*2);
137  fHistRhovsCent->GetXaxis()->SetTitle("Centrality (%)");
138  fHistRhovsCent->GetYaxis()->SetTitle("#rho (GeV/c * rad^{-1})");
139  fOutput->Add(fHistRhovsCent);
140 
141  if (fParticleCollArray.GetEntriesFast()>0) {
142  fHistRhovsNtrackvsV0Mult = new TH3F("fHistRhovsNtrackvsV0Mult", "fHistRhovsNtrackvsV0Mult", 150, Ntrackrange[0], Ntrackrange[1], fNbins, fMinBinPt, fMaxBinPt*2,100, V0Mult[0], V0Mult[1]);
143  fHistRhovsNtrackvsV0Mult->GetXaxis()->SetTitle("No. of tracks");
144  fHistRhovsNtrackvsV0Mult->GetYaxis()->SetTitle("#rho (GeV/c * rad^{-1})");
145  fHistRhovsNtrackvsV0Mult->GetZaxis()->SetTitle("V0 mult");
147  }
148 
149  if (fClusterCollArray.GetEntriesFast()>0) {
150  fHistRhovsNcluster = new TH2F("fHistRhovsNcluster", "fHistRhovsNcluster", 50, 0, 1500, fNbins, fMinBinPt, fMaxBinPt*2);
151  fHistRhovsNcluster->GetXaxis()->SetTitle("No. of clusters");
152  fHistRhovsNcluster->GetYaxis()->SetTitle("#rho (GeV/c * rad^{-1})");
154  }
155 
156  if (fJetCollArray.GetEntriesFast()>0) {
157  fHistJetPtvsCent = new TH2F("fHistJetPtvsCent", "fHistJetPtvsCent", 101, -1, 100, fNbins, fMinBinPt, fMaxBinPt);
158  fHistJetPtvsCent->GetXaxis()->SetTitle("Centrality (%)");
159  fHistJetPtvsCent->GetYaxis()->SetTitle("#it{p}_{T,jet} (GeV/c)");
161 
162  fHistJetAreavsCent = new TH2F("fHistJetAreavsCent", "fHistJetAreavsCent", 101, -1, 100, 100, 0, 1);
163  fHistJetAreavsCent->GetXaxis()->SetTitle("Centrality (%)");
164  fHistJetAreavsCent->GetYaxis()->SetTitle("Jet area");
166 
167  fHistJetRhovsCent = new TH2F("fHistJetRhovsCent", "fHistJetRhovsCent", 101, -1, 100, fNbins, fMinBinPt, fMaxBinPt*2);
168  fHistJetRhovsCent->GetXaxis()->SetTitle("Centrality (%)");
169  fHistJetRhovsCent->GetYaxis()->SetTitle("Jet #rho (GeV/c)");
171 
172  fHistNjetvsCent = new TH2F("fHistNjetvsCent", "fHistNjetvsCent", 101, -1, 100, 150, -0.5, 149.5);
173  fHistNjetvsCent->GetXaxis()->SetTitle("Centrality (%)");
174  fHistNjetvsCent->GetYaxis()->SetTitle("No. of jets");
175  fOutput->Add(fHistNjetvsCent);
176 
177 
178  if (fParticleCollArray.GetEntriesFast()>0) {
179  fHistJetPtvsNtrack = new TH2F("fHistJetPtvsNtrack", "fHistJetPtvsNtrack", 150, Ntrackrange[0], Ntrackrange[1], fNbins, fMinBinPt, fMaxBinPt);
180  fHistJetPtvsNtrack->GetXaxis()->SetTitle("No. of tracks");
181  fHistJetPtvsNtrack->GetYaxis()->SetTitle("#it{p}_{T,jet} (GeV/c)");
183 
184  fHistJetAreavsNtrack = new TH2F("fHistJetAreavsNtrack", "fHistJetAreavsNtrack", 150, Ntrackrange[0], Ntrackrange[1], 100, 0, 1);
185  fHistJetAreavsNtrack->GetXaxis()->SetTitle("No. of tracks");
186  fHistJetAreavsNtrack->GetYaxis()->SetTitle("Jet area");
188 
189  fHistNjetvsNtrack = new TH2F("fHistNjetvsNtrack", "fHistNjetvsNtrack", 150, Ntrackrange[0], Ntrackrange[1], 150, -0.5, 149.5);
190  fHistNjetvsNtrack->GetXaxis()->SetTitle("No. of tracks");
191  fHistNjetvsNtrack->GetYaxis()->SetTitle("No. of jets");
193  }
194 
195 
196  TString name;
197  for (Int_t i = 0; i < 4; i++) {
198  name = Form("fHistJetNconstVsPt_%d",i);
199  fHistJetNconstVsPt[i] = new TH2F(name, name, 150, -0.5, 149.5, fNbins, fMinBinPt, fMaxBinPt);
200  fHistJetNconstVsPt[i]->GetXaxis()->SetTitle("No. of constituents");
201  fHistJetNconstVsPt[i]->GetYaxis()->SetTitle("p_{T,jet} (GeV/c)");
202  fOutput->Add(fHistJetNconstVsPt[i]);
203 
204  name = Form("fHistJetRhovsEta_%d",i);
205  fHistJetRhovsEta[i] = new TH2F(name, name, fNbins, fMinBinPt, fMaxBinPt*2, 16, -0.8, 0.8);
206  fHistJetRhovsEta[i]->GetXaxis()->SetTitle("#rho (GeV/c * rad^{-1})");
207  fHistJetRhovsEta[i]->GetYaxis()->SetTitle("#eta");
208  fOutput->Add(fHistJetRhovsEta[i]);
209 
210  for (Int_t j = 0; j < 3; j++) {
211  name = Form("NjUEoverNjVsNj_%d_%d",i,j+1);
212  fHistNjUEoverNjVsNj[i*3+j] = new TH2F(name, name, 150, -0.5, 149.5, 120, 0.01, 1.21);
213  fHistNjUEoverNjVsNj[i*3+j]->GetXaxis()->SetTitle("N_{jet}");
214  fHistNjUEoverNjVsNj[i*3+j]->GetYaxis()->SetTitle("N_{jet_{UE}} / N_{jet}");
215  fOutput->Add(fHistNjUEoverNjVsNj[i*3+j]);
216  }
217  }
218  }
219 
220  if (!fCompareRhoName.IsNull()) {
221  fHistDeltaRhovsCent = new TH2F("fHistDeltaRhovsCent", "fHistDeltaRhovsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
222  fHistDeltaRhovsCent->GetXaxis()->SetTitle("Centrality (%)");
223  fHistDeltaRhovsCent->GetYaxis()->SetTitle("#Delta#rho (GeV/c * rad^{-1})");
225 
226  if (fParticleCollArray.GetEntriesFast()>0) {
227  fHistDeltaRhovsNtrack = new TH2F("fHistDeltaRhovsNtrack", "fHistDeltaRhovsNtrack", 150, Ntrackrange[0], Ntrackrange[1], fNbins, -fMaxBinPt, fMaxBinPt);
228  fHistDeltaRhovsNtrack->GetXaxis()->SetTitle("No. of tracks");
229  fHistDeltaRhovsNtrack->GetYaxis()->SetTitle("#Delta#rho (GeV/c * rad^{-1})");
231  }
232  }
233 
234  if (fScaleFunction) {
235  fHistRhoScaledvsCent = new TH2F("fHistRhoScaledvsCent", "fHistRhoScaledvsCent", 101, -1, 100, fNbins, fMinBinPt , fMaxBinPt*2);
236  fHistRhoScaledvsCent->GetXaxis()->SetTitle("Centrality (%)");
237  fHistRhoScaledvsCent->GetYaxis()->SetTitle("#rho_{scaled} (GeV/c * rad^{-1})");
239 
240  if (fParticleCollArray.GetEntriesFast()>0) {
241  fHistRhoScaledvsNtrackvsV0Mult = new TH3F("fHistRhoScaledvsNtrackvsV0Mult", "fHistRhoScaledvsNtrackvsV0Mult", 150, Ntrackrange[0], Ntrackrange[1], fNbins, fMinBinPt, fMaxBinPt*2,100, V0Mult[0], V0Mult[1]);
242  fHistRhoScaledvsNtrackvsV0Mult->GetXaxis()->SetTitle("No. of tracks");
243  fHistRhoScaledvsNtrackvsV0Mult->GetYaxis()->SetTitle("#rho (GeV/c * rad^{-1})");
244  fHistRhoScaledvsNtrackvsV0Mult->GetZaxis()->SetTitle("V0 mult");
246  }
247 
248  if (fClusterCollArray.GetEntriesFast()>0) {
249  fHistRhoScaledvsNcluster = new TH2F("fHistRhoScaledvsNcluster", "fHistRhoScaledvsNcluster", 50, 0, 1500, fNbins, fMinBinPt, fMaxBinPt*2);
250  fHistRhoScaledvsNcluster->GetXaxis()->SetTitle("No. of clusters");
251  fHistRhoScaledvsNcluster->GetYaxis()->SetTitle("#rho_{scaled} (GeV/c * rad^{-1})");
253  }
254 
255  if (!fCompareRhoScaledName.IsNull()) {
256  fHistDeltaRhoScalevsCent = new TH2F("fHistDeltaRhoScalevsCent", "fHistDeltaRhoScalevsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
257  fHistDeltaRhoScalevsCent->GetXaxis()->SetTitle("Centrality (%)");
258  fHistDeltaRhoScalevsCent->GetYaxis()->SetTitle("#Delta#rho_{scaled} (GeV/c * rad^{-1})");
260 
261  if (fParticleCollArray.GetEntriesFast()>0) {
262  fHistDeltaRhoScalevsNtrack = new TH2F("fHistDeltaRhoScalevsNtrack", "fHistDeltaRhoScalevsNtrack", 150, Ntrackrange[0], Ntrackrange[1], fNbins, -fMaxBinPt, fMaxBinPt);
263  fHistDeltaRhoScalevsNtrack->GetXaxis()->SetTitle("No. of tracks");
264  fHistDeltaRhoScalevsNtrack->GetYaxis()->SetTitle("#Delta#rho_{scaled} (GeV/c * rad^{-1})");
266  }
267  }
268  }
269 }
270 
271 //________________________________________________________________________
273 {
274  // Run the analysis.
275 
276  Double_t rho = GetRhoFactor(fCent);
277  fOutRho->SetVal(rho);
278 
279  if (fScaleFunction) {
280  Double_t rhoScaled = rho * GetScaleFactor(fCent);
281  fOutRhoScaled->SetVal(rhoScaled);
282  }
283 
284  return kTRUE;
285 }
286 
287 //________________________________________________________________________
289 {
290  // Fill histograms.
291 
292  Int_t Ntracks = 0;
293  Int_t Nclusters = 0;
294 
295  AliVVZERO* vV0 = InputEvent()->GetVZEROData();
296  Float_t multV0A = -1.;
297  Float_t multV0C = -1.;
298  if(vV0) {
299  multV0A = vV0->GetMTotV0A();
300  multV0C = vV0->GetMTotV0C();
301  }
302 
303  // Loop over all possible contianers
304  AliParticleContainer * partCont = 0;
305  TIter nextPartCont(&fParticleCollArray);
306  while ((partCont = static_cast<AliParticleContainer*>(nextPartCont()))) {
307  Ntracks += partCont->GetNAcceptedParticles();
308  }
309  AliClusterContainer * clusCont = 0;
310  TIter nextClusCont(&fClusterCollArray);
311  while ((clusCont = static_cast<AliClusterContainer*>(nextClusCont()))) {
312  Nclusters += clusCont->GetNAcceptedClusters();
313  }
314 
315  if (fJets) {
316  Int_t Njets = fJets->GetEntries();
317  Int_t NjetAcc = 0;
318  Int_t NjetUE1Sigma = 0;
319  Int_t NjetUE2Sigma = 0;
320  Int_t NjetUE3Sigma = 0;
321  Double_t rhoPlus1Sigma = fOutRho->GetVal() + fInEventSigmaRho;
322  Double_t rhoPlus2Sigma = fOutRho->GetVal() + 2*fInEventSigmaRho;
323  Double_t rhoPlus3Sigma = fOutRho->GetVal() + 3*fInEventSigmaRho;
324 
325  for (Int_t i = 0; i < Njets; ++i) {
326 
327  AliEmcalJet *jet = static_cast<AliEmcalJet*>(fJets->At(i));
328  if (!jet) {
329  AliError(Form("%s: Could not receive jet %d", GetName(), i));
330  continue;
331  }
332 
333  if (!AcceptJet(jet))
334  continue;
335 
336  fHistJetPtvsCent->Fill(fCent, jet->Pt());
337  fHistJetAreavsCent->Fill(fCent, jet->Area());
338  fHistJetRhovsCent->Fill(fCent, jet->Pt() / jet->Area());
339  fHistJetRhovsEta[fCentBin]->Fill(jet->Pt() / jet->Area(), jet->Eta());
340 
341  if (fTracks) {
342  fHistJetPtvsNtrack->Fill(Ntracks, jet->Pt());
343  fHistJetAreavsNtrack->Fill(Ntracks, jet->Area());
344  }
345 
346  fHistJetNconstVsPt[fCentBin]->Fill(jet->GetNumberOfConstituents(), jet->Pt());
347 
348  if (jet->Pt() < rhoPlus1Sigma * jet->Area())
349  NjetUE1Sigma++;
350 
351  if (jet->Pt() < rhoPlus2Sigma * jet->Area())
352  NjetUE2Sigma++;
353 
354  if (jet->Pt() < rhoPlus3Sigma * jet->Area())
355  NjetUE3Sigma++;
356 
357  NjetAcc++;
358  }
359 
360  if (NjetAcc>0) {
361  fHistNjUEoverNjVsNj[fCentBin*3 ]->Fill(NjetAcc,1.*NjetUE1Sigma/NjetAcc);
362  fHistNjUEoverNjVsNj[fCentBin*3+1]->Fill(NjetAcc,1.*NjetUE2Sigma/NjetAcc);
363  fHistNjUEoverNjVsNj[fCentBin*3+2]->Fill(NjetAcc,1.*NjetUE3Sigma/NjetAcc);
364  }
365 
366  fHistNjetvsCent->Fill(fCent, NjetAcc);
367  if (fTracks)
368  fHistNjetvsNtrack->Fill(Ntracks, NjetAcc);
369  }
370 
371  fHistRhovsCent->Fill(fCent, fOutRho->GetVal());
372 
373  if (fTracks)
374  fHistRhovsNtrackvsV0Mult->Fill(Ntracks, fOutRho->GetVal(),multV0A+multV0C);
375  if (fCaloClusters)
376  fHistRhovsNcluster->Fill(Nclusters, fOutRho->GetVal());
377  if (fCompareRho) {
378  fHistDeltaRhovsCent->Fill(fCent, fOutRho->GetVal() - fCompareRho->GetVal());
379  if (fTracks)
380  fHistDeltaRhovsNtrack->Fill(Ntracks, fOutRho->GetVal() - fCompareRho->GetVal());
381  }
382 
383  if (fOutRhoScaled) {
384  fHistRhoScaledvsCent->Fill(fCent, fOutRhoScaled->GetVal());
385  if (fTracks)
386  fHistRhoScaledvsNtrackvsV0Mult->Fill(Ntracks, fOutRhoScaled->GetVal(),multV0A+multV0C);
387  if (fCaloClusters)
388  fHistRhoScaledvsNcluster->Fill(Nclusters, fOutRhoScaled->GetVal());
389  if (fCompareRhoScaled) {
390  fHistDeltaRhoScalevsCent->Fill(fCent, fOutRhoScaled->GetVal() - fCompareRhoScaled->GetVal());
391  if (fTracks)
392  fHistDeltaRhoScalevsNtrack->Fill(Ntracks, fOutRhoScaled->GetVal() - fCompareRhoScaled->GetVal());
393  }
394  }
395 
396  return kTRUE;
397 }
398 
399 
400 //________________________________________________________________________
402 {
403  // Init the analysis.
404 
405  if (!fOutRho) {
407 
408  if (fAttachToEvent) {
409  if (!(InputEvent()->FindListObject(fOutRhoName))) {
410  InputEvent()->AddObject(fOutRho);
411  } else {
412  AliFatal(Form("%s: Container with same name %s already present. Aborting", GetName(), fOutRhoName.Data()));
413  return;
414  }
415  }
416  }
417 
418  if (fScaleFunction && !fOutRhoScaled) {
420 
421  if (fAttachToEvent) {
422  if (!(InputEvent()->FindListObject(fOutRhoScaledName))) {
423  InputEvent()->AddObject(fOutRhoScaled);
424  } else {
425  AliFatal(Form("%s: Container with same name %s already present. Aborting", GetName(), fOutRhoScaledName.Data()));
426  return;
427  }
428  }
429  }
430 
431  if (!fCompareRhoName.IsNull() && !fCompareRho) {
432  fCompareRho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(fCompareRhoName));
433  if (!fCompareRho) {
434  AliWarning(Form("%s: Could not retrieve rho %s!", GetName(), fCompareRhoName.Data()));
435  }
436  }
437 
438  if (!fCompareRhoScaledName.IsNull() && !fCompareRhoScaled) {
439  fCompareRhoScaled = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(fCompareRhoScaledName));
440  if (!fCompareRhoScaled) {
441  AliWarning(Form("%s: Could not retrieve rho %s!", GetName(), fCompareRhoScaledName.Data()));
442  }
443  }
444 
446 }
447 
448 //________________________________________________________________________
450 {
451  // Return rho per centrality.
452 
453  Double_t rho = 0;
454  if (fRhoFunction)
455  rho = fRhoFunction->Eval(cent);
456  return rho;
457 }
458 
459 //________________________________________________________________________
461 {
462  // Get scale factor.
463 
464  Double_t scale = 1;
465  if (fScaleFunction)
466  scale = fScaleFunction->Eval(cent);
467  return scale;
468 }
469 
470 //________________________________________________________________________
471 TF1* AliAnalysisTaskRhoBase::LoadRhoFunction(const char* path, const char* name)
472 {
473  // Load the scale function from a file.
474 
475  TString fname(path);
476  if (fname.BeginsWith("alien://")) {
477  TGrid::Connect("alien://");
478  }
479 
480  TFile* file = TFile::Open(path);
481 
482  if (!file || file->IsZombie()) {
483  ::Error("AddTaskRho", "Could not open scale function file");
484  return 0;
485  }
486 
487  TF1* sfunc = dynamic_cast<TF1*>(file->Get(name));
488 
489  if (sfunc) {
490  ::Info("AliAnalysisTaskRhoBase::LoadRhoFunction", "Scale function %s loaded from file %s.", name, path);
491  }
492  else {
493  ::Error("AliAnalysisTaskRhoBase::LoadRhoFunction", "Scale function %s not found in file %s.", name, path);
494  return 0;
495  }
496 
497  fScaleFunction = static_cast<TF1*>(sfunc->Clone());
498 
499  file->Close();
500  delete file;
501 
502  return fScaleFunction;
503 }
AliRhoParameter * fCompareRho
output scaled rho object
Double_t Area() const
Definition: AliEmcalJet.h:123
TObjArray fClusterCollArray
cluster collection array
TH2F * fHistDeltaRhovsNtrack
rhoscaled vs. no. of tracks vs V0mult
double Double_t
Definition: External.C:58
Definition: External.C:260
TH2F * fHistDeltaRhoScalevsNtrack
delta rho vs. no. of tracks
TH2F * fHistNjetvsNtrack
jet area vs. no. of tracks
Definition: External.C:236
Double_t Eta() const
Definition: AliEmcalJet.h:114
TH2F * fHistNjetvsCent
jet pt/area vs. centrality
Double_t fMinBinPt
min pt in histograms
Int_t fCentBin
!event centrality bin
TF1 * LoadRhoFunction(const char *path, const char *name)
TH2F * fHistJetRhovsCent
jet area vs. centrality
TH2F * fHistJetPtvsNtrack
no. of jets vs. centrality
UShort_t GetNumberOfConstituents() const
Definition: AliEmcalJet.h:133
Container for particles within the EMCAL framework.
virtual Double_t GetRhoFactor(Double_t cent)
TObjArray fParticleCollArray
particle/track collection array
AliRhoParameter * fOutRhoScaled
output rho object
TClonesArray * fCaloClusters
!clusters
AliRhoParameter * fCompareRhoScaled
rho object to compare
int Int_t
Definition: External.C:63
float Float_t
Definition: External.C:68
TH2F * fHistJetRhovsEta[4]
jet no. of constituents vs. pt
Int_t GetNAcceptedClusters() const
Double_t fCent
!event centrality
TH2F * fHistJetAreavsNtrack
jet pt vs. no. of tracks
TObjArray fJetCollArray
jet collection array
TClonesArray * fJets
! jets
TH3F * fHistRhovsNtrackvsV0Mult
delta rhoscaled vs. centrality
Double_t Pt() const
Definition: AliEmcalJet.h:102
TH2F * fHistRhoScaledvsCent
rho vs. centrality
TH2F * fHistRhovsNcluster
delta rho scaled vs. no. of tracks
virtual Double_t GetScaleFactor(Double_t cent)
AliEmcalList * fOutput
!output list
Double_t fMaxBinPt
max pt in histograms
TH2F * fHistNjUEoverNjVsNj[12]
no. of jets vs. no. of tracks
TH2F * fHistJetAreavsCent
jet pt vs. centrality
TClonesArray * fTracks
!tracks
TH2F * fHistJetNconstVsPt[4]
ratio no. of jets below rho*A+sigma_rho over. no. of jets vs. no. of jets
Bool_t Run()
Run function. This is the core function of the analysis and contains the user code. Therefore users have to implement this function.
TH2F * fHistRhoScaledvsNcluster
rho vs. no. of clusters
TH2F * fHistRhovsCent
rho vs. eta
TH2F * fHistJetPtvsCent
scaled rho object to compare
Bool_t fCreateHisto
whether or not create histograms
TFile * file
TList with histograms for a given trigger.
void SetMakeGeneralHistograms(Bool_t g)
Base task in the EMCAL jet framework.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
Bool_t FillHistograms()
Function filling histograms.
void UserCreateOutputObjects()
Main initialization function on the worker.
virtual Bool_t AcceptJet(AliEmcalJet *jet, Int_t c=0)
bool Bool_t
Definition: External.C:53
void ExecOnce()
Perform steps needed to initialize the analysis.
Int_t GetNAcceptedParticles() const
TH2F * fHistDeltaRhoScalevsCent
delta rho vs. centrality
Container structure for EMCAL clusters.
Int_t fNbins
no. of pt bins
TH2F * fHistDeltaRhovsCent
rhoscaled vs. centrality
TH3F * fHistRhoScaledvsNtrackvsV0Mult
rho vs. no. of tracks vs V0mult