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