AliPhysics  41af4b0 (41af4b0)
AliAnalysisTaskRhoBaseDev.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2017, 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 <TFile.h>
17 #include <TF1.h>
18 #include <TH1F.h>
19 #include <TH2F.h>
20 #include <TClonesArray.h>
21 #include <TGrid.h>
22 
23 #include <AliLog.h>
24 #include <AliVEventHandler.h>
25 #include <AliAnalysisManager.h>
26 
27 #include "AliRhoParameter.h"
28 #include "AliEmcalJet.h"
29 #include "AliParticleContainer.h"
30 #include "AliClusterContainer.h"
31 #include "AliJetContainer.h"
32 
34 
38 
44  fOutRhoName(),
45  fOutRhoScaledName(),
46  fRhoFunction(0),
47  fScaleFunction(0),
48  fAttachToEvent(kTRUE),
49  fTaskConfigured(kFALSE),
50  fOutRho(0),
51  fOutRhoScaled(0),
52  fHistRhoVsCent(0),
53  fHistRhoVsLeadJetPt(),
54  fHistLeadJetPtVsCent(),
55  fHistLeadJetPtDensityVsCent(),
56  fHistTotJetAreaVsCent(),
57  fHistLeadJetNconstVsCent(),
58  fHistLeadJetNconstVsPt(),
59  fHistNjetVsCent(),
60  fHistNjetVsNtrack(),
61  fHistRhoVsLeadTrackPt(0),
62  fHistRhoVsNtrack(0),
63  fHistLeadTrackPtVsCent(0),
64  fHistNtrackVsCent(0),
65  fHistRhoVsLeadClusterE(0),
66  fHistRhoVsNcluster(0),
67  fHistLeadClusterEVsCent(0),
68  fHistNclusterVsCent(0),
69  fHistRhoScaledVsCent(0),
70  fHistRhoScaledVsNtrack(0),
71  fHistRhoScaledVsNcluster(0)
72 {
73 }
74 
82  AliAnalysisTaskJetUE(name, histo),
83  fOutRhoName(),
85  fRhoFunction(0),
86  fScaleFunction(0),
87  fAttachToEvent(kTRUE),
88  fTaskConfigured(kFALSE),
89  fOutRho(0),
90  fOutRhoScaled(0),
91  fHistRhoVsCent(0),
101  fHistRhoVsNtrack(0),
111 {
113 }
114 
120 {
121  if (!fCreateHisto) return;
122 
124 
125  ::Info("UserCreateOutputObjects", "CreateOutputObjects of task %s", GetName());
126 
127  TString name;
128 
129  Int_t maxTracks = 6000;
130  Double_t maxRho = 500;
131  Int_t nRhoBins = 500;
132 
133  if (fForceBeamType == kpp) {
134  maxRho = 50;
135  maxTracks = 200;
136  }
137  else if (fForceBeamType == kpA) {
138  maxRho = 200;
139  maxTracks = 500;
140  }
141 
142  Int_t nPtBins = TMath::CeilNint(fMaxPt / fPtBinWidth);
143 
144  fHistRhoVsCent = new TH2F("fHistRhoVsCent", "fHistRhoVsCent", 100, 0, 100, nRhoBins, 0, maxRho);
145  fHistRhoVsCent->GetXaxis()->SetTitle("Centrality (%)");
146  fHistRhoVsCent->GetYaxis()->SetTitle("#rho (GeV/#it{c} #times rad^{-1})");
147  fOutput->Add(fHistRhoVsCent);
148 
149  if (fParticleCollArray.size() > 0) {
150  fHistRhoVsNtrack = new TH2F("fHistRhoVsNtrack", "fHistRhoVsNtrack", 200, 0, maxTracks, nRhoBins, 0, maxRho);
151  fHistRhoVsNtrack->GetXaxis()->SetTitle("No. of tracks");
152  fHistRhoVsNtrack->GetYaxis()->SetTitle("#rho (GeV/#it{c} #times rad^{-1})");
154 
155  fHistNtrackVsCent = new TH2F("fHistNtrackVsCent", "fHistNtrackVsCent", 100, 0, 100, 200, 0, maxTracks);
156  fHistNtrackVsCent->GetXaxis()->SetTitle("Centrality (%)");
157  fHistNtrackVsCent->GetYaxis()->SetTitle("No. of tracks");
159 
160  fHistRhoVsLeadTrackPt = new TH2F("fHistRhoVsLeadTrackPt", "fHistRhoVsLeadTrackPt", nPtBins, 0, fMaxPt, nRhoBins, 0, maxRho);
161  fHistRhoVsLeadTrackPt->GetXaxis()->SetTitle("#it{p}_{T,track} (GeV/c)");
162  fHistRhoVsLeadTrackPt->GetYaxis()->SetTitle("#rho (GeV/#it{c} #times rad^{-1})");
164 
165  fHistLeadTrackPtVsCent = new TH2F("fHistLeadTrackPtVsCent", "fHistLeadTrackPtVsCent", 100, 0, 100, nPtBins, 0, fMaxPt);
166  fHistLeadTrackPtVsCent->GetXaxis()->SetTitle("Centrality (%)");
167  fHistLeadTrackPtVsCent->GetYaxis()->SetTitle("#it{p}_{T,track} (GeV/c)");
169  }
170 
171  if (fClusterCollArray.size()>0) {
172  fHistRhoVsNcluster = new TH2F("fHistRhoVsNcluster", "fHistRhoVsNcluster", 50, 0, maxTracks / 4, nRhoBins, 0, maxRho);
173  fHistRhoVsNcluster->GetXaxis()->SetTitle("No. of clusters");
174  fHistRhoVsNcluster->GetYaxis()->SetTitle("#rho (GeV/#it{c} #times rad^{-1})");
176 
177  fHistNclusterVsCent = new TH2F("fHistNclusterVsCent", "fHistNclusterVsCent", 100, 0, 100, 50, 0, maxTracks / 4);
178  fHistNclusterVsCent->GetXaxis()->SetTitle("Centrality (%)");
179  fHistNclusterVsCent->GetYaxis()->SetTitle("No. of clusters");
181 
182  fHistRhoVsLeadClusterE = new TH2F("fHistRhoVsLeadClusterE", "fHistRhoVsLeadClusterE", nPtBins, 0, fMaxPt, nRhoBins, 0, maxRho);
183  fHistRhoVsLeadClusterE->GetXaxis()->SetTitle("#it{p}_{T,track} (GeV/c)");
184  fHistRhoVsLeadClusterE->GetYaxis()->SetTitle("#rho (GeV/#it{c} #times rad^{-1})");
186 
187  fHistLeadClusterEVsCent = new TH2F("fHistLeadClusterEVsCent", "fHistLeadClusterEVsCent", 100, 0, 100, nPtBins, 0, fMaxPt);
188  fHistLeadClusterEVsCent->GetXaxis()->SetTitle("Centrality (%)");
189  fHistLeadClusterEVsCent->GetYaxis()->SetTitle("#it{p}_{T,track} (GeV/c)");
191  }
192 
193  for (auto jetCont : fJetCollArray) {
194  name = TString::Format("%s_fHistRhoVsLeadJetPt", jetCont.first.c_str());
195  fHistRhoVsLeadJetPt[jetCont.first] = new TH2F(name, name, nPtBins, 0, fMaxPt, nRhoBins, 0, maxRho);
196  fHistRhoVsLeadJetPt[jetCont.first]->GetXaxis()->SetTitle("#it{p}_{T,jet} (GeV/c)");
197  fHistRhoVsLeadJetPt[jetCont.first]->GetYaxis()->SetTitle("#rho (GeV/#it{c} #times rad^{-1})");
198  fOutput->Add(fHistRhoVsLeadJetPt[jetCont.first]);
199 
200  name = TString::Format("%s_fHistLeadJetPtVsCent", jetCont.first.c_str());
201  fHistLeadJetPtVsCent[jetCont.first] = new TH2F(name, name, 100, 0, 100, nPtBins, 0, fMaxPt);
202  fHistLeadJetPtVsCent[jetCont.first]->GetXaxis()->SetTitle("Centrality (%)");
203  fHistLeadJetPtVsCent[jetCont.first]->GetYaxis()->SetTitle("#it{p}_{T,jet} (GeV/c)");
204  fOutput->Add(fHistLeadJetPtVsCent[jetCont.first]);
205 
206  name = TString::Format("%s_fHistLeadJetPtDensityVsCent", jetCont.first.c_str());
207  fHistLeadJetPtDensityVsCent[jetCont.first] = new TH2F(name, name, 100, 0, 100, nPtBins, 0, fMaxPt*2);
208  fHistLeadJetPtDensityVsCent[jetCont.first]->GetXaxis()->SetTitle("Centrality (%)");
209  fHistLeadJetPtDensityVsCent[jetCont.first]->GetYaxis()->SetTitle("#it{p}_{T,jet} / #it{A}_{jet} (GeV/#it{c})");
210  fOutput->Add(fHistLeadJetPtDensityVsCent[jetCont.first]);
211 
212  name = TString::Format("%s_fHistLeadJetNconstVsCent", jetCont.first.c_str());
213  fHistLeadJetNconstVsCent[jetCont.first] = new TH2F(name, name, 100, 0, 100, 150, -0.5, 149.5);
214  fHistLeadJetNconstVsCent[jetCont.first]->GetXaxis()->SetTitle("Centrality (%)");
215  fHistLeadJetNconstVsCent[jetCont.first]->GetYaxis()->SetTitle("No. of constituents");
216  fOutput->Add(fHistLeadJetNconstVsCent[jetCont.first]);
217 
218  if (fCentBins.size() > 1) {
219  fHistLeadJetNconstVsPt[jetCont.first] = new TH2*[fCentBins.size()-1];
220  for (Int_t i = 0; i < fCentBins.size()-1; i++) {
221  name = TString::Format("%s_fHistJetNconstVsPt_Cent%d_%d", jetCont.first.c_str(), TMath::FloorNint(fCentBins[i]), TMath::FloorNint(fCentBins[i+1]));
222  fHistLeadJetNconstVsPt[jetCont.first][i] = new TH2F(name, name, nPtBins, 0, fMaxPt, 150, -0.5, 149.5);
223  fHistLeadJetNconstVsPt[jetCont.first][i]->GetXaxis()->SetTitle("#it{p}_{T,jet} (GeV/#it{c})");
224  fHistLeadJetNconstVsPt[jetCont.first][i]->GetYaxis()->SetTitle("No. of constituents");
225  fOutput->Add(fHistLeadJetNconstVsPt[jetCont.first][i]);
226  }
227  }
228 
229  name = TString::Format("%s_fHistTotJetAreaVsCent", jetCont.first.c_str());
230  fHistTotJetAreaVsCent[jetCont.first] = new TH2F(name, name, 100, 0, 100, 500, 0, 15);
231  fHistTotJetAreaVsCent[jetCont.first]->GetXaxis()->SetTitle("Centrality (%)");
232  fHistTotJetAreaVsCent[jetCont.first]->GetYaxis()->SetTitle("Jet area");
233  fOutput->Add(fHistTotJetAreaVsCent[jetCont.first]);
234 
235  name = TString::Format("%s_fHistNjetVsCent", jetCont.first.c_str());
236  fHistNjetVsCent[jetCont.first] = new TH2F(name, name, 100, 0, 100, 150, -0.5, 149.5);
237  fHistNjetVsCent[jetCont.first]->GetXaxis()->SetTitle("Centrality (%)");
238  fHistNjetVsCent[jetCont.first]->GetYaxis()->SetTitle("No. of jets");
239  fOutput->Add(fHistNjetVsCent[jetCont.first]);
240 
241  if (fParticleCollArray.size() > 0) {
242  name = TString::Format("%s_fHistNjetVsNtrack", jetCont.first.c_str());
243  fHistNjetVsNtrack[jetCont.first] = new TH2F(name, name, 200, 0, maxTracks, 150, -0.5, 149.5);
244  fHistNjetVsNtrack[jetCont.first]->GetXaxis()->SetTitle("No. of tracks");
245  fHistNjetVsNtrack[jetCont.first]->GetYaxis()->SetTitle("No. of jets");
246  fOutput->Add(fHistNjetVsNtrack[jetCont.first]);
247  }
248  }
249 
250  if (fScaleFunction) {
251  fHistRhoScaledVsCent = new TH2F("fHistRhoScaledVsCent", "fHistRhoScaledVsCent", 100, 0, 100, nRhoBins, 0, maxRho);
252  fHistRhoScaledVsCent->GetXaxis()->SetTitle("Centrality (%)");
253  fHistRhoScaledVsCent->GetYaxis()->SetTitle("#rho_{scaled} (GeV/#it{c} #times rad^{-1})");
255 
256  if (fParticleCollArray.size() > 0) {
257  fHistRhoScaledVsNtrack = new TH2F("fHistRhoScaledVsNtrack", "fHistRhoScaledVsNtrack", 200, 0, maxTracks, nRhoBins, 0, maxRho);
258  fHistRhoScaledVsNtrack->GetXaxis()->SetTitle("No. of tracks");
259  fHistRhoScaledVsNtrack->GetYaxis()->SetTitle("#rho (GeV/#it{c} #times rad^{-1})");
261  }
262 
263  if (fClusterCollArray.size() > 0) {
264  fHistRhoScaledVsNcluster = new TH2F("fHistRhoScaledVsNcluster", "fHistRhoScaledVsNcluster", 50, 0, maxTracks / 4, nRhoBins, 0, maxRho);
265  fHistRhoScaledVsNcluster->GetXaxis()->SetTitle("No. of clusters");
266  fHistRhoScaledVsNcluster->GetYaxis()->SetTitle("#rho_{scaled} (GeV/#it{c} #times rad^{-1})");
268  }
269  }
270 }
271 
272 
278 {
279  Double_t rho = GetRhoFactor(fCent);
280  fOutRho->SetVal(rho);
281 }
282 
287 {
288  fOutRho->SetVal(0);
289  if (fOutRhoScaled) fOutRhoScaled->SetVal(0);
290 
292 
293  CalculateRho();
294 
295  if (fScaleFunction) {
296  Double_t rhoScaled = fOutRho->GetVal() * GetScaleFactor(fCent);
297  fOutRhoScaled->SetVal(rhoScaled);
298  }
299 
300  return kTRUE;
301 }
302 
307 {
308  fHistRhoVsCent->Fill(fCent, fOutRho->GetVal());
309 
310  if (fLeadingParticle) {
312  fHistRhoVsLeadTrackPt->Fill(fLeadingParticle->Pt(), fOutRho->GetVal());
313  }
314 
315  if (fLeadingCluster) {
317  fHistRhoVsLeadClusterE->Fill(fLeadingCluster->E(), fOutRho->GetVal());
318  }
319 
322 
323 
324  if (fHistRhoVsNtrack) fHistRhoVsNtrack->Fill(fNtracks, fOutRho->GetVal());
326 
327  if (fOutRhoScaled) {
328  fHistRhoScaledVsCent->Fill(fCent, fOutRhoScaled->GetVal());
331  }
332 
333  for (auto jetCont : fJetCollArray) {
334  fHistTotJetAreaVsCent[jetCont.first]->Fill(fCent, fTotJetArea[jetCont.first]);
335  if (fLeadingJet[jetCont.first]) {
336  fHistLeadJetPtVsCent[jetCont.first]->Fill(fCent, fLeadingJet[jetCont.first]->Pt());
337  fHistLeadJetPtDensityVsCent[jetCont.first]->Fill(fCent, fLeadingJet[jetCont.first]->Pt() / fLeadingJet[jetCont.first]->Area());
338  fHistLeadJetNconstVsCent[jetCont.first]->Fill(fCent, fLeadingJet[jetCont.first]->GetNumberOfConstituents());
339  fHistRhoVsLeadJetPt[jetCont.first]->Fill(fLeadingJet[jetCont.first]->Pt(), fOutRho->GetVal());
340  if (fCentBin >=0 && fCentBin < fCentBins.size()-1 && fHistLeadJetNconstVsPt[jetCont.first]) fHistLeadJetNconstVsPt[jetCont.first][fCentBin]->Fill(fLeadingJet[jetCont.first]->Pt(), fLeadingJet[jetCont.first]->GetNumberOfConstituents());
341  }
342  if (fHistNjetVsCent[jetCont.first]) fHistNjetVsCent[jetCont.first]->Fill(fCent, fNjets[jetCont.first]);
343 
344  if (fHistNjetVsNtrack[jetCont.first]) fHistNjetVsNtrack[jetCont.first]->Fill(fNtracks, fNjets[jetCont.first]);
345  }
346 
347  return kTRUE;
348 }
349 
354 {
355  if (!fOutRho) {
357 
358  if (fAttachToEvent) {
359  if (!(InputEvent()->FindListObject(fOutRhoName))) {
360  InputEvent()->AddObject(fOutRho);
361  } else {
362  AliFatal(Form("%s: Container with same name %s already present. Aborting", GetName(), fOutRhoName.Data()));
363  return;
364  }
365  }
366  }
367 
368  if (fScaleFunction && !fOutRhoScaled) {
370 
371  if (fAttachToEvent) {
372  if (!(InputEvent()->FindListObject(fOutRhoScaledName))) {
373  InputEvent()->AddObject(fOutRhoScaled);
374  } else {
375  AliFatal(Form("%s: Container with same name %s already present. Aborting", GetName(), fOutRhoScaledName.Data()));
376  return;
377  }
378  }
379  }
380 
382 
384 }
385 
392 {
393  Double_t rho = 0;
394  if (fRhoFunction) rho = fRhoFunction->Eval(cent);
395  return rho;
396 }
397 
404 {
405  Double_t scale = 1;
406  if (fScaleFunction) scale = fScaleFunction->Eval(cent);
407  return scale;
408 }
409 
416 TF1* AliAnalysisTaskRhoBaseDev::LoadRhoFunction(const char* path, const char* name)
417 {
418  TString fname(path);
419  if (fname.BeginsWith("alien://")) {
420  TGrid::Connect("alien://");
421  }
422 
423  TFile* file = TFile::Open(path);
424 
425  if (!file || file->IsZombie()) {
426  ::Error("AddTaskRho", "Could not open scale function file");
427  return 0;
428  }
429 
430  TF1* sfunc = dynamic_cast<TF1*>(file->Get(name));
431 
432  if (sfunc) {
433  ::Info("AliAnalysisTaskRhoBaseDev::LoadRhoFunction", "Scale function %s loaded from file %s.", name, path);
434  }
435  else {
436  ::Error("AliAnalysisTaskRhoBaseDev::LoadRhoFunction", "Scale function %s not found in file %s.", name, path);
437  return 0;
438  }
439 
440  fScaleFunction = static_cast<TF1*>(sfunc->Clone());
441 
442  file->Close();
443  delete file;
444 
445  return fScaleFunction;
446 }
447 
462 {
463  // Get the pointer to the existing analysis manager via the static access method.
464  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
465  if (!mgr) {
466  ::Error("AliAnalysisTaskRhoBaseDev::AddTaskRhoBaseDev", "No analysis manager to connect to.");
467  return nullptr;
468  }
469 
470  // Check the analysis type using the event handlers connected to the analysis manager.
471  AliVEventHandler* handler = mgr->GetInputEventHandler();
472  if (!handler) {
473  ::Error("AliAnalysisTaskRhoBaseDev::AddTaskRhoBaseDev", "This task requires an input event handler");
474  return nullptr;
475  }
476 
478 
479  if (handler->InheritsFrom("AliESDInputHandler")) {
480  dataType = kESD;
481  }
482  else if (handler->InheritsFrom("AliAODInputHandler")) {
483  dataType = kAOD;
484  }
485 
486  // Init the task and do settings
487  if (trackName == "usedefault") {
488  if (dataType == kESD) {
489  trackName = "Tracks";
490  }
491  else if (dataType == kAOD) {
492  trackName = "tracks";
493  }
494  else {
495  trackName = "";
496  }
497  }
498 
499  if (clusName == "usedefault") {
500  if (dataType == kESD) {
501  clusName = "CaloClusters";
502  }
503  else if (dataType == kAOD) {
504  clusName = "caloClusters";
505  }
506  else {
507  clusName = "";
508  }
509  }
510 
511  TString name("AliAnalysisTaskRhoBaseDev");
512  if (!suffix.IsNull()) {
513  name += "_";
514  name += suffix;
515  }
516 
517  AliAnalysisTaskRhoBaseDev* mgrTask = dynamic_cast<AliAnalysisTaskRhoBaseDev*>(mgr->GetTask(name.Data()));
518  if (mgrTask) {
519  ::Warning("AliAnalysisTaskRhoBaseDev::AddTaskRhoBaseDev", "Not adding the task again, since a task with the same name '%s' already exists", name.Data());
520  return mgrTask;
521  }
522 
523  AliAnalysisTaskRhoBaseDev* rhotask = new AliAnalysisTaskRhoBaseDev(name, histo);
524  rhotask->SetOutRhoName(nRho);
525 
526  AliParticleContainer* partCont = rhotask->AddParticleContainer(trackName.Data());
527  AliClusterContainer *clusterCont = rhotask->AddClusterContainer(clusName.Data());
528  if (clusterCont) {
529  clusterCont->SetClusECut(0.);
530  clusterCont->SetClusPtCut(0.);
531  clusterCont->SetClusHadCorrEnergyCut(0.3);
532  clusterCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
533  }
534 
535  AliJetContainer *jetCont = new AliJetContainer(jetType, AliJetContainer::kt_algorithm, rscheme, jetradius, partCont, clusterCont);
536  if (jetCont) {
537  jetCont->SetJetPtCut(0);
538  jetCont->SetJetAcceptanceType(acceptance);
539  jetCont->SetName("Background");
540  rhotask->AdoptJetContainer(jetCont);
541  }
542 
543  // Final settings, pass to manager and set the containers
544  mgr->AddTask(rhotask);
545 
546  // Create containers for input/output
547  mgr->ConnectInput(rhotask, 0, mgr->GetCommonInputContainer());
548  if (histo) {
549  TString contname(name);
550  contname += "_histos";
551  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contname.Data(),
552  TList::Class(), AliAnalysisManager::kOutputContainer,
553  Form("%s", AliAnalysisManager::GetCommonFileName()));
554  mgr->ConnectOutput(rhotask, 1, coutput1);
555  }
556 
557  return rhotask;
558 }
TString fOutRhoName
name of output rho object
AliClusterContainer * AddClusterContainer(std::string branchName, std::string contName="")
std::map< std::string, Int_t > fNjets
!number of jets
double Double_t
Definition: External.C:58
EDataType_t
Switch for the data type.
Definition: External.C:236
TF1 * fScaleFunction
pre-computed scale factor as a function of centrality
AliVCluster * fLeadingCluster
!leading cluster
TString fOutRhoScaledName
name of output scaled rho object
virtual Double_t GetRhoFactor(Double_t cent)
TH2 * fHistRhoVsCent
!rho vs. centrality
Int_t fNtracks
!number of tracks
Base class for a task that calculates the UE.
Bool_t fAttachToEvent
whether or not attach rho to the event objects list
std::map< std::string, TH2 * > fHistRhoVsLeadJetPt
!rho vs. leading jet pt
Bool_t fTaskConfigured
!kTRUE if the task is properly configured
std::map< std::string, TH2 * > fHistLeadJetPtVsCent
!leading jet pt vs. centrality
std::vector< double > fCentBins
how many centrality bins
std::map< std::string, TH2 * > fHistTotJetAreaVsCent
!total area covered by jets vs. centrality
TH2 * fHistNtrackVsCent
!no. of tracks vs. centrality
TH2 * fHistRhoVsLeadClusterE
!rho vs. leading cluster energy
Container for particles within the EMCAL framework.
EBeamType_t fForceBeamType
forced beam type
const Int_t nPtBins
std::map< std::string, TH2 * > fHistLeadJetPtDensityVsCent
!leading jet area vs. centrality
std::map< std::string, TH2 ** > fHistLeadJetNconstVsPt
!leading jet constituents vs. pt
Bool_t fCreateHisto
whether or not create histograms
int Int_t
Definition: External.C:63
void SetJetPtCut(Float_t cut)
void SetOutRhoName(const char *name)
unsigned int UInt_t
Definition: External.C:33
Float_t fMaxPt
Histogram pt limit.
TF1 * LoadRhoFunction(const char *path, const char *name)
TH2 * fHistRhoScaledVsCent
!rhoscaled vs. centrality
TH2 * fHistLeadClusterEVsCent
!leading cluster energy vs. centrality
Int_t fCentBin
!event centrality bin
TH2 * fHistRhoScaledVsNcluster
!rhoscaled vs. no. of clusters
std::map< std::string, TH2 * > fHistLeadJetNconstVsCent
!leading jet constituents vs. cent
virtual Double_t GetScaleFactor(Double_t cent)
static AliAnalysisTaskRhoBaseDev * AddTaskRhoBaseDev(TString nTracks="usedefault", TString nClusters="usedefault", TString nRho="Rho", Double_t jetradius=0.2, UInt_t acceptance=AliEmcalJet::kTPCfid, AliJetContainer::EJetType_t jetType=AliJetContainer::kChargedJet, AliJetContainer::ERecoScheme_t rscheme=AliJetContainer::pt_scheme, Bool_t histo=kTRUE, TString suffix="")
TH2 * fHistRhoVsNcluster
!rho vs. no. of clusters
std::map< std::string, TH2 * > fHistNjetVsNtrack
!no. of jets vs. no. of tracks
TH2 * fHistRhoVsLeadTrackPt
!rho vs. leading track pt
Base class for a task that studies the UE.
Float_t fPtBinWidth
Histogram pt bin width.
Int_t fNclusters
!number of clusters
AliParticleContainer * AddParticleContainer(std::string branchName, std::string contName="")
AliVParticle * fLeadingParticle
!leading particle
Definition: External.C:220
TH2 * fHistNclusterVsCent
!no. of cluster vs. centrality
TH2 * fHistRhoVsNtrack
!rho vs. no. of tracks
std::map< std::string, AliParticleContainer * > fParticleCollArray
particle/track collection array
TFile * file
TList with histograms for a given trigger.
TF1 * fRhoFunction
pre-computed rho as a function of centrality
virtual void CalculateEventProperties()
TH2 * fHistRhoScaledVsNtrack
!rhoscaled vs. no. of tracks
void SetClusPtCut(Double_t cut)
std::map< std::string, AliEmcalJet * > fLeadingJet
!leading jet
void AdoptJetContainer(AliJetContainer *cont)
std::map< std::string, AliJetContainer * > fJetCollArray
jet collection array
void SetJetAcceptanceType(UInt_t type)
bool Bool_t
Definition: External.C:53
Declaration of class AliAnalysisTaskRhoBaseDev.
AliRhoParameter * fOutRhoScaled
!output scaled rho object
void SetClusECut(Double_t cut)
void SetDefaultClusterEnergy(Int_t d)
std::map< std::string, AliClusterContainer * > fClusterCollArray
cluster collection array
Container structure for EMCAL clusters.
std::map< std::string, Double_t > fTotJetArea
!total area covered by jets
AliRhoParameter * fOutRho
!output rho object
Double_t fCent
!event centrality
Container for jet within the EMCAL jet framework.
std::map< std::string, TH2 * > fHistNjetVsCent
!no. of jets vs. centrality
TH2 * fHistLeadTrackPtVsCent
!leading track pt vs. centrality
void SetClusHadCorrEnergyCut(Double_t cut)