PWGLF/FORWARD/GEO/AliAnalysisTaskZDCPbPb.cxx

   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
  58 ClassImp(AliAnalysisTaskZDCPbPb)
  59
  60
  61 //________________________________________________________________________
  62 AliAnalysisTaskZDCPbPb::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),
  74     fhZNvsZEMwV0M(0x0),
  75     fhZDCvsZEM(0x0),
  76     fhZDCvsZEMwV0M(0x0),
  77     fhZNvsVZERO(0x0),
  78     fhZDCvsVZERO(0x0),
  79     fhZDCvsTracklets(0x0),
  80     fhZDCvsNclu1(0x0),
  81     fhVZEROvsZEM(0x0),
  82     fhDebunch(0x0),
  83     fhZNCcentroid(0x0),
  84     fhZNAcentroid(0x0),
  85     fhAsymm(0x0),
  86     fhZNAvsAsymm(0x0),
  87     fhZNCvsAsymm(0x0),
  88     fhZNCvscentrality(0x0),
  89     fhZNAvscentrality(0x0),
  90     fhZPCvscentrality(0x0),
  91     fhZPAvscentrality(0x0)
  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;
 106    for(int i=0; i<6; i++){
 107      fhTDCraw[i] = 0x0;
 108      fhTDC[i] = 0x0;
 109    }
 110    for(int i=0; i<4; i++) fhPMCvsPMQ[i] = 0x0;
 111 }
 112
 113 //________________________________________________________________________
 114 AliAnalysisTaskZDCPbPb::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),
 126     fhZNvsZEMwV0M(0x0),
 127     fhZDCvsZEM(0x0),
 128     fhZDCvsZEMwV0M(0x0),
 129     fhZNvsVZERO(0x0),
 130     fhZDCvsVZERO(0x0),
 131     fhZDCvsTracklets(0x0),
 132     fhZDCvsNclu1(0x0),
 133     fhVZEROvsZEM(0x0),
 134     fhDebunch(0x0),
 135     fhZNCcentroid(0x0),
 136     fhZNAcentroid(0x0),
 137     fhAsymm(0x0),
 138     fhZNAvsAsymm(0x0),
 139     fhZNCvsAsymm(0x0),
 140     fhZNCvscentrality(0x0),
 141     fhZNAvscentrality(0x0),
 142     fhZPCvscentrality(0x0),
 143     fhZPAvscentrality(0x0)
 144
 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;
 158    for(int i=0; i<6; i++){
 159      fhTDCraw[i] = 0x0;
 160      fhTDC[i] = 0x0;
 161    }
 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 //________________________________________________________________________
 170 AliAnalysisTaskZDCPbPb& 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 //________________________________________________________________________
 182 AliAnalysisTaskZDCPbPb::AliAnalysisTaskZDCPbPb(const AliAnalysisTaskZDCPbPb& ana):
 183   AliAnalysisTaskSE(ana),
 184     fAnalysisInput(ana.fAnalysisInput),
 185     fIsMCInput(ana.fIsMCInput),
 186     fCentrLowLim(ana.fCentrLowLim),
 187     fCentrUpLim(ana.fCentrUpLim),
 188     fCentrEstimator(ana.fCentrEstimator),
 189     fOutput(ana.fOutput),
 190     fhZNCvsZNA(ana.fhZNCvsZNA),
 191     fhZPCvsZPA(ana.fhZPCvsZPA),
 192     fhZDCCvsZDCCA(ana.fhZDCCvsZDCCA),
 193     fhZNvsZEM(ana.fhZNvsZEM),
 194     fhZNvsZEMwV0M(ana.fhZNvsZEM),
 195     fhZDCvsZEM(ana.fhZDCvsZEM),
 196     fhZDCvsZEMwV0M(ana.fhZDCvsZEMwV0M),
 197     fhZNvsVZERO(ana.fhZNvsVZERO),
 198     fhZDCvsVZERO(ana.fhZDCvsVZERO),
 199     fhZDCvsTracklets(ana.fhZDCvsTracklets),
 200     fhZDCvsNclu1(ana.fhZDCvsNclu1),
 201     fhVZEROvsZEM(ana.fhVZEROvsZEM),
 202     fhDebunch(ana.fhDebunch),
 203     fhZNCcentroid(ana.fhZNCcentroid),
 204     fhZNAcentroid(ana.fhZNAcentroid),
 205     fhAsymm(ana.fhAsymm),
 206     fhZNAvsAsymm(ana.fhZNAvsAsymm),
 207     fhZNCvsAsymm(ana.fhZNCvsAsymm),
 208     fhZNCvscentrality(ana.fhZNCvscentrality),
 209     fhZNAvscentrality(ana.fhZNAvscentrality),
 210     fhZPCvscentrality(ana.fhZPCvscentrality),
 211     fhZPAvscentrality(ana.fhZPAvscentrality)
 212
 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];
 228    for(int i=0; i<6; i++){
 229      fhTDCraw[i] = ana.fhTDCraw[i];
 230      fhTDC[i] = ana.fhTDC[i];
 231    }
 232    for(int i=0; i<4; i++) fhPMCvsPMQ[i] = ana.fhPMCvsPMQ[i];
 233 }
 234
 235 //________________________________________________________________________
 236 AliAnalysisTaskZDCPbPb::~AliAnalysisTaskZDCPbPb()
 237 {
 238   // Destructor
 239   if(fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()){
 240     delete fOutput; fOutput=0;
 241   }
 242
 243 }
 244
 245 //________________________________________________________________________
 246 void 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.);
 291        fhTDCraw[i] = new TH1F("hTDCZEM1raw", "hTDCZEM1raw", 200, -200., 0.);
 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.);
 300        fhTDCraw[i] = new TH1F("hTDCZEM2raw", "hTDCZEM2raw", 200, -200., 0.);
 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){
 308        fhTDCraw[i] = new TH1F("hTDCZNCraw", "hTDCZNCraw", 200, -200., 0.);
 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){
 315        fhTDCraw[i] = new TH1F("hTDCZPCraw", "hTDCZPCraw", 200, -200., 0.);
 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      }
 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      }
 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);
 342   fhZNvsZEMwV0M = new TH2F("hZNvsZEMwV0M","hZNvsZEM wV0M",200,0.,2500.,200,0.,200000.);
 343   fOutput->Add(fhZNvsZEMwV0M);
 344   fhZDCvsZEM = new TH2F("hZDCvsZEM","hZDCvsZEM",200,0.,2500.,200,0.,200000.);
 345   fOutput->Add(fhZDCvsZEM);
 346   fhZDCvsZEMwV0M = new TH2F("hZDCvsZEMwV0M","hZDCvsZEM wV0M",200,0.,2500.,200,0.,200000.);
 347   fOutput->Add(fhZDCvsZEMwV0M);
 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);
 354   fhZDCvsNclu1 = new TH2F("hZDCvsNclu1", "hZDCvsNclu1", 100, 0.,6000.,100,0.,200000.);
 355   fOutput->Add(fhZDCvsNclu1);
 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
 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
 381   PostData(1, fOutput);
 382 }
 383
 384 //________________________________________________________________________
 385 void 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();
 435       //for(Int_t ilay=0; ilay<6; ilay++) fNClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
 436       Int_t nClusterslay1 = mult->GetNumberOfITSClusters(1);
 437
 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){
 455                for(int ich=8; ich<=13; ich++) fhTDCraw[ich-8]->Fill(esdZDC->GetZDCTDCData(ich, 0)-esdZDC->GetZDCTDCData(itdc, i));
 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];
 466       if(znc && zna){
 467          tdcSum = esdZDC->GetZNTDCSum(0);
 468          tdcDiff = esdZDC->GetZNTDCDiff(0);
 469          fhDebunch->Fill(tdcDiff, tdcSum);
 470       }
 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());
 476       Float_t energyZEM1 = (Float_t) (esdZDC->GetZEM1Energy()/8.);
 477       Float_t energyZEM2 = (Float_t) (esdZDC->GetZEM2Energy()/8.);
 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);
 538         fhZNvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNC+energyZNA, centrperc);
 539         fhZDCvsZEM->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC);
 540         fhZDCvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC, centrperc);
 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);
 544         fhZDCvsNclu1->Fill((Float_t) (nClusterslay1), energyZNA+energyZPA+energyZNC+energyZPC);
 545         fhVZEROvsZEM->Fill(energyZEM1+energyZEM2, multV0A+multV0C);
 546
 547         Double_t asymmetry = (energyZNC-energyZNA)/(energyZNC+energyZNA);
 548         fhAsymm->Fill(asymmetry);
 549         fhZNAvsAsymm->Fill(asymmetry, energyZNA/1000.);
 550         fhZNCvsAsymm->Fill(asymmetry, energyZNC/1000.);
 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
 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);
 654       fhZDCvsZEM->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC);
 655       fhZDCvsZEMwV0M->Fill(energyZEM1+energyZEM2, energyZNA+energyZPA+energyZNC+energyZPC, centrperc);
 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);
 662       fhAsymm->Fill(asymmetry);
 663       fhZNAvsAsymm->Fill(asymmetry, energyZNA/1000.);
 664       fhZNCvsAsymm->Fill(asymmetry, energyZNC/1000.);
 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.);
 670     //}
 671   }
 672
 673   PostData(1, fOutput);
 674
 675 }
 676
 677
 678
 679 //________________________________________________________________________
 680 void 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 }