AliPhysics  9fe175b (9fe175b)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskCRCZDC.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2008, 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 thce 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 /**********************************
17  * analysis task for CRC with ZDC *
18  * *
19  * author: Jacopo Margutti *
20  * (margutti@nikhef.nl) *
21  **********************************/
22 
23 #include "Riostream.h" //needed as include
24 #include "TChain.h"
25 #include "TList.h"
26 #include "TTree.h"
27 #include "TRandom3.h"
28 #include "TTimeStamp.h"
29 #include "TStopwatch.h"
30 #include "TProfile.h"
31 #include <TList.h>
32 #include <TH1F.h>
33 #include <TH2F.h>
34 #include <TFile.h>
35 #include <TString.h>
36 #include <TCanvas.h>
37 #include <TParticle.h>
38 #include "TProfile3D.h"
39 
40 #include "AliAnalysisManager.h"
41 #include "AliInputEventHandler.h"
42 #include "AliVEvent.h"
43 #include "AliESD.h"
44 #include "AliESDEvent.h"
45 #include "AliESDHeader.h"
46 #include "AliESDInputHandler.h"
47 #include "AliESDZDC.h"
48 #include "AliMultiplicity.h"
49 #include "AliAnalysisUtils.h"
50 #include "AliAODHandler.h"
51 #include "AliAODTrack.h"
52 #include "AliAODEvent.h"
53 #include "AliAODHeader.h"
54 #include "AliAODVertex.h"
55 #include "AliAODVZERO.h"
56 #include "AliAODZDC.h"
57 #include "AliAODMCHeader.h"
58 #include "AliMCEventHandler.h"
59 #include "AliMCEvent.h"
60 #include "AliHeader.h"
61 #include "AliVParticle.h"
62 #include "AliStack.h"
63 #include "AliAODMCParticle.h"
64 #include "AliAnalysisTaskSE.h"
65 #include "AliGenEventHeader.h"
66 #include "AliPhysicsSelectionTask.h"
67 #include "AliPhysicsSelection.h"
68 #include "AliBackgroundSelection.h"
69 #include "AliTriggerAnalysis.h"
70 #include "AliCentrality.h"
71 #include "AliAnalysisTaskCRCZDC.h"
72 #include "AliMultSelection.h"
73 
74 // ALICE Correction Framework
75 #include "AliCFManager.h"
76 
77 // Interface to Event generators to get Reaction Plane Angle
78 #include "AliGenCocktailEventHeader.h"
79 #include "AliGenPythiaEventHeader.h"
80 #include "AliGenHijingEventHeader.h"
81 #include "AliGenGeVSimEventHeader.h"
82 #include "AliGenEposEventHeader.h"
83 
84 // Interface to Load short life particles
85 #include "TObjArray.h"
86 #include "AliFlowCandidateTrack.h"
87 
88 // Interface to make the Flow Event Simple used in the flow analysis methods
89 #include "AliFlowEvent.h"
90 #include "AliFlowTrackCuts.h"
91 #include "AliFlowEventCuts.h"
92 #include "AliFlowCommonConstants.h"
93 
95 
96 //________________________________________________________________________
98 AliAnalysisTaskSE(""),
99 fAnalysisType("AUTOMATIC"),
100 fRPType(""),
101 fCFManager1(NULL),
102 fCFManager2(NULL),
103 fCutsEvent(NULL),
104 fCutsRP(NULL),
105 fCutsPOI(NULL),
106 fCutContainer(new TList()),
107 fQAList(NULL),
108 fMinMult(0),
109 fMaxMult(10000000),
110 fMinA(-1.0),
111 fMaxA(-0.01),
112 fMinB(0.01),
113 fMaxB(1.0),
114 fGenHeader(NULL),
115 fPythiaGenHeader(NULL),
116 fHijingGenHeader(NULL),
117 fFlowTrack(NULL),
118 fAnalysisUtil(NULL),
119 fQAon(kFALSE),
120 fLoadCandidates(kFALSE),
121 fNbinsMult(10000),
122 fNbinsPt(100),
123 fNbinsPhi(100),
124 fNbinsEta(200),
125 fNbinsQ(500),
126 fNbinsMass(1),
127 fMultMin(0.),
128 fMultMax(10000.),
129 fPtMin(0.),
130 fPtMax(10.),
131 fPhiMin(0.),
132 fPhiMax(TMath::TwoPi()),
133 fEtaMin(-5.),
134 fEtaMax(5.),
135 fQMin(0.),
136 fQMax(3.),
137 fMassMin(-1.),
138 fMassMax(0.),
139 fHistWeightvsPhiMin(0.),
140 fHistWeightvsPhiMax(3.),
141 fExcludedEtaMin(0.),
142 fExcludedEtaMax(0.),
143 fExcludedPhiMin(0.),
144 fExcludedPhiMax(0.),
145 fAfterburnerOn(kFALSE),
146 fNonFlowNumberOfTrackClones(0),
147 fV1(0.),
148 fV2(0.),
149 fV3(0.),
150 fV4(0.),
151 fV5(0.),
152 fDifferentialV2(0),
153 fFlowEvent(NULL),
154 fShuffleTracks(kFALSE),
155 fMyTRandom3(NULL),
156 fAnalysisInput(kAOD),
157 fIsMCInput(kFALSE),
158 fUseMCCen(kTRUE),
159 fRejectPileUp(kTRUE),
160 fCentrLowLim(0.),
161 fCentrUpLim(100.),
162 fCentrEstimator("V0M"),
163 fOutput(0x0),
164 fhZNCvsZNA(0x0),
165 fhZPCvsZPA(0x0),
166 fhZDCCvsZDCCA(0x0),
167 fhZNCvsZPC(0x0),
168 fhZNAvsZPA(0x0),
169 fhZNvsZP(0x0),
170 fhZNvsVZERO(0x0),
171 fhZDCvsVZERO(0x0),
172 fhZDCvsTracklets(0x0),
173 fhZDCvsNclu1(0x0),
174 fhDebunch(0x0),
175 fhZNCcentroid(0x0),
176 fhZNAcentroid(0x0),
177 fhAsymm(0x0),
178 fhZNAvsAsymm(0x0),
179 fhZNCvsAsymm(0x0),
180 fhZNCvscentrality(0x0),
181 fhZNAvscentrality(0x0),
182 fhZPCvscentrality(0x0),
183 fhZPAvscentrality(0x0),
184 fhZNCpmcvscentr(0x0),
185 fhZNApmcvscentr(0x0),
186 fhZPCpmcvscentr(0x0),
187 fhZPApmcvscentr(0x0),
188 fhZNCpmcLR(0x0),
189 fhZNApmcLR(0x0),
190 fhZPCpmcLR(0x0),
191 fhZPApmcLR(0x0),
192 fCRCnRun(0),
193 fZDCGainAlpha(0.395),
194 fDataSet("2010"),
195 fStack(0x0),
196 fCutTPC(kFALSE),
197 fCenDis(0x0),
198 fMultSelection(0x0),
199 fCentrality(0x0),
200 fTowerEqList(NULL),
201 fCachedRunNum(0)
202 {
203  for(int i=0; i<5; i++){
204  fhZNCPM[i] = 0x0;
205  fhZNAPM[i] = 0x0;
206  fhZPCPM[i] = 0x0;
207  fhZPAPM[i] = 0x0;
208  fhZNCPMlg[i] = 0x0;
209  fhZNAPMlg[i] = 0x0;
210  fhZPCPMlg[i] = 0x0;
211  fhZPAPMlg[i] = 0x0;
212  }
213  for(int i=0; i<2; i++) fhZEM[i] = 0x0;
214  for(int i=0; i<6; i++){
215  fhTDCraw[i] = 0x0;
216  fhTDC[i] = 0x0;
217  }
218  for(int i=0; i<4; i++){
219  fhZNCPMQiPMC[i] = 0x0;
220  fhZNAPMQiPMC[i] = 0x0;
221  fhZPCPMQiPMC[i] = 0x0;
222  fhZPAPMQiPMC[i] = 0x0;
223  fhPMCvsPMQ[i] = 0x0;
224  }
225  for(Int_t r=0; r<fCRCMaxnRun; r++) {
226  fRunList[r] = 0;
227  }
228  for(Int_t k=0; k<8; k++) {
229  fTowerGainEq[k] = NULL;
230  }
231  this->InitializeRunArrays();
232  fMyTRandom3 = new TRandom3(1);
233  gRandom->SetSeed(fMyTRandom3->Integer(65539));
234  for(Int_t c=0; c<10; c++) {
235  fPtSpecGen[c] = NULL;
236  fPtSpecFB32[c] = NULL;
237  fPtSpecFB96[c] = NULL;
238  fPtSpecFB128[c] = NULL;
239  fPtSpecFB768[c] = NULL;
240  }
241 }
242 
243 //________________________________________________________________________
244 AliAnalysisTaskCRCZDC::AliAnalysisTaskCRCZDC(const char *name, TString RPtype, Bool_t on, TString DataSet, UInt_t iseed, Bool_t bCandidates):
245 AliAnalysisTaskSE(name),
246 fAnalysisType("AUTOMATIC"),
247 fRPType(RPtype),
248 fCFManager1(NULL),
249 fCFManager2(NULL),
250 fCutsEvent(NULL),
251 fCutsRP(NULL),
252 fCutsPOI(NULL),
253 fCutContainer(new TList()),
254 fQAList(NULL),
255 fMinMult(0),
256 fMaxMult(10000000),
257 fMinA(-1.0),
258 fMaxA(-0.01),
259 fMinB(0.01),
260 fMaxB(1.0),
261 fQAon(on),
262 fLoadCandidates(bCandidates),
263 fNbinsMult(10000),
264 fNbinsPt(100),
265 fNbinsPhi(100),
266 fNbinsEta(200),
267 fNbinsQ(500),
268 fNbinsMass(1),
269 fMultMin(0.),
270 fMultMax(10000.),
271 fPtMin(0.),
272 fPtMax(10.),
273 fPhiMin(0.),
274 fPhiMax(TMath::TwoPi()),
275 fEtaMin(-5.),
276 fEtaMax(5.),
277 fQMin(0.),
278 fQMax(3.),
279 fMassMin(-1.),
280 fMassMax(0.),
281 fHistWeightvsPhiMin(0.),
282 fHistWeightvsPhiMax(3.),
283 fExcludedEtaMin(0.),
284 fExcludedEtaMax(0.),
285 fExcludedPhiMin(0.),
286 fExcludedPhiMax(0.),
287 fAfterburnerOn(kFALSE),
288 fNonFlowNumberOfTrackClones(0),
289 fV1(0.),
290 fV2(0.),
291 fV3(0.),
292 fV4(0.),
293 fV5(0.),
294 fDifferentialV2(0),
295 fFlowEvent(NULL),
296 fShuffleTracks(kFALSE),
297 fMyTRandom3(NULL),
298 fAnalysisInput(kAOD),
299 fIsMCInput(kFALSE),
300 fUseMCCen(kTRUE),
301 fRejectPileUp(kTRUE),
302 fCentrLowLim(0.),
303 fCentrUpLim(100.),
304 fCentrEstimator("V0M"),
305 fOutput(0x0),
306 fhZNCvsZNA(0x0),
307 fhZPCvsZPA(0x0),
308 fhZDCCvsZDCCA(0x0),
309 fhZNCvsZPC(0x0),
310 fhZNAvsZPA(0x0),
311 fhZNvsZP(0x0),
312 fhZNvsVZERO(0x0),
313 fhZDCvsVZERO(0x0),
314 fhZDCvsTracklets(0x0),
315 fhZDCvsNclu1(0x0),
316 fhDebunch(0x0),
317 fhZNCcentroid(0x0),
318 fhZNAcentroid(0x0),
319 fhAsymm(0x0),
320 fhZNAvsAsymm(0x0),
321 fhZNCvsAsymm(0x0),
322 fhZNCvscentrality(0x0),
323 fhZNAvscentrality(0x0),
324 fhZPCvscentrality(0x0),
325 fhZPAvscentrality(0x0),
326 fhZNCpmcvscentr(0x0),
327 fhZNApmcvscentr(0x0),
328 fhZPCpmcvscentr(0x0),
329 fhZPApmcvscentr(0x0),
330 fhZNCpmcLR(0x0),
331 fhZNApmcLR(0x0),
332 fhZPCpmcLR(0x0),
333 fhZPApmcLR(0x0),
334 fDataSet(DataSet),
335 fCRCnRun(0),
336 fZDCGainAlpha(0.395),
337 fGenHeader(NULL),
338 fPythiaGenHeader(NULL),
339 fHijingGenHeader(NULL),
340 fFlowTrack(NULL),
341 fAnalysisUtil(NULL),
342 fStack(0x0),
343 fCutTPC(kFALSE),
344 fCenDis(0x0),
345 fMultSelection(0x0),
346 fCentrality(0x0),
347 fTowerEqList(NULL),
348 fCachedRunNum(0)
349 {
350 
351  for(int i=0; i<5; i++){
352  fhZNCPM[i] = 0x0;
353  fhZNAPM[i] = 0x0;
354  fhZPCPM[i] = 0x0;
355  fhZPAPM[i] = 0x0;
356  fhZNCPMlg[i] = 0x0;
357  fhZNAPMlg[i] = 0x0;
358  fhZPCPMlg[i] = 0x0;
359  fhZPAPMlg[i] = 0x0;
360  }
361  for(int i=0; i<2; i++) fhZEM[i] = 0x0;
362  for(int i=0; i<6; i++){
363  fhTDCraw[i] = 0x0;
364  fhTDC[i] = 0x0;
365  }
366  for(int i=0; i<4; i++){
367  fhZNCPMQiPMC[i] = 0x0;
368  fhZNAPMQiPMC[i] = 0x0;
369  fhZPCPMQiPMC[i] = 0x0;
370  fhZPAPMQiPMC[i] = 0x0;
371  fhPMCvsPMQ[i] = 0x0;
372  }
373  for(Int_t r=0; r<fCRCMaxnRun; r++) {
374  fRunList[r] = 0;
375  }
376  for(Int_t k=0; k<8; k++) {
377  fTowerGainEq[k] = NULL;
378  }
379  this->InitializeRunArrays();
380  fMyTRandom3 = new TRandom3(iseed);
381  gRandom->SetSeed(fMyTRandom3->Integer(65539));
382 
383  DefineInput(0, TChain::Class());
384  // Define output slots here
385  // Define here the flow event output
386  DefineOutput(1, AliFlowEventSimple::Class());
387  DefineOutput(2, TList::Class());
388 
389  for(Int_t c=0; c<10; c++) {
390  fPtSpecGen[c] = NULL;
391  fPtSpecFB32[c] = NULL;
392  fPtSpecFB96[c] = NULL;
393  fPtSpecFB128[c] = NULL;
394  fPtSpecFB768[c] = NULL;
395  }
396 
397 }
398 
399 //________________________________________________________________________
401 {
402  // Destructor
403  if(fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()){
404  delete fOutput; fOutput=0;
405  }
406  delete fMyTRandom3;
407  delete fFlowEvent;
408  delete fFlowTrack;
409  delete fCutsEvent;
410  if (fAnalysisUtil) delete fAnalysisUtil;
411  if (fQAList) delete fQAList;
412  if (fCutContainer) fCutContainer->Delete(); delete fCutContainer;
413 }
414 
415 //________________________________________________________________________
417 {
418  for(Int_t r=0;r<fCRCMaxnRun;r++) {
419  fCRCQVecListRun[r] = NULL;
420 // for(Int_t i=0;i<fCRCnTow;i++) {
421 // fhnTowerGain[r][i] = NULL;
422 // }
423  }
424  for(Int_t k=0;k<fCRCnTow;k++) {
425  fhnTowerGain[k] = NULL;
426  for(Int_t i=0;i<fnCen;i++) {
427  fhnTowerGainVtx[i][k] = NULL;
428  }
429  }
430 }
431 
432 //________________________________________________________________________
434 {
435  // Create the output containers
436 
437  if (!(fAnalysisType == "AOD" || fAnalysisType == "MCkine" || fAnalysisType == "MCAOD" || fAnalysisType == "AUTOMATIC" || fAnalysisType == "MCESD"))
438  {
439  AliError("WRONG ANALYSIS TYPE! only MCESD, MCkine, MCAOD, AOD and AUTOMATIC are allowed.");
440  exit(1);
441  }
442 
443  //set the common constants
446  cc->SetNbinsPt(fNbinsPt);
447  cc->SetNbinsPhi(fNbinsPhi);
448  cc->SetNbinsEta(fNbinsEta);
449  cc->SetNbinsQ(fNbinsQ);
451  cc->SetMultMin(fMultMin);
452  cc->SetMultMax(fMultMax);
453  cc->SetPtMin(fPtMin);
454  cc->SetPtMax(fPtMax);
455  cc->SetPhiMin(fPhiMin);
456  cc->SetPhiMax(fPhiMax);
457  cc->SetEtaMin(fEtaMin);
458  cc->SetEtaMax(fEtaMax);
459  cc->SetQMin(fQMin);
460  cc->SetQMax(fQMax);
461  cc->SetMassMin(fMassMin);
462  cc->SetMassMax(fMassMax);
465 
466  fFlowEvent = new AliFlowEvent(20000);
467  fFlowTrack = new AliFlowTrack();
468 
469  //printf(" AliAnalysisTaskCRCZDC::UserCreateOutputObjects()\n\n");
470  fOutput = new TList();
471  fOutput->SetOwner(kTRUE);
472  //fOutput->SetName("output");
473 
474  if (fQAon) {
475  fQAList = new TList();
476  fQAList->SetOwner(kTRUE);
477  fQAList->SetName("AliFlowEventCuts QA");
478  if (fCutsEvent->GetQA()) fQAList->Add(fCutsEvent->GetQA()); //0
479  if (fCutsRP->GetQA()) fQAList->Add(fCutsRP->GetQA()); //1
480  if (fCutsPOI->GetQA())fQAList->Add(fCutsPOI->GetQA()); //2
481  fOutput->Add(fQAList);
482  }
483 
484  fCenDis = new TH1F("fCenDis", "fCenDis", 100, 0., 100.);
485  fOutput->Add(fCenDis);
486 
487  for(Int_t k=0; k<8; k++) {
488  fTowerGainEq[k] = new TH1D(Form("fTowerGainEq[%d]",k),Form("fTowerGainEq[%d]",k),20,0.,100.);
489  fOutput->Add(fTowerGainEq[k]);
490  }
491 
492  Float_t xmin[] = {0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.,1.2,1.4,1.6,1.8,2.,2.33,2.66,3.,3.5,4.,4.5,5.,6.,7.,8.};
493  for(Int_t c=0; c<10; c++) {
494  fPtSpecGen[c] = new TH1F(Form("fPtSpecGen[%d]",c), Form("fPtSpecGen[%d]",c), 24, xmin);
495  fOutput->Add(fPtSpecGen[c]);
496  fPtSpecFB32[c] = new TH1F(Form("fPtSpecFB32[%d]",c), Form("fPtSpecFB32[%d]",c), 24, xmin);
497  fOutput->Add(fPtSpecFB32[c]);
498  fPtSpecFB96[c] = new TH1F(Form("fPtSpecFB96[%d]",c), Form("fPtSpecFB96[%d]",c), 24, xmin);
499  fOutput->Add(fPtSpecFB96[c]);
500  fPtSpecFB128[c] = new TH1F(Form("fPtSpecFB128[%d]",c), Form("fPtSpecFB128[%d]",c), 24, xmin);
501  fOutput->Add(fPtSpecFB128[c]);
502  fPtSpecFB768[c] = new TH1F(Form("fPtSpecFB768[%d]",c), Form("fPtSpecFB768[%d]",c), 24, xmin);
503  fOutput->Add(fPtSpecFB768[c]);
504  }
505 
506  fAnalysisUtil = new AliAnalysisUtils();
507 
508  for(int i=0; i<5; i++){
509  char hname[20];
510  sprintf(hname,"hZNCPM%d",i);
511  fhZNCPM[i] = new TH1F(hname, hname, 200, -50., 140000);
512  fOutput->Add(fhZNCPM[i]);
513  //
514  sprintf(hname,"hZNAPM%d",i);
515  fhZNAPM[i] = new TH1F(hname, hname, 200, -50., 140000);
516  fOutput->Add(fhZNAPM[i]);
517  //
518  sprintf(hname,"hZPCPM%d",i);
519  fhZPCPM[i] = new TH1F(hname, hname, 200, -50., 50000);
520  fOutput->Add(fhZPCPM[i]);
521  //
522  sprintf(hname,"hZPAPM%d",i);
523  fhZPAPM[i] = new TH1F(hname, hname, 200, -50., 50000);
524  fOutput->Add(fhZPAPM[i]);
525  //
526  sprintf(hname,"hZNCPMlg%d",i);
527  fhZNCPMlg[i] = new TH1F(hname, hname, 200, -50., 140000);
528  fOutput->Add(fhZNCPMlg[i]);
529  //
530  sprintf(hname,"hZNAPMlg%d",i);
531  fhZNAPMlg[i] = new TH1F(hname, hname, 200, -50., 140000);
532  fOutput->Add(fhZNAPMlg[i]);
533  //
534  sprintf(hname,"hZPCPMlg%d",i);
535  fhZPCPMlg[i] = new TH1F(hname, hname, 200, -50., 50000);
536  fOutput->Add(fhZPCPMlg[i]);
537  //
538  sprintf(hname,"hZPAPMlg%d",i);
539  fhZPAPMlg[i] = new TH1F(hname, hname, 200, -50., 50000);
540  fOutput->Add(fhZPAPMlg[i]);
541  //
542  if(i<4){
543  //
544  char hnamenc[20];
545  sprintf(hnamenc, "hZNCPMQ%dPMC",i+1);
546  fhZNCPMQiPMC[i] = new TH1F(hnamenc, hnamenc, 100, 0., 1.);
547  fOutput->Add(fhZNCPMQiPMC[i]);
548  //
549  char hnamena[20];
550  sprintf(hnamena, "hZNAPMQ%dPMC",i+1);
551  fhZNAPMQiPMC[i] = new TH1F(hnamena, hnamena, 100, 0., 1.);
552  fOutput->Add(fhZNAPMQiPMC[i]);
553  //
554  char hnamepc[20];
555  sprintf(hnamepc, "hZPCPMQ%dPMC",i+1);
556  fhZPCPMQiPMC[i] = new TH1F(hnamepc, hnamepc, 100, 0., 1.);
557  fOutput->Add(fhZPCPMQiPMC[i]);
558  //
559  char hnamepa[20];
560  sprintf(hnamepa, "hZPAPMQ%dPMC",i+1);
561  fhZPAPMQiPMC[i] = new TH1F(hnamepa, hnamepa, 100, 0., 1.);
562  fOutput->Add(fhZPAPMQiPMC[i]);
563  }
564  }
565  for(int i=0; i<6; i++){
566  if(i==0){
567  fhZEM[i] = new TH1F("hZEM1","hZEM1",200,-10.,1190.);
568  fhTDCraw[i] = new TH1F("hTDCZEM1raw", "hTDCZEM1raw", 200, -200., 0.);
569  fhTDC[i] = new TH1F("hTDCZEM1", "hTDCZEM1", 200, -150., 50.);
570  fhPMCvsPMQ[i] = new TH2F("hPMCvsPMQZNC","hPMCvsPMQZNC",200,-10.,140000,200,-10.,140000);
571  //
572  fOutput->Add(fhZEM[i]);
573  fOutput->Add(fhPMCvsPMQ[i]);
574  }
575  else if(i==1){
576  fhZEM[i] = new TH1F("hZEM2","hZEM2",200,-10.,1190.);
577  fhTDCraw[i] = new TH1F("hTDCZEM2raw", "hTDCZEM2raw", 200, -200., 0.);
578  fhTDC[i] = new TH1F("hTDCZEM2", "hTDCZEM2", 200, -150., 50.);
579  fhPMCvsPMQ[i] = new TH2F("hPMCvsPMQZPC","hPMCvsPMQZPC",200,-10.,50000,200,-10.,50000);
580  //
581  fOutput->Add(fhZEM[i]);
582  fOutput->Add(fhPMCvsPMQ[i]);
583  }
584  else if(i==2){
585  fhTDCraw[i] = new TH1F("hTDCZNCraw", "hTDCZNCraw", 200, -200., 0.);
586  fhTDC[i] = new TH1F("hTDCZNC", "hTDCZNC", 200, -150., 50.);
587  fhPMCvsPMQ[i] = new TH2F("hPMCvsPMQZNA","hPMCvsPMQZNA",200,-10.,140000,200,-10.,140000);
588  //
589  fOutput->Add(fhPMCvsPMQ[i]);
590  }
591  else if(i==3){
592  fhTDCraw[i] = new TH1F("hTDCZPCraw", "hTDCZPCraw", 200, -200., 0.);
593  fhTDC[i] = new TH1F("hTDCZPC", "hTDCZPC", 200, -150., 50.);
594  fhPMCvsPMQ[i] = new TH2F("hPMCvsPMQZPA","hPMCvsPMQZPA",200,-10.,50000,200,-10.,50000);
595  //
596  fOutput->Add(fhPMCvsPMQ[i]);
597  }
598  else if(i==4){
599  fhTDCraw[i] = new TH1F("hTDCZNAraw", "hTDCZNAraw", 200, -200., 0.);
600  fhTDC[i] = new TH1F("hTDCZNA", "hTDCZNA", 200, -150., 50.);
601  }
602  else if(i==5){
603  fhTDCraw[i] = new TH1F("hTDCZPAraw", "hTDCZPAraw", 200, -200., 0.);
604  fhTDC[i] = new TH1F("hTDCZPA", "hTDCZPA", 200, -150., 50.);
605  }
606  //
607  fOutput->Add(fhTDC[i]);
608  }
609 
610  fhZNCvsZNA = new TH2F("hZNCvsZNA","hZNCvsZNA",200,-50.,140000,200,-50.,140000);
611  fOutput->Add(fhZNCvsZNA);
612  fhZPCvsZPA = new TH2F("hZPCvsZPA","hZPCvsZPA",200,-50.,50000,200,-50.,50000);
613  fOutput->Add(fhZPCvsZPA);
614  fhZDCCvsZDCCA = new TH2F("hZDCCvsZDCCA","hZDCCvsZDCCA",200,0.,180000.,200,0.,200000.);
615  fOutput->Add(fhZDCCvsZDCCA);
616  fhZNCvsZPC = new TH2F("hZNCvsZPC","hZNCvsZPC",200,-50.,50000,200,-50.,140000);
617  fOutput->Add(fhZNCvsZPC);
618  fhZNAvsZPA = new TH2F("hZNAvsZPA","hZNAvsZPA",200,-50.,50000,200,-50.,140000);
619  fOutput->Add(fhZNAvsZPA);
620  fhZNvsZP = new TH2F("hZNvsZP","hZNvsZP",200,-50.,80000,200,-50.,200000);
621  fOutput->Add(fhZNvsZP);
622  fhZNvsVZERO = new TH2F("hZNvsVZERO","hZNvsVZERO",250,0.,25000.,200,0.,200000.);
623  fOutput->Add(fhZNvsVZERO);
624  fhZDCvsVZERO = new TH2F("hZDCvsVZERO","hZDCvsVZERO",250,0.,25000.,250,0.,250000.);
625  fOutput->Add(fhZDCvsVZERO);
626  fhZDCvsTracklets = new TH2F("hZDCvsTracklets","hZDCvsTracklets",200,0.,4000.,250,0.,250000.);
628  fhZDCvsNclu1 = new TH2F("hZDCvsNclu1", "hZDCvsNclu1", 200, 0.,8000.,200,0.,250000.);
629  fOutput->Add(fhZDCvsNclu1);
630  fhDebunch = new TH2F("hDebunch","hDebunch",240,-100.,-40.,240,-30.,30.);
631  fOutput->Add(fhDebunch);
632  fhZNCcentroid = new TH2F("hZNCcentroid","hZNCcentroid",100,-3.5,3.5,100,-3.5,3.5);
633  fOutput->Add(fhZNCcentroid);
634  fhZNAcentroid = new TH2F("hZNAcentroid","hZNAcentroid",100,-3.5,3.5,100,-3.5,3.5);
635  fOutput->Add(fhZNAcentroid);
636 
637  fhAsymm = new TH1F("hAsymm" , "Asimmetry ",200,-1.,1.);
638  fOutput->Add(fhAsymm);
639  fhZNAvsAsymm = new TH2F("hZNAvsAsymm","ZNA vs. asymm.",200,-1.,1.,200,0.,80.);
640  fOutput->Add(fhZNAvsAsymm);
641  fhZNCvsAsymm = new TH2F("hZNCvsAsymm","ZNC vs. asymm.",200,-1.,1.,200,0.,80.);
642  fOutput->Add(fhZNCvsAsymm);
643 
644  fhZNCvscentrality = new TH2F("hZNCvscentrality","ZNC vs. centrality",100,0.,100.,100,0.,100.);
646  fhZNAvscentrality = new TH2F("hZNAvscentrality","ZNA vs. centrality",100,0.,100.,100,0.,100.);
648  fhZPCvscentrality = new TH2F("hZPCvscentrality","ZPC vs. centrality",100,0.,100.,100,0.,100.);
650  fhZPAvscentrality = new TH2F("hZPAvscentrality","ZPA vs. centrality",100,0.,100.,100,0.,100.);
652 
653  fhZNCpmcvscentr = new TH2F("hZNCpmcvscentr","ZNC PMC vs. centrality",100,0.,100.,100,0.,100.);
654  fOutput->Add(fhZNCpmcvscentr);
655  fhZNApmcvscentr = new TH2F("hZNApmcvscentr","ZNA PMC vs. centrality",100,0.,100.,100,0.,100.);
656  fOutput->Add(fhZNApmcvscentr);
657  fhZPCpmcvscentr = new TH2F("hZPCpmcvscentr","ZPC PMC vs. centrality",100,0.,100.,100,0.,100.);
658  fOutput->Add(fhZPCpmcvscentr);
659  fhZPApmcvscentr = new TH2F("hZPApmcvscentr","ZPA PMC vs. centrality",100,0.,100.,100,0.,100.);
660  fOutput->Add(fhZPApmcvscentr);
661 
662  fhZNCpmcLR = new TH1F("hZNCpmcLR","ZNC PMC lr", 100, 0., 10.);
663  fOutput->Add(fhZNCpmcLR);
664  fhZNApmcLR = new TH1F("hZNApmcLR","ZNA PMC lr", 100, 0., 10.);
665  fOutput->Add(fhZNApmcLR);
666  fhZPCpmcLR = new TH1F("hZPCpmcLR","ZPC PMC lr", 100, 0., 10.);
667  fOutput->Add(fhZPCpmcLR);
668  fhZPApmcLR = new TH1F("hZPApmcLR","ZPA PMC lr", 100, 0., 10.);
669  fOutput->Add(fhZPApmcLR);
670 
671  //********************************************************************
672 
673  Int_t dRun10h[] = {139510, 139507, 139505, 139503, 139465, 139438, 139437, 139360, 139329, 139328, 139314, 139310, 139309, 139173, 139107, 139105, 139038, 139037, 139036, 139029, 139028, 138872, 138871, 138870, 138837, 138732, 138730, 138666, 138662, 138653, 138652, 138638, 138624, 138621, 138583, 138582, 138579, 138578, 138534, 138469, 138442, 138439, 138438, 138396, 138364, 138275, 138225, 138201, 138197, 138192, 138190, 137848, 137844, 137752, 137751, 137724, 137722, 137718, 137704, 137693, 137692, 137691, 137686, 137685, 137639, 137638, 137608, 137595, 137549, 137546, 137544, 137541, 137539, 137531, 137530, 137443, 137441, 137440, 137439, 137434, 137432, 137431, 137430, 137366, 137243, 137236, 137235, 137232, 137231, 137230, 137162, 137161};
674 
675  Int_t dRun11h[] = {167902, 167903, 167915, 167920, 167985, 167987, 167988, 168066, 168068, 168069, 168076, 168104, 168105, 168107, 168108, 168115, 168212, 168310, 168311, 168322, 168325, 168341, 168342, 168361, 168362, 168458, 168460, 168461, 168464, 168467, 168511, 168512, 168514, 168777, 168826, 168984, 168988, 168992, 169035, 169040, 169044, 169045, 169091, 169094, 169099, 169138, 169143, 169144, 169145, 169148, 169156, 169160, 169167, 169238, 169411, 169415, 169417, 169418, 169419, 169420, 169475, 169498, 169504, 169506, 169512, 169515, 169550, 169553, 169554, 169555, 169557, 169586, 169587, 169588, 169590, 169591, 169835, 169837, 169838, 169846, 169855, 169858, 169859, 169923, 169956, 169965, 170027, 170036,170040, 170081, 170083, 170084, 170085, 170088, 170089, 170091, 170155, 170159, 170163, 170193, 170203, 170204, 170207, 170228, 170230, 170268, 170269, 170270, 170306, 170308, 170309, 170311, 170312, 170313, 170315, 170387, 170388, 170572, 170593};
676 
677  Int_t dRun15h[] = {244917, 244918, 244975, 244980, 244982, 244983, 245061, 245064, 245066, 245068};
678 
679  if(fDataSet.EqualTo("2010")) {fCRCnRun=92;}
680  if(fDataSet.EqualTo("2011")) {fCRCnRun=119;}
681  if(fDataSet.EqualTo("2015")) {fCRCnRun=10;}
682  if(fDataSet.EqualTo("MCkine")) {fCRCnRun=1;}
683 
684  Int_t d=0;
685  for(Int_t r=0; r<fCRCnRun; r++) {
686  if(fDataSet.EqualTo("2010")) fRunList[d] = dRun10h[r];
687  if(fDataSet.EqualTo("2011")) fRunList[d] = dRun11h[r];
688  if(fDataSet.EqualTo("2015")) fRunList[d] = dRun15h[r];
689  if(fDataSet.EqualTo("MCkine")) fRunList[d] = 1;
690  d++;
691  }
692 
693  for(Int_t k=0;k<fCRCnTow;k++) {
694  fhnTowerGain[k] = new TProfile(Form("fhnTowerGain[%d]",k),
695  Form("fhnTowerGain[%d]",k),100,0.,100.,"s");
696  fhnTowerGain[k]->Sumw2();
697  fOutput->Add(fhnTowerGain[k]);
698  }
699  for(Int_t k=0;k<fCRCnTow;k++) {
700  for(Int_t i=0;i<fnCen;i++) {
701  fhnTowerGainVtx[i][k] = new TProfile3D(Form("fhnTowerGainVtx[%d][%d]",i,k),
702  Form("fhnTowerGainVtx[%d][%d]",i,k),20,-0.035,0.015,20,0.145,0.220,10,-10.,10.,"s");
703  fhnTowerGainVtx[i][k]->Sumw2();
704  fOutput->Add(fhnTowerGainVtx[i][k]);
705  }
706  }
707 
708  for(Int_t r=0;r<fCRCnRun;r++) {
709  fCRCQVecListRun[r] = new TList();
710  fCRCQVecListRun[r]->SetName(Form("Run %d",fRunList[r]));
711  fCRCQVecListRun[r]->SetOwner(kTRUE);
712  fOutput->Add(fCRCQVecListRun[r]);
713  }
714 
715  PostData(2, fOutput);
716 }
717 
718 //________________________________________________________________________
719 void AliAnalysisTaskCRCZDC::UserExec(Option_t */*option*/)
720 {
721  // Execute analysis for current event:
722  AliMCEvent* McEvent = MCEvent();
723  AliAODEvent *aod = dynamic_cast<AliAODEvent*>(InputEvent());
724  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(InputEvent());
725 // AliMultiplicity* myTracklets = NULL;
726 // AliESDPmdTrack* pmdtracks = NULL;
727 // int availableINslot=1;
728 
729  if (!(fCutsRP&&fCutsPOI&&fCutsEvent)) {
730  AliError("cuts not set");
731  return;
732  }
733 
734  //DEFAULT - automatically takes care of everything
735  if (fAnalysisType == "AUTOMATIC") {
736 
737  //check event cuts
738  if (InputEvent()) {
739  if(!fCutsEvent->IsSelected(InputEvent(),MCEvent())) return;
740  if(fRejectPileUp && fAnalysisUtil->IsPileUpEvent(InputEvent())) return;
741  }
742 
743  //first attach all possible information to the cuts
744  fCutsRP->SetEvent( InputEvent(), MCEvent() ); //attach event
745  fCutsPOI->SetEvent( InputEvent(), MCEvent() );
746 
747  //then make the event
749 
751  fFlowEvent->SetCentrality(fCutsEvent->GetCentrality(InputEvent(),McEvent));
752 
753  fFlowEvent->SetCentralityCL1(((AliVAODHeader*)aod->GetHeader())->GetCentralityP()->GetCentralityPercentile("CL1"));
754  fFlowEvent->SetCentralityTRK(((AliVAODHeader*)aod->GetHeader())->GetCentralityP()->GetCentralityPercentile("TRK"));
755  fFlowEvent->SetNITSCL1(((AliVAODHeader*)aod->GetHeader())->GetNumberOfITSClusters(1));
756 
757  Double_t vtxpos[3]={0.,0.,0.};
758  vtxpos[0] = ((AliAODVertex*)aod->GetPrimaryVertex())->GetX();
759  vtxpos[1] = ((AliAODVertex*)aod->GetPrimaryVertex())->GetY();
760  vtxpos[2] = ((AliAODVertex*)aod->GetPrimaryVertex())->GetZ();
761  fFlowEvent->SetVertexPosition(vtxpos);
762 
763  if (McEvent && McEvent->GenEventHeader()) fFlowEvent->SetMCReactionPlaneAngle(McEvent);
764 
765  }
766 
767  if (fAnalysisType == "MCAOD") {
768 
769  //check event cuts
770  if (InputEvent()) {
771  if(!fCutsEvent->IsSelected(InputEvent(),MCEvent())) return;
772  if(fRejectPileUp && fAnalysisUtil->IsPileUpEvent(InputEvent())) return;
773  }
774 
776 
777  if(!McEvent) {
778  AliError("ERROR: Could not retrieve MCEvent");
779  return;
780  }
781  fStack = (TClonesArray*)aod->FindListObject(AliAODMCParticle::StdBranchName());
782  if(!fStack){
783  AliError("ERROR: Could not retrieve MCStack");
784  return;
785  }
786 
787  // get centrality (from AliMultSelection or AliCentrality)
788  Float_t centr = 300;
789  if(fDataSet == "2015") {
790  fMultSelection = (AliMultSelection*)aod->FindListObject("MultSelection");
791  if(!fMultSelection) {
792  //If you get this warning (and lPercentiles 300) please check that the AliMultSelectionTask actually ran (before your task)
793  AliWarning("AliMultSelection object not found!");
794  } else {
795  centr = fMultSelection->GetMultiplicityPercentile("V0M");
796  }
797  } else {
798  centr = (((AliVAODHeader*)aod->GetHeader())->GetCentralityP())->GetCentralityPercentile("V0M");
799  }
800  fCenDis->Fill(centr);
801  // centrality bin
802  if (centr<fCentrLowLim || centr>=fCentrUpLim ) return;
803  Int_t CenBin = -1;
804  if (centr>0. && centr<5.) CenBin=0;
805  if (centr>5. && centr<10.) CenBin=1;
806  if (centr>10. && centr<20.) CenBin=2;
807  if (centr>20. && centr<30.) CenBin=3;
808  if (centr>30. && centr<40.) CenBin=4;
809  if (centr>40. && centr<50.) CenBin=5;
810  if (centr>50. && centr<60.) CenBin=6;
811  if (centr>60. && centr<70.) CenBin=7;
812  if (centr>70. && centr<80.) CenBin=8;
813  if (centr>80. && centr<90.) CenBin=9;
814  if(CenBin==-1) return;
815 
816  // reconstructed
817  for(Int_t jTracks = 0; jTracks<aod->GetNumberOfTracks(); jTracks++){
818 
819  AliAODTrack* track = (AliAODTrack*)aod->GetTrack(jTracks);
820  if(!track) continue;
821 
822  // select primaries
823  Int_t lp = TMath::Abs(track->GetLabel());
824  if (!((AliAODMCParticle*)fStack->At(lp))->IsPhysicalPrimary()) continue;
825 
826  // general kinematic & quality cuts
827  if (track->Pt() < .2 || track->Pt() > 8. || TMath::Abs(track->Eta()) > .8 || track->GetTPCNcls() < 70) continue;
828 
829  // test filter bits
830  if (track->TestFilterBit(32)) fPtSpecFB32[CenBin]->Fill(track->Pt());
831  if (track->TestFilterBit(96)) fPtSpecFB96[CenBin]->Fill(track->Pt());
832  if (track->TestFilterBit(128)) fPtSpecFB128[CenBin]->Fill(track->Pt());
833  if (track->TestFilterBit(768)) fPtSpecFB768[CenBin]->Fill(track->Pt());
834  }
835 
836  // generated (physical primaries)xw
837 
838  for(Int_t jTracks = 0; jTracks<fStack->GetEntriesFast(); jTracks++) {
839  AliAODMCParticle *MCpart = (AliAODMCParticle*)fStack->At(jTracks);
840  if (!MCpart) {
841  printf("ERROR: Could not receive MC track %d\n", jTracks);
842  continue;
843  }
844  // kinematic cuts
845  if ( MCpart->Pt() < 0.2 || MCpart->Pt() > 8. || TMath::Abs(MCpart->Eta()) > .8 ) continue;
846  // select charged primaries
847  if ( MCpart->Charge() == 0. || !MCpart->IsPhysicalPrimary()) continue;
848 
849  fPtSpecGen[CenBin]->Fill(MCpart->Pt());
850  }
851 
852 // fGenHeader = McEvent->GenEventHeader();
853 // if(fGenHeader) fPythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(fGenHeader);
854  // printf("#reconstructed : %d (rejected from cuts %d), #MC primaries : %d (rejected from cuts %d) \n",AODPOIs,AODbads,MCPrims,MCSecos);
855  fFlowEvent->SetReferenceMultiplicity(aod->GetNumberOfTracks());
856  fFlowEvent->SetCentrality(centr);
857 // if (McEvent && McEvent->GenEventHeader()) fFlowEvent->SetMCReactionPlaneAngle(McEvent);
858  fFlowEvent->SetRun(aod->GetRunNumber());
859  // printf("Run : %d, RefMult : %d, Cent : %f \n",fFlowEvent->GetRun(),fFlowEvent->GetReferenceMultiplicity(),fFlowEvent->GetCentrality());
860  }
861 
862  if(fAnalysisType == "MCESD") {
863 
865 
866  if(!esd) {
867  AliError("ERROR: Could not retrieve ESDEvent");
868  return;
869  }
870  if(!McEvent) {
871  AliError("ERROR: Could not retrieve MCEvent");
872  return;
873  }
874  AliStack* fStack = fMCEvent->Stack();
875  if(!fStack) {
876  AliError("ERROR: Could not retrieve MCStack");
877  return;
878  }
879 
880  AliESDVertex *vertex = (AliESDVertex*) esd->GetPrimaryVertex();
881  if (!vertex) return;
882  if (TMath::Abs(vertex->GetZ()) > 10. ) return;
883  if (vertex->GetNContributors() < 1 ) return;
884  AliCentrality *centrality = esd->GetCentrality();
885  if (!centrality) return;
886  Double_t centr = centrality->GetCentralityPercentile("V0M");
887  if (centr<fCentrLowLim || centr>=fCentrUpLim ) return;
888  Int_t CenBin = -1;
889  if (centr>0. && centr<5.) CenBin=0;
890  if (centr>5. && centr<10.) CenBin=1;
891  if (centr>10. && centr<20.) CenBin=2;
892  if (centr>20. && centr<30.) CenBin=3;
893  if (centr>30. && centr<40.) CenBin=4;
894  if (centr>40. && centr<50.) CenBin=5;
895  if (centr>50. && centr<60.) CenBin=6;
896  if (centr>60. && centr<70.) CenBin=7;
897  if (centr>70. && centr<80.) CenBin=8;
898  if (centr>80. && centr<90.) CenBin=9;
899  if(CenBin==-1) return;
900 
901  //Generated
902  Int_t MCPrims = 0;
903  for ( Int_t i=0 ; i<fStack->GetNtrack() ; i++ ) {
904 
905  //Primaries Selection
906  TParticle *particle = (TParticle*)fStack->Particle(i);
907  if (!particle) continue;
908  if (!fStack->IsPhysicalPrimary(i)) continue;
909  if ( particle->GetPDG()->Charge() == 0.) continue;
910 
911  //Kinematic Cuts
912  if ( particle->Pt()<0.2 || particle->Pt()>10. ) continue;
913  if ( TMath::Abs(particle->Eta())>0.8 ) continue;
914 
915  fFlowTrack->SetPhi(particle->Phi());
916  fFlowTrack->SetEta(particle->Eta());
917  fFlowTrack->SetPt(particle->Pt());
923  MCPrims++;
924 
925  fPtSpecGen[CenBin]->Fill(particle->Pt());
926 
927  }
928 
929  //Reconstructed
930  Int_t ESDPrims = 0;
931  for (Int_t i=0 ; i<esd->GetNumberOfTracks() ; i++) {
932 
933  //Get reconstructed track
934  AliVTrack *vtrack = static_cast<AliVTrack*>(esd->GetTrack(i));
935  AliESDtrack *track = dynamic_cast<AliESDtrack*>(vtrack);
936  if (!track) continue;
937 
938  //Primaries selection
939  Int_t lp = TMath::Abs(track->GetLabel());
940  if (!fStack->IsPhysicalPrimary(lp)) continue;
941  TParticle *particle = (TParticle*)fStack->Particle(lp);
942  if (!particle) continue;
943  if (particle->GetPDG()->Charge() == 0.) continue;
944 
945 // if(!fCutsPOI->PassesESDcuts(track)) continue;
946 
947  Bool_t pass = kTRUE;
948 
949  if(fCutTPC) {
950 // printf("******* cutting TPC ******** \n");
951  UShort_t ntpccls = track->GetTPCNcls();
952  Double_t tpcchi2 = track->GetTPCchi2();
953  if (tpcchi2<0.2 || tpcchi2 >=4.) {
954 // printf("TPCchi2 : %e %e ",tpcchi2,track->GetTPCchi2Iter1());
955  pass=kFALSE;
956  }
957  if (ntpccls < 70) {
958 // printf("#TPCcluster : %u %u %u %u ",ntpccls,track->GetTPCNclsF(),track->GetTPCNclsFIter1(),track->GetTPCNclsIter1());
959  pass=kFALSE;
960  }
961  }
962 
963  Float_t dcaxy=0.0;
964  Float_t dcaz=0.0;
965  track->GetImpactParameters(dcaxy,dcaz);
966  if (dcaxy > 0.3 || dcaz > 0.3) {
967 // printf("DCA : %e %e ",dcaxy,dcaz);
968  pass=kFALSE;
969  }
970  if(!pass) continue;
971 
972  //Kinematic Cuts
973  if ( track->Pt()<0.2 || track->Pt()>10. ) continue;
974  if ( TMath::Abs(track->Eta())>0.8 ) continue;
975 
976  fFlowTrack->SetPhi(track->Phi());
977  fFlowTrack->SetEta(track->Eta());
978  fFlowTrack->SetPt(track->Pt());
980  fFlowTrack->SetForRPSelection(kFALSE);
984  ESDPrims++;
985 
986  }
987 
988 // printf("#reconstructed : %d , #MC primaries : %d \n",ESDPrims,MCPrims);
989  fFlowEvent->SetReferenceMultiplicity(esd->GetNumberOfTracks());
990  fFlowEvent->SetCentrality(centr);
991  if (McEvent && McEvent->GenEventHeader()) fFlowEvent->SetMCReactionPlaneAngle(McEvent);
992  fFlowEvent->SetRun(esd->GetRunNumber());
993 // printf("Run : %d, RefMult : %d, Cent : %f \n",fFlowEvent->GetRun(),fFlowEvent->GetReferenceMultiplicity(),fFlowEvent->GetCentrality());
994 
995  } // end of if(fAnalysisType == "MCESD")
996 
997  if(fAnalysisType == "MCkine") {
998 
1000 
1001  AliInputEventHandler* McHandler = dynamic_cast<AliInputEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
1002  if(!McHandler) {
1003  AliError("ERROR: Could not retrieve MCtruthEventHandler");
1004  return;
1005  }
1006  McEvent = McHandler->MCEvent();
1007  if(!McEvent) {
1008  AliError("ERROR: Could not retrieve MC event");
1009  return;
1010  }
1011 
1012  Int_t nTracks = McEvent->GetNumberOfTracks();
1013 // Int_t nPrimTr = McEvent->GetNumberOfPrimaries();
1014 
1015  //loop over tracks
1016  for (Int_t itrkN=0; itrkN<nTracks; itrkN++) {
1017  //get input particle
1018  AliMCParticle* pParticle = dynamic_cast<AliMCParticle*>(McEvent->GetTrack(itrkN));
1019  if (!pParticle) continue;
1020 
1021  //check if track passes the cuts
1022  if (McEvent->IsPhysicalPrimary(itrkN) && pParticle->Charge()!=0) {
1023  fFlowTrack->Set(pParticle);
1025  fFlowTrack->SetForRPSelection(kTRUE);
1030  }
1031  }// for all tracks
1032 
1033  // if monte carlo event get reaction plane from monte carlo (depends on generator)
1034  if (McEvent && McEvent->GenEventHeader()) fFlowEvent->SetMCReactionPlaneAngle(McEvent);
1035  // set reference multiplicity
1036  fFlowEvent->SetReferenceMultiplicity(McEvent->GetNumberOfTracks());
1037  // tag subevents
1039  // set centrality from impact parameter
1040  Double_t ImpPar=0., CenPer=0.;
1041  fGenHeader = McEvent->GenEventHeader();
1042  if(fGenHeader){
1043  fPythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(fGenHeader);
1044  if(fPythiaGenHeader) ImpPar = fPythiaGenHeader->GetImpactParameter();
1045  fHijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(fGenHeader);
1046  if(fHijingGenHeader) ImpPar = fHijingGenHeader->ImpactParameter();
1047  if(ImpPar) CenPer = 0.3859796743103508*pow(ImpPar,2.);
1048  if(CenPer>0. && CenPer<100.) fFlowEvent->SetCentrality(CenPer);
1049  else return;
1050  fFlowEvent->SetRun(1);
1051  }
1052 
1053  } // end of if(fAnalysisType == "MCkine")
1054 
1055  if (!fFlowEvent) return; //shuts up coverity
1056 
1057  //check final event cuts
1058  Int_t mult = fFlowEvent->NumberOfTracks();
1059  // AliInfo(Form("FlowEvent has %i tracks",mult));
1060  if (mult<fMinMult || mult>fMaxMult) {
1061  AliWarning("FlowEvent cut on multiplicity"); return;
1062  }
1063 
1064  //define dead zone
1066 
1069  if (fAfterburnerOn)
1070  {
1071  //if reaction plane not set from elsewhere randomize it before adding flow
1073  fFlowEvent->SetMCReactionPlaneAngle(gRandom->Uniform(0.0,TMath::TwoPi()));
1074 
1075  if(fDifferentialV2)
1077  else
1078  fFlowEvent->AddFlow(fV1,fV2,fV3,fV4,fV5); //add flow
1079  fFlowEvent->CloneTracks(fNonFlowNumberOfTrackClones); //add nonflow by cloning tracks
1080  }
1082 
1083  //tag subEvents
1085 
1086  //do we want to serve shullfed tracks to everybody?
1088 
1089  // associate the mother particles to their daughters in the flow event (if any)
1091 
1092  //fListHistos->Print();
1093  //fOutputFile->WriteObject(fFlowEvent,"myFlowEventSimple");
1094 
1095 // printf("event : ntr %d, cen %f **********************************************************************************************************\n"
1096 
1097  //********************************************************************************************************************************
1098 
1099  if(fAnalysisType == "AOD" || fAnalysisType == "AUTOMATIC") {
1100 
1101  // PHYSICS SELECTION
1102  AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
1103  AliInputEventHandler *hdr = (AliInputEventHandler*)am->GetInputEventHandler();
1104 
1105  if(hdr->IsEventSelected() && AliVEvent::kAny) {
1106 
1107  AliCentrality* centrality = aod->GetCentrality();
1108  Float_t centrperc = centrality->GetCentralityPercentile(fCentrEstimator.Data());
1109 
1110  AliAODTracklets *trackl = aod->GetTracklets();
1111  Int_t nTracklets = trackl->GetNumberOfTracklets();
1112 
1113  AliAODVZERO *vzeroAOD = aod->GetVZEROData();
1114  Float_t multV0A = vzeroAOD->GetMTotV0A();
1115  Float_t multV0C = vzeroAOD->GetMTotV0C();
1116 
1117  AliAODZDC *aodZDC = aod->GetZDCData();
1118 
1119  Float_t energyZNC = (Float_t) (aodZDC->GetZNCEnergy());
1120  Float_t energyZPC = (Float_t) (aodZDC->GetZPCEnergy());
1121  Float_t energyZNA = (Float_t) (aodZDC->GetZNAEnergy());
1122  Float_t energyZPA = (Float_t) (aodZDC->GetZPAEnergy());
1123  Float_t energyZEM1 = (Float_t) (aodZDC->GetZEM1Energy());
1124  Float_t energyZEM2 = (Float_t) (aodZDC->GetZEM2Energy());
1125 
1126  const Double_t * towZNC = aodZDC->GetZNCTowerEnergy();
1127  const Double_t * towZPC = aodZDC->GetZPCTowerEnergy();
1128  const Double_t * towZNA = aodZDC->GetZNATowerEnergy();
1129  const Double_t * towZPA = aodZDC->GetZPATowerEnergy();
1130  //
1131  const Double_t * towZNClg = aodZDC->GetZNCTowerEnergyLR();
1132  const Double_t * towZNAlg = aodZDC->GetZNATowerEnergyLR();
1133  //
1134  Double_t towZPClg[5], towZPAlg[5]={0.};
1135  for(Int_t it=0; it<5; it++){
1136  towZPClg[it] = 8*towZPC[it];
1137  towZPAlg[it] = 8*towZNA[it];
1138  }
1139 
1140  // Get centroid from ZDCs *******************************************************
1141 
1142  Double_t xyZNC[2]={999.,999.}, xyZNA[2]={999.,999.};
1143  Float_t zncEnergy=0., znaEnergy=0.;
1144  for(Int_t i=0; i<5; i++){
1145  zncEnergy += towZNC[i];
1146  znaEnergy += towZNA[i];
1147  }
1148  fFlowEvent->SetZNCEnergy(towZNC[0]);
1149  fFlowEvent->SetZNAEnergy(towZNA[0]);
1150 
1151  Int_t CenBin = GetCenBin(centrperc);
1152  Double_t zvtxpos[3]={0.,0.,0.};
1153  fFlowEvent->GetVertexPosition(zvtxpos);
1154  Int_t RunNum=fFlowEvent->GetRun();
1155  if(fTowerEqList) {
1156  if(RunNum!=fCachedRunNum) {
1157  for(Int_t i=0; i<8; i++) {
1158  fTowerGainEq[i] = (TH1D*)(fTowerEqList->FindObject(Form("Run %d",RunNum))->FindObject(Form("fhnTowerGainEqFactor[%d][%d]",RunNum,i)));
1159  }
1160  }
1161  }
1162  Double_t AvTowerGain[8] = {1., 1., 1., 1., 1., 1., 1., 1.};
1163 
1164  if (fUseMCCen) {
1165  if(aod->GetRunNumber() < 209122) aodZDC->GetZNCentroidInPbPb(1380., xyZNC, xyZNA);
1166  else aodZDC->GetZNCentroidInPbPb(2510., xyZNC, xyZNA);
1167  } else {
1168  // set tower gain equalization, if available
1169  if(fTowerEqList) {
1170  for(Int_t i=0; i<8; i++) {
1171  if(fTowerGainEq[i]) AvTowerGain[i] = fTowerGainEq[i]->GetBinContent(fTowerGainEq[i]->FindBin(centrperc));
1172  }
1173  }
1174  const Float_t x[4] = {-1.75, 1.75, -1.75, 1.75};
1175  const Float_t y[4] = {-1.75, -1.75, 1.75, 1.75};
1176  Float_t numXZNC=0., numYZNC=0., denZNC=0., wZNC;
1177  Float_t numXZNA=0., numYZNA=0., denZNA=0., wZNA;
1178  for(Int_t i=0; i<4; i++) {
1179  if(towZNC[i+1]>0.) {
1180  wZNC = TMath::Power(towZNC[i+1], fZDCGainAlpha)*AvTowerGain[i];
1181  numXZNC += x[i]*wZNC;
1182  numYZNC += y[i]*wZNC;
1183  denZNC += wZNC;
1184  }
1185  if(towZNA[i+1]>0.) {
1186  wZNA = TMath::Power(towZNA[i+1], fZDCGainAlpha)*AvTowerGain[i+4];
1187  numXZNA += x[i]*wZNA;
1188  numYZNA += y[i]*wZNA;
1189  denZNA += wZNA;
1190  }
1191  }
1192  if(denZNC!=0) {
1193  xyZNC[0] = numXZNC/denZNC;
1194  xyZNC[1] = numYZNC/denZNC;
1195  }
1196  else{
1197  xyZNC[0] = xyZNC[1] = 999.;
1198  zncEnergy = 0.;
1199  }
1200  if(denZNA!=0) {
1201  xyZNA[0] = numXZNA/denZNA;
1202  xyZNA[1] = numYZNA/denZNA;
1203  }
1204  else{
1205  xyZNA[0] = xyZNA[1] = 999.;
1206  znaEnergy = 0.;
1207  }
1208  }
1209 
1210  Float_t MulA=0., MulC=0.;
1211  for(Int_t i=0; i<4; i++) {
1212  if(towZNC[i+1]>0.) {
1213  MulC += TMath::Power(towZNC[i+1], fZDCGainAlpha)*AvTowerGain[i+4];
1214  }
1215  if(towZNA[i+1]>0.) {
1216  MulA += TMath::Power(towZNA[i+1], fZDCGainAlpha)*AvTowerGain[i+4];
1217  }
1218  }
1219 
1220  fhZNCcentroid->Fill(xyZNC[0], xyZNC[1]);
1221  fhZNAcentroid->Fill(xyZNA[0], xyZNA[1]);
1222  fFlowEvent->SetZDC2Qsub(xyZNC,MulC,xyZNA,MulA);
1223 
1224  Int_t RunBin=-1, bin=0;
1225  for(Int_t c=0;c<fCRCnRun;c++) {
1226  if(fRunList[c]==RunNum) RunBin=bin;
1227  else bin++;
1228  }
1229  if(fDataSet.EqualTo("MCkine")) RunBin=0;
1230 
1231  if(CenBin!=-1) {
1232  for(Int_t i=0; i<4; i++) {
1233  if(towZNC[i+1]>0.) {
1234  fhnTowerGainVtx[CenBin][i]->Fill(zvtxpos[0],zvtxpos[1],zvtxpos[2],TMath::Power(towZNC[i+1], fZDCGainAlpha)*AvTowerGain[i]);
1235  fhnTowerGain[i]->Fill(centrperc,TMath::Power(towZNC[i+1], fZDCGainAlpha)*AvTowerGain[i]);
1236  }
1237  if(towZNA[i+1]>0.) {
1238  fhnTowerGainVtx[CenBin][i+4]->Fill(zvtxpos[0],zvtxpos[1],zvtxpos[2],TMath::Power(towZNA[i+1], fZDCGainAlpha)*AvTowerGain[i+4]);
1239  fhnTowerGain[i+4]->Fill(centrperc,TMath::Power(towZNA[i+1], fZDCGainAlpha)*AvTowerGain[i+4]);
1240  }
1241  }
1242  }
1243 
1244  // ******************************************************************************
1245 
1246  Float_t tdcSum = aodZDC->GetZDCTimeSum();
1247  Float_t tdcDiff = aodZDC->GetZDCTimeDiff();
1248  fhDebunch->Fill(tdcDiff, tdcSum);
1249 
1250  for(int i=0; i<5; i++){
1251  fhZNCPM[i]->Fill(towZNC[i]);
1252  fhZNCPMlg[i]->Fill(towZNClg[i]);
1253  if((i<4) && (towZNC[0]>0.)) fhZNCPMQiPMC[i]->Fill(towZNC[i+1]/towZNC[0]);
1254  fhZNCpmcLR->Fill(towZNClg[0]/1000.);
1255  }
1256  fhPMCvsPMQ[0]->Fill(towZNC[1]+towZNC[2]+towZNC[3]+towZNC[4], towZNC[0]);
1257  for(int i=0; i<5; i++){
1258  fhZPCPM[i]->Fill(towZPC[i]);
1259  fhZPCPMlg[i]->Fill(towZPClg[i]);
1260  if(((i<4) && towZPC[0]>0.)) fhZPCPMQiPMC[i]->Fill(towZPC[i+1]/towZPC[0]);
1261  fhZPCpmcLR->Fill(towZPClg[0]/1000.);
1262  }
1263  fhPMCvsPMQ[1]->Fill(towZPC[1]+towZPC[2]+towZPC[3]+towZPC[4], towZPC[0]);
1264  for(int i=0; i<5; i++){
1265  fhZNAPM[i]->Fill(towZNA[i]);
1266  fhZNAPMlg[i]->Fill(towZNAlg[i]);
1267  if(((i<4) && towZNA[0]>0.)) fhZNAPMQiPMC[i]->Fill(towZNA[i+1]/towZNA[0]);
1268  fhZNApmcLR->Fill(towZNAlg[0]/1000.);
1269  }
1270  fhPMCvsPMQ[2]->Fill(towZNA[1]+towZNA[2]+towZNA[3]+towZNA[4], towZNA[0]);
1271  for(int i=0; i<5; i++){
1272  fhZPAPM[i]->Fill(towZPA[i]);
1273  fhZPAPMlg[i]->Fill(towZPAlg[i]);
1274  if(((i<4) && towZPA[0]>0.)) fhZPAPMQiPMC[i]->Fill(towZPA[i+1]/towZPA[0]);
1275  fhZPApmcLR->Fill(towZPAlg[0]/1000.);
1276  }
1277  fhPMCvsPMQ[3]->Fill(towZPA[1]+towZPA[2]+towZPA[3]+towZPA[4], towZPA[0]);
1278  fhZEM[0]->Fill(energyZEM1);
1279  fhZEM[1]->Fill(energyZEM2);
1280 
1281  fhZNCvsZNA->Fill(energyZNA, energyZNC);
1282  fhZPCvsZPA->Fill(energyZPA, energyZPC);
1283  fhZDCCvsZDCCA->Fill(energyZNA+energyZPA, energyZNC+energyZPC);
1284  fhZNCvsZPC->Fill(energyZPC, energyZNC);
1285  fhZNAvsZPA->Fill(energyZPA, energyZNA);
1286  fhZNvsZP->Fill(energyZPA+energyZPC, energyZNA+energyZNC);
1287  fhZNvsVZERO->Fill(multV0A+multV0C, energyZNC+energyZNA);
1288  fhZDCvsVZERO->Fill(multV0A+multV0C, energyZNA+energyZPA+energyZNC+energyZPC);
1289  fhZDCvsTracklets->Fill((Float_t) (nTracklets), energyZNA+energyZPA+energyZNC+energyZPC);
1290 
1291  Double_t asymmetry = -999.;
1292  if((energyZNC+energyZNA)>0.) asymmetry = (energyZNC-energyZNA)/(energyZNC+energyZNA);
1293  fhAsymm->Fill(asymmetry);
1294  fhZNAvsAsymm->Fill(asymmetry, energyZNA/1000.);
1295  fhZNCvsAsymm->Fill(asymmetry, energyZNC/1000.);
1296 
1297  fhZNCvscentrality->Fill(centrperc, energyZNC/1000.);
1298  fhZNAvscentrality->Fill(centrperc, energyZNA/1000.);
1299  fhZPCvscentrality->Fill(centrperc, energyZPC/1000.);
1300  fhZPAvscentrality->Fill(centrperc, energyZPA/1000.);
1301 
1302  fhZNCpmcvscentr->Fill(centrperc, towZNC[0]/1380.);
1303  fhZNApmcvscentr->Fill(centrperc, towZNA[0]/1380.);
1304  fhZPCpmcvscentr->Fill(centrperc, towZPC[0]/1380.);
1305  fhZPApmcvscentr->Fill(centrperc, towZPA[0]/1380.);
1306 
1307  } // PHYSICS SELECTION
1308 
1309  }
1310 
1311  // p) cache run number
1313 
1314  PostData(1, fFlowEvent);
1315 
1316  PostData(2, fOutput);
1317 }
1318 //________________________________________________________________________
1319 
1320 Int_t AliAnalysisTaskCRCZDC::GetCenBin(Double_t Centrality)
1321 {
1322  Int_t CenBin=-1;
1323  if (Centrality>0. && Centrality<5.) CenBin=0;
1324  if (Centrality>5. && Centrality<10.) CenBin=1;
1325  if (Centrality>10. && Centrality<20.) CenBin=2;
1326  if (Centrality>20. && Centrality<30.) CenBin=3;
1327  if (Centrality>30. && Centrality<40.) CenBin=4;
1328  if (Centrality>40. && Centrality<50.) CenBin=5;
1329  if (Centrality>50. && Centrality<60.) CenBin=6;
1330  if (Centrality>60. && Centrality<70.) CenBin=7;
1331  if (Centrality>70. && Centrality<80.) CenBin=8;
1332  if (Centrality>80. && Centrality<90.) CenBin=9;
1333  if (CenBin>=fnCen) CenBin=-1;
1334  if (fnCen==1) CenBin=0;
1335  return CenBin;
1336 } // end of AliFlowAnalysisCRC::GetCRCCenBin(Double_t Centrality)
1337 
1338 //________________________________________________________________________
1340  fCutContainer->AddAt(cutsRP,0); fCutsRP=cutsRP; cutsRP->SetPOItype(0);
1341 }
1342 
1343 //________________________________________________________________________
1345  fCutContainer->AddAt(cutsPOI,1); fCutsPOI=cutsPOI; cutsPOI->SetPOItype(1);
1346 }
1347 
1348 //________________________________________________________________________
1349 void AliAnalysisTaskCRCZDC::Terminate(Option_t */*option*/)
1350 {
1351  // Terminate analysis
1352  //
1353  /* if(fDebug > 1) printf(" **** AliAnalysisTaskCRCZDC::Terminate() \n");
1354 
1355  //fOutput = dynamic_cast<TList*> (GetOutputData(1));
1356  //if(!fOutput) printf("ERROR: fOutput not available\n");
1357  */
1358 }
TH1F * fhZPCpmcLR
ZNA PMC low res. chain.
TH2F * fhZDCCvsZDCCA
ZPC vs ZPA;.
TH2F * fhZNvsVZERO
ZNC+ZNA vs ZPC+ZPA;.
void FindDaughters(Bool_t keepDaughtersInRPselection=kFALSE)
TProfile * fhnTowerGain[fCRCnTow]
Run list.
Float_t GetCentrality(AliVEvent *event, AliMCEvent *mcEvent)
void SetEta(Double_t eta)
TH1F * fhZPCPMlg[5]
ZNA PM low res.
Int_t fRunList[fCRCMaxnRun]
TH2F * fhZNCpmcvscentr
ZPA vs. centrality.
TH2F * fhZDCvsTracklets
ZDC vs VZERO;.
static const Int_t fCRCnTow
TH1F * fhZNCPMQiPMC[4]
corrected TDC histos
TH2F * fhZNCvsZPC
ZDCC vs ZDCCA.
virtual void GetVertexPosition(Double_t *pos)
virtual void SetZDC2Qsub(Double_t *QVC, Double_t MC, Double_t *QVA, Double_t MA)
TH2F * fhZPCpmcvscentr
ZNA vs. centrality.
TH1F * fPtSpecFB32[10]
PtSpecGen.
void AddFlow(Double_t v1, Double_t v2, Double_t v3, Double_t v4, Double_t v5)
Int_t GetReferenceMultiplicity(AliVEvent *event, AliMCEvent *mcEvent)
TH1F * fhZNApmcLR
ZPA PMC low res. chain.
centrality
void Set(const AliVParticle *p)
TH2F * fhZNCvsAsymm
ZNA vs asymmetry.
void SetMCReactionPlaneAngle(const AliMCEvent *mcEvent)
void SetCutsPOI(AliFlowTrackCuts *cutsPOI)
virtual void UserExec(Option_t *option)
void SetHistWeightvsPhiMax(Double_t d)
TH2F * fhZNCvscentrality
ZNC vs asymmetry.
void SetZNAEnergy(Double_t const en)
TH1F * fhZPCPMQiPMC[4]
PMQi/PMC for ZNA.
TH1F * fhZPCPM[5]
ZNA PM high res.
void SetReferenceMultiplicity(Int_t m)
virtual Int_t GetCenBin(Double_t Centrality)
void SetCutsRP(AliFlowTrackCuts *cutsRP)
TH2F * fhZPCvsZPA
ZNC vs ZNA;.
TRandom * gRandom
TH2F * fhZNCvsZNA
PMQi/PMC for ZPA.
TH2F * fhDebunch
ZDC vs N_cluster layer 1;.
TH1F * fhAsymm
PMC vs sum PMQi.
void SetCentralityCL1(Double_t c)
virtual void SetVertexPosition(Double_t *pos)
void IncrementNumberOfPOIs(Int_t poiType=1)
TH1F * fhTDC[6]
raw TDC histos
TList * GetQA() const
void SetForRPSelection(Bool_t b=kTRUE)
TH1F * fhTDCraw[6]
ZPA PM low res.
TH2F * fhZNApmcvscentr
ZNC vs. centrality.
TProfile3D * fhnTowerGainVtx[fnCen][fCRCnTow]
towers gain
void Fill(AliFlowTrackCuts *rpCuts, AliFlowTrackCuts *poiCuts)
TH2F * fhZNAvsZPA
ZNC vs ZPC;.
TH1F * fhZNAPM[5]
ZNC PM high res.
void SetShuffleTracks(Bool_t b)
AliMultSelection * fMultSelection
centrality distribution
void SetNITSCL1(Double_t c)
virtual void UserCreateOutputObjects()
TH1F * fhZPAPMQiPMC[4]
PMQi/PMC for ZPC.
static AliFlowCommonConstants * GetMaster()
TH2F * fhZDCvsNclu1
ZDC vs N_tracklets;.
AliFlowEventCuts * fCutsEvent
TH1F * fhZPApmcLR
ZPC PMC low res. chain.
ClassImp(AliAnalysisTaskCRCZDC) AliAnalysisTaskCRCZDC
void SetCentrality(Double_t c)
AliFlowTrackCuts * fCutsPOI
void SetRun(Int_t const run)
void SetSource(trackSource s)
Definition: AliFlowTrack.h:37
TH2F * fhZPAvscentrality
ZPC vs. centrality.
void SetPhi(Double_t phi)
void DefineDeadZone(Double_t etaMin, Double_t etaMax, Double_t phiMin, Double_t phiMax)
AliGenEventHeader * fGenHeader
void SetPt(Double_t pt)
TList * fCRCQVecListRun[fCRCMaxnRun]
towers gain vtx
void SetZNCEnergy(Double_t const en)
TH1F * fPtSpecFB128[10]
PtSpecRec FB96.
virtual void Terminate(Option_t *option)
TH2F * fhZPApmcvscentr
ZPC vs. centrality.
void SetEvent(AliVEvent *event, AliMCEvent *mcEvent=NULL)
TH2F * fhZPCvscentrality
ZNA vs. centrality.
TH2F * fhZNAcentroid
ZNC centroid.
Bool_t IsSetMCReactionPlaneAngle() const
TClonesArray * fStack
Q Vectors list per run.
TList * GetQA() const
static const Int_t fCRCMaxnRun
ZPA PMC low res. chain.
void SetForPOISelection(Bool_t b=kTRUE)
TH1F * fPtSpecFB96[10]
PtSpecRec FB32.
void SetHistWeightvsPhiMin(Double_t d)
TH1F * fhZNAPMQiPMC[4]
PMQi/PMC for ZNC.
void AddV2(Double_t v2)
TH2F * fhZDCvsVZERO
ZN vs VZERO;.
void TagSubeventsInEta(Double_t etaMinA, Double_t etaMaxA, Double_t etaMinB, Double_t etaMaxB)
TH1F * fhZPAPMlg[5]
ZPC PM low res.
TH2F * fhZNAvsAsymm
ZN asymmetry.
TH2F * fhZNAvscentrality
ZNC vs. centrality.
virtual Bool_t IsSelected(TObject *obj, TObject *objmc)
TH1F * fhZPAPM[5]
ZPC PM high res.
TH1F * fhZNCPM[5]
list send on output slot 0
void SetCentralityTRK(Double_t c)
Bool_t fCutTPC
PtSpecRec FB768.
TH2F * fhPMCvsPMQ[4]
ZNA centroid.
TH1F * fhZNCpmcLR
ZPA vs. centrality.
TH1F * fPtSpecFB768[10]
PtSpecRec FB128.
TH1F * fhZNAPMlg[5]
ZNC PM low res.
TH1F * fhZEM[2]
ZPA PM high res.
AliFlowTrackCuts * fCutsRP
void InsertTrack(AliFlowTrack *)
virtual void ClearFast()
AliAnalysisUtils * fAnalysisUtil
Event selection.
TH2F * fhZNCcentroid
Debunch;.
TH2F * fhZNvsZP
ZNA vs ZPA;.
AliGenHijingEventHeader * fHijingGenHeader
TH1F * fhZNCPMlg[5]
ZEM PM high res.
AliGenPythiaEventHeader * fPythiaGenHeader
Int_t NumberOfTracks() const