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