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