AliPhysics  2c6b7ad (2c6b7ad)
AliAnalysisTaskCLQA.cxx
Go to the documentation of this file.
1 // $Id: $
2 //
3 // Constantin's Task
4 //
5 // Author: C.Loizides
6 
7 #include <complex>
8 
9 #include "AliAnalysisTaskCLQA.h"
10 #include <TChain.h>
11 #include <TClonesArray.h>
12 #include <TDirectory.h>
13 #include <TFile.h>
14 #include <TH1F.h>
15 #include <TH2F.h>
16 #include <TH3F.h>
17 #include <TList.h>
18 #include <TLorentzVector.h>
19 #include <TNtuple.h>
20 #include <TNtupleD.h>
21 #include <TProfile.h>
22 #include <TTree.h>
23 #include "AliAODEvent.h"
24 #include "AliAnalysisManager.h"
25 #include "AliAnalysisUtils.h"
26 #include "AliCentrality.h"
27 #include "AliEMCALGeoParams.h"
28 #include "AliEMCALGeometry.h"
29 #include "AliEMCALRecoUtils.h"
30 #include "AliESDEvent.h"
31 #include "AliESDMuonTrack.h"
32 #include "AliEmcalJet.h"
33 #include "AliExternalTrackParam.h"
34 #include "AliInputEventHandler.h"
35 #include "AliLog.h"
36 #include "AliMultSelection.h"
37 #include "AliPicoTrack.h"
38 #include "AliTrackerBase.h"
39 #include "AliVCluster.h"
40 #include "AliVEventHandler.h"
41 #include "AliVParticle.h"
42 #include "AliVTrack.h"
43 #include "AliPhysicsSelectionTask.h"
44 #include "AliPhysicsSelection.h"
45 
46 ClassImp(AliAnalysisTaskCLQA)
47 
48 //________________________________________________________________________
51  fDoVertexCut(1),
52  fDoTracking(0), fDoMuonTracking(0), fDoCumulants(0), fDoCumNtuple(0), fDoProp(0),
53  fCumPtMin(0.3), fCumPtMax(5.0), fCumEtaMin(-1.0), fCumEtaMax(1.0), fCumMmin(15), fCumMbins(250),
54  fDoHet(0), fQC4EG(-1), fHetEtmin(6),
55  fCentCL1In(0), fCentV0AIn(0),
56  fNtupCum(0), fNtupCumInfo(0), fNtupZdcInfo(0),
57  fNtupHet(0), fNtupHetInfo(0), fCum(0)
58 {
59  // Default constructor.
60 
61  for (Int_t i=0;i<1000;++i)
62  fHists[i] = 0;
63 }
64 
65 //________________________________________________________________________
67  AliAnalysisTaskEmcal(name, kTRUE),
68  fDoVertexCut(1),
69  fDoTracking(1), fDoMuonTracking(0), fDoCumulants(0), fDoCumNtuple(0), fDoProp(0),
70  fCumPtMin(0.3), fCumPtMax(5.0), fCumEtaMin(-1.0), fCumEtaMax(1.0), fCumMmin(15), fCumMbins(250),
71  fDoHet(0), fQC4EG(-1), fHetEtmin(6),
72  fCentCL1In(0), fCentV0AIn(0),
73  fNtupCum(0), fNtupCumInfo(0), fNtupZdcInfo(0),
74  fNtupHet(0), fNtupHetInfo(0), fCum(0)
75 {
76  // Standard constructor.
77 
78  for (Int_t i=0;i<1000;++i)
79  fHists[i] = 0;
80 }
81 
82 //________________________________________________________________________
84 {
85  // Destructor
86 }
87 
88 //________________________________________________________________________
90  Double_t rangeMin, Double_t rangeMax) const
91 {
92  // Calculate Delta Phi.
93 
94  Double_t dphi = -999;
95  const Double_t tpi = TMath::TwoPi();
96 
97  if (phia < 0) phia += tpi;
98  else if (phia > tpi) phia -= tpi;
99  if (phib < 0) phib += tpi;
100  else if (phib > tpi) phib -= tpi;
101  dphi = phib - phia;
102  if (dphi < rangeMin) dphi += tpi;
103  else if (dphi > rangeMax) dphi -= tpi;
104 
105  return dphi;
106 }
107 
108 //________________________________________________________________________
110 {
111  // Fill histograms.
112 
113  AliVEvent *event = InputEvent();
114  AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
115 
116  UInt_t trig = ((AliInputEventHandler*)(am->GetInputEventHandler()))->IsEventSelected();
117  for (Int_t i=0;i<31;++i) {
118  if (trig & (1<<i))
119  fHists[0]->Fill(i);
120  }
121 
122  Double_t vz = event->GetPrimaryVertex()->GetZ();
123  fHists[1]->Fill(vz);
124 
125  Int_t run = event->GetRunNumber();
126  Int_t vzn = event->GetPrimaryVertex()->GetNContributors();
127  if ((vzn<1)&&(run>0))
128  return kFALSE;
129  fHists[2]->Fill(vz);
130 
131  if (TMath::Abs(vz)>10)
132  return kFALSE;
133 
134  if (fDoVertexCut) {
135  if ((run>=188356&&run<=188366) || (run>=195344&&run<=197388)) {
136  AliAnalysisUtils anau;
137  if (anau.IsFirstEventInChunk(event))
138  return kFALSE;
139  if (!anau.IsVertexSelected2013pA(event))
140  return kFALSE;
141  } else if (run>=260014) {
142  //https://twiki.cern.ch/twiki/bin/view/ALICE/AliDPGtoolsEventProp#Pileup_removal
143  const Double_t SPDZDiffCut=0.8; // (vertices with z separation lower than 8 mm are not considered for tagging)
144  Int_t SPDContributorsCut=5; //3 for low multiplicity pp events (higher efficiency, but also higher contamination from false positives), fSPDContributorsCut=5 at high multiplicity
145  Bool_t isPileupFromSPD=event->IsPileupFromSPD(SPDContributorsCut,SPDZDiffCut,3.,2.,5.);
146  if (isPileupFromSPD)
147  fHists[3]->Fill(1);
148  const Double_t minContributors=5;
149  const Double_t minChi2=5.;
150  const Double_t minWeiZDiff=15;
151  const Bool_t checkPlpFromDifferentBC=kFALSE;
152  AliAnalysisUtils anau;
153  anau.SetMinPlpContribMV(minContributors);
154  anau.SetMaxPlpChi2MV(minChi2);
155  anau.SetMinWDistMV(minWeiZDiff);
156  anau.SetCheckPlpFromDifferentBCMV(checkPlpFromDifferentBC);
157  Bool_t isPileupFromMV = anau.IsPileUpMV(event);
158  if (isPileupFromMV)
159  fHists[3]->Fill(2);
160  if (isPileupFromSPD||isPileupFromMV)
161  return kFALSE;
162  }
163  }
164 
165  // accepted events
166  fHists[9]->Fill(1,run);
167 
168  AliMultSelection *ms = dynamic_cast<AliMultSelection*>(InputEvent()->FindListObject("MultSelection"));
169  Double_t v0acent=-1,znacent=-1,v0mcent=-1;
170  if (ms) {
171  v0acent = ms->GetMultiplicityPercentile("V0A");
172  znacent = ms->GetMultiplicityPercentile("ZNA");
173  v0mcent = ms->GetMultiplicityPercentile("V0M");
174  } else {
175  AliCentrality *cent = InputEvent()->GetCentrality();
176  v0acent = cent->GetCentralityPercentile("V0A");
177  znacent = cent->GetCentralityPercentile("ZNA");
178  v0mcent = cent->GetCentralityPercentile("V0M");
179  }
180  fHists[10]->Fill(v0acent);
181  fHists[11]->Fill(znacent);
182  fHists[12]->Fill(v0mcent);
183 
184  if (fDoTracking) {
185  const Int_t ntracks = fTracks->GetEntries();
186  if (fTracks) {
187  for (Int_t i=0; i<ntracks; ++i) {
188  AliVTrack *track = dynamic_cast<AliVTrack*>(fTracks->At(i));
189  if (!track)
190  continue;
191  if (track->Charge()==0)
192  continue;
193 
194  AliPicoTrack *picot = dynamic_cast<AliPicoTrack*>(track);
195  if (picot && picot->GetTrack())
196  track = picot->GetTrack();
197 
198  Double_t phi = track->Phi();
199  Double_t eta = track->Eta();
200  Double_t pt = track->Pt();
201  fHists[20]->Fill(phi,eta);
202  fHists[21]->Fill(phi,pt);
203  fHists[22]->Fill(eta,pt);
204  if (TMath::Abs(eta)<0.8) {
205  fHists[23]->Fill(pt,v0acent);
206  fHists[24]->Fill(pt,znacent);
207  }
208  Int_t ttype = AliPicoTrack::GetTrackType(track);
209  fHists[25+ttype]->Fill(phi,pt);
210  if (fDoProp) {
211  if (track->IsExtrapolatedToEMCAL()) {
212  Double_t dphi = TVector2::Phi_mpi_pi(phi-track->GetTrackPhiOnEMCal());
213  fHists[28]->Fill(dphi,pt);
214  } else {
215  AliEMCALRecoUtils::ExtrapolateTrackToEMCalSurface(track,440);
216  if (track->IsExtrapolatedToEMCAL()) {
217  Double_t dphi = TVector2::Phi_mpi_pi(phi-track->GetTrackPhiOnEMCal());
218  fHists[29]->Fill(dphi,pt);
219  }
220  }
221  if (track->IsEMCAL() && track->IsExtrapolatedToEMCAL()) {
222  Int_t id = track->GetEMCALcluster();
223  AliVCluster *clus = InputEvent()->GetCaloCluster(id);
224  if (id>=0&&clus) {
225  Float_t pos[3];
226  clus->GetPosition(pos);
227  TVector3 vpos(pos);
228  Double_t dphi = TVector2::Phi_mpi_pi(vpos.Phi()-track->GetTrackPhiOnEMCal());
229  fHists[30]->Fill(dphi,pt);
230  }
231  }
232  if (track->IsExtrapolatedToEMCAL()) {
233  Double_t phi1 = track->GetTrackPhiOnEMCal();
234  AliEMCALRecoUtils::ExtrapolateTrackToEMCalSurface(track,440);
235  Double_t phi2 = track->GetTrackPhiOnEMCal();
236  Double_t dphi = TVector2::Phi_mpi_pi(phi1-phi2);
237  fHists[31]->Fill(dphi,pt);
238  }
239  }
240  }
241  }
242  }
243 
244  if (fDoMuonTracking) {
245  AliAODEvent *aod = dynamic_cast<AliAODEvent*>(InputEvent());
246  if (aod) {
247  for (Int_t iMu = 0; iMu<aod->GetNumberOfTracks(); ++iMu) {
248  AliAODTrack* muonTrack = static_cast<AliAODTrack*>(aod->GetTrack(iMu));
249  if (!muonTrack)
250  continue;
251  if (!muonTrack->IsMuonTrack())
252  continue;
253  Double_t dThetaAbs = TMath::ATan(muonTrack->GetRAtAbsorberEnd()/505.)* TMath::RadToDeg();
254  if ((dThetaAbs<2.) || (dThetaAbs>10.))
255  continue;
256  Double_t dEta = muonTrack->Eta();
257  if ((dEta<-4.) || (dEta>-2.5))
258  continue;
259  if (0) {
260  if (muonTrack->GetMatchTrigger()<0.5)
261  continue;
262  }
263  Double_t ptMu = muonTrack->Pt();
264  Double_t etaMu = muonTrack->Eta();
265  Double_t phiMu = muonTrack->Phi();
266  fHists[50]->Fill(phiMu,etaMu);
267  fHists[51]->Fill(phiMu,ptMu);
268  fHists[52]->Fill(etaMu,ptMu);
269  fHists[53]->Fill(ptMu,v0acent);
270  fHists[54]->Fill(ptMu,znacent);
271  }
272  } else {
273  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(InputEvent());
274  if (esd) {
275  for (Int_t iMu = 0; iMu<esd->GetNumberOfMuonTracks(); ++iMu) {
276  AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iMu);
277  if (!muonTrack)
278  continue;
279  if (!muonTrack->ContainTrackerData())
280  continue;
281  Double_t thetaTrackAbsEnd = TMath::ATan(muonTrack->GetRAtAbsorberEnd()/505.) * TMath::RadToDeg();
282  if ((thetaTrackAbsEnd < 2.) || (thetaTrackAbsEnd > 10.))
283  continue;
284  Double_t eta = muonTrack->Eta();
285  if ((eta < -4.) || (eta > -2.5))
286  return kFALSE;
287  if (0) {
288  if (!muonTrack->ContainTriggerData())
289  continue;
290  if (muonTrack->GetMatchTrigger() < 0.5)
291  continue;
292  }
293  }
294  }
295  }
296  }
297 
298  return kTRUE;
299 }
300 
301 //________________________________________________________________________
303 {
304  // Retrieve event objects.
305 
307  return kFALSE;
308 
309  return kTRUE;
310 }
311 
312 //________________________________________________________________________
314 {
315  // Run various functions.
316 
317  if (fCum)
318  RunCumulants();
319  else
321 
322  return kTRUE;
323 }
324 
325 //________________________________________________________________________
327 {
328  // Run cumulant analysis.
329 
330  if (!fDoCumulants)
331  return;
332 
333  if (!fTracks)
334  return;
335 
336  if (!fCum)
337  return;
338 
339  TObjArray &objs = *fTracks;
340  fCum->SetTracks(objs);
341  fCum->RunAll();
342 
343  Int_t M=fCum->GetM();
344  if (M<fCumMmin)
345  return;
346  AliVVZERO *vzero = InputEvent()->GetVZEROData();
347  Double_t v0a = vzero->GetMTotV0A();
348  Double_t v0c = vzero->GetMTotV0C();
349  Double_t v0m = vzero->GetMTotV0A()+vzero->GetMTotV0C();
350  fHists[117]->Fill(v0a,M);
351  fHists[118]->Fill(v0c,M);
352  fHists[119]->Fill(v0m,M);
353 }
354 
355 //________________________________________________________________________
357 {
358  // Run cumulant analysis.
359 
360  if (!fDoCumulants)
361  return;
362 
363  if (!fTracks)
364  return;
365 
366  Bool_t isMC = 0;
367  TString tname(fTracks->GetName());
368  if (tname.Contains("mc"))
369  isMC = 1;
370 
371  const Int_t ntracks = fTracks->GetEntries();
372  Int_t Mall=0,M=0,Mall2=0;
373  Double_t ptmaxall=0,ptsumall=0,pt2sumall=0,ptsumall2=0;
374  Double_t tsa00=0,tsa10=0,tsa11=0;
375  Double_t Q2r=0,Q2i=0;
376  Double_t Q3r=0,Q3i=0;
377  Double_t Q4r=0,Q4i=0;
378  Double_t Q6r=0,Q6i=0;
379  Double_t mpt=0,mpt2=0,ptmaxq=0;
380  Double_t ts00=0,ts10=0,ts11=0;
381  Double_t v0ach=0, v0cch=0;
382  Double_t cl1ch=0;
383 
384  for (Int_t i =0; i<ntracks; ++i) {
385  AliVParticle *track = dynamic_cast<AliVParticle*>(fTracks->At(i));
386  if (!track)
387  continue;
388  if (track->Charge()==0)
389  continue;
390  Double_t eta = track->Eta();
391  if ((eta<5.1)&&(eta>2.8))
392  ++v0ach;
393  else if ((eta>-3.7)&&(eta<-1.7))
394  ++v0cch;
395  if (TMath::Abs(eta)<1.4) {
396  ++cl1ch;
397  }
398  if ((eta<etamin) || (eta>etamax))
399  continue;
400  Double_t pt = track->Pt();
401  if (pt>ptmaxall)
402  ptmaxall = pt;
403  if (pt>1) {
404  ptsumall2 += pt;
405  ++Mall2;
406  }
407  ptsumall +=pt;
408  pt2sumall +=pt*pt;
409  Double_t px = track->Px();
410  Double_t py = track->Py();
411  tsa00 += px*px/pt;
412  tsa10 += px*py/pt;
413  tsa11 += py*py/pt;
414  ++Mall;
415  if ((pt<ptmin) || (pt>ptmax))
416  continue;
417  if (pt>ptmaxq)
418  ptmaxq = pt;
419  Double_t phi = track->Phi();
420  ++M;
421  mpt += pt;
422  mpt2 += pt*pt;
423  ts00 += px*px/pt;
424  ts10 += px*py/pt;
425  ts11 += py*py/pt;
426  Q2r += TMath::Cos(2*phi);
427  Q2i += TMath::Sin(2*phi);
428  Q3r += TMath::Cos(3*phi);
429  Q3i += TMath::Sin(3*phi);
430  Q4r += TMath::Cos(4*phi);
431  Q4i += TMath::Sin(4*phi);
432  Q6r += TMath::Cos(6*phi);
433  Q6i += TMath::Sin(6*phi);
434  }
435 
436  if (M<=1)
437  return;
438 
439  Int_t pmult=0;
440  Double_t v2g=0;
441  Double_t v3g=0;
442  Int_t pmult14=0;
443  Double_t v2g14=0;
444  Double_t v3g14=0;
445  Int_t pmult18=0;
446  Double_t v2g18=0;
447  Double_t v3g18=0;
448  for (Int_t i=0; i<ntracks; ++i) {
449  AliVParticle *track1 = dynamic_cast<AliVParticle*>(fTracks->At(i));
450  if (!track1)
451  continue;
452  if (track1->Charge()==0)
453  continue;
454  Double_t eta1 = track1->Eta();
455  if ((eta1<etamin) || (eta1>etamax))
456  continue;
457  Double_t pt1 = track1->Pt();
458  if ((pt1<ptmin) || (pt1>ptmax))
459  continue;
460  Double_t phi1 = track1->Phi();
461  for (Int_t j = i+1; j<ntracks; ++j) {
462  AliVParticle *track2 = dynamic_cast<AliVParticle*>(fTracks->At(j));
463  if (!track2)
464  continue;
465  if (track2->Charge()==0)
466  continue;
467  Double_t eta2 = track2->Eta();
468  if ((eta2<etamin) || (eta2>etamax))
469  continue;
470  Double_t pt2 = track2->Pt();
471  if ((pt2<ptmin) || (pt2>ptmax))
472  continue;
473  ((TH3*)fHists[128])->Fill(DeltaPhi(phi1,track2->Phi()),eta1-eta2,M);
474  fHists[129]->Fill(M);
475  Double_t deta=TMath::Abs(eta1-eta2);
476  if(deta<1)
477  continue;
478  Double_t dphi=TVector2::Phi_0_2pi(phi1-track2->Phi());
479  pmult++;
480  v2g+=TMath::Cos(2*dphi);
481  v3g+=TMath::Cos(3*dphi);
482  if (deta>1.4) {
483  pmult14++;
484  v2g14+=TMath::Cos(2*dphi);
485  v3g14+=TMath::Cos(3*dphi);
486  }
487  if (deta>1.8) {
488  pmult18++;
489  v2g18+=TMath::Cos(2*dphi);
490  v3g18+=TMath::Cos(3*dphi);
491  }
492  }
493  }
494 
495  if (pmult>0) {
496  v2g/=pmult;
497  v3g/=pmult;
498  }
499  if (pmult14>0) {
500  v2g14/=pmult14;
501  v3g14/=pmult14;
502  }
503  if (pmult18>0) {
504  v2g18/=pmult18;
505  v3g18/=pmult18;
506  }
507 
508  std::complex<double> q2(Q2r,Q2i);
509  std::complex<double> q3(Q3r,Q3i);
510  std::complex<double> q4(Q4r,Q4i);
511  std::complex<double> q6(Q6r,Q6i);
512  Double_t Q22 = std::abs(q2)*std::abs(q2);
513  Double_t Q32 = std::abs(q3)*std::abs(q3);
514  Double_t Q42 = std::abs(q4)*std::abs(q4);
515  Double_t Q62 = std::abs(q6)*std::abs(q6);
516  Double_t Q32re = std::real(q6*std::conj(q3)*std::conj(q3));
517  Double_t Q42re = std::real(q4*std::conj(q2)*std::conj(q2));
518  Double_t Q6are = std::real(q4*q2*std::conj(q2)*std::conj(q2)*std::conj(q2));
519  Double_t Q6bre = std::real(q6*std::conj(q2)*std::conj(q2)*std::conj(q2));
520  Double_t Q6cre = std::real(q6*std::conj(q4)*std::conj(q2));
521 
522  Double_t tsall = -1;
523  Double_t tsax = (tsa00+tsa11)*(tsa00+tsa11)-4*(tsa00*tsa11-tsa10*tsa10);
524  if (tsax>=0) {
525  Double_t l1 = 0.5*(tsa00+tsa11+TMath::Sqrt(tsax))/ptsumall;
526  Double_t l2 = 0.5*(tsa00+tsa11-TMath::Sqrt(tsax))/ptsumall;
527  tsall = 2*l2/(l1+l2);
528  }
529 
530  Double_t ts = -1;
531  Double_t tsx = (ts00+ts11)*(ts00+ts11)-4*(ts00*ts11-ts10*ts10);
532  if (tsx>=0) {
533  Double_t l1 = 0.5*(ts00+ts11+TMath::Sqrt(tsx))/ptsumall;
534  Double_t l2 = 0.5*(ts00+ts11-TMath::Sqrt(tsx))/ptsumall;
535  ts = 2*l2/(l1+l2);
536  }
537 
538  if (isMC) {
539  fHists[106]->Fill(cl1ch);
540  fHists[107]->Fill(v0ach);
541  fHists[108]->Fill(v0cch);
542  AliCentrality *cent = InputEvent()->GetCentrality();
543  if (fCentCL1In) {
544  cent->SetCentralityCL1(100*fCentCL1In->GetBinContent(fCentCL1In->FindBin(cl1ch)));
545  cent->SetQuality(0);
546  }
547  if (fCentV0AIn) {
548  cent->SetCentralityV0A(100*fCentV0AIn->GetBinContent(fCentV0AIn->FindBin(v0ach)));
549  cent->SetQuality(0);
550  }
551  }
552 
553  AliAnalysisUtils anau;
554  AliVEvent *event = InputEvent();
555  AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
556 
557  fNtupCumInfo->fTrig = ((AliInputEventHandler*)(am->GetInputEventHandler()))->IsEventSelected();
558  fNtupCumInfo->fRun = event->GetRunNumber();
559  fNtupCumInfo->fVz = event->GetPrimaryVertex()->GetZ();
560  fNtupCumInfo->fIsFEC = anau.IsFirstEventInChunk(event);
561  fNtupCumInfo->fIsVSel = anau.IsVertexSelected2013pA(event);
562  fNtupCumInfo->fIsP = event->IsPileupFromSPD(3/*minContributors*/,
563  0.8/*minZdist*/,
564  3./*nSigmaZdist*/,
565  2./*nSigmaDiamXY*/,
566  5./*nSigmaDiamZ*/);
567 
568  fNtupCumInfo->fMall = Mall;
569  fNtupCumInfo->fMall2 = Mall2;
570  fNtupCumInfo->fPtMaxall = ptmaxall;
571  fNtupCumInfo->fMPtall = ptsumall/Mall;
572  fNtupCumInfo->fMPt2all = pt2sumall/Mall;
573  if (Mall2>0)
574  fNtupCumInfo->fMPtall2 = ptsumall2/Mall2;
575  else
576  fNtupCumInfo->fMPtall2 = -1;
577  fNtupCumInfo->fTSall = tsall;
578  fNtupCumInfo->fM = M;
579  fNtupCumInfo->fQ2abs = Q22;
580  fNtupCumInfo->fQ4abs = Q42;
581  fNtupCumInfo->fQ42re = Q42re;
582  fNtupCumInfo->fCos2phi = Q2r;
583  fNtupCumInfo->fSin2phi = Q2i;
584  fNtupCumInfo->fPtMax = ptmaxq;
585  fNtupCumInfo->fMPt = mpt/M;
586  fNtupCumInfo->fMPt2 = mpt2/M;
587  fNtupCumInfo->fTS = ts;
588 
589  if (isMC) {
590  fNtupCumInfo->fMV0M = v0ach + v0cch;
591  } else {
592  AliVVZERO *vzero = InputEvent()->GetVZEROData();
593  fNtupCumInfo->fMV0M = vzero->GetMTotV0A()+vzero->GetMTotV0C();
594  }
595 
596  AliMultSelection *ms = dynamic_cast<AliMultSelection*>(InputEvent()->FindListObject("MultSelection"));
597  if (ms) {
598  fNtupCumInfo->fCl1 = ms->GetMultiplicityPercentile("CL1");
599  fNtupCumInfo->fV0M = ms->GetMultiplicityPercentile("V0M");
600  fNtupCumInfo->fV0MEq = ms->GetMultiplicityPercentile("V0MEq");
601  fNtupCumInfo->fV0A = ms->GetMultiplicityPercentile("V0A");
602  fNtupCumInfo->fV0AEq = ms->GetMultiplicityPercentile("V0AEq");
603  fNtupCumInfo->fZNA = ms->GetMultiplicityPercentile("ZNA");
604  } else {
605  AliCentrality *cent = InputEvent()->GetCentrality();
606  fNtupCumInfo->fCl1 = cent->GetCentralityPercentile("CL1");
607  fNtupCumInfo->fV0M = cent->GetCentralityPercentile("V0M");
608  fNtupCumInfo->fV0MEq = cent->GetCentralityPercentile("V0MEq");
609  fNtupCumInfo->fV0A = cent->GetCentralityPercentile("V0A");
610  fNtupCumInfo->fV0AEq = cent->GetCentralityPercentile("V0AEq");
611  fNtupCumInfo->fZNA = cent->GetCentralityPercentile("ZNA");
612  }
613 
614  AliVZDC *vZDC = InputEvent()->GetZDCData();
615  const Double_t *znaTowers = vZDC->GetZNATowerEnergy();
616  fNtupZdcInfo->fZna0 = znaTowers[0];
617  fNtupZdcInfo->fZna1 = znaTowers[1];
618  fNtupZdcInfo->fZna2 = znaTowers[2];
619  fNtupZdcInfo->fZna3 = znaTowers[3];
620  fNtupZdcInfo->fZna4 = znaTowers[4];
621 
622  if (fDoCumNtuple && (M>=Mmin)) {
623  fNtupCum->Fill();
624  }
625 
626  fHists[109]->Fill(fNtupCumInfo->fCl1);
627  fHists[110]->Fill(fNtupCumInfo->fV0A);
628  fHists[111]->Fill(fNtupCumInfo->fZNA);
629 
630  Bool_t fillCumHist = kTRUE;
631  if (fillCumHist) {
632  Int_t run = InputEvent()->GetRunNumber();
633  if (fDoVertexCut) {
634  if ((run>=188356&&run<=188366) || (run>=195344&&run<=197388)) {
635  if (anau.IsFirstEventInChunk(event))
636  fillCumHist = kFALSE;
637  if (!anau.IsVertexSelected2013pA(event))
638  fillCumHist = kFALSE;
639  }
640  }
641  Double_t vz = InputEvent()->GetPrimaryVertex()->GetZ();
642  if (TMath::Abs(vz)>10)
643  fillCumHist = kFALSE;
644  }
645  if (fillCumHist) {
646  AliVVZERO *vzero = InputEvent()->GetVZEROData();
647  Double_t v0a = vzero->GetMTotV0A();
648  Double_t v0c = vzero->GetMTotV0C();
649  Double_t v0m = vzero->GetMTotV0A()+vzero->GetMTotV0C();
650  fHists[112]->Fill(Mall);
651  fHists[113]->Fill(M);
652  fHists[117]->Fill(v0a,M);
653  fHists[118]->Fill(v0c,M);
654  fHists[119]->Fill(v0m,M);
655  if (M>1) {
656  fHists[114]->Fill(M,(Q22-M)/M/(M-1));
657  fHists[120]->Fill(M,(Q32-M)/M/(M-1));
658  fHists[122]->Fill(M,v2g);
659  fHists[123]->Fill(M,v3g);
660  fHists[124]->Fill(M,v2g14);
661  fHists[125]->Fill(M,v3g14);
662  fHists[126]->Fill(M,v2g18);
663  fHists[127]->Fill(M,v3g18);
664  fHists[130]->Fill(M,Q2r/M);
665  fHists[131]->Fill(M,Q2i/M);
666  fHists[132]->Fill(M,Q3r/M);
667  fHists[133]->Fill(M,Q3i/M);
668  fHists[134]->Fill(M,Q4r/M);
669  fHists[135]->Fill(M,Q4i/M);
670  fHists[136]->Fill(M,Q6r/M);
671  fHists[137]->Fill(M,Q6i/M);
672  }
673  if (M>3) {
674  Double_t qc4tmp = (Q22*Q22+Q42-2*Q42re-4*(M-2)*Q22+2*M*(M-3));
675  fHists[115]->Fill(M,qc4tmp/M/(M-1)/(M-2)/(M-3));
676  qc4tmp = (Q32*Q32+Q62-2*Q32re-4*(M-2)*Q32+2*M*(M-3));
677  fHists[121]->Fill(M,qc4tmp/M/(M-1)/(M-2)/(M-3));
678  }
679  if (M>5) {
680  Double_t qc6tmp = Q22*Q22*Q22 + 9*Q42*Q22 - 6*Q6are
681  + 4*Q6bre - 12*Q6cre
682  + 18*(M-4)*Q42re + 4*Q62
683  - 9*(M-4)*Q22*Q22 - 9*(M-4)*Q42
684  + 18*(M-2)*(M-5)*Q22
685  - 6*M*(M-4)*(M-5);
686  fHists[116]->Fill(M,qc6tmp/M/(M-1)/(M-2)/(M-3)/(M-4)/(M-5));
687  }
688  }
689 
690  if ((isMC) ||
691  ((TMath::Abs(fNtupCumInfo->fVz)<10) && !fNtupCumInfo->fIsFEC && fNtupCumInfo->fIsVSel)) {
692  for (Int_t i =0; i<ntracks; ++i) {
693  AliVParticle *track1 = dynamic_cast<AliVParticle*>(fTracks->At(i));
694  if (!track1)
695  continue;
696  Double_t phi1 = track1->Phi();
697  Double_t eta1 = track1->Eta();
698  Double_t pt1 = track1->Pt();
699  ((TH3*)fHists[103])->Fill(pt1,eta1,fNtupCumInfo->fCl1);
700  ((TH3*)fHists[104])->Fill(pt1,eta1,fNtupCumInfo->fV0A);
701  ((TH3*)fHists[105])->Fill(pt1,eta1,fNtupCumInfo->fZNA);
702  if ((eta1<etamin) || (eta1>etamax))
703  continue;
704  if ((pt1<ptmin) || (pt1>ptmax))
705  continue;
706  for (Int_t j =0; j<ntracks; ++j) {
707  AliVParticle *track2 = dynamic_cast<AliVParticle*>(fTracks->At(j));
708  if (!track2)
709  continue;
710  Double_t eta2 = track2->Eta();
711  if ((eta2<etamin) || (eta2>etamax))
712  continue;
713  Double_t pt2 = track2->Pt();
714  if ((pt2<ptmin) || (pt2>ptmax))
715  continue;
716  Double_t phi2 = track2->Phi();
717  Double_t deta = eta1-eta2;
718  Double_t dphi = phi1-phi2;
719  while (dphi<-TMath::Pi())
720  dphi+=TMath::TwoPi();
721  while (dphi>3*TMath::Pi()/2)
722  dphi-=TMath::TwoPi();
723  ((TH3*)fHists[100])->Fill(dphi,deta,fNtupCumInfo->fCl1);
724  ((TH3*)fHists[101])->Fill(dphi,deta,fNtupCumInfo->fV0A);
725  ((TH3*)fHists[102])->Fill(dphi,deta,fNtupCumInfo->fZNA);
726  }
727  }
728  }
729 }
730 
731 //________________________________________________________________________
733 {
734  // Run het analysis.
735 
736  if (!fDoHet)
737  return;
738 }
739 
740 //________________________________________________________________________
742 {
743  // Set parameters for cumulants.
744 
745  fCumMmin = Mmin;
746  fCumPtMin = ptmin;
747  fCumPtMax = ptmax;
748  fCumEtaMin = etamin;
749  fCumEtaMax = etamax;
750 }
751 
752 //________________________________________________________________________
754 {
755  // Set parameters for het.
756 
757  fHetEtmin = etmin;
758 }
759 
760 //________________________________________________________________________
762 {
763  // Create histograms
764 
766 
767  AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
768  if (am) {
769  AliPhysicsSelectionTask *t=dynamic_cast<AliPhysicsSelectionTask*>(am->GetTopTasks()->At(0));
770  if (t) {
771  AliPhysicsSelection *ps=t->GetPhysicsSelection();
772  fOutput->Add(ps->GetStatistics(""));
773  }
774  }
775 
776  fHists[0] = new TH1D("fTrigBits",";bit",32,-0.5,31.5);
777  fOutput->Add(fHists[0]);
778  fHists[1] = new TH1D("fVertexZ",";vertex z (cm)",51,-25.5,25.5);
779  fOutput->Add(fHists[1]);
780  fHists[2] = new TH1D("fVertexZnc",";vertex z (cm)",51,-25.5,25.5);
781  fOutput->Add(fHists[2]);
782  fHists[3] = new TH1D("fVertexCuts","",1,0.5,2.5);
783  fOutput->Add(fHists[3]);
784  fHists[9] = new TProfile("fAccepted","",1,0.5,1.5);
785  fOutput->Add(fHists[9]);
786  fHists[10] = new TH1D("fV0ACent",";percentile",20,0,100);
787  fOutput->Add(fHists[10]);
788  fHists[11] = new TH1D("fZNACent",";percentile",20,0,100);
789  fOutput->Add(fHists[11]);
790  fHists[12] = new TH1D("fV0MCent",";percentile",20,0,100);
791  fOutput->Add(fHists[12]);
792 
793  if (fDoTracking) {
794  fHists[20] = new TH2D("fPhiEtaTracks",";#phi;#eta",60,0,TMath::TwoPi(),20,-2,2);
795  fHists[20]->Sumw2();
796  fOutput->Add(fHists[20]);
797  fHists[21] = new TH2D("fPhiPtTracks",";#phi;p_{T} (GeV/c)",60,0,TMath::TwoPi(),40,0,20);
798  fHists[21]->Sumw2();
799  fOutput->Add(fHists[21]);
800  fHists[22] = new TH2D("fEtaPtTracks",";#eta;p_{T} (GeV/c)",20,-2,2,40,0,20);
801  fHists[22]->Sumw2();
802  fOutput->Add(fHists[22]);
803  fHists[23] = new TH2D("fPtV0ATracks",";#p_{T} (GeV/c);percentile",100,0,20,20,0,100);
804  fHists[23]->Sumw2();
805  fOutput->Add(fHists[23]);
806  fHists[24] = new TH2D("fPtZNATracks",";#p_{T} (GeV/c);percentile",100,0,20,20,0,100);
807  fHists[24]->Sumw2();
808  fOutput->Add(fHists[24]);
809  fHists[25] = new TH2D("fPhiPtTracks_type0",";#phi;p_{T} (GeV/c)",60,0,TMath::TwoPi(),40,0,20);
810  fHists[25]->Sumw2();
811  fOutput->Add(fHists[25]);
812  fHists[26] = new TH2D("fPhiPtTracks_type1",";#phi;p_{T} (GeV/c)",60,0,TMath::TwoPi(),40,0,20);
813  fHists[26]->Sumw2();
814  fOutput->Add(fHists[26]);
815  fHists[27] = new TH2D("fPhiPtTracks_type2",";#phi;p_{T} (GeV/c)",60,0,TMath::TwoPi(),40,0,20);
816  fHists[27]->Sumw2();
817  fOutput->Add(fHists[27]);
818  if (fDoProp) {
819  fHists[28] = new TH2D("fDPhiPtTracks",";#Delta#phi;p_{T} (GeV/c)",60,-TMath::Pi(),TMath::Pi(),40,0,20);
820  fHists[28]->Sumw2();
821  fOutput->Add(fHists[28]);
822  fHists[29] = new TH2D("fDPhiPtTracks2",";#Delta#phi;p_{T} (GeV/c)",60,-TMath::Pi(),TMath::Pi(),40,0,20);
823  fHists[29]->Sumw2();
824  fOutput->Add(fHists[29]);
825  fHists[30] = new TH2D("fDPhiPtClusTracks",";#Delta#phi;p_{T} (GeV/c)",60,-TMath::Pi(),TMath::Pi(),40,0,20);
826  fHists[30]->Sumw2();
827  fOutput->Add(fHists[30]);
828  fHists[31] = new TH2D("fDPhiPtReTracks",";#Delta#phi;p_{T} (GeV/c)",60,-TMath::Pi(),TMath::Pi(),40,0,20);
829  fHists[31]->Sumw2();
830  fOutput->Add(fHists[31]);
831  }
832  }
833 
834  if (fDoMuonTracking) {
835  fHists[50] = new TH2D("fPhiEtaMuonTracks",";#phi;#eta",60,0,TMath::TwoPi(),15,-4,-2.5);
836  fHists[50]->Sumw2();
837  fOutput->Add(fHists[50]);
838  fHists[51] = new TH2D("fPhiPtMuonTracks",";#phi;p_{T} (GeV/c)",60,0,TMath::TwoPi(),200,0,20);
839  fHists[51]->Sumw2();
840  fOutput->Add(fHists[51]);
841  fHists[52] = new TH2D("fEtaPtMuonTracks",";#eta;p_{T} (GeV/c)",15,-4,-2.5,200,0,20);
842  fHists[52]->Sumw2();
843  fOutput->Add(fHists[52]);
844  fHists[53] = new TH2D("fPtV0AMuonTracks",";#p_{T} (GeV/c);percentile",100,0,10,20,0,100);
845  fHists[53]->Sumw2();
846  fOutput->Add(fHists[53]);
847  fHists[54] = new TH2D("fPtZNAMuonTracks",";#p_{T} (GeV/c);percentile",100,0,10,20,0,100);
848  fHists[54]->Sumw2();
849  fOutput->Add(fHists[54]);
850  }
851 
852  if (fDoCumulants) {
853  fCum = new Cumulants("cmhists",fCumMbins,fCumMmin);
855  fCum->EnableEG();
856  fCum->EnableQC();
857  if (fQC4EG<0)
859  else
861  TList *l=fCum->GetList();
862  for (Int_t i=0; i<l->GetEntries(); ++i)
863  fOutput->Add(l->At(i));
864  Int_t v0bins=1000;
865  if (fCumMbins>1000)
866  v0bins=25000;
867  fHists[117] = new TH2D("fCumV0ACentVsM",";v0a;M",v0bins,0,v0bins,fCumMbins,0,fCumMbins);
868  fOutput->Add(fHists[117]);
869  fHists[118] = new TH2D("fCumV0CCentVsM",";v0c;M",v0bins,0,v0bins,fCumMbins,0,fCumMbins);
870  fOutput->Add(fHists[118]);
871  fHists[119] = new TH2D("fCumV0MCentVsM",";v0m;M",v0bins,0,v0bins,fCumMbins,0,fCumMbins);
872  fOutput->Add(fHists[119]);
873  }
874  if (!fCum&&fDoCumulants) {
875  fHists[100] = new TH3D("fCumPhiEtaCl1",";#Delta#phi;#Delta#eta",32,-TMath::Pi()/2,3*TMath::Pi()/2,60,-3,3,10,0,100);
876  fOutput->Add(fHists[100]);
877  fHists[101] = new TH3D("fCumPhiEtaV0A",";#Delta#phi;#Delta#eta",32,-TMath::Pi()/2,3*TMath::Pi()/2,60,-3,3,10,0,100);
878  fOutput->Add(fHists[101]);
879  fHists[102] = new TH3D("fCumPhiEtaZNA",";#Delta#phi;#Delta#eta",32,-TMath::Pi()/2,3*TMath::Pi()/2,60,-3,3,10,0,100);
880  fOutput->Add(fHists[102]);
881  fHists[103] = new TH3D("fCumPtEtaCl1",";p_{T} (GeV/c);#eta",100,0,25,20,-2,2,10,0,100);
882  fOutput->Add(fHists[103]);
883  fHists[104] = new TH3D("fCumPtEtaV0A",";p_{T} (GeV/c);#eta",100,0,25,20,-2,2,10,0,100);
884  fOutput->Add(fHists[104]);
885  fHists[105] = new TH3D("fCumPtEtaZNA",";p_{T} (GeV/c);#eta",100,0,25,20,-2,2,10,0,100);
886  fOutput->Add(fHists[105]);
887  fHists[106] = new TH1D("fCumCL1MC",";#tracks",fCumMbins,0,fCumMbins);
888  fOutput->Add(fHists[106]);
889  fHists[107] = new TH1D("fCumV0AMC",";#tracks",fCumMbins,0,fCumMbins);
890  fOutput->Add(fHists[107]);
891  fHists[108] = new TH1D("fCumV0CMC",";#tracks",fCumMbins,0,fCumMbins);
892  fOutput->Add(fHists[108]);
893  fHists[109] = new TH1D("fCumCl1Cent",";percentile",10,0,100);
894  fOutput->Add(fHists[109]);
895  fHists[110] = new TH1D("fCumV0ACent",";percentile",10,0,100);
896  fOutput->Add(fHists[110]);
897  fHists[111] = new TH1D("fCumZNACent",";percentile",10,0,100);
898  fOutput->Add(fHists[111]);
899  fHists[112] = new TH1D("fCumMall",";mult",fCumMbins,0,fCumMbins);
900  fOutput->Add(fHists[112]);
901  fHists[113] = new TH1D("fCumM",";mult",fCumMbins,0,fCumMbins);
902  fOutput->Add(fHists[113]);
903  fHists[114] = new TProfile("fCumQC2",";qc2",fCumMbins,0,fCumMbins);
904  fOutput->Add(fHists[114]);
905  fHists[115] = new TProfile("fCumQC4",";qc4",fCumMbins,0,fCumMbins);
906  fOutput->Add(fHists[115]);
907  fHists[116] = new TProfile("fCumQC6",";qc6",fCumMbins,0,fCumMbins);
908  fOutput->Add(fHists[116]);
909  Int_t v0bins=1000;
910  if (fCumMbins>1000)
911  v0bins=25000;
912  fHists[117] = new TH2D("fCumV0ACentVsM",";v0a;M",v0bins,0,v0bins,fCumMbins,0,fCumMbins);
913  fOutput->Add(fHists[117]);
914  fHists[118] = new TH2D("fCumV0CCentVsM",";v0c;M",v0bins,0,v0bins,fCumMbins,0,fCumMbins);
915  fOutput->Add(fHists[118]);
916  fHists[119] = new TH2D("fCumV0MCentVsM",";v0m;M",v0bins,0,v0bins,fCumMbins,0,fCumMbins);
917  fOutput->Add(fHists[119]);
918  fHists[120] = new TProfile("fCum3QC2",";qc2",fCumMbins,0,fCumMbins);
919  fOutput->Add(fHists[120]);
920  fHists[121] = new TProfile("fCum3QC4",";qc4",fCumMbins,0,fCumMbins);
921  fOutput->Add(fHists[121]);
922  fHists[122] = new TProfile("fEtaGapV2",";M",fCumMbins,0,fCumMbins);
923  fOutput->Add(fHists[122]);
924  fHists[123] = new TProfile("fEtaGapV3",";M",fCumMbins,0,fCumMbins);
925  fOutput->Add(fHists[123]);
926  fHists[124] = new TProfile("fEtaGapV214",";M",fCumMbins,0,fCumMbins);
927  fOutput->Add(fHists[124]);
928  fHists[125] = new TProfile("fEtaGapV314",";M",fCumMbins,0,fCumMbins);
929  fOutput->Add(fHists[125]);
930  fHists[126] = new TProfile("fEtaGapV218",";M",fCumMbins,0,fCumMbins);
931  fOutput->Add(fHists[126]);
932  fHists[127] = new TProfile("fEtaGapV318",";M",fCumMbins,0,fCumMbins);
933  fOutput->Add(fHists[127]);
934  fHists[128] = new TH3D("fDPhiDEtaTracks",";#Delta#phi;#Delta#eta;M",64,-0.5*TMath::Pi(),1.5*TMath::Pi(),60,-3,3,fCumMbins/10,0,fCumMbins);
935  fHists[128]->Sumw2();
936  fOutput->Add(fHists[128]);
937  fHists[129] = new TH1D("fDPhiDEtaTrigs",";M",fCumMbins/10,0,fCumMbins);
938  fHists[129]->Sumw2();
939  fOutput->Add(fHists[129]);
940  fHists[130] = new TProfile("fCumQ2r",";q2r",fCumMbins,0,fCumMbins);
941  fOutput->Add(fHists[130]);
942  fHists[131] = new TProfile("fCumQ2i",";q2i",fCumMbins,0,fCumMbins);
943  fOutput->Add(fHists[131]);
944  fHists[132] = new TProfile("fCumQ3r",";q3r",fCumMbins,0,fCumMbins);
945  fOutput->Add(fHists[132]);
946  fHists[133] = new TProfile("fCumQ3i",";q3i",fCumMbins,0,fCumMbins);
947  fOutput->Add(fHists[133]);
948  fHists[134] = new TProfile("fCumQ4r",";q4r",fCumMbins,0,fCumMbins);
949  fOutput->Add(fHists[134]);
950  fHists[135] = new TProfile("fCumQ4i",";q4i",fCumMbins,0,fCumMbins);
951  fOutput->Add(fHists[135]);
952  fHists[136] = new TProfile("fCumQ6r",";q6r",fCumMbins,0,fCumMbins);
953  fOutput->Add(fHists[136]);
954  fHists[137] = new TProfile("fCumQ6i",";q6i",fCumMbins,0,fCumMbins);
955  fOutput->Add(fHists[137]);
956 
957  fNtupCum = new TTree("NtupCum", "Ntuple for cumulant analysis");
958  if (1) {
959  fNtupCum->SetDirectory(0);
960  } else {
961  TFile *f = OpenFile(1);
962  if (f) {
963  f->SetCompressionLevel(2);
964  fNtupCum->SetDirectory(f);
965  fNtupCum->SetAutoFlush(-4*1024*1024);
966  fNtupCum->SetAutoSave(0);
967  }
968  }
970  fNtupCum->Branch("cumulants", &fNtupCumInfo, 32*1024, 99);
972  fNtupCum->Branch("zdc", &fNtupZdcInfo, 32*1024, 99);
973  if (fDoCumNtuple)
974  fOutput->Add(fNtupCum);
975  }
976 
977  if (fDoHet) {
978  fNtupHet = new TTree("NtupHet", "Ntuple for het analysis");
979  if (1) {
980  fNtupHet->SetDirectory(0);
981  } else {
982  TFile *f = OpenFile(1);
983  if (f) {
984  f->SetCompressionLevel(2);
985  fNtupHet->SetDirectory(f);
986  fNtupHet->SetAutoFlush(-4*1024*1024);
987  fNtupHet->SetAutoSave(0);
988  }
989  }
991  fNtupHet->Branch("het", &fNtupHetInfo, 32*1024, 99);
992  fOutput->Add(fNtupHet);
993  }
994 
995  PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram
996 }
void RunHet(Double_t Etmin)
double Double_t
Definition: External.C:58
Definition: External.C:244
void SetHetParams(Double_t Etmin)
Base task in the EMCAL framework.
void AddQC4withEG(Double_t etagap)
Definition: Cumulants.cxx:39
void EnableEG()
Definition: Cumulants.cxx:58
Int_t GetM() const
Definition: Cumulants.h:27
void RunAll()
Definition: Cumulants.cxx:190
Double_t DeltaPhi(Double_t phia, Double_t phib, Double_t rangeMin=-TMath::Pi()/2, Double_t rangeMax=3 *TMath::Pi()/2) const
pointer to cumulant class
AliNtupZdcInfo * fNtupZdcInfo
object holding cumulant results
const Double_t etamin
int Int_t
Definition: External.C:63
void SetKine(Double_t etamin, Double_t etamax, Double_t ptmin, Double_t ptmax)
Definition: Cumulants.h:30
unsigned int UInt_t
Definition: External.C:33
float Float_t
Definition: External.C:68
void EnableQC()
Definition: Cumulants.cxx:88
void SetCumParams(Double_t Mmin, Double_t ptmin, Double_t ptmax, Double_t etamin, Double_t etamax)
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.
void SetTracks(TObjArray &trks, Bool_t doKinCuts=1)
Definition: Cumulants.cxx:621
const Double_t ptmax
Definition: External.C:252
Definition: External.C:228
Definition: External.C:212
const Double_t ptmin
Byte_t GetTrackType() const
Definition: AliPicoTrack.h:43
virtual Bool_t RetrieveEventObjects()
Retrieve common objects from event.
AliNtupHetInfo * fNtupHetInfo
ntuple for het analysis
Bool_t FillHistograms()
Function filling histograms.
AliVTrack * GetTrack() const
Definition: AliPicoTrack.h:60
Bool_t RetrieveEventObjects()
Retrieve common objects from event.
Bool_t isMC
void EnableQC4withEG()
Definition: Cumulants.cxx:183
AliEmcalList * fOutput
!output list
TClonesArray * fTracks
!tracks
TH1 * fHists[1000]
object holding het info
const Double_t etamax
Cumulants * fCum
pointers to histograms
void UserCreateOutputObjects()
Main initialization function on the worker.
TList * GetList() const
Definition: Cumulants.h:26
bool Bool_t
Definition: External.C:53
AliNtupCumInfo * fNtupCumInfo
ntuple for cumulant analysis
TList * OpenFile(const char *fname)
Definition: DrawAnaELoss.C:65
TTree * fNtupHet
object holding zdc info