AliPhysics  ad6828d (ad6828d)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalLight.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 #include <RVersion.h>
16 #include <TClonesArray.h>
17 #include <TList.h>
18 #include <TObject.h>
19 #include <TH1F.h>
20 #include <TProfile.h>
21 #include <TSystem.h>
22 #include <TFile.h>
23 #include <TChain.h>
24 #include <TKey.h>
25 
26 #include "AliStack.h"
27 #include "AliAODEvent.h"
28 #include "AliAnalysisManager.h"
29 #include "AliCentrality.h"
30 #include "AliEMCALGeometry.h"
31 #include "AliESDEvent.h"
32 #include "AliEmcalParticle.h"
33 #include "AliEventplane.h"
34 #include "AliInputEventHandler.h"
35 #include "AliLog.h"
36 #include "AliMCParticle.h"
37 #include "AliVCluster.h"
38 #include "AliVEventHandler.h"
39 #include "AliVParticle.h"
40 #include "AliAODTrack.h"
41 #include "AliVCaloTrigger.h"
42 #include "AliGenPythiaEventHeader.h"
43 #include "AliAODMCHeader.h"
44 #include "AliMCEvent.h"
45 #include "AliEMCALTriggerPatchInfo.h"
46 
47 #include "AliMultSelection.h"
48 
50 
52 
56 
62  fForceBeamType(kNA),
63  fGeneralHistograms(kFALSE),
64  fCreateHisto(kTRUE),
65  fNeedEmcalGeom(kTRUE),
66  fCentBins(),
67  fUseNewCentralityEstimation(kFALSE),
68  fIsPythia(kFALSE),
69  fCaloCellsName(),
70  fCaloTriggersName(),
71  fCaloTriggerPatchInfoName(),
72  fCentEst("V0M"),
73  fParticleCollArray(),
74  fClusterCollArray(),
75  fTriggerSelectionBitMap(0),
76  fMinCent(-1),
77  fMaxCent(-1),
78  fMinVz(-999),
79  fMaxVz(999),
80  fMaxVzDiff(-1),
81  fMinNVertCont(0),
82  fMinPtHard(-1),
83  fMaxPtHard(-1),
84  fMaxMinimumBiasPtHard(-1),
85  fAcceptedTriggerClasses(),
86  fRejectedTriggerClasses(),
87  fMCRejectFilter(kFALSE),
88  fPtHardAndJetPtFactor(0.),
89  fPtHardAndClusterPtFactor(0.),
90  fPtHardAndTrackPtFactor(0.),
91  fSwitchOffLHC15oFaultyBranches(kFALSE),
92  fLocalInitialized(kFALSE),
93  fDataType(kAOD),
94  fGeom(0),
95  fCaloCells(0),
96  fCaloTriggers(0),
97  fTriggerPatchInfo(0),
98  fCent(-1),
99  fCentBin(-1),
100  fEPV0(-1.0),
101  fEPV0A(-1.0),
102  fEPV0C(-1.0),
103  fNVertCont(0),
104  fNVertSPDCont(0),
105  fFiredTriggerBitMap(0),
106  fFiredTriggerClasses(),
107  fBeamType(kNA),
108  fPythiaHeader(0),
109  fPtHardBin(-1),
110  fPtHard(0),
111  fNTrials(0),
112  fXsection(0),
113  fOutput(0),
114  fHistEventCount(0),
115  fHistTrialsVsPtHard(0),
116  fHistEventsVsPtHard(0),
117  fHistXsectionVsPtHard(0),
118  fHistTrials(0),
119  fHistEvents(0),
120  fHistXsection(0),
121  fHistCentrality(0),
122  fHistZVertex(0),
123  fHistEventPlane(0),
124  fHistEventRejection(0),
125  fHistTriggerClasses(0)
126 {
127  fVertex[0] = 0;
128  fVertex[1] = 0;
129  fVertex[2] = 0;
130  fVertexSPD[0] = 0;
131  fVertexSPD[1] = 0;
132  fVertexSPD[2] = 0;
133 }
134 
146  AliAnalysisTaskSE(name),
147  fForceBeamType(kNA),
148  fGeneralHistograms(kFALSE),
149  fCreateHisto(kTRUE),
150  fNeedEmcalGeom(kTRUE),
151  fCentBins(6),
152  fUseNewCentralityEstimation(kFALSE),
153  fIsPythia(kFALSE),
154  fCaloCellsName(),
155  fCaloTriggersName(),
156  fCaloTriggerPatchInfoName(),
157  fCentEst("V0M"),
158  fParticleCollArray(),
159  fClusterCollArray(),
160  fTriggerSelectionBitMap(0),
161  fMinCent(-1),
162  fMaxCent(-1),
163  fMinVz(-999),
164  fMaxVz(999),
165  fMaxVzDiff(-1),
166  fMinNVertCont(0),
167  fMinPtHard(-1),
168  fMaxPtHard(-1),
169  fMaxMinimumBiasPtHard(-1),
170  fAcceptedTriggerClasses(),
171  fRejectedTriggerClasses(),
172  fMCRejectFilter(kFALSE),
173  fPtHardAndJetPtFactor(0.),
174  fPtHardAndClusterPtFactor(0.),
175  fPtHardAndTrackPtFactor(0.),
176  fSwitchOffLHC15oFaultyBranches(kFALSE),
177  fLocalInitialized(kFALSE),
178  fDataType(kAOD),
179  fGeom(0),
180  fCaloCells(0),
181  fCaloTriggers(0),
182  fTriggerPatchInfo(0),
183  fCent(0),
184  fCentBin(-1),
185  fEPV0(-1.0),
186  fEPV0A(-1.0),
187  fEPV0C(-1.0),
188  fNVertCont(0),
189  fNVertSPDCont(0),
190  fFiredTriggerBitMap(0),
191  fFiredTriggerClasses(),
192  fBeamType(kNA),
193  fPythiaHeader(0),
194  fPtHardBin(-1),
195  fPtHard(0),
196  fNTrials(0),
197  fXsection(0),
198  fOutput(0),
199  fHistEventCount(0),
200  fHistTrialsVsPtHard(0),
201  fHistEventsVsPtHard(0),
202  fHistXsectionVsPtHard(0),
203  fHistTrials(0),
204  fHistEvents(0),
205  fHistXsection(0),
206  fHistCentrality(0),
207  fHistZVertex(0),
208  fHistEventPlane(0),
209  fHistEventRejection(0),
210  fHistTriggerClasses(0)
211 {
212  fVertex[0] = 0;
213  fVertex[1] = 0;
214  fVertex[2] = 0;
215  fVertexSPD[0] = 0;
216  fVertexSPD[1] = 0;
217  fVertexSPD[2] = 0;
218 
219  fCentBins[0] = 0;
220  fCentBins[1] = 10;
221  fCentBins[2] = 30;
222  fCentBins[3] = 50;
223  fCentBins[4] = 90;
224  fCentBins[5] = 100;
225 
226  if (fCreateHisto) DefineOutput(1, TList::Class());
227 }
228 
233 {
234  for (auto cont_it : fParticleCollArray) delete cont_it.second;
235  for (auto cont_it : fClusterCollArray) delete cont_it.second;
236 }
237 
258 {
259  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
260  if (mgr) {
261  AliVEventHandler *evhand = mgr->GetInputEventHandler();
262  if (evhand) {
263  if (evhand->InheritsFrom("AliESDInputHandler")) {
264  fDataType = kESD;
265  }
266  else {
267  fDataType = kAOD;
268  }
269  }
270  else {
271  AliError("Event handler not found!");
272  }
273  }
274  else {
275  AliError("Analysis manager not found!");
276  }
277 
278  if (!fCreateHisto)
279  return;
280 
281  OpenFile(1);
282  fOutput = new TList();
283  fOutput->SetOwner();
284 
285  if (fForceBeamType == kpp) fCentBins.clear();
286 
287  if (!fGeneralHistograms)
288  return;
289 
290  if (fIsPythia) {
291  fHistEventsVsPtHard = new TH1F("fHistEventsVsPtHard", "fHistEventsVsPtHard", 1000, 0, 1000);
292  fHistEventsVsPtHard->GetXaxis()->SetTitle("#it{p}_{T,hard} (GeV/#it{c})");
293  fHistEventsVsPtHard->GetYaxis()->SetTitle("events");
295 
296  fHistTrialsVsPtHard = new TH1F("fHistTrialsVsPtHard", "fHistTrialsVsPtHard", 1000, 0, 1000);
297  fHistTrialsVsPtHard->GetXaxis()->SetTitle("#it{p}_{T,hard} (GeV/#it{c})");
298  fHistTrialsVsPtHard->GetYaxis()->SetTitle("trials");
300 
301  fHistXsectionVsPtHard = new TProfile("fHistXsectionVsPtHard", "fHistXsectionVsPtHard", 1000, 0, 1000);
302  fHistXsectionVsPtHard->GetXaxis()->SetTitle("#it{p}_{T,hard} (GeV/#it{c})");
303  fHistXsectionVsPtHard->GetYaxis()->SetTitle("xsection");
305 
306  fHistTrials = new TH1F("fHistTrials", "fHistTrials", 50, 0, 50);
307  fHistTrials->GetXaxis()->SetTitle("#it{p}_{T,hard} bin");
308  fHistTrials->GetYaxis()->SetTitle("trials");
309  fOutput->Add(fHistTrials);
310 
311  fHistEvents = new TH1F("fHistEvents", "fHistEvents", 50, 0, 50);
312  fHistEvents->GetXaxis()->SetTitle("#it{p}_{T,hard} bin");
313  fHistEvents->GetYaxis()->SetTitle("total events");
314  fOutput->Add(fHistEvents);
315 
316  fHistXsection = new TProfile("fHistXsection", "fHistXsection", 50, 0, 50);
317  fHistXsection->GetXaxis()->SetTitle("#it{p}_{T,hard} bin");
318  fHistXsection->GetYaxis()->SetTitle("xsection");
319  fOutput->Add(fHistXsection);
320  }
321 
322  fHistZVertex = new TH1F("fHistZVertex","Z vertex position", 60, -30, 30);
323  fHistZVertex->GetXaxis()->SetTitle("V_{#it{z}}");
324  fHistZVertex->GetYaxis()->SetTitle("counts");
325  fOutput->Add(fHistZVertex);
326 
327  if (fForceBeamType != kpp) {
328  fHistCentrality = new TH1F("fHistCentrality","Event centrality distribution", 101, 0, 101);
329  fHistCentrality->GetXaxis()->SetTitle("Centrality (%)");
330  fHistCentrality->GetYaxis()->SetTitle("counts");
331  fOutput->Add(fHistCentrality);
332 
333  fHistEventPlane = new TH1F("fHistEventPlane","Event plane", 120, -TMath::Pi(), TMath::Pi());
334  fHistEventPlane->GetXaxis()->SetTitle("event plane");
335  fHistEventPlane->GetYaxis()->SetTitle("counts");
336  fOutput->Add(fHistEventPlane);
337  }
338 
339  fHistEventRejection = new TH1F("fHistEventRejection","Reasons to reject event",20,0,20);
340 #if ROOT_VERSION_CODE < ROOT_VERSION(6,4,2)
341  fHistEventRejection->SetBit(TH1::kCanRebin);
342 #else
343  fHistEventRejection->SetCanExtend(TH1::kAllAxes);
344 #endif
345  fHistEventRejection->GetXaxis()->SetBinLabel(1,"PhysSel");
346  fHistEventRejection->GetXaxis()->SetBinLabel(2,"trigger");
347  fHistEventRejection->GetXaxis()->SetBinLabel(3,"trigTypeSel");
348  fHistEventRejection->GetXaxis()->SetBinLabel(4,"Cent");
349  fHistEventRejection->GetXaxis()->SetBinLabel(5,"vertex contr.");
350  fHistEventRejection->GetXaxis()->SetBinLabel(6,"Vz");
351  fHistEventRejection->GetXaxis()->SetBinLabel(7,"VzSPD");
352  fHistEventRejection->GetXaxis()->SetBinLabel(8,"trackInEmcal");
353  fHistEventRejection->GetXaxis()->SetBinLabel(9,"minNTrack");
354  fHistEventRejection->GetXaxis()->SetBinLabel(10,"VtxSel2013pA");
355  fHistEventRejection->GetXaxis()->SetBinLabel(11,"PileUp");
356  fHistEventRejection->GetXaxis()->SetBinLabel(12,"EvtPlane");
357  fHistEventRejection->GetXaxis()->SetBinLabel(13,"SelPtHardBin");
358  fHistEventRejection->GetXaxis()->SetBinLabel(14,"Bkg evt");
359  fHistEventRejection->GetXaxis()->SetBinLabel(14,"MCOutlier");
360  fHistEventRejection->GetYaxis()->SetTitle("counts");
362 
363  fHistTriggerClasses = new TH1F("fHistTriggerClasses","fHistTriggerClasses",3,0,3);
364 #if ROOT_VERSION_CODE < ROOT_VERSION(6,4,2)
365  fHistTriggerClasses->SetBit(TH1::kCanRebin);
366 #else
367  fHistTriggerClasses->SetCanExtend(TH1::kAllAxes);
368 #endif
370 
371  fHistEventCount = new TH1F("fHistEventCount","fHistEventCount",2,0,2);
372  fHistEventCount->GetXaxis()->SetBinLabel(1,"Accepted");
373  fHistEventCount->GetXaxis()->SetBinLabel(2,"Rejected");
374  fHistEventCount->GetYaxis()->SetTitle("counts");
375  fOutput->Add(fHistEventCount);
376 
377  PostData(1, fOutput);
378 }
379 
394 {
395  if (fIsPythia) {
396  fHistEventsVsPtHard->Fill(fPtHard, 1);
399  }
400 
401  fHistZVertex->Fill(fVertex[2]);
402 
403  if (fForceBeamType != kpp) {
404  fHistCentrality->Fill(fCent);
405  fHistEventPlane->Fill(fEPV0);
406  }
407 
408  TObjArray* triggerClasses = InputEvent()->GetFiredTriggerClasses().Tokenize(" ");
409  TIter next(triggerClasses);
410  TObjString* triggerClass = 0;
411  while ((triggerClass = static_cast<TObjString*>(next()))) {
412  fHistTriggerClasses->Fill(triggerClass->GetString(), 1);
413  }
414  delete triggerClasses;
415  triggerClasses = 0;
416 
417  return kTRUE;
418 }
419 
440 {
441  if (!fLocalInitialized)
442  ExecOnce();
443 
444  if (!fLocalInitialized)
445  return;
446 
447  if (!RetrieveEventObjects())
448  return;
449 
450  if (IsEventSelected()) {
451  if (fGeneralHistograms) fHistEventCount->Fill("Accepted",1);
452  }
453  else {
454  if (fGeneralHistograms) fHistEventCount->Fill("Rejected",1);
455  return;
456  }
457 
459  if (!FillGeneralHistograms())
460  return;
461  }
462 
463  if (!Run())
464  return;
465 
466  if (fCreateHisto) {
467  if (!FillHistograms())
468  return;
469  }
470 
471  if (fCreateHisto && fOutput) {
472  // information for this iteration of the UserExec in the container
473  PostData(1, fOutput);
474  }
475 }
476 
488 Bool_t AliAnalysisTaskEmcalLight::PythiaInfoFromFile(const char* currFile, Float_t &fXsec, Float_t &fTrials, Int_t &pthard)
489 {
490 
491  TString file(currFile);
492  fXsec = 0;
493  fTrials = 1;
494 
495  if (file.Contains(".zip#")) {
496  Ssiz_t pos1 = file.Index("root_archive",12,0,TString::kExact);
497  Ssiz_t pos = file.Index("#",1,pos1,TString::kExact);
498  Ssiz_t pos2 = file.Index(".root",5,TString::kExact);
499  file.Replace(pos+1,pos2-pos1,"");
500  } else {
501  // not an archive take the basename....
502  file.ReplaceAll(gSystem->BaseName(file.Data()),"");
503  }
504  AliDebug(1,Form("File name: %s",file.Data()));
505 
506  // Get the pt hard bin
507  TString strPthard(file);
508 
509  strPthard.Remove(strPthard.Last('/'));
510  strPthard.Remove(strPthard.Last('/'));
511  if (strPthard.Contains("AOD")) strPthard.Remove(strPthard.Last('/'));
512  strPthard.Remove(0,strPthard.Last('/')+1);
513  if (strPthard.IsDec()) {
514  pthard = strPthard.Atoi();
515  }
516  else {
517  AliWarning(Form("Could not extract file number from path %s", strPthard.Data()));
518  pthard = -1;
519  }
520 
521  // problem that we cannot really test the existance of a file in a archive so we have to live with open error message from root
522  TFile *fxsec = TFile::Open(Form("%s%s",file.Data(),"pyxsec.root"));
523 
524  if (!fxsec) {
525  // next trial fetch the histgram file
526  fxsec = TFile::Open(Form("%s%s",file.Data(),"pyxsec_hists.root"));
527  if (!fxsec) {
528  // not a severe condition but inciate that we have no information
529  return kFALSE;
530  } else {
531  // find the tlist we want to be independtent of the name so use the Tkey
532  TKey* key = static_cast<TKey*>(fxsec->GetListOfKeys()->At(0));
533  if (!key) {
534  fxsec->Close();
535  return kFALSE;
536  }
537  TList *list = dynamic_cast<TList*>(key->ReadObj());
538  if (!list) {
539  fxsec->Close();
540  return kFALSE;
541  }
542  fXsec = static_cast<TProfile*>(list->FindObject("h1Xsec"))->GetBinContent(1);
543  fTrials = static_cast<TH1F*>(list->FindObject("h1Trials"))->GetBinContent(1);
544  fxsec->Close();
545  }
546  } else { // no tree pyxsec.root
547  TTree *xtree = static_cast<TTree*>(fxsec->Get("Xsection"));
548  if (!xtree) {
549  fxsec->Close();
550  return kFALSE;
551  }
552  UInt_t ntrials = 0;
553  Double_t xsection = 0;
554  xtree->SetBranchAddress("xsection",&xsection);
555  xtree->SetBranchAddress("ntrials",&ntrials);
556  xtree->GetEntry(0);
557  fTrials = ntrials;
558  fXsec = xsection;
559  fxsec->Close();
560  }
561  return kTRUE;
562 }
563 
578 {
580  return kTRUE;
581 
582  TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
583  if (!tree) {
584  AliError(Form("%s - UserNotify: No current tree!",GetName()));
585  return kFALSE;
586  }
587 
588  Float_t xsection = 0;
589  Float_t trials = 0;
590  Int_t pthardbin = 0;
591 
592  TFile *curfile = tree->GetCurrentFile();
593  if (!curfile) {
594  AliError(Form("%s - UserNotify: No current file!",GetName()));
595  return kFALSE;
596  }
597 
598  TChain *chain = dynamic_cast<TChain*>(tree);
599  if (chain) tree = chain->GetTree();
600 
601  Int_t nevents = tree->GetEntriesFast();
602 
603  Bool_t res = PythiaInfoFromFile(curfile->GetName(), xsection, trials, pthardbin);
604 
605  fPtHardBin = pthardbin;
606 
607  if (!res) return kTRUE;
608 
609  fHistTrials->Fill(fPtHardBin, trials);
610  fHistXsection->Fill(fPtHardBin, xsection);
611  fHistEvents->Fill(fPtHardBin, nevents);
612 
613  return kTRUE;
614 }
615 
627 {
628  if (!InputEvent()) {
629  AliError(Form("%s: Could not retrieve event! Returning!", GetName()));
630  return;
631  }
632 
633  if (fNeedEmcalGeom) {
634  fGeom = AliEMCALGeometry::GetInstanceFromRunNumber(InputEvent()->GetRunNumber());
635  if (!fGeom) {
636  AliFatal(Form("%s: Can not get EMCal geometry instance. If you do not need the EMCal geometry, disable it by setting task->SetNeedEmcalGeometry(kFALSE).", GetName()));
637  return;
638  }
639  }
640 
641  if (fSwitchOffLHC15oFaultyBranches && dynamic_cast<AliAODEvent*>(InputEvent())) {
642  TTree *aodTree = AliAnalysisManager::GetAnalysisManager()->GetTree();
643  aodTree->SetBranchStatus("D0toKpi.fPx", 0);
644  aodTree->SetBranchStatus("D0toKpi.fPy", 0);
645  aodTree->SetBranchStatus("D0toKpi.fPz", 0);
646  aodTree->SetBranchStatus("D0toKpi.fd0", 0);
647  aodTree->SetBranchStatus("Charm3Prong.fPx", 0);
648  aodTree->SetBranchStatus("Charm3Prong.fPy", 0);
649  aodTree->SetBranchStatus("Charm3Prong.fPz", 0);
650  aodTree->SetBranchStatus("Charm3Prong.fd0", 0);
651  aodTree->SetBranchStatus("Dstar.fPx", 0);
652  aodTree->SetBranchStatus("Dstar.fPy", 0);
653  aodTree->SetBranchStatus("Dstar.fPz", 0);
654  aodTree->SetBranchStatus("Dstar.fd0", 0);
655  }
656 
657  //Load all requested track branches - each container knows name already
658  for (auto cont_it : fParticleCollArray) cont_it.second->SetArray(InputEvent());
659 
660  //Load all requested cluster branches - each container knows name already
661  for (auto cont_it : fClusterCollArray) cont_it.second->SetArray(InputEvent());
662 
663  if (!fCaloCellsName.IsNull() && !fCaloCells) {
664  fCaloCells = dynamic_cast<AliVCaloCells*>(InputEvent()->FindListObject(fCaloCellsName));
665  if (!fCaloCells) {
666  AliError(Form("%s: Could not retrieve cells %s!", GetName(), fCaloCellsName.Data()));
667  return;
668  }
669  }
670 
671  if (!fCaloTriggersName.IsNull() && !fCaloTriggers) {
672  fCaloTriggers = dynamic_cast<AliVCaloTrigger*>(InputEvent()->FindListObject(fCaloTriggersName));
673  if (!fCaloTriggers) {
674  AliError(Form("%s: Could not retrieve calo triggers %s!", GetName(), fCaloTriggersName.Data()));
675  return;
676  }
677  }
678 
679  if (!fCaloTriggerPatchInfoName.IsNull() && !fTriggerPatchInfo) {
680  fTriggerPatchInfo = GetArrayFromEvent(fCaloTriggerPatchInfoName.Data(),"AliEMCALTriggerPatchInfo");
681  if (!fTriggerPatchInfo) {
682  AliError(Form("%s: Could not retrieve calo trigger patch info %s!", GetName(), fCaloTriggerPatchInfoName.Data()));
683  return;
684  }
685 
686  }
687 
688  fLocalInitialized = kTRUE;
689 }
690 
697 {
698  if (fForceBeamType != kNA)
699  return fForceBeamType;
700 
701  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(InputEvent());
702  if (esd) {
703  const AliESDRun *run = esd->GetESDRun();
704  TString beamType = run->GetBeamType();
705  if (beamType == "p-p")
706  return kpp;
707  else if (beamType == "A-A")
708  return kAA;
709  else if (beamType == "p-A")
710  return kpA;
711  else
712  return kNA;
713  } else {
714  Int_t runNumber = InputEvent()->GetRunNumber();
715  // All run number ranges taken from the RCT
716  if ((runNumber >= 136833 && runNumber <= 139517) || // LHC10h
717  (runNumber >= 167693 && runNumber <= 170593) || // LHC11h
718  (runNumber >= 244824 && runNumber <= 246994)) { // LHC15o
719  return kAA;
720  } else if ((runNumber >= 188356 && runNumber <= 188366) || // LHC12g
721  (runNumber >= 195164 && runNumber <= 197388) || // LHC13b-f
722  (runNumber >= 265015 && runNumber <= 267166)) { // LHC16q-t
723  return kpA;
724  } else {
725  return kpp;
726  }
727  }
728 }
729 
752 {
754  if (fGeneralHistograms) fHistEventRejection->Fill("PhysSel",1);
755  return kFALSE;
756  }
757 
758  Bool_t acceptedTrgClassFound = kFALSE;
759  if (fAcceptedTriggerClasses.size() > 0) {
760  for (auto trg_it : fAcceptedTriggerClasses) {
761  if (fFiredTriggerClasses.Contains(trg_it.c_str())) {
762  acceptedTrgClassFound = kTRUE;
763  break;
764  }
765  }
766 
767  if (!acceptedTrgClassFound) {
768  if (fGeneralHistograms) fHistEventRejection->Fill("Trg class (acc)",1);
769  return kFALSE;
770  }
771  }
772 
773  if (fRejectedTriggerClasses.size() > 0) {
774  for (auto trg_it : fRejectedTriggerClasses) {
775  if (fFiredTriggerClasses.Contains(trg_it.c_str())) {
776  if (fGeneralHistograms) fHistEventRejection->Fill("Trg class (rej)",1);
777  return kFALSE;
778  }
779  }
780  }
781 
782  if (fMinCent < fMaxCent && fMaxCent > 0) {
783  if (fCent < fMinCent || fCent > fMaxCent) {
784  if (fGeneralHistograms) fHistEventRejection->Fill("Cent",1);
785  return kFALSE;
786  }
787  }
788 
789  if (fNVertCont < fMinNVertCont) {
790  if (fGeneralHistograms) fHistEventRejection->Fill("vertex contr.",1);
791  return kFALSE;
792  }
793 
794  if (fMinVz < fMaxVz) {
795  if (fVertex[2] < fMinVz || fVertex[2] > fMaxVz) {
796  if (fGeneralHistograms) fHistEventRejection->Fill("Vz",1);
797  return kFALSE;
798  }
799  }
800 
801  if (fMaxVzDiff >= 0) {
802  if (fNVertSPDCont > 0) {
803  Double_t vzSPD = fVertexSPD[2];
804  Double_t dvertex = TMath::Abs(fVertex[2] - vzSPD);
805  //if difference larger than fZvertexDiff
806  if (dvertex > fMaxVzDiff) {
807  if (fGeneralHistograms) fHistEventRejection->Fill("VzSPD",1);
808  return kFALSE;
809  }
810  }
811  }
812 
813  if (fMinPtHard >= 0 && fPtHard < fMinPtHard) {
814  if (fGeneralHistograms) fHistEventRejection->Fill("SelPtHardBin",1);
815  return kFALSE;
816  }
817 
818  if (fMaxPtHard >= 0 && fPtHard >= fMaxPtHard) {
819  if (fGeneralHistograms) fHistEventRejection->Fill("SelPtHardBin",1);
820  return kFALSE;
821  }
822 
824  if (fGeneralHistograms) fHistEventRejection->Fill("SelPtHardBin",1);
825  return kFALSE;
826  }
827 
828  // Reject filter for MC data
829  if (!CheckMCOutliers()) {
830  if (fGeneralHistograms) fHistEventRejection->Fill("MCOutlier",1);
831  return kFALSE;
832  }
833 
834  return kTRUE;
835 }
836 
845 TClonesArray *AliAnalysisTaskEmcalLight::GetArrayFromEvent(const char *name, const char *clname)
846 {
847  TClonesArray *arr = 0;
848  TString sname(name);
849  if (!sname.IsNull()) {
850  arr = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(sname));
851  if (!arr) {
852  AliWarning(Form("%s: Could not retrieve array with name %s!", GetName(), name));
853  return 0;
854  }
855  } else {
856  return 0;
857  }
858 
859  if (!clname)
860  return arr;
861 
862  TString objname(arr->GetClass()->GetName());
863  TClass cls(objname);
864  if (!cls.InheritsFrom(clname)) {
865  AliWarning(Form("%s: Objects of type %s in %s are not inherited from %s!",
866  GetName(), cls.GetName(), name, clname));
867  return 0;
868  }
869  return arr;
870 }
871 
877 {
878  fVertex[0] = 0;
879  fVertex[1] = 0;
880  fVertex[2] = 0;
881  fNVertCont = 0;
882 
883  fVertexSPD[0] = 0;
884  fVertexSPD[1] = 0;
885  fVertexSPD[2] = 0;
886  fNVertSPDCont = 0;
887 
888  fFiredTriggerClasses = InputEvent()->GetFiredTriggerClasses();
889 
890  if (fDataType == kESD) {
891  fFiredTriggerBitMap = static_cast<AliInputEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())->IsEventSelected();
892  }
893  else {
894  fFiredTriggerBitMap = static_cast<AliVAODHeader*>(InputEvent()->GetHeader())->GetOfflineTrigger();
895  }
896 
897  const AliVVertex *vert = InputEvent()->GetPrimaryVertex();
898  if (vert) {
899  vert->GetXYZ(fVertex);
900  fNVertCont = vert->GetNContributors();
901  }
902 
903  const AliVVertex *vertSPD = InputEvent()->GetPrimaryVertexSPD();
904  if (vertSPD) {
905  vertSPD->GetXYZ(fVertexSPD);
906  fNVertSPDCont = vertSPD->GetNContributors();
907  }
908 
910 
911  fCent = 99;
912  fCentBin = 0;
913  fEPV0 = -999;
914  fEPV0A = -999;
915  fEPV0C = -999;
916 
917  if (fBeamType == kAA || fBeamType == kpA ) {
919  AliMultSelection *MultSelection = static_cast<AliMultSelection*>(InputEvent()->FindListObject("MultSelection"));
920  if (MultSelection) {
921  fCent = MultSelection->GetMultiplicityPercentile(fCentEst.Data());
922  }
923  else {
924  AliWarning(Form("%s: Could not retrieve centrality information! Assuming 99", GetName()));
925  }
926  }
927  else { // old centrality estimation < 2015
928  AliCentrality *aliCent = InputEvent()->GetCentrality();
929  if (aliCent) {
930  fCent = aliCent->GetCentralityPercentile(fCentEst.Data());
931  }
932  else {
933  AliWarning(Form("%s: Could not retrieve centrality information! Assuming 99", GetName()));
934  }
935  }
936 
937  fCentBin = -1;
938  for (auto cent_it = fCentBins.begin(); cent_it != fCentBins.end() - 1; cent_it++) {
939  if (fCent >= *cent_it && fCent < *(cent_it+1)) fCentBin = cent_it - fCentBins.begin();
940  }
941 
942  AliEventplane *aliEP = InputEvent()->GetEventplane();
943  if (aliEP) {
944  fEPV0 = aliEP->GetEventplane("V0" ,InputEvent());
945  fEPV0A = aliEP->GetEventplane("V0A",InputEvent());
946  fEPV0C = aliEP->GetEventplane("V0C",InputEvent());
947  } else {
948  AliWarning(Form("%s: Could not retrieve event plane information!", GetName()));
949  }
950  }
951 
952  if (fIsPythia) {
953  if (MCEvent()) {
954  fPythiaHeader = dynamic_cast<AliGenPythiaEventHeader*>(MCEvent()->GenEventHeader());
955  if (!fPythiaHeader) {
956  // Check if AOD
957  AliAODMCHeader* aodMCH = dynamic_cast<AliAODMCHeader*>(InputEvent()->FindListObject(AliAODMCHeader::StdBranchName()));
958 
959  if (aodMCH) {
960  for (UInt_t i = 0;i<aodMCH->GetNCocktailHeaders();i++) {
961  fPythiaHeader = dynamic_cast<AliGenPythiaEventHeader*>(aodMCH->GetCocktailHeader(i));
962  if (fPythiaHeader) break;
963  }
964  }
965  }
966  }
967 
968  if (fPythiaHeader) {
969  fPtHard = fPythiaHeader->GetPtHard();
970  fXsection = fPythiaHeader->GetXsection();
971  fNTrials = fPythiaHeader->Trials();
972  }
973  }
974 
975  for (auto cont_it : fParticleCollArray) cont_it.second->NextEvent();
976  for (auto cont_it : fClusterCollArray) cont_it.second->NextEvent();
977 
978  return kTRUE;
979 }
980 
989 AliParticleContainer* AliAnalysisTaskEmcalLight::AddParticleContainer(std::string branchName, std::string contName)
990 {
991  if (branchName.size() == 0) return 0;
992 
993  AliParticleContainer* cont = 0;
994 
995  if (branchName == "tracks" || branchName == "Tracks") cont = new AliTrackContainer(branchName.c_str());
996  else if (branchName == "mcparticles") cont = new AliMCParticleContainer(branchName.c_str());
997  else cont = new AliParticleContainer(branchName.c_str());
998 
999  if (contName.size() > 0) cont->SetName(contName.c_str());
1000 
1001  AdoptParticleContainer(cont);
1002 
1003  return cont;
1004 }
1005 
1014 AliClusterContainer* AliAnalysisTaskEmcalLight::AddClusterContainer(std::string branchName, std::string contName)
1015 {
1016  if (branchName.size() == 0) return 0;
1017 
1018  AliClusterContainer* cont = new AliClusterContainer(branchName.c_str());
1019 
1020  if (contName.size() > 0) cont->SetName(contName.c_str());
1021 
1022  AdoptClusterContainer(cont);
1023 
1024  return cont;
1025 }
1026 
1033 {
1034  std::map<std::string, AliParticleContainer*>::const_iterator cont_it = fParticleCollArray.find(name);
1035  if (cont_it != fParticleCollArray.end()) return cont_it->second;
1036  else return nullptr;
1037 }
1038 
1045 {
1046  std::map<std::string, AliClusterContainer*>::const_iterator cont_it = fClusterCollArray.find(name);
1047  if (cont_it != fClusterCollArray.end()) return cont_it->second;
1048  else return nullptr;
1049 }
1050 
1057 {
1058  if (!(InputEvent()->FindListObject(obj->GetName()))) {
1059  InputEvent()->AddObject(obj);
1060  }
1061  else {
1062  if (!attempt) {
1063  AliFatal(Form("%s: Container with name %s already present. Aborting", GetName(), obj->GetName()));
1064  }
1065  }
1066 }
1067 
1076 {
1077 
1078  if (!fGeom) {
1079  AliWarning(Form("%s - AliAnalysisTaskEmcalBase::IsTrackInEmcalAcceptance - Geometry is not available!", GetName()));
1080  return kFALSE;
1081  }
1082 
1083  Double_t minPhi = fGeom->GetArm1PhiMin() - edges;
1084  Double_t maxPhi = fGeom->GetArm1PhiMax() + edges;
1085 
1086  if (part->Phi() > minPhi && part->Phi() < maxPhi) {
1087  return kTRUE;
1088  }
1089  else {
1090  return kFALSE;
1091  }
1092 }
1093 
1095 {
1096  axis->SetBinLabel(1, "NullObject");
1097  axis->SetBinLabel(2, "Pt");
1098  axis->SetBinLabel(3, "Acceptance");
1099  axis->SetBinLabel(4, "MCLabel");
1100  axis->SetBinLabel(5, "BitMap");
1101  axis->SetBinLabel(6, "HF cut");
1102  axis->SetBinLabel(7, "Bit6");
1103  axis->SetBinLabel(8, "NotHybridTrack");
1104  axis->SetBinLabel(9, "MCFlag");
1105  axis->SetBinLabel(10, "MCGenerator");
1106  axis->SetBinLabel(11, "ChargeCut");
1107  axis->SetBinLabel(12, "MinDistanceTPCSectorEdge");
1108  axis->SetBinLabel(13, "Bit12");
1109  axis->SetBinLabel(14, "IsEMCal");
1110  axis->SetBinLabel(15, "Time");
1111  axis->SetBinLabel(16, "Energy");
1112  axis->SetBinLabel(17, "ExoticCut");
1113  axis->SetBinLabel(18, "Bit17");
1114  axis->SetBinLabel(19, "Area");
1115  axis->SetBinLabel(20, "AreaEmc");
1116  axis->SetBinLabel(21, "ZLeadingCh");
1117  axis->SetBinLabel(22, "ZLeadingEmc");
1118  axis->SetBinLabel(23, "NEF");
1119  axis->SetBinLabel(24, "MinLeadPt");
1120  axis->SetBinLabel(25, "MaxTrackPt");
1121  axis->SetBinLabel(26, "MaxClusterPt");
1122  axis->SetBinLabel(27, "Flavour");
1123  axis->SetBinLabel(28, "TagStatus");
1124  axis->SetBinLabel(29, "MinNConstituents");
1125  axis->SetBinLabel(30, "Bit29");
1126  axis->SetBinLabel(31, "Bit30");
1127  axis->SetBinLabel(32, "Bit31");
1128 }
1129 
1136 Double_t AliAnalysisTaskEmcalLight::GetParallelFraction(AliVParticle* part1, AliVParticle* part2)
1137 {
1138  TVector3 vect1(part1->Px(), part1->Py(), part1->Pz());
1139  TVector3 vect2(part2->Px(), part2->Py(), part2->Pz());
1140  Double_t z = (vect1 * vect2) / (vect2 * vect2);
1141  return z;
1142 }
1143 
1150 Double_t AliAnalysisTaskEmcalLight::GetParallelFraction(const TVector3& vect1, AliVParticle* part2)
1151 {
1152  TVector3 vect2(part2->Px(), part2->Py(), part2->Pz());
1153  Double_t z = (vect1 * vect2) / (vect2 * vect2);
1154  return z;
1155 }
1156 
1165 void AliAnalysisTaskEmcalLight::GetEtaPhiDiff(const AliVTrack *t, const AliVCluster *v, Double_t &phidiff, Double_t &etadiff)
1166 {
1167  phidiff = 999;
1168  etadiff = 999;
1169 
1170  if (!t||!v) return;
1171 
1172  Double_t veta = t->GetTrackEtaOnEMCal();
1173  Double_t vphi = t->GetTrackPhiOnEMCal();
1174 
1175  Float_t pos[3] = {0};
1176  v->GetPosition(pos);
1177  TVector3 cpos(pos);
1178  Double_t ceta = cpos.Eta();
1179  Double_t cphi = cpos.Phi();
1180  etadiff=veta-ceta;
1181  phidiff=TVector2::Phi_mpi_pi(vphi-cphi);
1182 }
1183 
1190 {
1191  Byte_t ret = 0;
1192  if (t->TestBit(BIT(22)) && !t->TestBit(BIT(23)))
1193  ret = 1;
1194  else if (!t->TestBit(BIT(22)) && t->TestBit(BIT(23)))
1195  ret = 2;
1196  else if (t->TestBit(BIT(22)) && t->TestBit(BIT(23)))
1197  ret = 3;
1198  return ret;
1199 }
1200 
1210 Byte_t AliAnalysisTaskEmcalLight::GetTrackType(const AliAODTrack *aodTrack, UInt_t filterBit1, UInt_t filterBit2)
1211 {
1212 
1213  Int_t res = 0;
1214 
1215  if (aodTrack->TestFilterBit(filterBit1)) {
1216  res = 0;
1217  }
1218  else if (aodTrack->TestFilterBit(filterBit2)) {
1219  if ((aodTrack->GetStatus()&AliVTrack::kITSrefit)!=0) {
1220  res = 1;
1221  }
1222  else {
1223  res = 2;
1224  }
1225  }
1226  else {
1227  res = 3;
1228  }
1229 
1230  return res;
1231 }
1232 
1239 {
1240  EBeamType_t b = kpp;
1241  if ((runnumber >= 136833 && runnumber <= 139517) || // LHC10h Run-1 (Pb-Pb)
1242  (runnumber >= 167693 && runnumber <= 170593) || // LHC11h Run-1 (Pb-Pb)
1243  (runnumber >= 244824 && runnumber <= 246994)) { // LHC15o Run-2 (Pb-Pb)
1244  b = kAA;
1245  }
1246  else if ((runnumber > 188356 && runnumber <= 188503) || // LHC12g Run-1 (p-Pb pilot)
1247  (runnumber >= 195164 && runnumber <= 197388) || // LHC13b,c,d,e,f Run-1 (p-Pb)
1248  (runnumber >= 265077 && runnumber <= 999999)) { // LHC16 Run-2 (p-Pb)
1249  b = kpA;
1250  }
1251  return b;
1252 }
1253 
1260 {
1261  if (!fPythiaHeader || !fMCRejectFilter) return kTRUE;
1262 
1263  // Condition 1: Pythia jet / pT-hard > factor
1264  if (fPtHardAndJetPtFactor > 0.) {
1265  AliTLorentzVector jet;
1266 
1267  Int_t nTriggerJets = fPythiaHeader->NTriggerJets();
1268 
1269  AliDebug(1,Form("Njets: %d, pT Hard %f",nTriggerJets, fPtHard));
1270 
1271  Float_t tmpjet[]={0,0,0,0};
1272  for (Int_t ijet = 0; ijet< nTriggerJets; ijet++) {
1273  fPythiaHeader->TriggerJet(ijet, tmpjet);
1274 
1275  jet.SetPxPyPzE(tmpjet[0],tmpjet[1],tmpjet[2],tmpjet[3]);
1276 
1277  AliDebug(1,Form("jet %d; pycell jet pT %f",ijet, jet.Pt()));
1278 
1279  //Compare jet pT and pt Hard
1280  if (jet.Pt() > fPtHardAndJetPtFactor * fPtHard) {
1281  AliInfo(Form("Reject jet event with : pT Hard %2.2f, pycell jet pT %2.2f, rejection factor %1.1f\n", fPtHard, jet.Pt(), fPtHardAndJetPtFactor));
1282  return kFALSE;
1283  }
1284  }
1285  }
1286  // end condition 1
1287 
1288  // Condition 2 : Reconstructed EMCal cluster pT / pT-hard > factor
1289  if (fPtHardAndClusterPtFactor > 0.) {
1290  AliClusterContainer* mccluscont = GetClusterContainer(0);
1291  if ((Bool_t)mccluscont) {
1292  for (auto cluster : mccluscont->all()) {// Not cuts applied ; use accept for cuts
1293  Float_t ecluster = cluster->E();
1294 
1295  if (ecluster > (fPtHardAndClusterPtFactor * fPtHard)) {
1296  AliInfo(Form("Reject : ecluster %2.2f, calo %d, factor %2.2f, ptHard %f",ecluster,cluster->GetType(),fPtHardAndClusterPtFactor,fPtHard));
1297  return kFALSE;
1298  }
1299  }
1300  }
1301  }
1302  // end condition 2
1303 
1304  // condition 3 : Reconstructed track pT / pT-hard >factor
1305  if (fPtHardAndTrackPtFactor > 0.) {
1306  AliMCParticleContainer* mcpartcont = dynamic_cast<AliMCParticleContainer*>(GetParticleContainer(0));
1307  if ((Bool_t)mcpartcont) {
1308  for (auto mctrack : mcpartcont->all()) {// Not cuts applied ; use accept for cuts
1309  Float_t trackpt = mctrack->Pt();
1310  if (trackpt > (fPtHardAndTrackPtFactor * fPtHard) ) {
1311  AliInfo(Form("Reject : track %2.2f, factor %2.2f, ptHard %f", trackpt, fPtHardAndTrackPtFactor, fPtHard));
1312  return kFALSE;
1313  }
1314  }
1315  }
1316  }
1317  // end condition 3
1318 
1319  return kTRUE;
1320 }
1321 
Bool_t fSwitchOffLHC15oFaultyBranches
Switch off faulty tree branches in LHC15o AOD trees.
AliClusterContainer * AddClusterContainer(std::string branchName, std::string contName="")
Float_t fPtHardAndJetPtFactor
Factor between ptHard and jet pT to reject/accept event.
Double_t fVertexSPD[3]
!event Svertex
TString fCaloTriggersName
name of calo triggers collection
AliEMCALGeometry * fGeom
!emcal geometry
EBeamType_t fBeamType
!event beam type
double Double_t
Definition: External.C:58
TClonesArray * GetArrayFromEvent(const char *name, const char *clname=0)
Float_t fXsection
!x-section from pythia header
Double_t fEPV0A
!event plane V0A
Double_t fEPV0
!event plane V0
TH1 * fHistEventCount
!incoming and selected events
Container with name, TClonesArray and cuts for particles.
TSystem * gSystem
Bool_t fMCRejectFilter
enable the filtering of events by tail rejection
TString fCaloTriggerPatchInfoName
trigger patch info array name
Double_t fMinVz
min vertex for event selection
TList * list
TString fCentEst
name of the centrality estimator
UInt_t fTriggerSelectionBitMap
trigger selection bit map
TH1 * fHistCentrality
!event centrality distribution
const AliMCParticleIterableContainer all() const
std::vector< double > fCentBins
how many centrality bins
static Byte_t GetTrackType(const AliVTrack *t)
TH1 * fHistTriggerClasses
!number of events in each trigger class
TString fCaloCellsName
name of calo cell collection
TH1 * fHistEvents
!total number of events per pt hard bin
Bool_t IsTrackInEmcalAcceptance(AliVParticle *part, Double_t edges=0.9) const
std::set< std::string > fRejectedTriggerClasses
list of accepted trigger classes
Double_t fMaxMinimumBiasPtHard
maximum pt hard for the minimum bias pt hard bin (MC)
Container for particles within the EMCAL framework.
static void GetEtaPhiDiff(const AliVTrack *t, const AliVCluster *v, Double_t &phidiff, Double_t &etadiff)
void AddObjectToEvent(TObject *obj, Bool_t attempt=kFALSE)
static Double_t fgkEMCalDCalPhiDivide
phi value used to distinguish between DCal and EMCal
EBeamType_t fForceBeamType
forced beam type
Bool_t fCreateHisto
whether or not create histograms
TH1 * fHistTrialsVsPtHard
!total number of trials per pt hard bin after selection
TH1 * fHistEventRejection
!book keep reasons for rejecting event
int Int_t
Definition: External.C:63
TH1 * fHistTrials
!trials from pyxsec.root
Double_t fMinPtHard
select minimum pt hard (MC)
unsigned int UInt_t
Definition: External.C:33
TString fFiredTriggerClasses
!trigger classes fired by the current event
float Float_t
Definition: External.C:68
Base task in the EMCAL framework (lighter version of AliAnalysisTaskEmcal)
TH1 * fHistEventsVsPtHard
!total number of events per pt hard bin after selection
Float_t fPtHardAndClusterPtFactor
Factor between ptHard and cluster pT to reject/accept event.
Double_t fMaxVzDiff
upper limit for distance between primary and SPD vertex
Double_t fVertex[3]
!event vertex
AliClusterContainer * GetClusterContainer(std::string name) const
void AdoptClusterContainer(AliClusterContainer *cont)
Bool_t fIsPythia
if it is a PYTHIA production
TProfile * fHistXsection
!x section from pyxsec.root
Int_t fCentBin
!event centrality bin
Double_t fMaxCent
max centrality for event selection
ULong_t fFiredTriggerBitMap
!bit map of fired triggers
Double_t fMinNVertCont
minumum number of vertex contributors
Int_t fNVertSPDCont
!event SPD vertex number of contributors
std::set< std::string > fAcceptedTriggerClasses
list of accepted trigger classes
Bool_t PythiaInfoFromFile(const char *currFile, Float_t &fXsec, Float_t &fTrials, Int_t &pthard)
Bool_t fLocalInitialized
!whether or not the task has been already initialized
static EBeamType_t BeamTypeFromRunNumber(Int_t runnumber)
AliParticleContainer * AddParticleContainer(std::string branchName, std::string contName="")
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
std::map< std::string, AliParticleContainer * > fParticleCollArray
particle/track collection array
TFile * file
Int_t nevents[nsamples]
Int_t fNVertCont
!event vertex number of contributors
Bool_t fGeneralHistograms
whether or not it should fill some general histograms
Int_t GetRunNumber(TString)
Definition: PlotMuonQA.C:2235
AliGenPythiaEventHeader * fPythiaHeader
!event Pythia header
const char Option_t
Definition: External.C:48
Float_t fPtHardAndTrackPtFactor
Factor between ptHard and track pT to reject/accept event.
AliParticleContainer * GetParticleContainer(std::string name) const
bool Bool_t
Definition: External.C:53
TH1 * fHistEventPlane
!event plane distribution
std::map< std::string, AliClusterContainer * > fClusterCollArray
cluster collection array
EBeamType_t
Switch for the beam type.
AliVCaloTrigger * fCaloTriggers
!calo triggers
TProfile * fHistXsectionVsPtHard
!x section from pythia header
Container structure for EMCAL clusters.
Container for MC-true particles within the EMCAL framework.
TH1 * fHistZVertex
!z vertex position
void AdoptParticleContainer(AliParticleContainer *cont)
Double_t fMaxVz
max vertex for event selection
Double_t fCent
!event centrality
Double_t fEPV0C
!event plane V0C
Bool_t fUseNewCentralityEstimation
Use new centrality estimation (for 2015 data)
TClonesArray * fTriggerPatchInfo
!trigger patch info array
Double_t fMaxPtHard
select maximum pt hard (MC)
TList * OpenFile(const char *fname)
Definition: DrawAnaELoss.C:65
Bool_t fNeedEmcalGeom
whether or not the task needs the emcal geometry
static Double_t GetParallelFraction(AliVParticle *part1, AliVParticle *part2)
EDataType_t fDataType
!data type (ESD or AOD)