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