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