1 /**************************************************************************
2 * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 /////////////////////////////////////////////////////////////
18 // Class to analyze centrality measurements //
20 /////////////////////////////////////////////////////////////
31 #include "AliAnalysisManager.h"
32 #include "AliVEvent.h"
34 #include "AliESDEvent.h"
35 #include "AliESDHeader.h"
36 #include "AliESDInputHandler.h"
37 #include "AliESDZDC.h"
38 #include "AliESDFMD.h"
39 #include "AliESDVZERO.h"
40 #include "AliMultiplicity.h"
41 #include "AliAODHandler.h"
42 #include "AliAODEvent.h"
43 #include "AliAODVertex.h"
44 #include "AliAODMCHeader.h"
45 #include "AliMCEvent.h"
46 #include "AliMCEventHandler.h"
47 #include "AliMCParticle.h"
49 #include "AliHeader.h"
50 #include "AliAODMCParticle.h"
51 #include "AliAnalysisTaskSE.h"
52 #include "AliGenEventHeader.h"
53 #include "AliGenHijingEventHeader.h"
54 #include "AliPhysicsSelectionTask.h"
55 #include "AliPhysicsSelection.h"
56 #include "AliBackgroundSelection.h"
57 #include "AliAnalysisTaskCentrality.h"
59 ClassImp(AliAnalysisTaskCentrality)
62 //________________________________________________________________________
63 AliAnalysisTaskCentrality::AliAnalysisTaskCentrality():
66 fAnalysisInput("ESD"),
78 fhNtrackletsvsEzdc(0x0),
79 fhNclusters0vsEzdc(0x0),
83 fhNtrackletsvsEzem(0x0),
84 fhNclusters0vsEzem(0x0),
87 fhNtracksvsmultV0(0x0),
88 fhNtrackletsvsmultV0(0x0),
89 fhNclusters0vsmultV0(0x0),
90 fhNtracksvsmultFMD(0x0),
91 fhNtrackletsvsmultFMD(0x0),
92 fhNclusters0vsmultFMD(0x0),
93 fhmultV0vsmultFMD(0x0),
139 // Default constructor
142 //________________________________________________________________________
143 AliAnalysisTaskCentrality::AliAnalysisTaskCentrality(const char *name):
144 AliAnalysisTaskSE(name),
146 fAnalysisInput("ESD"),
157 fhNtracksvsEzdc(0x0),
158 fhNtrackletsvsEzdc(0x0),
159 fhNclusters0vsEzdc(0x0),
161 fhmultFMDvsEzdc(0x0),
162 fhNtracksvsEzem(0x0),
163 fhNtrackletsvsEzem(0x0),
164 fhNclusters0vsEzem(0x0),
166 fhmultFMDvsEzem(0x0),
167 fhNtracksvsmultV0(0x0),
168 fhNtrackletsvsmultV0(0x0),
169 fhNclusters0vsmultV0(0x0),
170 fhNtracksvsmultFMD(0x0),
171 fhNtrackletsvsmultFMD(0x0),
172 fhNclusters0vsmultFMD(0x0),
173 fhmultV0vsmultFMD(0x0),
219 // Default constructor
221 // Output slot #1 writes into a TList container
222 DefineOutput(1, TList::Class());
226 //________________________________________________________________________
227 AliAnalysisTaskCentrality& AliAnalysisTaskCentrality::operator=(const AliAnalysisTaskCentrality& c)
230 // Assignment operator
233 AliAnalysisTaskSE::operator=(c);
238 //________________________________________________________________________
239 AliAnalysisTaskCentrality::AliAnalysisTaskCentrality(const AliAnalysisTaskCentrality& ana):
240 AliAnalysisTaskSE(ana),
242 fAnalysisInput(ana.fDebug),
243 fIsMCInput(ana.fIsMCInput),
244 fOutput(ana.fOutput),
247 fhNtracks(ana.fhNtracks),
248 fhNtracklets(ana.fhNtracklets),
249 fhNclusters0(ana.fhNclusters0),
250 fhmultV0(ana.fhmultV0),
251 fhmultFMD(ana.fhmultFMD),
252 fhEzemvsEzdc(ana.fhEzemvsEzdc),
253 fhNtracksvsEzdc(ana.fhNtracksvsEzdc),
254 fhNtrackletsvsEzdc(ana.fhNtrackletsvsEzdc),
255 fhNclusters0vsEzdc(ana.fhNclusters0vsEzdc),
256 fhmultV0vsEzdc(ana.fhmultV0vsEzdc),
257 fhmultFMDvsEzdc(ana.fhmultFMDvsEzdc),
258 fhNtracksvsEzem(ana.fhNtracksvsEzem),
259 fhNtrackletsvsEzem(ana.fhNtrackletsvsEzem),
260 fhNclusters0vsEzem(ana.fhNclusters0vsEzem),
261 fhmultV0vsEzem(ana.fhmultV0vsEzem),
262 fhmultFMDvsEzem(ana.fhmultFMDvsEzem),
263 fhNtracksvsmultV0(ana.fhNtracksvsmultV0),
264 fhNtrackletsvsmultV0(ana.fhNtrackletsvsmultV0),
265 fhNclusters0vsmultV0(ana.fhNclusters0vsmultV0),
266 fhNtracksvsmultFMD(ana.fhNtracksvsmultFMD),
267 fhNtrackletsvsmultFMD(ana.fhNtrackletsvsmultFMD),
268 fhNclusters0vsmultFMD(ana.fhNclusters0vsmultFMD),
269 fhmultV0vsmultFMD(ana.fhmultV0vsmultFMD),
271 fBeamEnergy(ana.fBeamEnergy),
272 fNmyTracksgen(ana.fNmyTracksgen),
273 fxVertex(ana.fxVertex),
274 fyVertex(ana.fyVertex),
275 fzVertex(ana.fzVertex),
276 fVertexer3d(ana.fVertexer3d),
278 fNpartTargMC(ana.fNpartTargMC),
279 fNpartProjMC(ana.fNpartProjMC),
280 fNNColl(ana.fNNColl),
281 fNNwColl(ana.fNNwColl),
282 fNwNColl(ana.fNwNColl),
283 fNwNwColl(ana.fNwNwColl),
284 fNTracklets(ana.fNTracklets),
285 fNSingleClusters(ana.fNSingleClusters),
287 fNpartZDC(ana.fNpartZDC),
289 fNpartZDCA(ana.fNpartZDCA),
291 fNpartZDCC(ana.fNpartZDCC),
292 fESDFlag(ana.fESDFlag),
293 fZNCEnergy(ana.fZNCEnergy),
294 fZPCEnergy(ana.fZPCEnergy),
295 fZNAEnergy(ana.fZNAEnergy),
296 fZPAEnergy(ana.fZPAEnergy),
297 fZEM1Energy(ana.fZEM1Energy),
298 fZEM2Energy(ana.fZEM2Energy),
305 fNTracks(ana.fNTracks),
306 fNPmdTracks(ana.fNPmdTracks),
307 fMultV0A(ana.fMultV0A),
308 fMultV0C(ana.fMultV0C),
309 fMultFMDA(ana.fMultFMDA),
310 fMultFMDC(ana.fMultFMDC)
316 for (Int_t i=0; i<5; ++i) {
317 fZNCtower[i] = ana.fZNCtower[i];
318 fZPCtower[i] = ana.fZPCtower[i];
319 fZNAtower[i] = ana.fZNAtower[i];
320 fZPAtower[i] = ana.fZPAtower[i];
322 for (Int_t i=0; i<2; ++i) {
323 fCentrZNC[i] = ana.fCentrZNC[i];
324 fCentrZNA[i] = ana.fCentrZNA[i];
328 //________________________________________________________________________
329 AliAnalysisTaskCentrality::~AliAnalysisTaskCentrality()
333 delete fOutput; fOutput=0;
337 //________________________________________________________________________
338 void AliAnalysisTaskCentrality::UserCreateOutputObjects()
341 // Create the output containers
342 if(fDebug>1) printf("AnalysisTaskZDCpp::UserCreateOutputObjects() \n");
344 // Several histograms are more conveniently managed in a TList
345 fOutput = new TList();
347 fOutput->SetName("OutputHistos");
349 fhEzdc = new TH1F("hEzdc","hEzdc",500,0,150);
350 fhEzem = new TH1F("hEzem","hEzem",500,0,5);
351 fhNtracks = new TH1F("hNtracks","hNtracks",500,0,17000);
352 fhNtracklets = new TH1F("hNtracklets","hNtracklets",500,0,10000);
353 fhNclusters0 = new TH1F("hNclusters0","hNclusters0",500,0,15000);
354 fhmultV0 = new TH1F("hmultV0","hmultV0",500,0,30000);
355 fhmultFMD = new TH1F("hmultFMD","hmultFMD",500,0,24000);
357 fhEzemvsEzdc = new TProfile("hEzemvsEzdc","hEzemvsEzdc",500,0,5,"");
358 fhNtracksvsEzdc = new TProfile("hNtracksvsEzdc","hNtracksvsEzdc",500,0,17000,"");
359 fhNtrackletsvsEzdc = new TProfile("hNtrackletsvsEzdc","hNtrackletsvsEzdc",500,0,10000,"");
360 fhNclusters0vsEzdc = new TProfile("hNclusters0vsEzdc","hNclusters0vsEzdc",500,0,15000,"");
361 fhmultV0vsEzdc = new TProfile("hmultV0vsEzdc","hmultV0vsEzdc",500,0,30000,"");
362 fhmultFMDvsEzdc = new TProfile("hmultFMDvsEzdc","hmultFMDvsEzdc",500,0,24000,"");
363 fhNtracksvsEzem = new TProfile("hNtracksvsEzem","hNtracksvsEzem",500,0,17000,"");
364 fhNtrackletsvsEzem = new TProfile("hNtrackletsvsEzem","hNtrackletsvsEzem",500,0,10000,"");
365 fhNclusters0vsEzem = new TProfile("hNclusters0vsEzem","hNclusters0vsEzem",500,0,15000,"");
366 fhmultV0vsEzem = new TProfile("hmultV0vsEzem","hmultV0vsEzem",500,0,30000,"");
367 fhmultFMDvsEzem = new TProfile("hmultFMDvsEzem","hmultFMDvsEzem",500,0,24000,"");
368 fhNtracksvsmultV0 = new TProfile("hNtracksvsmultV0","hNtracksvsmultV0",500,0,17000,"");
369 fhNtrackletsvsmultV0 = new TProfile("hNtrackletsvsmultV0","hNtrackletsvsmultV0",500,0,10000,"");
370 fhNclusters0vsmultV0 = new TProfile("hNclusters0vsmultV0","hNclusters0vsmultV0",500,0,15000,"");
371 fhNtracksvsmultFMD = new TProfile("hNtracksvsmultFMD","hNtracksvsmultFMD",500,0,17000,"");
372 fhNtrackletsvsmultFMD= new TProfile("hNtrackletsvsmultFMD","hNtrackletsvsmultFMD",500,0,10000,"");
373 fhNclusters0vsmultFMD= new TProfile("hNclusters0vsmultFMD","hNclusters0vsmultFMD",500,0,15000,"");
374 fhmultV0vsmultFMD = new TProfile("hmultV0vsmultFMD","hmultV0vsmultFMD",500,0,30000,"");
376 fhEzdc ->GetXaxis()->SetTitle("E_{ZDC}[TeV]");
377 fhEzem ->GetXaxis()->SetTitle("E_{ZEM}[TeV]");
378 fhNtracks ->GetXaxis()->SetTitle("N_{tracks}");
379 fhNtracklets ->GetXaxis()->SetTitle("N_{tracklets}");
380 fhNclusters0 ->GetXaxis()->SetTitle("N_{clusters0}");
381 fhmultV0 ->GetXaxis()->SetTitle("V0 mult");
382 fhmultFMD ->GetXaxis()->SetTitle("FMD mult");
384 fhEzemvsEzdc ->GetYaxis()->SetTitle("E_{ZDC}[TeV]");
385 fhNtracksvsEzdc ->GetYaxis()->SetTitle("E_{ZDC}[TeV]");
386 fhNtrackletsvsEzdc ->GetYaxis()->SetTitle("E_{ZDC}[TeV]");
387 fhNclusters0vsEzdc ->GetYaxis()->SetTitle("E_{ZDC}[TeV]");
388 fhmultV0vsEzdc ->GetYaxis()->SetTitle("E_{ZDC}[TeV]");
389 fhmultFMDvsEzdc ->GetYaxis()->SetTitle("E_{ZDC}[TeV]");
390 fhNtracksvsEzem ->GetYaxis()->SetTitle("E_{ZEM}[TeV]");
391 fhNtrackletsvsEzem ->GetYaxis()->SetTitle("E_{ZEM}[TeV]");
392 fhNclusters0vsEzem ->GetYaxis()->SetTitle("E_{ZEM}[TeV]");
393 fhmultV0vsEzem ->GetYaxis()->SetTitle("E_{ZEM}[TeV]");
394 fhmultFMDvsEzem ->GetYaxis()->SetTitle("E_{ZEM}[TeV]");
395 fhNtracksvsmultV0 ->GetYaxis()->SetTitle("V0 mult");
396 fhNtrackletsvsmultV0 ->GetYaxis()->SetTitle("V0 mult");
397 fhNclusters0vsmultV0 ->GetYaxis()->SetTitle("V0 mult");
398 fhNtracksvsmultFMD ->GetYaxis()->SetTitle("FMD mult");
399 fhNtrackletsvsmultFMD->GetYaxis()->SetTitle("FMD mult");
400 fhNclusters0vsmultFMD->GetYaxis()->SetTitle("FMD mult");
401 fhmultV0vsmultFMD ->GetYaxis()->SetTitle("FMD mult");
403 fhEzemvsEzdc ->GetXaxis()->SetTitle("E_{ZEM}[TeV]");
404 fhNtracksvsEzdc ->GetXaxis()->SetTitle("N_{tracks}");
405 fhNtrackletsvsEzdc ->GetXaxis()->SetTitle("N_{tracklets}");
406 fhNclusters0vsEzdc ->GetXaxis()->SetTitle("N_{clusters0}");
407 fhmultV0vsEzdc ->GetXaxis()->SetTitle("V0 mult");
408 fhmultFMDvsEzdc ->GetXaxis()->SetTitle("FMD mult");
409 fhNtracksvsEzem ->GetXaxis()->SetTitle("N_{tracks}");
410 fhNtrackletsvsEzem ->GetXaxis()->SetTitle("N_{tracklets}");
411 fhNclusters0vsEzem ->GetXaxis()->SetTitle("N_{clusters0}");
412 fhmultV0vsEzem ->GetXaxis()->SetTitle("V0 mult");
413 fhmultFMDvsEzem ->GetXaxis()->SetTitle("FMD mult");
414 fhNtracksvsmultV0 ->GetXaxis()->SetTitle("N_{tracks}");
415 fhNtrackletsvsmultV0 ->GetXaxis()->SetTitle("N_{tracklets}");
416 fhNclusters0vsmultV0 ->GetXaxis()->SetTitle("N_{clusters0}");
417 fhNtracksvsmultFMD ->GetXaxis()->SetTitle("N_{tracks}");
418 fhNtrackletsvsmultFMD->GetXaxis()->SetTitle("N_{tracklets}");
419 fhNclusters0vsmultFMD->GetXaxis()->SetTitle("N_{clusters}");
420 fhmultV0vsmultFMD ->GetXaxis()->SetTitle("V0 mult");
422 fOutput->Add(fhEzdc);
423 fOutput->Add(fhEzem);
424 fOutput->Add(fhNtracks);
425 fOutput->Add(fhNtracklets);
426 fOutput->Add(fhNclusters0);
427 fOutput->Add(fhmultV0);
428 fOutput->Add(fhmultFMD);
430 fOutput->Add(fhEzemvsEzdc);
431 fOutput->Add(fhNtracksvsEzdc);
432 fOutput->Add(fhNtrackletsvsEzdc);
433 fOutput->Add(fhNclusters0vsEzdc);
434 fOutput->Add(fhmultV0vsEzdc);
435 fOutput->Add(fhmultFMDvsEzdc);
436 fOutput->Add(fhNtracksvsEzem);
437 fOutput->Add(fhNtrackletsvsEzem);
438 fOutput->Add(fhNclusters0vsEzem);
439 fOutput->Add(fhmultV0vsEzem);
440 fOutput->Add(fhmultFMDvsEzem);
441 fOutput->Add(fhNtracksvsmultV0);
442 fOutput->Add(fhNtrackletsvsmultV0);
443 fOutput->Add(fhNclusters0vsmultV0);
444 fOutput->Add(fhNtracksvsmultFMD);
445 fOutput->Add(fhNtrackletsvsmultFMD);
446 fOutput->Add(fhNclusters0vsmultFMD);
447 fOutput->Add(fhmultV0vsmultFMD);
449 PostData(1, fOutput);
452 //________________________________________________________________________
453 void AliAnalysisTaskCentrality::UserExec(Option_t */*option*/)
455 // Execute analysis for current event:
456 if(fDebug>1) printf(" **** AliAnalysisTaskCentrality::UserExec() \n");
458 if(fAnalysisInput.CompareTo("ESD")==0){
460 AliVEvent* event = InputEvent();
461 AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
465 fNTracks = event->GetNumberOfTracks();
466 fNPmdTracks = esd->GetNumberOfPmdTracks();
468 AliESDVZERO* esdV0 = esd->GetVZEROData();
469 fMultV0A=esdV0->GetMTotV0A();
470 fMultV0C=esdV0->GetMTotV0C();
474 AliMCEvent* mcEvent = MCEvent();
476 printf(" Could not retrieve MC event!!!\n");
481 AliStack *stack = 0x0; // needed for MC studies
482 stack = MCEvent()->Stack();
483 for (Int_t iTrack = 0; iTrack < MCEvent()->GetNumberOfTracks(); iTrack++) {
484 //get properties of mc particle
485 AliMCParticle* mcP = (AliMCParticle*) MCEvent()->GetTrack(iTrack);
487 if (!(stack->IsPhysicalPrimary(mcP->Label()))) continue;
488 //charged tracks only
489 if (mcP->Particle()->GetPDG()->Charge() == 0) continue;
490 //same cuts as on ESDtracks
491 // if(TMath::Abs(mcP->Eta())>0.9)continue;
492 // if(mcP->Pt()<0.2)continue;
493 // if(mcP->Pt()>200)continue;
498 AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
500 printf(" Event generator header not available!!!\n");
504 if(genHeader->InheritsFrom(AliGenHijingEventHeader::Class())){
505 fbMC = ((AliGenHijingEventHeader*) genHeader)->ImpactParameter();
506 Int_t specNeutronProj = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsn();
507 Int_t specProtonProj = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsp();
508 Int_t specNeutronTarg = ((AliGenHijingEventHeader*) genHeader)->TargSpectatorsn();
509 Int_t specProtonTarg = ((AliGenHijingEventHeader*) genHeader)->TargSpectatorsp();
510 fNpartTargMC = (Int_t)(208.-(specNeutronTarg+specProtonTarg));
511 fNpartProjMC = (Int_t)(208.-(specNeutronProj+specProtonProj));
512 fNNColl = ((AliGenHijingEventHeader*) genHeader)->NN();
513 fNNwColl = ((AliGenHijingEventHeader*) genHeader)->NNw();
514 fNwNColl = ((AliGenHijingEventHeader*) genHeader)->NwN();
515 fNwNwColl = ((AliGenHijingEventHeader*) genHeader)->NwNw();
520 fBeamEnergy = esd->GetBeamEnergy();
522 // ***** Trigger selection
523 TString triggerClass = esd->GetFiredTriggerClasses();
524 sprintf(fTrigClass,"%s",triggerClass.Data());
526 const AliESDVertex *vertex = esd->GetPrimaryVertexSPD();
527 fxVertex = vertex->GetX();
528 fyVertex = vertex->GetY();
529 fzVertex = vertex->GetZ();
530 if(vertex->IsFromVertexer3D()) fVertexer3d = kTRUE;
531 else fVertexer3d = kFALSE;
533 vertex->GetXYZ(vertex3);
535 const AliMultiplicity *mult = esd->GetMultiplicity();
536 fNTracklets = mult->GetNumberOfTracklets();
538 for(Int_t ilay=0; ilay<6; ilay++){
539 fNClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
541 fNSingleClusters = mult->GetNumberOfSingleClusters();
543 for(Int_t ilay=0; ilay<2; ilay++){
544 fNChips[ilay] = mult->GetNumberOfFiredChips(ilay);
548 AliESDFMD *fmd = esd->GetFMDData();
549 Float_t totalMultA = 0;
550 Float_t totalMultC = 0;
551 const Float_t fFMDLowCut = 0.4;
553 for(UShort_t det=1;det<=3;det++) {
554 Int_t nRings = (det==1 ? 1 : 2);
555 for (UShort_t ir = 0; ir < nRings; ir++) {
556 Char_t ring = (ir == 0 ? 'I' : 'O');
557 UShort_t nsec = (ir == 0 ? 20 : 40);
558 UShort_t nstr = (ir == 0 ? 512 : 256);
559 for(UShort_t sec =0; sec < nsec; sec++) {
560 for(UShort_t strip = 0; strip < nstr; strip++) {
562 Float_t fmdmult = fmd->Multiplicity(det,ring,sec,strip);
563 if(fmdmult == 0 || fmdmult == AliESDFMD::kInvalidMult) continue;
565 Float_t nParticles=0;
567 if(fmdmult > fFMDLowCut) {
571 if (det<3) totalMultA = totalMultA + nParticles;
572 else totalMultC = totalMultC + nParticles;
578 fMultFMDA = totalMultA;
579 fMultFMDC = totalMultC;
581 AliESDZDC *esdZDC = esd->GetESDZDC();
582 fESDFlag = esdZDC->GetESDQuality();
583 fZNCEnergy = (Float_t) (esdZDC->GetZDCN1Energy());
584 fZPCEnergy = (Float_t) (esdZDC->GetZDCP1Energy());
585 fZNAEnergy = (Float_t) (esdZDC->GetZDCN2Energy());
586 fZPAEnergy = (Float_t) (esdZDC->GetZDCP2Energy());
587 fZEM1Energy = (Float_t) (esdZDC->GetZDCEMEnergy(0));
588 fZEM2Energy = (Float_t) (esdZDC->GetZDCEMEnergy(1));
590 fbZDC = esdZDC->GetImpactParameter();
591 fNpartZDC = esdZDC->GetZDCParticipants();
592 fbZDCA = esdZDC->GetImpactParamSideA();
593 fNpartZDCA = esdZDC->GetZDCPartSideA();
594 fbZDCC = esdZDC->GetImpactParamSideC();
595 fNpartZDCC = esdZDC->GetZDCPartSideC();
597 const Double_t * towZNC = esdZDC->GetZN1TowerEnergy();
598 const Double_t * towZPC = esdZDC->GetZP1TowerEnergy();
599 const Double_t * towZNA = esdZDC->GetZN2TowerEnergy();
600 const Double_t * towZPA = esdZDC->GetZP2TowerEnergy();
602 for(Int_t it=0; it<5; it++){
603 fZNCtower[it] = (Float_t) (towZNC[it]);
604 fZPCtower[it] = (Float_t) (towZPC[it]);
605 fZNAtower[it] = (Float_t) (towZNA[it]);
606 fZPAtower[it] = (Float_t) (towZPA[it]);
609 Double_t xyZNC[2]={-99.,-99.}, xyZNA[2]={-99.,-99.};
610 esdZDC->GetZNCentroidInPbPb(fBeamEnergy, xyZNC, xyZNA);
611 for(Int_t it=0; it<2; it++){
612 fCentrZNC[it] = xyZNC[it];
613 fCentrZNA[it] = xyZNA[it];
617 fhEzdc ->Fill((fZNCEnergy+fZPCEnergy+fZNAEnergy+fZPAEnergy)/1000.);
618 fhEzem ->Fill(fZEM1Energy+fZEM2Energy);
619 fhNtracks ->Fill(fNTracks);
620 fhNtracklets ->Fill(fNTracklets);
621 fhNclusters0 ->Fill(fNClusters[0]);
622 fhmultV0 ->Fill(fMultV0A+fMultV0C);
623 fhmultFMD ->Fill(fMultFMDA+fMultFMDC);
624 fhEzemvsEzdc ->Fill(fZEM1Energy+fZEM2Energy, (fZNCEnergy+fZPCEnergy+fZNAEnergy+fZPAEnergy)/1000.);
625 fhNtracksvsEzdc ->Fill(fNTracks, (fZNCEnergy+fZPCEnergy+fZNAEnergy+fZPAEnergy)/1000.);
626 fhNtrackletsvsEzdc ->Fill(fNTracklets, (fZNCEnergy+fZPCEnergy+fZNAEnergy+fZPAEnergy)/1000.);
627 fhNclusters0vsEzdc ->Fill(fNClusters[0], (fZNCEnergy+fZPCEnergy+fZNAEnergy+fZPAEnergy)/1000.);
628 fhmultV0vsEzdc ->Fill(fMultV0A+fMultV0C, (fZNCEnergy+fZPCEnergy+fZNAEnergy+fZPAEnergy)/1000.);
629 fhmultFMDvsEzdc ->Fill(fMultFMDA+fMultFMDC, (fZNCEnergy+fZPCEnergy+fZNAEnergy+fZPAEnergy)/1000.);
630 fhNtracksvsEzem ->Fill(fNTracks, fZEM1Energy+fZEM2Energy);
631 fhNtrackletsvsEzem ->Fill(fNTracklets, fZEM1Energy+fZEM2Energy);
632 fhNclusters0vsEzem ->Fill(fNClusters[0], fZEM1Energy+fZEM2Energy);
633 fhmultV0vsEzem ->Fill(fMultV0A+fMultV0C, fZEM1Energy+fZEM2Energy);
634 fhmultFMDvsEzem ->Fill(fMultFMDA+fMultFMDC, fZEM1Energy+fZEM2Energy);
635 fhNtracksvsmultV0 ->Fill(fNTracks,fMultV0A+fMultV0C);
636 fhNtrackletsvsmultV0 ->Fill(fNTracklets,fMultV0A+fMultV0C);
637 fhNclusters0vsmultV0 ->Fill(fNClusters[0],fMultV0A+fMultV0C);
638 fhNtracksvsmultFMD ->Fill(fNTracks,fMultFMDA+fMultFMDC);
639 fhNtrackletsvsmultFMD->Fill(fNTracklets,fMultFMDA+fMultFMDC);
640 fhNclusters0vsmultFMD->Fill(fNClusters[0],fMultFMDA+fMultFMDC);
641 fhmultV0vsmultFMD ->Fill(fMultV0A+fMultV0C,fMultFMDA+fMultFMDC);
643 else if(fAnalysisInput.CompareTo("AOD")==0){
644 //AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
646 printf(" AOD analysis not yet implemented!!!\n\n");
649 PostData(1, fOutput);
652 //________________________________________________________________________
653 void AliAnalysisTaskCentrality::Terminate(Option_t */*option*/)
655 // Terminate analysis