]> 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
moved
[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);
297 fhZNCPM[i] = new TH1F(hname, hname, 200., -50., 140000);
298 fOutput->Add(fhZNCPM[i]);
299 //
300 sprintf(hname,"hZNAPM%d",i);
301 fhZNAPM[i] = new TH1F(hname, hname, 200., -50., 140000);
302 fOutput->Add(fhZNAPM[i]);
303 //
304 sprintf(hname,"hZPCPM%d",i);
305 fhZPCPM[i] = new TH1F(hname, hname, 200., -50., 50000);
306 fOutput->Add(fhZPCPM[i]);
307 //
308 sprintf(hname,"hZPAPM%d",i);
309 fhZPAPM[i] = new TH1F(hname, hname, 200., -50., 50000);
310 fOutput->Add(fhZPAPM[i]);
311 //
312 sprintf(hname,"hZNCPMlg%d",i);
313 fhZNCPMlg[i] = new TH1F(hname, hname, 200., -50., 140000);
314 fOutput->Add(fhZNCPMlg[i]);
315 //
316 sprintf(hname,"hZNAPMlg%d",i);
317 fhZNAPMlg[i] = new TH1F(hname, hname, 200., -50., 140000);
318 fOutput->Add(fhZNAPMlg[i]);
319 //
320 sprintf(hname,"hZPCPMlg%d",i);
321 fhZPCPMlg[i] = new TH1F(hname, hname, 200., -50., 50000);
322 fOutput->Add(fhZPCPMlg[i]);
323 //
324 sprintf(hname,"hZPAPMlg%d",i);
325 fhZPAPMlg[i] = new TH1F(hname, hname, 200., -50., 50000);
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());
502 if(centrperc<fCentrLowLim || centrperc>fCentrUpLim) {
fdbc1dc8 503// return;
d43c6096 504 }
505
506
507 // ***** Trigger selection
508 /*TString triggerClass = esd->GetFiredTriggerClasses();
509 sprintf(fTrigClass,"%s",triggerClass.Data());*/
510
511 const AliMultiplicity *mult = esd->GetMultiplicity();
512 Int_t nTracklets = mult->GetNumberOfTracklets();
d43c6096 513 //for(Int_t ilay=0; ilay<6; ilay++) fNClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
763e0758 514 Int_t nClusterslay1 = mult->GetNumberOfITSClusters(1);
515
d43c6096 516 AliESDVZERO *vzeroAOD = esd->GetVZEROData();
517 Float_t multV0A = vzeroAOD->GetMTotV0A();
518 Float_t multV0C = vzeroAOD->GetMTotV0C();
519
520 AliESDZDC *esdZDC = esd->GetESDZDC();
521
522 Int_t tdc[32][4], tdcSum=-999., tdcDiff=-999.;
523 Bool_t tdcMult[6] = {kFALSE};
524 for(Int_t itdc=0; itdc<32; itdc++){
525 for(Int_t i=0; i<4; i++){
526 if(esdZDC->GetZDCTDCData(itdc, i)!=0.){
527 tdc[itdc][i] = esdZDC->GetZDCTDCCorrected(itdc, i);
528 if(itdc>=8 && itdc<=13){
529 tdcMult[itdc-8] = kTRUE;
530 fhTDC[itdc-8]->Fill(tdc[itdc][i]);
531 }
532 else if(itdc==15 && i==0){
3bb49453 533 for(int ich=8; ich<=13; ich++) fhTDCraw[ich-8]->Fill(esdZDC->GetZDCTDCData(ich, 0)-esdZDC->GetZDCTDCData(itdc, i));
d43c6096 534 }
535 }
536 }
537 }
538 Bool_t zem1 = tdcMult[0];
539 Bool_t zem2 = tdcMult[1];
540 Bool_t znc = tdcMult[2];
541 Bool_t zpc = tdcMult[3];
542 Bool_t zna = tdcMult[4];
543 Bool_t zpa = tdcMult[5];
3bb49453 544 if(znc && zna){
545 tdcSum = esdZDC->GetZNTDCSum(0);
546 tdcDiff = esdZDC->GetZNTDCDiff(0);
547 fhDebunch->Fill(tdcDiff, tdcSum);
548 }
d43c6096 549
550 Float_t energyZNC = (Float_t) (esdZDC->GetZNCEnergy());
551 Float_t energyZPC = (Float_t) (esdZDC->GetZPCEnergy());
552 Float_t energyZNA = (Float_t) (esdZDC->GetZNAEnergy());
553 Float_t energyZPA = (Float_t) (esdZDC->GetZPAEnergy());
7f533345 554 Float_t energyZEM1 = (Float_t) (esdZDC->GetZEM1Energy()/8.);
555 Float_t energyZEM2 = (Float_t) (esdZDC->GetZEM2Energy()/8.);
d43c6096 556
557 const Double_t * towZNC = esdZDC->GetZNCTowerEnergy();
558 const Double_t * towZPC = esdZDC->GetZPCTowerEnergy();
559 const Double_t * towZNA = esdZDC->GetZNATowerEnergy();
560 const Double_t * towZPA = esdZDC->GetZPATowerEnergy();
561 //
562 const Double_t * towZNClg = esdZDC->GetZNCTowerEnergyLR();
563 const Double_t * towZPClg = esdZDC->GetZPCTowerEnergyLR();
564 const Double_t * towZNAlg = esdZDC->GetZNATowerEnergyLR();
565 const Double_t * towZPAlg = esdZDC->GetZPATowerEnergyLR();
566
567 Double_t xyZNC[2]={-99.,-99.}, xyZNA[2]={-99.,-99.};
568 esdZDC->GetZNCentroidInPbPb(esd->GetBeamEnergy(), xyZNC, xyZNA);
569 fhZNCcentroid->Fill(xyZNC[0], xyZNC[1]);
570 fhZNAcentroid->Fill(xyZNA[0], xyZNA[1]);
571
572 /* //Only for MC
573 fbZDC = esdZDC->GetImpactParameter();
574 fNpartZDC = esdZDC->GetZDCParticipants();
575 fbZDCA = esdZDC->GetImpactParamSideA();
576 fNpartZDCA = esdZDC->GetZDCPartSideA();
577 fbZDCC = esdZDC->GetImpactParamSideC();
578 fNpartZDCC = esdZDC->GetZDCPartSideC();*/
579
580 if(znc){
581 for(int i=0; i<5; i++){
582 fhZNCPM[i]->Fill(towZNC[i]);
583 fhZNCPMlg[i]->Fill(towZNClg[i]);
ca3061e5 584 if((i<4) && (towZNC[0]>0.)) fhZNCPMQiPMC[i]->Fill(towZNC[i+1]/towZNC[0]);
d43c6096 585 }
586 fhPMCvsPMQ[0]->Fill(towZNC[1]+towZNC[2]+towZNC[3]+towZNC[4], towZNC[0]);
587 }
588 if(zpc){
589 for(int i=0; i<5; i++){
590 fhZPCPM[i]->Fill(towZPC[i]);
591 fhZPCPMlg[i]->Fill(towZPClg[i]);
ca3061e5 592 if(((i<4) && towZPC[0]>0.)) fhZPCPMQiPMC[i]->Fill(towZPC[i+1]/towZPC[0]);
d43c6096 593 }
594 fhPMCvsPMQ[1]->Fill(towZPC[1]+towZPC[2]+towZPC[3]+towZPC[4], towZPC[0]);
595 }
596 if(zna){
597 for(int i=0; i<5; i++){
598 fhZNAPM[i]->Fill(towZNA[i]);
599 fhZNAPMlg[i]->Fill(towZNAlg[i]);
ca3061e5 600 if(((i<4) && towZNA[0]>0.)) fhZNAPMQiPMC[i]->Fill(towZNA[i+1]/towZNA[0]);
d43c6096 601 }
602 fhPMCvsPMQ[2]->Fill(towZNA[1]+towZNA[2]+towZNA[3]+towZNA[4], towZNA[0]);
603 }
604 if(zpa){
605 for(int i=0; i<5; i++){
606 fhZPAPM[i]->Fill(towZPA[i]);
607 fhZPAPMlg[i]->Fill(towZPAlg[i]);
ca3061e5 608 if(((i<4) && towZPA[0]>0.)) fhZPAPMQiPMC[i]->Fill(towZPA[i+1]/towZPA[0]);
d43c6096 609 }
610 fhPMCvsPMQ[3]->Fill(towZPA[1]+towZPA[2]+towZPA[3]+towZPA[4], towZPA[0]);
611 }
612 if(zem1) fhZEM[0]->Fill(energyZEM1);
613 if(zem2) fhZEM[1]->Fill(energyZEM2);
614
615 if(znc || zna){
616 fhZNCvsZNA->Fill(energyZNA, energyZNC);
617 fhZPCvsZPA->Fill(energyZPA, energyZPC);
618 fhZDCCvsZDCCA->Fill(energyZNA+energyZPA, energyZNC+energyZPC);
fdbc1dc8 619 fhZNCvsZPC->Fill(energyZPC, energyZNC);
620 fhZNAvsZPA->Fill(energyZPA, energyZNA);
621 fhZNvsZP->Fill(energyZPA+energyZPC, energyZNA+energyZNC);
d43c6096 622 fhZNvsZEM->Fill(energyZEM1+energyZEM2, energyZNC+energyZNA);
d1a28c63 623 fhZNvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNC+energyZNA, centrperc);
d43c6096 624 fhZDCvsZEM->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC);
d1a28c63 625 fhZDCvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC, centrperc);
d43c6096 626 fhZNvsVZERO->Fill(multV0A+multV0C, energyZNC+energyZNA);
627 fhZDCvsVZERO->Fill(multV0A+multV0C, energyZNA+energyZPA+energyZNC+energyZPC);
628 fhZDCvsTracklets->Fill((Float_t) (nTracklets), energyZNA+energyZPA+energyZNC+energyZPC);
763e0758 629 fhZDCvsNclu1->Fill((Float_t) (nClusterslay1), energyZNA+energyZPA+energyZNC+energyZPC);
d43c6096 630 fhVZEROvsZEM->Fill(energyZEM1+energyZEM2, multV0A+multV0C);
631
632 Double_t asymmetry = (energyZNC-energyZNA)/(energyZNC+energyZNA);
d1a28c63 633 fhAsymm->Fill(asymmetry);
d43c6096 634 fhZNAvsAsymm->Fill(asymmetry, energyZNA/1000.);
635 fhZNCvsAsymm->Fill(asymmetry, energyZNC/1000.);
763e0758 636
637 fhZNCvscentrality->Fill(centrperc, energyZNC/1000.);
638 fhZNAvscentrality->Fill(centrperc, energyZNA/1000.);
639 fhZPCvscentrality->Fill(centrperc, energyZPC/1000.);
640 fhZPAvscentrality->Fill(centrperc, energyZPA/1000.);
641
a0073ce0 642 fhZNCpmcvscentr->Fill(centrperc, towZNC[0]/1000.);
643 fhZNApmcvscentr->Fill(centrperc, towZNA[0]/1000.);
644 fhZPCpmcvscentr->Fill(centrperc, towZPC[0]/1000.);
645 fhZPApmcvscentr->Fill(centrperc, towZPA[0]/1000.);
646
d43c6096 647 }
648// } // PHYSICS SELECTION
649
650 }
651 else if(fAnalysisInput==kAOD){
652
653 AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
654 if(!aod) return;
655
656 // Select PHYSICS events (type=7, for data)
657 if(!fIsMCInput && aod->GetEventType()!=7) return;
658
659 // AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
660 // use response of AliPhysicsSelection
661 //if(((AliInputEventHandler*)(am->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kAnyINT){
662
663 AliCentrality *centrality = aod->GetCentrality();
664 Float_t centrperc = centrality->GetCentralityPercentile(fCentrEstimator.Data());
665 if(centrperc<fCentrLowLim || centrperc>fCentrUpLim) {
666 return;
667 }
668
669 // ***** Trigger selection
670 /*TString triggerClass = aod->GetFiredTriggerClasses();
671 sprintf(fTrigClass,"%s",triggerClass.Data());
672
673 const AliAODVertex *vertex = aod->GetPrimaryVertexSPD();
674 fxVertex = vertex->GetX();
675 fyVertex = vertex->GetY();
676 fzVertex = vertex->GetZ();*/
677
678 AliAODTracklets *trackl = aod->GetTracklets();
679 Int_t nTracklets = trackl->GetNumberOfTracklets();
680
681 AliAODVZERO *vzeroAOD = aod->GetVZEROData();
682 Float_t multV0A = vzeroAOD->GetMTotV0A();
683 Float_t multV0C = vzeroAOD->GetMTotV0C();
684
685 AliAODZDC *aodZDC = aod->GetZDCData();
686
687 Float_t energyZNC = (Float_t) (aodZDC->GetZNCEnergy());
688 Float_t energyZPC = (Float_t) (aodZDC->GetZPCEnergy());
689 Float_t energyZNA = (Float_t) (aodZDC->GetZNAEnergy());
690 Float_t energyZPA = (Float_t) (aodZDC->GetZPAEnergy());
691 Float_t energyZEM1 = (Float_t) (aodZDC->GetZEM1Energy());
692 Float_t energyZEM2 = (Float_t) (aodZDC->GetZEM2Energy());
693
694 const Double_t * towZNC = aodZDC->GetZNCTowerEnergy();
695 const Double_t * towZPC = aodZDC->GetZPCTowerEnergy();
696 const Double_t * towZNA = aodZDC->GetZNATowerEnergy();
697 const Double_t * towZPA = aodZDC->GetZPATowerEnergy();
698 //
699 const Double_t * towZNClg = aodZDC->GetZNCTowerEnergyLR();
700 const Double_t * towZNAlg = aodZDC->GetZNATowerEnergyLR();
701 //
702 Double_t towZPClg[5], towZPAlg[5]={0.};
703 for(Int_t it=0; it<5; it++){
704 towZPClg[it] = 8*towZPC[it];
705 towZPAlg[it] = 8*towZNA[it];
706 }
707
708 Double_t xyZNC[2]={-99.,-99.}, xyZNA[2]={-99.,-99.};
709 aodZDC->GetZNCentroidInPbPb(1380., xyZNC, xyZNA);
710 fhZNCcentroid->Fill(xyZNC[0], xyZNC[1]);
711 fhZNAcentroid->Fill(xyZNA[0], xyZNA[1]);
712
713 Float_t tdcSum = aodZDC->GetZDCTimeSum();
714 Float_t tdcDiff = aodZDC->GetZDCTimeDiff();
715 fhDebunch->Fill(tdcDiff, tdcSum);
716
717 for(int i=0; i<5; i++){
718 fhZNCPM[i]->Fill(towZNC[i]);
719 fhZNCPMlg[i]->Fill(towZNClg[i]);
ca3061e5 720 if((i<4) && (towZNC[0]>0.)) fhZNCPMQiPMC[i]->Fill(towZNC[i+1]/towZNC[0]);
d43c6096 721 }
722 fhPMCvsPMQ[0]->Fill(towZNC[1]+towZNC[2]+towZNC[3]+towZNC[4], towZNC[0]);
723 for(int i=0; i<5; i++){
724 fhZPCPM[i]->Fill(towZPC[i]);
725 fhZPCPMlg[i]->Fill(towZPClg[i]);
ca3061e5 726 if(((i<4) && towZPC[0]>0.)) fhZPCPMQiPMC[i]->Fill(towZPC[i+1]/towZPC[0]);
d43c6096 727 }
728 fhPMCvsPMQ[1]->Fill(towZPC[1]+towZPC[2]+towZPC[3]+towZPC[4], towZPC[0]);
729 for(int i=0; i<5; i++){
730 fhZNAPM[i]->Fill(towZNA[i]);
731 fhZNAPMlg[i]->Fill(towZNAlg[i]);
ca3061e5 732 if(((i<4) && towZNA[0]>0.)) fhZNAPMQiPMC[i]->Fill(towZNA[i+1]/towZNA[0]);
d43c6096 733 }
734 fhPMCvsPMQ[2]->Fill(towZNA[1]+towZNA[2]+towZNA[3]+towZNA[4], towZNA[0]);
735 for(int i=0; i<5; i++){
736 fhZPAPM[i]->Fill(towZPA[i]);
737 fhZPAPMlg[i]->Fill(towZPAlg[i]);
ca3061e5 738 if(((i<4) && towZPA[0]>0.)) fhZPAPMQiPMC[i]->Fill(towZPA[i+1]/towZPA[0]);
d43c6096 739 }
740 fhPMCvsPMQ[3]->Fill(towZPA[1]+towZPA[2]+towZPA[3]+towZPA[4], towZPA[0]);
741 fhZEM[0]->Fill(energyZEM1);
742 fhZEM[1]->Fill(energyZEM2);
743
744 fhZNCvsZNA->Fill(energyZNA, energyZNC);
745 fhZPCvsZPA->Fill(energyZPA, energyZPC);
746 fhZDCCvsZDCCA->Fill(energyZNA+energyZPA, energyZNC+energyZPC);
fdbc1dc8 747 fhZNCvsZPC->Fill(energyZPC, energyZNC);
748 fhZNAvsZPA->Fill(energyZPA, energyZNA);
749 fhZNvsZP->Fill(energyZPA+energyZPC, energyZNA+energyZNC);
d43c6096 750 fhZNvsZEM->Fill(energyZEM1+energyZEM2, energyZNC+energyZNA);
d1a28c63 751 fhZDCvsZEM->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC);
752 fhZDCvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC, centrperc);
d43c6096 753 fhZNvsVZERO->Fill(multV0A+multV0C, energyZNC+energyZNA);
754 fhZDCvsVZERO->Fill(multV0A+multV0C, energyZNA+energyZPA+energyZNC+energyZPC);
755 fhZDCvsTracklets->Fill((Float_t) (nTracklets), energyZNA+energyZPA+energyZNC+energyZPC);
756 fhVZEROvsZEM->Fill(energyZEM1+energyZEM2, multV0A+multV0C);
757
758 Double_t asymmetry = (energyZNC-energyZNA)/(energyZNC+energyZNA);
7f533345 759 fhAsymm->Fill(asymmetry);
d43c6096 760 fhZNAvsAsymm->Fill(asymmetry, energyZNA/1000.);
761 fhZNCvsAsymm->Fill(asymmetry, energyZNC/1000.);
763e0758 762
763 fhZNCvscentrality->Fill(centrperc, energyZNC/1000.);
764 fhZNAvscentrality->Fill(centrperc, energyZNA/1000.);
765 fhZPCvscentrality->Fill(centrperc, energyZPC/1000.);
766 fhZPAvscentrality->Fill(centrperc, energyZPA/1000.);
a0073ce0 767
768 fhZNCpmcvscentr->Fill(centrperc, towZNC[0]/1000.);
769 fhZNApmcvscentr->Fill(centrperc, towZNA[0]/1000.);
770 fhZPCpmcvscentr->Fill(centrperc, towZPC[0]/1000.);
771 fhZPApmcvscentr->Fill(centrperc, towZPA[0]/1000.);
d43c6096 772 //}
773 }
774
775 PostData(1, fOutput);
776
777}
778
779
780
781//________________________________________________________________________
782void AliAnalysisTaskZDCPbPb::Terminate(Option_t */*option*/)
783{
784 // Terminate analysis
785 //
786/* if(fDebug > 1) printf(" **** AliAnalysisTaskZDCPbPb::Terminate() \n");
787
788 //fOutput = dynamic_cast<TList*> (GetOutputData(1));
789 //if(!fOutput) printf("ERROR: fOutput not available\n");
790*/
791}