]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGLF/FORWARD/GEO/AliAnalysisTaskZDCPbPb.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Updating analysis task
[u/mrichter/AliRoot.git] / PWGLF / FORWARD / GEO / AliAnalysisTaskZDCPbPb.cxx
CommitLineData
d43c6096 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 the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/////////////////////////////////////////////////////////////
17// //
18// Class to analyze ZDC data //
19// //
20/////////////////////////////////////////////////////////////
21
22#include <TList.h>
23#include <TH1F.h>
24#include <TH2F.h>
25#include <TFile.h>
26#include <TString.h>
27#include <TCanvas.h>
28
29#include "AliAnalysisManager.h"
30#include "AliInputEventHandler.h"
31#include "AliVEvent.h"
32#include "AliESD.h"
33#include "AliESDEvent.h"
34#include "AliESDHeader.h"
35#include "AliESDInputHandler.h"
36#include "AliESDZDC.h"
37#include "AliMultiplicity.h"
38#include "AliAODHandler.h"
39#include "AliAODEvent.h"
aa16ad3c 40#include "AliAODHeader.h"
d43c6096 41#include "AliAODVertex.h"
42#include "AliAODVZERO.h"
43#include "AliAODZDC.h"
44#include "AliAODMCHeader.h"
45#include "AliMCEventHandler.h"
46#include "AliMCEvent.h"
47#include "AliHeader.h"
48#include "AliAODMCParticle.h"
49#include "AliAnalysisTaskSE.h"
50#include "AliGenEventHeader.h"
51#include "AliGenHijingEventHeader.h"
52#include "AliPhysicsSelectionTask.h"
53#include "AliPhysicsSelection.h"
54#include "AliBackgroundSelection.h"
55#include "AliTriggerAnalysis.h"
56#include "AliCentrality.h"
57#include "AliAnalysisTaskZDCPbPb.h"
58
59ClassImp(AliAnalysisTaskZDCPbPb)
60
61
62//________________________________________________________________________
63AliAnalysisTaskZDCPbPb::AliAnalysisTaskZDCPbPb():
64 AliAnalysisTaskSE(),
65 fAnalysisInput(kESD),
66 fIsMCInput(kFALSE),
67 fCentrLowLim(0),
68 fCentrUpLim(0),
69 fCentrEstimator(0),
70 fOutput(0x0),
71 fhZNCvsZNA(0x0),
72 fhZPCvsZPA(0x0),
73 fhZDCCvsZDCCA(0x0),
fdbc1dc8 74 fhZNCvsZPC(0x0),
75 fhZNAvsZPA(0x0),
76 fhZNvsZP(0x0),
d43c6096 77 fhZNvsZEM(0x0),
d1a28c63 78 fhZNvsZEMwV0M(0x0),
79 fhZDCvsZEM(0x0),
80 fhZDCvsZEMwV0M(0x0),
d43c6096 81 fhZNvsVZERO(0x0),
82 fhZDCvsVZERO(0x0),
83 fhZDCvsTracklets(0x0),
763e0758 84 fhZDCvsNclu1(0x0),
d43c6096 85 fhVZEROvsZEM(0x0),
86 fhDebunch(0x0),
87 fhZNCcentroid(0x0),
88 fhZNAcentroid(0x0),
89 fhAsymm(0x0),
90 fhZNAvsAsymm(0x0),
763e0758 91 fhZNCvsAsymm(0x0),
92 fhZNCvscentrality(0x0),
93 fhZNAvscentrality(0x0),
94 fhZPCvscentrality(0x0),
a0073ce0 95 fhZPAvscentrality(0x0),
96 fhZNCpmcvscentr(0x0),
97 fhZNApmcvscentr(0x0),
98 fhZPCpmcvscentr(0x0),
aa16ad3c 99 fhZPApmcvscentr(0x0),
100 fhZNCpmcLR(0x0),
101 fhZNApmcLR(0x0),
102 fhZPCpmcLR(0x0),
103 fhZPApmcLR(0x0)
d43c6096 104{
105 // Default constructor
106 for(int i=0; i<5; i++){
107 fhZNCPM[i] = 0x0;
108 fhZNAPM[i] = 0x0;
109 fhZPCPM[i] = 0x0;
110 fhZPAPM[i] = 0x0;
111 fhZNCPMlg[i] = 0x0;
112 fhZNAPMlg[i] = 0x0;
113 fhZPCPMlg[i] = 0x0;
114 fhZPAPMlg[i] = 0x0;
115 }
116 for(int i=0; i<2; i++) fhZEM[i] = 0x0;
3bb49453 117 for(int i=0; i<6; i++){
118 fhTDCraw[i] = 0x0;
119 fhTDC[i] = 0x0;
120 }
ca3061e5 121 for(int i=0; i<4; i++){
122 fhZNCPMQiPMC[i] = 0x0;
123 fhZNAPMQiPMC[i] = 0x0;
124 fhZPCPMQiPMC[i] = 0x0;
125 fhZPAPMQiPMC[i] = 0x0;
126 fhPMCvsPMQ[i] = 0x0;
127 }
d43c6096 128}
129
130//________________________________________________________________________
131AliAnalysisTaskZDCPbPb::AliAnalysisTaskZDCPbPb(const char *name):
132 AliAnalysisTaskSE(name),
133 fAnalysisInput(kESD),
134 fIsMCInput(kFALSE),
135 fCentrLowLim(0.),
136 fCentrUpLim(100.),
137 fCentrEstimator("V0M"),
138 fOutput(0x0),
139 fhZNCvsZNA(0x0),
140 fhZPCvsZPA(0x0),
141 fhZDCCvsZDCCA(0x0),
fdbc1dc8 142 fhZNCvsZPC(0x0),
143 fhZNAvsZPA(0x0),
144 fhZNvsZP(0x0),
d43c6096 145 fhZNvsZEM(0x0),
d1a28c63 146 fhZNvsZEMwV0M(0x0),
d43c6096 147 fhZDCvsZEM(0x0),
d1a28c63 148 fhZDCvsZEMwV0M(0x0),
d43c6096 149 fhZNvsVZERO(0x0),
150 fhZDCvsVZERO(0x0),
151 fhZDCvsTracklets(0x0),
763e0758 152 fhZDCvsNclu1(0x0),
d43c6096 153 fhVZEROvsZEM(0x0),
154 fhDebunch(0x0),
155 fhZNCcentroid(0x0),
156 fhZNAcentroid(0x0),
157 fhAsymm(0x0),
158 fhZNAvsAsymm(0x0),
763e0758 159 fhZNCvsAsymm(0x0),
160 fhZNCvscentrality(0x0),
161 fhZNAvscentrality(0x0),
162 fhZPCvscentrality(0x0),
a0073ce0 163 fhZPAvscentrality(0x0),
164 fhZNCpmcvscentr(0x0),
165 fhZNApmcvscentr(0x0),
166 fhZPCpmcvscentr(0x0),
aa16ad3c 167 fhZPApmcvscentr(0x0),
168 fhZNCpmcLR(0x0),
169 fhZNApmcLR(0x0),
170 fhZPCpmcLR(0x0),
171 fhZPApmcLR(0x0)
d43c6096 172{
173
174 for(int i=0; i<5; i++){
175 fhZNCPM[i] = 0x0;
176 fhZNAPM[i] = 0x0;
177 fhZPCPM[i] = 0x0;
178 fhZPAPM[i] = 0x0;
179 fhZNCPMlg[i] = 0x0;
180 fhZNAPMlg[i] = 0x0;
181 fhZPCPMlg[i] = 0x0;
182 fhZPAPMlg[i] = 0x0;
183 }
184 for(int i=0; i<2; i++) fhZEM[i] = 0x0;
3bb49453 185 for(int i=0; i<6; i++){
186 fhTDCraw[i] = 0x0;
187 fhTDC[i] = 0x0;
188 }
ca3061e5 189 for(int i=0; i<4; i++){
190 fhZNCPMQiPMC[i] = 0x0;
191 fhZNAPMQiPMC[i] = 0x0;
192 fhZPCPMQiPMC[i] = 0x0;
193 fhZPAPMQiPMC[i] = 0x0;
194 fhPMCvsPMQ[i] = 0x0;
195 }
d43c6096 196
197 // Output slot #1 writes into a TList container
198 DefineOutput(1, TList::Class());
199
200}
201
202//________________________________________________________________________
203AliAnalysisTaskZDCPbPb& AliAnalysisTaskZDCPbPb::operator=(const AliAnalysisTaskZDCPbPb& c)
204{
205 //
206 // Assignment operator
207 //
208 if (this!=&c) {
209 AliAnalysisTaskSE::operator=(c);
210 }
211 return *this;
212}
213
214//________________________________________________________________________
215AliAnalysisTaskZDCPbPb::AliAnalysisTaskZDCPbPb(const AliAnalysisTaskZDCPbPb& ana):
216 AliAnalysisTaskSE(ana),
38e86734 217 fAnalysisInput(ana.fAnalysisInput),
218 fIsMCInput(ana.fIsMCInput),
219 fCentrLowLim(ana.fCentrLowLim),
220 fCentrUpLim(ana.fCentrUpLim),
221 fCentrEstimator(ana.fCentrEstimator),
d43c6096 222 fOutput(ana.fOutput),
223 fhZNCvsZNA(ana.fhZNCvsZNA),
224 fhZPCvsZPA(ana.fhZPCvsZPA),
225 fhZDCCvsZDCCA(ana.fhZDCCvsZDCCA),
fdbc1dc8 226 fhZNCvsZPC(ana.fhZNCvsZPC),
227 fhZNAvsZPA(ana.fhZNAvsZPA),
228 fhZNvsZP(ana.fhZNvsZP),
d43c6096 229 fhZNvsZEM(ana.fhZNvsZEM),
d1a28c63 230 fhZNvsZEMwV0M(ana.fhZNvsZEM),
d43c6096 231 fhZDCvsZEM(ana.fhZDCvsZEM),
d1a28c63 232 fhZDCvsZEMwV0M(ana.fhZDCvsZEMwV0M),
d43c6096 233 fhZNvsVZERO(ana.fhZNvsVZERO),
234 fhZDCvsVZERO(ana.fhZDCvsVZERO),
763e0758 235 fhZDCvsTracklets(ana.fhZDCvsTracklets),
236 fhZDCvsNclu1(ana.fhZDCvsNclu1),
d43c6096 237 fhVZEROvsZEM(ana.fhVZEROvsZEM),
238 fhDebunch(ana.fhDebunch),
239 fhZNCcentroid(ana.fhZNCcentroid),
240 fhZNAcentroid(ana.fhZNAcentroid),
241 fhAsymm(ana.fhAsymm),
242 fhZNAvsAsymm(ana.fhZNAvsAsymm),
763e0758 243 fhZNCvsAsymm(ana.fhZNCvsAsymm),
244 fhZNCvscentrality(ana.fhZNCvscentrality),
245 fhZNAvscentrality(ana.fhZNAvscentrality),
246 fhZPCvscentrality(ana.fhZPCvscentrality),
a0073ce0 247 fhZPAvscentrality(ana.fhZPAvscentrality),
248 fhZNCpmcvscentr(ana.fhZNCpmcvscentr),
249 fhZNApmcvscentr(ana.fhZNApmcvscentr),
250 fhZPCpmcvscentr(ana.fhZPCpmcvscentr),
aa16ad3c 251 fhZPApmcvscentr(ana.fhZPApmcvscentr),
252 fhZNCpmcLR(ana.fhZNCpmcLR),
253 fhZNApmcLR(ana.fhZNApmcLR),
254 fhZPCpmcLR(ana.fhZPCpmcLR),
255 fhZPApmcLR(ana.fhZPApmcLR)
256
763e0758 257
d43c6096 258{
259 //
260 // Copy Constructor
261 //
262 for(int i=0; i<5; i++){
263 fhZNCPM[i] = ana.fhZNCPM[i];
264 fhZNAPM[i] = ana.fhZNAPM[i];
265 fhZPCPM[i] = ana.fhZPCPM[i];
266 fhZPAPM[i] = ana.fhZPAPM[i];
267 fhZNCPMlg[i] = ana.fhZNCPMlg[i];
268 fhZNAPMlg[i] = ana.fhZNAPMlg[i];
269 fhZPCPMlg[i] = ana.fhZPCPMlg[i];
270 fhZPAPMlg[i] = ana.fhZPAPMlg[i];
271 }
272 for(int i=0; i<2; i++) fhZEM[i] = ana.fhZEM[i];
3bb49453 273 for(int i=0; i<6; i++){
274 fhTDCraw[i] = ana.fhTDCraw[i];
275 fhTDC[i] = ana.fhTDC[i];
276 }
d43c6096 277 for(int i=0; i<4; i++) fhPMCvsPMQ[i] = ana.fhPMCvsPMQ[i];
ca3061e5 278 for(int i=0; i<4; i++){
279 fhZNCPMQiPMC[i] = ana.fhZNCPMQiPMC[i];
280 fhZNAPMQiPMC[i] = ana.fhZNAPMQiPMC[i];
281 fhZPCPMQiPMC[i] = ana.fhZPCPMQiPMC[i];
282 fhZPAPMQiPMC[i] = ana.fhZPAPMQiPMC[i];
283 fhPMCvsPMQ[i] = ana.fhPMCvsPMQ[i];
284 }
d43c6096 285}
286
287//________________________________________________________________________
288AliAnalysisTaskZDCPbPb::~AliAnalysisTaskZDCPbPb()
289{
290 // Destructor
291 if(fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()){
292 delete fOutput; fOutput=0;
293 }
294
295}
296
297//________________________________________________________________________
298void AliAnalysisTaskZDCPbPb::UserCreateOutputObjects()
299{
300 // Create the output containers
301 //printf(" AliAnalysisTaskZDCPbPb::UserCreateOutputObjects()\n\n");
302 fOutput = new TList;
303 fOutput->SetOwner();
304 //fOutput->SetName("output");
305
306 for(int i=0; i<5; i++){
307 char hname[20];
308 sprintf(hname,"hZNCPM%d",i);
0e00432a 309 fhZNCPM[i] = new TH1F(hname, hname, 200, -50., 140000);
d43c6096 310 fOutput->Add(fhZNCPM[i]);
311 //
312 sprintf(hname,"hZNAPM%d",i);
0e00432a 313 fhZNAPM[i] = new TH1F(hname, hname, 200, -50., 140000);
d43c6096 314 fOutput->Add(fhZNAPM[i]);
315 //
316 sprintf(hname,"hZPCPM%d",i);
0e00432a 317 fhZPCPM[i] = new TH1F(hname, hname, 200, -50., 50000);
d43c6096 318 fOutput->Add(fhZPCPM[i]);
319 //
320 sprintf(hname,"hZPAPM%d",i);
0e00432a 321 fhZPAPM[i] = new TH1F(hname, hname, 200, -50., 50000);
d43c6096 322 fOutput->Add(fhZPAPM[i]);
323 //
324 sprintf(hname,"hZNCPMlg%d",i);
0e00432a 325 fhZNCPMlg[i] = new TH1F(hname, hname, 200, -50., 140000);
d43c6096 326 fOutput->Add(fhZNCPMlg[i]);
327 //
328 sprintf(hname,"hZNAPMlg%d",i);
0e00432a 329 fhZNAPMlg[i] = new TH1F(hname, hname, 200, -50., 140000);
d43c6096 330 fOutput->Add(fhZNAPMlg[i]);
331 //
332 sprintf(hname,"hZPCPMlg%d",i);
0e00432a 333 fhZPCPMlg[i] = new TH1F(hname, hname, 200, -50., 50000);
d43c6096 334 fOutput->Add(fhZPCPMlg[i]);
335 //
336 sprintf(hname,"hZPAPMlg%d",i);
0e00432a 337 fhZPAPMlg[i] = new TH1F(hname, hname, 200, -50., 50000);
d43c6096 338 fOutput->Add(fhZPAPMlg[i]);
ca3061e5 339 //
340 if(i<4){
341 //
342 char hnamenc[20];
343 sprintf(hnamenc, "hZNCPMQ%dPMC",i+1);
344 fhZNCPMQiPMC[i] = new TH1F(hnamenc, hnamenc, 100, 0., 1.);
345 fOutput->Add(fhZNCPMQiPMC[i]);
346 //
347 char hnamena[20];
348 sprintf(hnamena, "hZNAPMQ%dPMC",i+1);
349 fhZNAPMQiPMC[i] = new TH1F(hnamena, hnamena, 100, 0., 1.);
350 fOutput->Add(fhZNAPMQiPMC[i]);
351 //
352 char hnamepc[20];
353 sprintf(hnamepc, "hZPCPMQ%dPMC",i+1);
354 fhZPCPMQiPMC[i] = new TH1F(hnamepc, hnamepc, 100, 0., 1.);
355 fOutput->Add(fhZPCPMQiPMC[i]);
356 //
357 char hnamepa[20];
358 sprintf(hnamepa, "hZPAPMQ%dPMC",i+1);
359 fhZPAPMQiPMC[i] = new TH1F(hnamepa, hnamepa, 100, 0., 1.);
360 fOutput->Add(fhZPAPMQiPMC[i]);
361 }
d43c6096 362 }
363 for(int i=0; i<6; i++){
364 if(i==0){
65071b1a 365 fhZEM[i] = new TH1F("hZEM1","hZEM1",200,-10.,1190.);
3bb49453 366 fhTDCraw[i] = new TH1F("hTDCZEM1raw", "hTDCZEM1raw", 200, -200., 0.);
d43c6096 367 fhTDC[i] = new TH1F("hTDCZEM1", "hTDCZEM1", 200, -150., 50.);
368 fhPMCvsPMQ[i] = new TH2F("hPMCvsPMQZNC","hPMCvsPMQZNC",200,-10.,140000,200,-10.,140000);
369 //
370 fOutput->Add(fhZEM[i]);
371 fOutput->Add(fhPMCvsPMQ[i]);
372 }
373 else if(i==1){
65071b1a 374 fhZEM[i] = new TH1F("hZEM2","hZEM2",200,-10.,1190.);
3bb49453 375 fhTDCraw[i] = new TH1F("hTDCZEM2raw", "hTDCZEM2raw", 200, -200., 0.);
d43c6096 376 fhTDC[i] = new TH1F("hTDCZEM2", "hTDCZEM2", 200, -150., 50.);
377 fhPMCvsPMQ[i] = new TH2F("hPMCvsPMQZPC","hPMCvsPMQZPC",200,-10.,50000,200,-10.,50000);
378 //
379 fOutput->Add(fhZEM[i]);
380 fOutput->Add(fhPMCvsPMQ[i]);
381 }
382 else if(i==2){
3bb49453 383 fhTDCraw[i] = new TH1F("hTDCZNCraw", "hTDCZNCraw", 200, -200., 0.);
d43c6096 384 fhTDC[i] = new TH1F("hTDCZNC", "hTDCZNC", 200, -150., 50.);
385 fhPMCvsPMQ[i] = new TH2F("hPMCvsPMQZNA","hPMCvsPMQZNA",200,-10.,140000,200,-10.,140000);
386 //
387 fOutput->Add(fhPMCvsPMQ[i]);
388 }
389 else if(i==3){
3bb49453 390 fhTDCraw[i] = new TH1F("hTDCZPCraw", "hTDCZPCraw", 200, -200., 0.);
d43c6096 391 fhTDC[i] = new TH1F("hTDCZPC", "hTDCZPC", 200, -150., 50.);
392 fhPMCvsPMQ[i] = new TH2F("hPMCvsPMQZPA","hPMCvsPMQZPA",200,-10.,50000,200,-10.,50000);
393 //
394 fOutput->Add(fhPMCvsPMQ[i]);
395 }
3bb49453 396 else if(i==4){
397 fhTDCraw[i] = new TH1F("hTDCZNAraw", "hTDCZNAraw", 200, -200., 0.);
398 fhTDC[i] = new TH1F("hTDCZNA", "hTDCZNA", 200, -150., 50.);
399 }
400 else if(i==5){
401 fhTDCraw[i] = new TH1F("hTDCZPAraw", "hTDCZPAraw", 200, -200., 0.);
402 fhTDC[i] = new TH1F("hTDCZPA", "hTDCZPA", 200, -150., 50.);
403 }
d43c6096 404 //
405 fOutput->Add(fhTDC[i]);
406 }
407
408
409 fhZNCvsZNA = new TH2F("hZNCvsZNA","hZNCvsZNA",200,-50.,140000,200,-50.,140000);
410 fOutput->Add(fhZNCvsZNA);
411 fhZPCvsZPA = new TH2F("hZPCvsZPA","hZPCvsZPA",200,-50.,50000,200,-50.,50000);
412 fOutput->Add(fhZPCvsZPA);
fdbc1dc8 413 fhZDCCvsZDCCA = new TH2F("hZDCCvsZDCCA","hZDCCvsZDCCA",200,0.,180000.,200,0.,200000.);
d43c6096 414 fOutput->Add(fhZDCCvsZDCCA);
fdbc1dc8 415 fhZNCvsZPC = new TH2F("hZNCvsZPC","hZNCvsZPC",200,-50.,50000,200,-50.,140000);
416 fOutput->Add(fhZNCvsZPC);
417 fhZNAvsZPA = new TH2F("hZNAvsZPA","hZNAvsZPA",200,-50.,50000,200,-50.,140000);
418 fOutput->Add(fhZNAvsZPA);
419 fhZNvsZP = new TH2F("hZNvsZP","hZNvsZP",200,-50.,80000,200,-50.,200000);
420 fOutput->Add(fhZNvsZP);
d43c6096 421 fhZNvsZEM = new TH2F("hZNvsZEM","hZNvsZEM",200,0.,2500.,200,0.,200000.);
422 fOutput->Add(fhZNvsZEM);
d1a28c63 423 fhZNvsZEMwV0M = new TH2F("hZNvsZEMwV0M","hZNvsZEM wV0M",200,0.,2500.,200,0.,200000.);
424 fOutput->Add(fhZNvsZEMwV0M);
65071b1a 425 fhZDCvsZEM = new TH2F("hZDCvsZEM","hZDCvsZEM",200,0.,2500.,250,0.,250000.);
d43c6096 426 fOutput->Add(fhZDCvsZEM);
65071b1a 427 fhZDCvsZEMwV0M = new TH2F("hZDCvsZEMwV0M","hZDCvsZEM wV0M",200,0.,2500.,250,0.,250000.);
d1a28c63 428 fOutput->Add(fhZDCvsZEMwV0M);
65071b1a 429 fhZNvsVZERO = new TH2F("hZNvsVZERO","hZNvsVZERO",250,0.,25000.,200,0.,200000.);
d43c6096 430 fOutput->Add(fhZNvsVZERO);
65071b1a 431 fhZDCvsVZERO = new TH2F("hZDCvsVZERO","hZDCvsVZERO",250,0.,25000.,250,0.,250000.);
d43c6096 432 fOutput->Add(fhZDCvsVZERO);
65071b1a 433 fhZDCvsTracklets = new TH2F("hZDCvsTracklets","hZDCvsTracklets",200,0.,4000.,250,0.,250000.);
d43c6096 434 fOutput->Add(fhZDCvsTracklets);
65071b1a 435 fhZDCvsNclu1 = new TH2F("hZDCvsNclu1", "hZDCvsNclu1", 200, 0.,8000.,200,0.,250000.);
763e0758 436 fOutput->Add(fhZDCvsNclu1);
d43c6096 437 fhVZEROvsZEM = new TH2F("hVZEROvsZEM","hVZEROvsZEM",250,0.,2500.,250,0.,25000.);
438 fOutput->Add(fhVZEROvsZEM);
65071b1a 439 fhDebunch = new TH2F("hDebunch","hDebunch",240,-100.,-40.,240,-30.,30.);
d43c6096 440 fOutput->Add(fhDebunch);
441 fhZNCcentroid = new TH2F("hZNCcentroid","hZNCcentroid",100,-3.5,3.5,100,-3.5,3.5);
442 fOutput->Add(fhZNCcentroid);
443 fhZNAcentroid = new TH2F("hZNAcentroid","hZNAcentroid",100,-3.5,3.5,100,-3.5,3.5);
444 fOutput->Add(fhZNAcentroid);
445
446 fhAsymm = new TH1F("hAsymm" , "Asimmetry ",200,-1.,1.);
447 fOutput->Add(fhAsymm);
448 fhZNAvsAsymm = new TH2F("hZNAvsAsymm","ZNA vs. asymm.",200,-1.,1.,200,0.,80.);
449 fOutput->Add(fhZNAvsAsymm);
450 fhZNCvsAsymm = new TH2F("hZNCvsAsymm","ZNC vs. asymm.",200,-1.,1.,200,0.,80.);
451 fOutput->Add(fhZNCvsAsymm);
452
763e0758 453 fhZNCvscentrality = new TH2F("hZNCvscentrality","ZNC vs. centrality",100,0.,100.,100,0.,100.);
454 fOutput->Add(fhZNCvscentrality);
455 fhZNAvscentrality = new TH2F("hZNAvscentrality","ZNA vs. centrality",100,0.,100.,100,0.,100.);
456 fOutput->Add(fhZNAvscentrality);
457 fhZPCvscentrality = new TH2F("hZPCvscentrality","ZPC vs. centrality",100,0.,100.,100,0.,100.);
458 fOutput->Add(fhZPCvscentrality);
459 fhZPAvscentrality = new TH2F("hZPAvscentrality","ZPA vs. centrality",100,0.,100.,100,0.,100.);
460 fOutput->Add(fhZPAvscentrality);
461
a0073ce0 462 fhZNCpmcvscentr = new TH2F("hZNCpmcvscentr","ZNC PMC vs. centrality",100,0.,100.,100,0.,100.);
463 fOutput->Add(fhZNCpmcvscentr);
464 fhZNApmcvscentr = new TH2F("hZNApmcvscentr","ZNA PMC vs. centrality",100,0.,100.,100,0.,100.);
465 fOutput->Add(fhZNApmcvscentr);
466 fhZPCpmcvscentr = new TH2F("hZPCpmcvscentr","ZPC PMC vs. centrality",100,0.,100.,100,0.,100.);
467 fOutput->Add(fhZPCpmcvscentr);
468 fhZPApmcvscentr = new TH2F("hZPApmcvscentr","ZPA PMC vs. centrality",100,0.,100.,100,0.,100.);
469 fOutput->Add(fhZPApmcvscentr);
470
aa16ad3c 471 fhZNCpmcLR = new TH1F("hZNCpmcLR","ZNC PMC lr", 100, 0., 10.);
472 fOutput->Add(fhZNCpmcLR);
473 fhZNApmcLR = new TH1F("hZNApmcLR","ZNA PMC lr", 100, 0., 10.);
474 fOutput->Add(fhZNApmcLR);
475 fhZPCpmcLR = new TH1F("hZPCpmcLR","ZPC PMC lr", 100, 0., 10.);
476 fOutput->Add(fhZPCpmcLR);
477 fhZPApmcLR = new TH1F("hZPApmcLR","ZPA PMC lr", 100, 0., 10.);
478 fOutput->Add(fhZPApmcLR);
479
d43c6096 480 PostData(1, fOutput);
481}
482
483//________________________________________________________________________
484void AliAnalysisTaskZDCPbPb::UserExec(Option_t */*option*/)
485{
486 // Execute analysis for current event:
487
aa16ad3c 488 if(!InputEvent()){
d43c6096 489 printf("ERROR: InputEvent not available");
490 return;
491 }
492
aa16ad3c 493 if(fAnalysisInput==kESD){
d43c6096 494
495 AliESDEvent* esd = dynamic_cast<AliESDEvent*> (InputEvent());
496 if(!esd) return;
497
498 // Select PHYSICS events (type=7, for data)
499 if(!fIsMCInput && esd->GetEventType()!=7) return;
500
501 // ********* MC INFO *********************************
fdbc1dc8 502 /*if(fIsMCInput){
d43c6096 503 AliMCEventHandler* eventHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
fdbc1dc8 504 if(!eventHandler){
d43c6096 505 printf("ERROR: Could not retrieve MC event handler");
506 return;
507 }
508
509 AliMCEvent* mcEvent = eventHandler->MCEvent();
fdbc1dc8 510 if(!mcEvent){
d43c6096 511 printf("ERROR: Could not retrieve MC event");
512 return;
513 }
fdbc1dc8 514 }*/
515 // ****************************************************
d43c6096 516
aa16ad3c 517 // PHYSICS SELECTION
518// AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
519// AliInputEventHandler *hdr = (AliInputEventHandler*)am->GetInputEventHandler();
520// printf(" PS selection %d\n",hdr->IsEventSelected());
521// if(hdr->IsEventSelected() & AliVEvent::kAnyINT){
d43c6096 522
523 AliCentrality *centrality = esd->GetCentrality();
524 Float_t centrperc = centrality->GetCentralityPercentile(fCentrEstimator.Data());
f699f086 525 if(centrperc<fCentrLowLim || centrperc>fCentrUpLim) return;
d43c6096 526
527 // ***** Trigger selection
528 /*TString triggerClass = esd->GetFiredTriggerClasses();
529 sprintf(fTrigClass,"%s",triggerClass.Data());*/
530
531 const AliMultiplicity *mult = esd->GetMultiplicity();
532 Int_t nTracklets = mult->GetNumberOfTracklets();
d43c6096 533 //for(Int_t ilay=0; ilay<6; ilay++) fNClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
763e0758 534 Int_t nClusterslay1 = mult->GetNumberOfITSClusters(1);
535
d43c6096 536 AliESDVZERO *vzeroAOD = esd->GetVZEROData();
537 Float_t multV0A = vzeroAOD->GetMTotV0A();
538 Float_t multV0C = vzeroAOD->GetMTotV0C();
539
540 AliESDZDC *esdZDC = esd->GetESDZDC();
541
bde0d5e6 542 Float_t tdc[32][4], tdcSum=-999, tdcDiff=-999;
d43c6096 543 Bool_t tdcMult[6] = {kFALSE};
544 for(Int_t itdc=0; itdc<32; itdc++){
545 for(Int_t i=0; i<4; i++){
546 if(esdZDC->GetZDCTDCData(itdc, i)!=0.){
bde0d5e6 547 tdc[itdc][i] = esdZDC->GetZDCTDCCorrected(itdc, i);
d43c6096 548 if(itdc>=8 && itdc<=13){
549 tdcMult[itdc-8] = kTRUE;
550 fhTDC[itdc-8]->Fill(tdc[itdc][i]);
551 }
552 else if(itdc==15 && i==0){
3bb49453 553 for(int ich=8; ich<=13; ich++) fhTDCraw[ich-8]->Fill(esdZDC->GetZDCTDCData(ich, 0)-esdZDC->GetZDCTDCData(itdc, i));
d43c6096 554 }
555 }
556 }
557 }
558 Bool_t zem1 = tdcMult[0];
559 Bool_t zem2 = tdcMult[1];
560 Bool_t znc = tdcMult[2];
561 Bool_t zpc = tdcMult[3];
562 Bool_t zna = tdcMult[4];
563 Bool_t zpa = tdcMult[5];
3bb49453 564 if(znc && zna){
aa16ad3c 565 tdcSum = esdZDC->GetZNTDCSum(0);
566 tdcDiff = esdZDC->GetZNTDCDiff(0);
0e00432a 567 fhDebunch->Fill(tdcDiff, tdcSum);
3bb49453 568 }
d43c6096 569
570 Float_t energyZNC = (Float_t) (esdZDC->GetZNCEnergy());
571 Float_t energyZPC = (Float_t) (esdZDC->GetZPCEnergy());
572 Float_t energyZNA = (Float_t) (esdZDC->GetZNAEnergy());
573 Float_t energyZPA = (Float_t) (esdZDC->GetZPAEnergy());
7f533345 574 Float_t energyZEM1 = (Float_t) (esdZDC->GetZEM1Energy()/8.);
575 Float_t energyZEM2 = (Float_t) (esdZDC->GetZEM2Energy()/8.);
d43c6096 576
577 const Double_t * towZNC = esdZDC->GetZNCTowerEnergy();
578 const Double_t * towZPC = esdZDC->GetZPCTowerEnergy();
579 const Double_t * towZNA = esdZDC->GetZNATowerEnergy();
580 const Double_t * towZPA = esdZDC->GetZPATowerEnergy();
581 //
582 const Double_t * towZNClg = esdZDC->GetZNCTowerEnergyLR();
583 const Double_t * towZPClg = esdZDC->GetZPCTowerEnergyLR();
584 const Double_t * towZNAlg = esdZDC->GetZNATowerEnergyLR();
585 const Double_t * towZPAlg = esdZDC->GetZPATowerEnergyLR();
586
587 Double_t xyZNC[2]={-99.,-99.}, xyZNA[2]={-99.,-99.};
588 esdZDC->GetZNCentroidInPbPb(esd->GetBeamEnergy(), xyZNC, xyZNA);
589 fhZNCcentroid->Fill(xyZNC[0], xyZNC[1]);
590 fhZNAcentroid->Fill(xyZNA[0], xyZNA[1]);
591
592 /* //Only for MC
593 fbZDC = esdZDC->GetImpactParameter();
594 fNpartZDC = esdZDC->GetZDCParticipants();
595 fbZDCA = esdZDC->GetImpactParamSideA();
596 fNpartZDCA = esdZDC->GetZDCPartSideA();
597 fbZDCC = esdZDC->GetImpactParamSideC();
598 fNpartZDCC = esdZDC->GetZDCPartSideC();*/
599
600 if(znc){
601 for(int i=0; i<5; i++){
602 fhZNCPM[i]->Fill(towZNC[i]);
603 fhZNCPMlg[i]->Fill(towZNClg[i]);
ca3061e5 604 if((i<4) && (towZNC[0]>0.)) fhZNCPMQiPMC[i]->Fill(towZNC[i+1]/towZNC[0]);
d43c6096 605 }
606 fhPMCvsPMQ[0]->Fill(towZNC[1]+towZNC[2]+towZNC[3]+towZNC[4], towZNC[0]);
aa16ad3c 607 fhZNCpmcLR->Fill(towZNClg[0]/1000.);
d43c6096 608 }
609 if(zpc){
610 for(int i=0; i<5; i++){
611 fhZPCPM[i]->Fill(towZPC[i]);
612 fhZPCPMlg[i]->Fill(towZPClg[i]);
ca3061e5 613 if(((i<4) && towZPC[0]>0.)) fhZPCPMQiPMC[i]->Fill(towZPC[i+1]/towZPC[0]);
d43c6096 614 }
615 fhPMCvsPMQ[1]->Fill(towZPC[1]+towZPC[2]+towZPC[3]+towZPC[4], towZPC[0]);
aa16ad3c 616 fhZPCpmcLR->Fill(towZPClg[0]/1000.);
d43c6096 617 }
618 if(zna){
619 for(int i=0; i<5; i++){
620 fhZNAPM[i]->Fill(towZNA[i]);
621 fhZNAPMlg[i]->Fill(towZNAlg[i]);
ca3061e5 622 if(((i<4) && towZNA[0]>0.)) fhZNAPMQiPMC[i]->Fill(towZNA[i+1]/towZNA[0]);
d43c6096 623 }
624 fhPMCvsPMQ[2]->Fill(towZNA[1]+towZNA[2]+towZNA[3]+towZNA[4], towZNA[0]);
aa16ad3c 625 fhZNApmcLR->Fill(towZNAlg[0]/1000.);
d43c6096 626 }
627 if(zpa){
628 for(int i=0; i<5; i++){
629 fhZPAPM[i]->Fill(towZPA[i]);
630 fhZPAPMlg[i]->Fill(towZPAlg[i]);
ca3061e5 631 if(((i<4) && towZPA[0]>0.)) fhZPAPMQiPMC[i]->Fill(towZPA[i+1]/towZPA[0]);
d43c6096 632 }
633 fhPMCvsPMQ[3]->Fill(towZPA[1]+towZPA[2]+towZPA[3]+towZPA[4], towZPA[0]);
aa16ad3c 634 fhZPApmcLR->Fill(towZPAlg[0]/1000.);
d43c6096 635 }
636 if(zem1) fhZEM[0]->Fill(energyZEM1);
637 if(zem2) fhZEM[1]->Fill(energyZEM2);
638
639 if(znc || zna){
640 fhZNCvsZNA->Fill(energyZNA, energyZNC);
641 fhZPCvsZPA->Fill(energyZPA, energyZPC);
642 fhZDCCvsZDCCA->Fill(energyZNA+energyZPA, energyZNC+energyZPC);
fdbc1dc8 643 fhZNCvsZPC->Fill(energyZPC, energyZNC);
644 fhZNAvsZPA->Fill(energyZPA, energyZNA);
645 fhZNvsZP->Fill(energyZPA+energyZPC, energyZNA+energyZNC);
d43c6096 646 fhZNvsZEM->Fill(energyZEM1+energyZEM2, energyZNC+energyZNA);
d1a28c63 647 fhZNvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNC+energyZNA, centrperc);
d43c6096 648 fhZDCvsZEM->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC);
d1a28c63 649 fhZDCvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC, centrperc);
d43c6096 650 fhZNvsVZERO->Fill(multV0A+multV0C, energyZNC+energyZNA);
651 fhZDCvsVZERO->Fill(multV0A+multV0C, energyZNA+energyZPA+energyZNC+energyZPC);
652 fhZDCvsTracklets->Fill((Float_t) (nTracklets), energyZNA+energyZPA+energyZNC+energyZPC);
763e0758 653 fhZDCvsNclu1->Fill((Float_t) (nClusterslay1), energyZNA+energyZPA+energyZNC+energyZPC);
d43c6096 654 fhVZEROvsZEM->Fill(energyZEM1+energyZEM2, multV0A+multV0C);
655
aa16ad3c 656 Double_t asymmetry = -999.;
657 if((energyZNC+energyZNA)>0.) asymmetry = (energyZNC-energyZNA)/(energyZNC+energyZNA);
d1a28c63 658 fhAsymm->Fill(asymmetry);
d43c6096 659 fhZNAvsAsymm->Fill(asymmetry, energyZNA/1000.);
660 fhZNCvsAsymm->Fill(asymmetry, energyZNC/1000.);
763e0758 661
662 fhZNCvscentrality->Fill(centrperc, energyZNC/1000.);
663 fhZNAvscentrality->Fill(centrperc, energyZNA/1000.);
664 fhZPCvscentrality->Fill(centrperc, energyZPC/1000.);
665 fhZPAvscentrality->Fill(centrperc, energyZPA/1000.);
666
a0073ce0 667 fhZNCpmcvscentr->Fill(centrperc, towZNC[0]/1000.);
668 fhZNApmcvscentr->Fill(centrperc, towZNA[0]/1000.);
669 fhZPCpmcvscentr->Fill(centrperc, towZPC[0]/1000.);
670 fhZPApmcvscentr->Fill(centrperc, towZPA[0]/1000.);
671
d43c6096 672 }
673// } // PHYSICS SELECTION
674
675 }
676 else if(fAnalysisInput==kAOD){
677
aa16ad3c 678 AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
679 if(!aod){
680 printf("AODs not available");
681 return;
682 }
683
684 // Select PHYSICS events (type=7, for data)
685 //if(!fIsMCInput && aod->GetEventType()!=7) return;
686
687 // PHYSICS SELECTION
688 AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
689 AliInputEventHandler *hdr = (AliInputEventHandler*)am->GetInputEventHandler();
690 if(hdr->IsEventSelected() & AliVEvent::kAnyINT){
691
692 AliCentrality* centrality = aod->GetCentrality();
d43c6096 693 Float_t centrperc = centrality->GetCentralityPercentile(fCentrEstimator.Data());
aa16ad3c 694
695 /*AliAODHeader *aodheader = aod->GetHeader();
696 AliCentrality *centralityp = aodheader->GetCentralityP();
697 Float_t centrperc = centralityp->GetCentralityPercentile(fCentrEstimator.Data());
698 */
699
700 if(centrperc<fCentrLowLim || centrperc>fCentrUpLim) return;
d43c6096 701
702 // ***** Trigger selection
703 /*TString triggerClass = aod->GetFiredTriggerClasses();
704 sprintf(fTrigClass,"%s",triggerClass.Data());
705
706 const AliAODVertex *vertex = aod->GetPrimaryVertexSPD();
707 fxVertex = vertex->GetX();
708 fyVertex = vertex->GetY();
709 fzVertex = vertex->GetZ();*/
710
711 AliAODTracklets *trackl = aod->GetTracklets();
712 Int_t nTracklets = trackl->GetNumberOfTracklets();
713
714 AliAODVZERO *vzeroAOD = aod->GetVZEROData();
715 Float_t multV0A = vzeroAOD->GetMTotV0A();
716 Float_t multV0C = vzeroAOD->GetMTotV0C();
717
718 AliAODZDC *aodZDC = aod->GetZDCData();
719
720 Float_t energyZNC = (Float_t) (aodZDC->GetZNCEnergy());
721 Float_t energyZPC = (Float_t) (aodZDC->GetZPCEnergy());
722 Float_t energyZNA = (Float_t) (aodZDC->GetZNAEnergy());
723 Float_t energyZPA = (Float_t) (aodZDC->GetZPAEnergy());
724 Float_t energyZEM1 = (Float_t) (aodZDC->GetZEM1Energy());
725 Float_t energyZEM2 = (Float_t) (aodZDC->GetZEM2Energy());
726
727 const Double_t * towZNC = aodZDC->GetZNCTowerEnergy();
728 const Double_t * towZPC = aodZDC->GetZPCTowerEnergy();
729 const Double_t * towZNA = aodZDC->GetZNATowerEnergy();
730 const Double_t * towZPA = aodZDC->GetZPATowerEnergy();
731 //
732 const Double_t * towZNClg = aodZDC->GetZNCTowerEnergyLR();
733 const Double_t * towZNAlg = aodZDC->GetZNATowerEnergyLR();
734 //
735 Double_t towZPClg[5], towZPAlg[5]={0.};
736 for(Int_t it=0; it<5; it++){
737 towZPClg[it] = 8*towZPC[it];
738 towZPAlg[it] = 8*towZNA[it];
739 }
740
741 Double_t xyZNC[2]={-99.,-99.}, xyZNA[2]={-99.,-99.};
742 aodZDC->GetZNCentroidInPbPb(1380., xyZNC, xyZNA);
743 fhZNCcentroid->Fill(xyZNC[0], xyZNC[1]);
744 fhZNAcentroid->Fill(xyZNA[0], xyZNA[1]);
745
746 Float_t tdcSum = aodZDC->GetZDCTimeSum();
747 Float_t tdcDiff = aodZDC->GetZDCTimeDiff();
748 fhDebunch->Fill(tdcDiff, tdcSum);
749
750 for(int i=0; i<5; i++){
751 fhZNCPM[i]->Fill(towZNC[i]);
752 fhZNCPMlg[i]->Fill(towZNClg[i]);
ca3061e5 753 if((i<4) && (towZNC[0]>0.)) fhZNCPMQiPMC[i]->Fill(towZNC[i+1]/towZNC[0]);
aa16ad3c 754 fhZNCpmcLR->Fill(towZNClg[0]/1000.);
d43c6096 755 }
756 fhPMCvsPMQ[0]->Fill(towZNC[1]+towZNC[2]+towZNC[3]+towZNC[4], towZNC[0]);
757 for(int i=0; i<5; i++){
758 fhZPCPM[i]->Fill(towZPC[i]);
759 fhZPCPMlg[i]->Fill(towZPClg[i]);
ca3061e5 760 if(((i<4) && towZPC[0]>0.)) fhZPCPMQiPMC[i]->Fill(towZPC[i+1]/towZPC[0]);
aa16ad3c 761 fhZPCpmcLR->Fill(towZPClg[0]/1000.);
d43c6096 762 }
763 fhPMCvsPMQ[1]->Fill(towZPC[1]+towZPC[2]+towZPC[3]+towZPC[4], towZPC[0]);
764 for(int i=0; i<5; i++){
765 fhZNAPM[i]->Fill(towZNA[i]);
766 fhZNAPMlg[i]->Fill(towZNAlg[i]);
ca3061e5 767 if(((i<4) && towZNA[0]>0.)) fhZNAPMQiPMC[i]->Fill(towZNA[i+1]/towZNA[0]);
aa16ad3c 768 fhZNApmcLR->Fill(towZNAlg[0]/1000.);
d43c6096 769 }
770 fhPMCvsPMQ[2]->Fill(towZNA[1]+towZNA[2]+towZNA[3]+towZNA[4], towZNA[0]);
771 for(int i=0; i<5; i++){
772 fhZPAPM[i]->Fill(towZPA[i]);
773 fhZPAPMlg[i]->Fill(towZPAlg[i]);
ca3061e5 774 if(((i<4) && towZPA[0]>0.)) fhZPAPMQiPMC[i]->Fill(towZPA[i+1]/towZPA[0]);
aa16ad3c 775 fhZPApmcLR->Fill(towZPAlg[0]/1000.);
d43c6096 776 }
777 fhPMCvsPMQ[3]->Fill(towZPA[1]+towZPA[2]+towZPA[3]+towZPA[4], towZPA[0]);
778 fhZEM[0]->Fill(energyZEM1);
779 fhZEM[1]->Fill(energyZEM2);
780
781 fhZNCvsZNA->Fill(energyZNA, energyZNC);
782 fhZPCvsZPA->Fill(energyZPA, energyZPC);
783 fhZDCCvsZDCCA->Fill(energyZNA+energyZPA, energyZNC+energyZPC);
fdbc1dc8 784 fhZNCvsZPC->Fill(energyZPC, energyZNC);
785 fhZNAvsZPA->Fill(energyZPA, energyZNA);
786 fhZNvsZP->Fill(energyZPA+energyZPC, energyZNA+energyZNC);
d43c6096 787 fhZNvsZEM->Fill(energyZEM1+energyZEM2, energyZNC+energyZNA);
d1a28c63 788 fhZDCvsZEM->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC);
789 fhZDCvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC, centrperc);
d43c6096 790 fhZNvsVZERO->Fill(multV0A+multV0C, energyZNC+energyZNA);
791 fhZDCvsVZERO->Fill(multV0A+multV0C, energyZNA+energyZPA+energyZNC+energyZPC);
792 fhZDCvsTracklets->Fill((Float_t) (nTracklets), energyZNA+energyZPA+energyZNC+energyZPC);
793 fhVZEROvsZEM->Fill(energyZEM1+energyZEM2, multV0A+multV0C);
794
aa16ad3c 795 Double_t asymmetry = -999.;
796 if((energyZNC+energyZNA)>0.) asymmetry = (energyZNC-energyZNA)/(energyZNC+energyZNA);
7f533345 797 fhAsymm->Fill(asymmetry);
d43c6096 798 fhZNAvsAsymm->Fill(asymmetry, energyZNA/1000.);
799 fhZNCvsAsymm->Fill(asymmetry, energyZNC/1000.);
763e0758 800
801 fhZNCvscentrality->Fill(centrperc, energyZNC/1000.);
802 fhZNAvscentrality->Fill(centrperc, energyZNA/1000.);
803 fhZPCvscentrality->Fill(centrperc, energyZPC/1000.);
804 fhZPAvscentrality->Fill(centrperc, energyZPA/1000.);
a0073ce0 805
806 fhZNCpmcvscentr->Fill(centrperc, towZNC[0]/1000.);
807 fhZNApmcvscentr->Fill(centrperc, towZNA[0]/1000.);
808 fhZPCpmcvscentr->Fill(centrperc, towZPC[0]/1000.);
809 fhZPApmcvscentr->Fill(centrperc, towZPA[0]/1000.);
aa16ad3c 810
811 } // PHYSICS SELECTION
d43c6096 812 }
813
814 PostData(1, fOutput);
815
816}
817
818
819
820//________________________________________________________________________
821void AliAnalysisTaskZDCPbPb::Terminate(Option_t */*option*/)
822{
823 // Terminate analysis
824 //
825/* if(fDebug > 1) printf(" **** AliAnalysisTaskZDCPbPb::Terminate() \n");
826
827 //fOutput = dynamic_cast<TList*> (GetOutputData(1));
828 //if(!fOutput) printf("ERROR: fOutput not available\n");
829*/
830}