ANALYSIS/AliCentralitySelectionTask.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 //   Class AliCentralitySelectionTask
  18 //   Class to analyze determine centrality
  19 //   author: Alberica Toia
  20 //*****************************************************
  21
  22 #include "AliCentralitySelectionTask.h"
  23
  24 #include <TTree.h>
  25 #include <TList.h>
  26 #include <TH1F.h>
  27 #include <TH2F.h>
  28 #include <TF1.h>
  29 #include <TProfile.h>
  30 #include <TFile.h>
  31 #include <TObjString.h>
  32 #include <TString.h>
  33 #include <TCanvas.h>
  34 #include <TROOT.h>
  35 #include <TDirectory.h>
  36 #include <TSystem.h>
  37 #include <iostream>
  38
  39 #include "AliAnalysisManager.h"
  40 #include "AliHeader.h"
  41 #include "AliVEvent.h"
  42 #include "AliESD.h"
  43 #include "AliESDEvent.h"
  44 #include "AliESDHeader.h"
  45 #include "AliESDInputHandler.h"
  46 #include "AliESDZDC.h"
  47 #include "AliESDFMD.h"
  48 #include "AliESDTZERO.h"
  49 #include "AliESDVZERO.h"
  50 #include "AliESDtrackCuts.h"
  51 #include "AliESDVertex.h"
  52 #include "AliCentrality.h"
  53 #include "AliOADBCentrality.h"
  54 #include "AliOADBContainer.h"
  55 #include "AliMultiplicity.h"
  56 #include "AliAODHandler.h"
  57 #include "AliAODHeader.h"
  58 #include "AliAODEvent.h"
  59 #include "AliAODVertex.h"
  60 #include "AliAODVZERO.h"
  61 #include "AliAODTracklets.h"
  62 #include "AliAODMCHeader.h"
  63 #include "AliMCEventHandler.h"
  64 #include "AliMCEvent.h"
  65 #include "AliAODMCParticle.h"
  66 #include "AliMCParticle.h"
  67 #include "AliStack.h"
  68 #include "AliAnalysisTaskSE.h"
  69 #include "AliGenEventHeader.h"
  70 #include "AliGenHijingEventHeader.h"
  71 #include "AliPhysicsSelectionTask.h"
  72 #include "AliPhysicsSelection.h"
  73 #include "AliBackgroundSelection.h"
  74 #include "AliESDUtils.h"
  75
  76 ClassImp(AliCentralitySelectionTask)
  77
  78
  79 //________________________________________________________________________
  80 AliCentralitySelectionTask::AliCentralitySelectionTask():
  81 AliAnalysisTaskSE(),
  82   fAnalysisInput("ESD"),
  83   fIsMCInput(kFALSE),
  84   fCurrentRun(-1),
  85   fUseScaling(0),
  86   fUseCleaning(0),
  87   fFillHistos(0),
  88   fV0MScaleFactor(0),
  89   fSPDScaleFactor(0),
  90   fTPCScaleFactor(0),
  91   fV0MScaleFactorMC(0),
  92   fV0MSPDOutlierPar0(0),
  93   fV0MSPDOutlierPar1(0),
  94   fV0MTPCOutlierPar0(0),
  95   fV0MTPCOutlierPar1(0),
  96   fV0MSPDSigmaOutlierPar0(0),
  97   fV0MSPDSigmaOutlierPar1(0),
  98   fV0MSPDSigmaOutlierPar2(0),
  99   fV0MTPCSigmaOutlierPar0(0),
 100   fV0MTPCSigmaOutlierPar1(0),
 101   fV0MTPCSigmaOutlierPar2(0),
 102   fV0MZDCOutlierPar0(0),
 103   fV0MZDCOutlierPar1(0),
 104   fV0MZDCEcalOutlierPar0(0),
 105   fV0MZDCEcalOutlierPar1(0),
 106   fTrackCuts(0),
 107   fZVCut(10),
 108   fOutliersCut(5),
 109   fQuality(999),
 110   fIsSelected(0),
 111   fMSL(0),
 112   fMSH(0),
 113   fMUL(0),
 114   fMLL(0),
 115   fEJE(0),
 116   fEGA(0),
 117   fPHS(0),
 118   fMB(0),
 119   fCVHN(0),
 120   fCVLN(0),
 121   fCVHNbit(0),
 122   fCVLNbit(0),
 123   fCCENT(0),
 124   fCSEMI(0),
 125   fCCENTbit(0),
 126   fCSEMIbit(0),
 127   fCentV0M(0),
 128   fCentV0A(0),
 129   fCentV0C(0),
 130   fCentFMD(0),
 131   fCentTRK(0),
 132   fCentTKL(0),
 133   fCentCL0(0),
 134   fCentCL1(0),
 135   fCentCND(0),
 136   fCentV0MvsFMD(0),
 137   fCentTKLvsV0M(0),
 138   fCentZEMvsZDC(0),
 139   fHtempV0M(0),
 140   fHtempV0A(0),
 141   fHtempV0C(0),
 142   fHtempFMD(0),
 143   fHtempTRK(0),
 144   fHtempTKL(0),
 145   fHtempCL0(0),
 146   fHtempCL1(0),
 147   fHtempCND(0),
 148   fHtempV0MvsFMD(0),
 149   fHtempTKLvsV0M(0),
 150   fHtempZEMvsZDC(0),
 151   fOutputList(0),
 152   fHOutCentV0M    (0),
 153   fHOutCentV0A    (0),
 154   fHOutCentV0C    (0),
 155   fHOutCentV0MCVHN(0),
 156   fHOutCentV0MCVLN(0),
 157   fHOutCentV0MCVHNinMB(0),
 158   fHOutCentV0MCVLNinMB(0),
 159   fHOutCentV0MCCENT(0),
 160   fHOutCentV0MCSEMI(0),
 161   fHOutCentV0MCCENTinMB(0),
 162   fHOutCentV0MCSEMIinMB(0),
 163   fHOutCentV0MMSL(0),
 164   fHOutCentV0MMSH(0),
 165   fHOutCentV0MMUL(0),
 166   fHOutCentV0MMLL(0),
 167   fHOutCentV0MEJE(0),
 168   fHOutCentV0MEGA(0),
 169   fHOutCentV0MPHS(0),
 170   fHOutCentV0MMSLinMB(0),
 171   fHOutCentV0MMSHinMB(0),
 172   fHOutCentV0MMULinMB(0),
 173   fHOutCentV0MMLLinMB(0),
 174   fHOutCentV0MEJEinMB(0),
 175   fHOutCentV0MEGAinMB(0),
 176   fHOutCentV0MPHSinMB(0),
 177   fHOutCentFMD     (0),
 178   fHOutCentTRK     (0),
 179   fHOutCentTKL     (0),
 180   fHOutCentCL0     (0),
 181   fHOutCentCL1     (0),
 182   fHOutCentCND     (0),
 183   fHOutCentV0MvsFMD(0),
 184   fHOutCentTKLvsV0M(0),
 185   fHOutCentZEMvsZDC(0),
 186   fHOutCentV0MvsCentCL1(0),
 187   fHOutCentV0MvsCentTRK(0),
 188   fHOutCentTRKvsCentCL1(0),
 189   fHOutCentV0MvsCentZDC(0),
 190   fHOutCentV0AvsCentV0C(0),
 191   fHOutCentV0AvsCentTRK(0),
 192   fHOutCentV0AvsCentCND(0),
 193   fHOutCentV0AvsCentCL1(0),
 194   fHOutCentV0CvsCentTRK(0),
 195   fHOutCentV0CvsCentCND(0),
 196   fHOutCentV0CvsCentCL1(0),
 197   fHOutMultV0AC(0),
 198   fHOutMultV0M(0),
 199   fHOutMultV0A(0),
 200   fHOutMultV0C(0),
 201   fHOutMultV0O(0),
 202   fHOutMultV0Cells(0),
 203   fHOutMultFMD(0),
 204   fHOutMultTRK(0),
 205   fHOutMultTKL(0),
 206   fHOutMultCL0(0),
 207   fHOutMultCL1(0),
 208   fHOutMultCND(0),
 209   fHOutMultV0MvsZDN(0),
 210   fHOutMultZEMvsZDN(0),
 211   fHOutMultV0MvsZDC(0),
 212   fHOutMultZEMvsZDC(0),
 213   fHOutMultZEMvsZDCw(0),
 214   fHOutMultV0MvsCL1(0),
 215   fHOutMultV0MvsTRK(0),
 216   fHOutMultTRKvsCL1(0),
 217   fHOutMultV0MvsV0O(0),
 218   fHOutMultV0OvsCL1(0),
 219   fHOutMultV0OvsTRK(0),
 220   fHOutMultCL1vsTKL(0),
 221   fHOutCentV0Mqual1(0),
 222   fHOutCentTRKqual1(0),
 223   fHOutCentCL1qual1(0),
 224   fHOutMultV0MvsCL1qual1(0),
 225   fHOutMultV0MvsTRKqual1(0),
 226   fHOutMultTRKvsCL1qual1(0),
 227   fHOutCentV0Mqual2(0),
 228   fHOutCentTRKqual2(0),
 229   fHOutCentCL1qual2(0),
 230   fHOutMultV0MvsCL1qual2(0),
 231   fHOutMultV0MvsTRKqual2(0),
 232   fHOutMultTRKvsCL1qual2(0),
 233   fHOutQuality(0),
 234   fHOutVertex(0),
 235   fHOutVertexT0(0)
 236 {
 237   // Default constructor
 238   AliInfo("Centrality Selection enabled.");
 239
 240   fUseScaling=kTRUE;
 241   fUseCleaning=kTRUE;
 242   fFillHistos=kFALSE;
 243   fBranchNames="ESD:AliESDRun.,AliESDHeader.,AliESDZDC.,AliESDFMD.,AliESDVZERO.,AliESDTZERO."
 244     ",SPDVertex.,TPCVertex.,PrimaryVertex.,AliMultiplicity.,Tracks ";
 245 }
 246
 247 //________________________________________________________________________
 248 AliCentralitySelectionTask::AliCentralitySelectionTask(const char *name):
 249   AliAnalysisTaskSE(name),
 250   fAnalysisInput("ESD"),
 251   fIsMCInput(kFALSE),
 252   fCurrentRun(-1),
 253   fUseScaling(0),
 254   fUseCleaning(0),
 255   fFillHistos(0),
 256   fV0MScaleFactor(0),
 257   fSPDScaleFactor(0),
 258   fTPCScaleFactor(0),
 259   fV0MScaleFactorMC(0),
 260   fV0MSPDOutlierPar0(0),
 261   fV0MSPDOutlierPar1(0),
 262   fV0MTPCOutlierPar0(0),
 263   fV0MTPCOutlierPar1(0),
 264   fV0MSPDSigmaOutlierPar0(0),
 265   fV0MSPDSigmaOutlierPar1(0),
 266   fV0MSPDSigmaOutlierPar2(0),
 267   fV0MTPCSigmaOutlierPar0(0),
 268   fV0MTPCSigmaOutlierPar1(0),
 269   fV0MTPCSigmaOutlierPar2(0),
 270   fV0MZDCOutlierPar0(0),
 271   fV0MZDCOutlierPar1(0),
 272   fV0MZDCEcalOutlierPar0(0),
 273   fV0MZDCEcalOutlierPar1(0),
 274   fTrackCuts(0),
 275   fZVCut(10),
 276   fOutliersCut(5),
 277   fQuality(999),
 278   fIsSelected(0),
 279   fMSL(0),
 280   fMSH(0),
 281   fMUL(0),
 282   fMLL(0),
 283   fEJE(0),
 284   fEGA(0),
 285   fPHS(0),
 286   fMB(0),
 287   fCVHN(0),
 288   fCVLN(0),
 289   fCVHNbit(0),
 290   fCVLNbit(0),
 291   fCCENT(0),
 292   fCSEMI(0),
 293   fCCENTbit(0),
 294   fCSEMIbit(0),
 295   fCentV0M(0),
 296   fCentV0A(0),
 297   fCentV0C(0),
 298   fCentFMD(0),
 299   fCentTRK(0),
 300   fCentTKL(0),
 301   fCentCL0(0),
 302   fCentCL1(0),
 303   fCentCND(0),
 304   fCentV0MvsFMD(0),
 305   fCentTKLvsV0M(0),
 306   fCentZEMvsZDC(0),
 307   fHtempV0M(0),
 308   fHtempV0A(0),
 309   fHtempV0C(0),
 310   fHtempFMD(0),
 311   fHtempTRK(0),
 312   fHtempTKL(0),
 313   fHtempCL0(0),
 314   fHtempCL1(0),
 315   fHtempCND(0),
 316   fHtempV0MvsFMD(0),
 317   fHtempTKLvsV0M(0),
 318   fHtempZEMvsZDC(0),
 319   fOutputList(0),
 320   fHOutCentV0M    (0),
 321   fHOutCentV0A    (0),
 322   fHOutCentV0C    (0),
 323   fHOutCentV0MCVHN(0),
 324   fHOutCentV0MCVLN(0),
 325   fHOutCentV0MCVHNinMB(0),
 326   fHOutCentV0MCVLNinMB(0),
 327   fHOutCentV0MCCENT(0),
 328   fHOutCentV0MCSEMI(0),
 329   fHOutCentV0MCCENTinMB(0),
 330   fHOutCentV0MCSEMIinMB(0),
 331   fHOutCentV0MMSL(0),
 332   fHOutCentV0MMSH(0),
 333   fHOutCentV0MMUL(0),
 334   fHOutCentV0MMLL(0),
 335   fHOutCentV0MEJE(0),
 336   fHOutCentV0MEGA(0),
 337   fHOutCentV0MPHS(0),
 338   fHOutCentV0MMSLinMB(0),
 339   fHOutCentV0MMSHinMB(0),
 340   fHOutCentV0MMULinMB(0),
 341   fHOutCentV0MMLLinMB(0),
 342   fHOutCentV0MEJEinMB(0),
 343   fHOutCentV0MEGAinMB(0),
 344   fHOutCentV0MPHSinMB(0),
 345   fHOutCentFMD     (0),
 346   fHOutCentTRK     (0),
 347   fHOutCentTKL     (0),
 348   fHOutCentCL0     (0),
 349   fHOutCentCL1     (0),
 350   fHOutCentCND     (0),
 351   fHOutCentV0MvsFMD(0),
 352   fHOutCentTKLvsV0M(0),
 353   fHOutCentZEMvsZDC(0),
 354   fHOutCentV0MvsCentCL1(0),
 355   fHOutCentV0MvsCentTRK(0),
 356   fHOutCentTRKvsCentCL1(0),
 357   fHOutCentV0MvsCentZDC(0),
 358   fHOutCentV0AvsCentV0C(0),
 359   fHOutCentV0AvsCentTRK(0),
 360   fHOutCentV0AvsCentCND(0),
 361   fHOutCentV0AvsCentCL1(0),
 362   fHOutCentV0CvsCentTRK(0),
 363   fHOutCentV0CvsCentCND(0),
 364   fHOutCentV0CvsCentCL1(0),
 365   fHOutMultV0AC(0),
 366   fHOutMultV0M(0),
 367   fHOutMultV0A(0),
 368   fHOutMultV0C(0),
 369   fHOutMultV0O(0),
 370   fHOutMultV0Cells(0),
 371   fHOutMultFMD(0),
 372   fHOutMultTRK(0),
 373   fHOutMultTKL(0),
 374   fHOutMultCL0(0),
 375   fHOutMultCL1(0),
 376   fHOutMultCND(0),
 377   fHOutMultV0MvsZDN(0),
 378   fHOutMultZEMvsZDN(0),
 379   fHOutMultV0MvsZDC(0),
 380   fHOutMultZEMvsZDC(0),
 381   fHOutMultZEMvsZDCw(0),
 382   fHOutMultV0MvsCL1(0),
 383   fHOutMultV0MvsTRK(0),
 384   fHOutMultTRKvsCL1(0),
 385   fHOutMultV0MvsV0O(0),
 386   fHOutMultV0OvsCL1(0),
 387   fHOutMultV0OvsTRK(0),
 388   fHOutMultCL1vsTKL(0),
 389   fHOutCentV0Mqual1(0),
 390   fHOutCentTRKqual1(0),
 391   fHOutCentCL1qual1(0),
 392   fHOutMultV0MvsCL1qual1(0),
 393   fHOutMultV0MvsTRKqual1(0),
 394   fHOutMultTRKvsCL1qual1(0),
 395   fHOutCentV0Mqual2(0),
 396   fHOutCentTRKqual2(0),
 397   fHOutCentCL1qual2(0),
 398   fHOutMultV0MvsCL1qual2(0),
 399   fHOutMultV0MvsTRKqual2(0),
 400   fHOutMultTRKvsCL1qual2(0),
 401   fHOutQuality(0),
 402   fHOutVertex(0),
 403   fHOutVertexT0(0)
 404 {
 405   // Default constructor
 406   AliInfo("Centrality Selection enabled.");
 407   //DefineOutput(1, TList::Class());
 408   fUseScaling=kTRUE;
 409   fUseCleaning=kTRUE;
 410   fFillHistos=kFALSE;
 411   fBranchNames="ESD:AliESDRun.,AliESDHeader.,AliESDZDC.,AliESDFMD.,AliESDVZERO.,AliESDTZERO."
 412     ",SPDVertex.,TPCVertex.,PrimaryVertex.,AliMultiplicity.,Tracks ";
 413 }
 414
 415 //________________________________________________________________________
 416 AliCentralitySelectionTask& AliCentralitySelectionTask::operator=(const AliCentralitySelectionTask& c)
 417 {
 418   // Assignment operator
 419   if (this!=&c) {
 420     AliAnalysisTaskSE::operator=(c);
 421   }
 422   return *this;
 423 }
 424
 425 //________________________________________________________________________
 426 AliCentralitySelectionTask::AliCentralitySelectionTask(const AliCentralitySelectionTask& ana):
 427   AliAnalysisTaskSE(ana),
 428   fAnalysisInput(ana.fAnalysisInput),
 429   fIsMCInput(ana.fIsMCInput),
 430   fCurrentRun(ana.fCurrentRun),
 431   fUseScaling(ana.fUseScaling),
 432   fUseCleaning(ana.fUseCleaning),
 433   fFillHistos(ana.fFillHistos),
 434   fV0MScaleFactor(ana.fV0MScaleFactor),
 435   fSPDScaleFactor(ana.fSPDScaleFactor),
 436   fTPCScaleFactor(ana.fTPCScaleFactor),
 437   fV0MScaleFactorMC(ana.fV0MScaleFactorMC),
 438   fV0MSPDOutlierPar0(ana.fV0MSPDOutlierPar0),
 439   fV0MSPDOutlierPar1(ana.fV0MSPDOutlierPar1),
 440   fV0MTPCOutlierPar0(ana.fV0MTPCOutlierPar0),
 441   fV0MTPCOutlierPar1(ana.fV0MTPCOutlierPar1),
 442   fV0MSPDSigmaOutlierPar0(ana.fV0MSPDSigmaOutlierPar0),
 443   fV0MSPDSigmaOutlierPar1(ana.fV0MSPDSigmaOutlierPar1),
 444   fV0MSPDSigmaOutlierPar2(ana.fV0MSPDSigmaOutlierPar2),
 445   fV0MTPCSigmaOutlierPar0(ana.fV0MTPCSigmaOutlierPar0),
 446   fV0MTPCSigmaOutlierPar1(ana.fV0MTPCSigmaOutlierPar1),
 447   fV0MTPCSigmaOutlierPar2(ana.fV0MTPCSigmaOutlierPar2),
 448   fV0MZDCOutlierPar0(ana.fV0MZDCOutlierPar0),
 449   fV0MZDCOutlierPar1(ana.fV0MZDCOutlierPar1),
 450   fV0MZDCEcalOutlierPar0(ana.fV0MZDCEcalOutlierPar0),
 451   fV0MZDCEcalOutlierPar1(ana.fV0MZDCEcalOutlierPar1),
 452   fTrackCuts(ana.fTrackCuts),
 453   fZVCut(ana.fZVCut),
 454   fOutliersCut(ana.fOutliersCut),
 455   fQuality(ana.fQuality),
 456   fIsSelected(ana.fIsSelected),
 457   fMSL(ana.fMSL),
 458   fMSH(ana.fMSH),
 459   fMUL(ana.fMUL),
 460   fMLL(ana.fMLL),
 461   fEJE(ana.fEJE),
 462   fEGA(ana.fEGA),
 463   fPHS(ana.fPHS),
 464   fMB(ana.fMB),
 465   fCVHN(ana.fCVHN),
 466   fCVLN(ana.fCVLN),
 467   fCVHNbit(ana.fCVHNbit),
 468   fCVLNbit(ana.fCVLNbit),
 469   fCCENT(ana.fCCENT),
 470   fCSEMI(ana.fCSEMI),
 471   fCCENTbit(ana.fCCENTbit),
 472   fCSEMIbit(ana.fCSEMIbit),
 473   fCentV0M(ana.fCentV0M),
 474   fCentV0A(ana.fCentV0A),
 475   fCentV0C(ana.fCentV0C),
 476   fCentFMD(ana.fCentFMD),
 477   fCentTRK(ana.fCentTRK),
 478   fCentTKL(ana.fCentTKL),
 479   fCentCL0(ana.fCentCL0),
 480   fCentCL1(ana.fCentCL1),
 481   fCentCND(ana.fCentCND),
 482   fCentV0MvsFMD(ana.fCentV0MvsFMD),
 483   fCentTKLvsV0M(ana.fCentTKLvsV0M),
 484   fCentZEMvsZDC(ana.fCentZEMvsZDC),
 485   fHtempV0M(ana.fHtempV0M),
 486   fHtempV0A(ana.fHtempV0A),
 487   fHtempV0C(ana.fHtempV0C),
 488   fHtempFMD(ana.fHtempFMD),
 489   fHtempTRK(ana.fHtempTRK),
 490   fHtempTKL(ana.fHtempTKL),
 491   fHtempCL0(ana.fHtempCL0),
 492   fHtempCL1(ana.fHtempCL1),
 493   fHtempCND(ana.fHtempCND),
 494   fHtempV0MvsFMD(ana.fHtempV0MvsFMD),
 495   fHtempTKLvsV0M(ana.fHtempTKLvsV0M),
 496   fHtempZEMvsZDC(ana.fHtempZEMvsZDC),
 497   fOutputList(ana.fOutputList),
 498   fHOutCentV0M    (ana.fHOutCentV0M    ),
 499   fHOutCentV0A    (ana.fHOutCentV0A    ),
 500   fHOutCentV0C    (ana.fHOutCentV0C    ),
 501   fHOutCentV0MCVHN(ana.fHOutCentV0MCVHN),
 502   fHOutCentV0MCVLN(ana.fHOutCentV0MCVLN),
 503   fHOutCentV0MCVHNinMB(ana.fHOutCentV0MCVHNinMB),
 504   fHOutCentV0MCVLNinMB(ana.fHOutCentV0MCVLNinMB),
 505   fHOutCentV0MCCENT(ana.fHOutCentV0MCCENT),
 506   fHOutCentV0MCSEMI(ana.fHOutCentV0MCSEMI),
 507   fHOutCentV0MCCENTinMB(ana.fHOutCentV0MCCENTinMB),
 508   fHOutCentV0MCSEMIinMB(ana.fHOutCentV0MCSEMIinMB),
 509   fHOutCentV0MMSL(ana.fHOutCentV0MMSL),
 510   fHOutCentV0MMSH(ana.fHOutCentV0MMSH),
 511   fHOutCentV0MMUL(ana.fHOutCentV0MMUL),
 512   fHOutCentV0MMLL(ana.fHOutCentV0MMLL),
 513   fHOutCentV0MEJE(ana.fHOutCentV0MEJE),
 514   fHOutCentV0MEGA(ana.fHOutCentV0MEGA),
 515   fHOutCentV0MPHS(ana.fHOutCentV0MPHS),
 516   fHOutCentV0MMSLinMB(ana.fHOutCentV0MMSLinMB),
 517   fHOutCentV0MMSHinMB(ana.fHOutCentV0MMSHinMB),
 518   fHOutCentV0MMULinMB(ana.fHOutCentV0MMULinMB),
 519   fHOutCentV0MMLLinMB(ana.fHOutCentV0MMLLinMB),
 520   fHOutCentV0MEJEinMB(ana.fHOutCentV0MEJEinMB),
 521   fHOutCentV0MEGAinMB(ana.fHOutCentV0MEGAinMB),
 522   fHOutCentV0MPHSinMB(ana.fHOutCentV0MPHSinMB),
 523   fHOutCentFMD     (ana.fHOutCentFMD     ),
 524   fHOutCentTRK     (ana.fHOutCentTRK     ),
 525   fHOutCentTKL     (ana.fHOutCentTKL     ),
 526   fHOutCentCL0     (ana.fHOutCentCL0     ),
 527   fHOutCentCL1     (ana.fHOutCentCL1     ),
 528   fHOutCentCND     (ana.fHOutCentCND     ),
 529   fHOutCentV0MvsFMD(ana.fHOutCentV0MvsFMD),
 530   fHOutCentTKLvsV0M(ana.fHOutCentTKLvsV0M),
 531   fHOutCentZEMvsZDC(ana.fHOutCentZEMvsZDC),
 532   fHOutCentV0MvsCentCL1(ana.fHOutCentV0MvsCentCL1),
 533   fHOutCentV0MvsCentTRK(ana.fHOutCentV0MvsCentTRK),
 534   fHOutCentTRKvsCentCL1(ana.fHOutCentTRKvsCentCL1),
 535   fHOutCentV0MvsCentZDC(ana.fHOutCentV0MvsCentZDC),
 536   fHOutCentV0AvsCentV0C(ana.fHOutCentV0AvsCentV0C),
 537   fHOutCentV0AvsCentTRK(ana.fHOutCentV0AvsCentTRK),
 538   fHOutCentV0AvsCentCND(ana.fHOutCentV0AvsCentCND),
 539   fHOutCentV0AvsCentCL1(ana.fHOutCentV0AvsCentCL1),
 540   fHOutCentV0CvsCentTRK(ana.fHOutCentV0CvsCentTRK),
 541   fHOutCentV0CvsCentCND(ana.fHOutCentV0CvsCentCND),
 542   fHOutCentV0CvsCentCL1(ana.fHOutCentV0CvsCentCL1),
 543   fHOutMultV0AC(ana.fHOutMultV0AC),
 544   fHOutMultV0M(ana.fHOutMultV0M),
 545   fHOutMultV0A(ana.fHOutMultV0A),
 546   fHOutMultV0C(ana.fHOutMultV0C),
 547   fHOutMultV0O(ana.fHOutMultV0O),
 548   fHOutMultV0Cells(ana.fHOutMultV0Cells),
 549   fHOutMultFMD(ana.fHOutMultFMD),
 550   fHOutMultTRK(ana.fHOutMultTRK),
 551   fHOutMultTKL(ana.fHOutMultTKL),
 552   fHOutMultCL0(ana.fHOutMultCL0),
 553   fHOutMultCL1(ana.fHOutMultCL1),
 554   fHOutMultCND(ana.fHOutMultCND),
 555   fHOutMultV0MvsZDN(ana.fHOutMultV0MvsZDN),
 556   fHOutMultZEMvsZDN(ana.fHOutMultZEMvsZDN),
 557   fHOutMultV0MvsZDC(ana.fHOutMultV0MvsZDC),
 558   fHOutMultZEMvsZDC(ana.fHOutMultZEMvsZDC),
 559   fHOutMultZEMvsZDCw(ana.fHOutMultZEMvsZDCw),
 560   fHOutMultV0MvsCL1(ana.fHOutMultV0MvsCL1),
 561   fHOutMultV0MvsTRK(ana.fHOutMultV0MvsTRK),
 562   fHOutMultTRKvsCL1(ana.fHOutMultTRKvsCL1),
 563   fHOutMultV0MvsV0O(ana.fHOutMultV0MvsV0O),
 564   fHOutMultV0OvsCL1(ana.fHOutMultV0OvsCL1),
 565   fHOutMultV0OvsTRK(ana.fHOutMultV0OvsTRK),
 566   fHOutMultCL1vsTKL(ana.fHOutMultCL1vsTKL),
 567   fHOutCentV0Mqual1(ana.fHOutCentV0Mqual1),
 568   fHOutCentTRKqual1(ana.fHOutCentTRKqual1),
 569   fHOutCentCL1qual1(ana.fHOutCentCL1qual1),
 570   fHOutMultV0MvsCL1qual1(ana.fHOutMultV0MvsCL1qual1),
 571   fHOutMultV0MvsTRKqual1(ana.fHOutMultV0MvsTRKqual1),
 572   fHOutMultTRKvsCL1qual1(ana.fHOutMultTRKvsCL1qual1),
 573   fHOutCentV0Mqual2(ana.fHOutCentV0Mqual2),
 574   fHOutCentTRKqual2(ana.fHOutCentTRKqual2),
 575   fHOutCentCL1qual2(ana.fHOutCentCL1qual2),
 576   fHOutMultV0MvsCL1qual2(ana.fHOutMultV0MvsCL1qual2),
 577   fHOutMultV0MvsTRKqual2(ana.fHOutMultV0MvsTRKqual2),
 578   fHOutMultTRKvsCL1qual2(ana.fHOutMultTRKvsCL1qual2),
 579   fHOutQuality(ana.fHOutQuality),
 580   fHOutVertex(ana.fHOutVertex),
 581   fHOutVertexT0(ana.fHOutVertexT0)
 582 {
 583   // Copy Constructor
 584
 585 }
 586
 587 //________________________________________________________________________
 588 AliCentralitySelectionTask::~AliCentralitySelectionTask()
 589 {
 590   // Destructor
 591   if (fOutputList && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) delete fOutputList;
 592   if (fTrackCuts) delete fTrackCuts;
 593 }
 594
 595 //________________________________________________________________________
 596 void AliCentralitySelectionTask::UserCreateOutputObjects()
 597 {
 598   // Create the output containers
 599   if(fDebug>1) printf("AnalysisCentralitySelectionTask::UserCreateOutputObjects() \n");
 600   AliLog::SetClassDebugLevel("AliCentralitySelectionTask", AliLog::kInfo);
 601
 602   if (fFillHistos) {
 603     fOutputList = new TList();
 604     fOutputList->SetOwner();
 605     fHOutCentV0M     = new TH1F("fHOutCentV0M","fHOutCentV0M; Centrality V0",505,0,101);
 606     fHOutCentV0A    = new TH1F("fHOutCentV0A","fHOutCentV0A; Centrality V0A",505,0,101);
 607     fHOutCentV0C    = new TH1F("fHOutCentV0C","fHOutCentV0C; Centrality V0C",505,0,101);
 608     fHOutCentV0MCVHN= new TH1F("fHOutCentV0M_CVHN","fHOutCentV0M_CVHN; Centrality V0",505,0,101);
 609     fHOutCentV0MCVLN= new TH1F("fHOutCentV0M_CVLN","fHOutCentV0M_CVLN; Centrality V0",505,0,101);
 610     fHOutCentV0MCVHNinMB= new TH1F("fHOutCentV0M_CVHNinMB","fHOutCentV0M_CVHN; Centrality V0",505,0,101);
 611     fHOutCentV0MCVLNinMB= new TH1F("fHOutCentV0M_CVLNinMB","fHOutCentV0M_CVLN; Centrality V0",505,0,101);
 612     fHOutCentV0MCCENT= new TH1F("fHOutCentV0M_CCENT","fHOutCentV0M_CCENT; Centrality V0",505,0,101);
 613     fHOutCentV0MCSEMI= new TH1F("fHOutCentV0M_CSEMI","fHOutCentV0M_CSEMI; Centrality V0",505,0,101);
 614     fHOutCentV0MCCENTinMB= new TH1F("fHOutCentV0M_CCENTinMB","fHOutCentV0M_CCENT; Centrality V0",505,0,101);
 615     fHOutCentV0MCSEMIinMB= new TH1F("fHOutCentV0M_CSEMIinMB","fHOutCentV0M_CSEMI; Centrality V0",505,0,101);
 616     fHOutCentV0MMSL= new TH1F("fHOutCentV0M_MSL","fHOutCentV0M_MSL; Centrality V0",505,0,101);
 617     fHOutCentV0MMSH= new TH1F("fHOutCentV0M_MSH","fHOutCentV0M_MSH; Centrality V0",505,0,101);
 618     fHOutCentV0MMUL= new TH1F("fHOutCentV0M_MUL","fHOutCentV0M_MUL; Centrality V0",505,0,101);
 619     fHOutCentV0MMLL= new TH1F("fHOutCentV0M_MLL","fHOutCentV0M_MLL; Centrality V0",505,0,101);
 620     fHOutCentV0MEJE= new TH1F("fHOutCentV0M_EJE","fHOutCentV0M_EJE; Centrality V0",505,0,101);
 621     fHOutCentV0MEGA= new TH1F("fHOutCentV0M_EGA","fHOutCentV0M_EGA; Centrality V0",505,0,101);
 622     fHOutCentV0MPHS= new TH1F("fHOutCentV0M_PHS","fHOutCentV0M_PHS; Centrality V0",505,0,101);
 623     fHOutCentV0MMSLinMB= new TH1F("fHOutCentV0M_MSLinMB","fHOutCentV0M_MSLinMB; Centrality V0",505,0,101);
 624     fHOutCentV0MMSHinMB= new TH1F("fHOutCentV0M_MSHinMB","fHOutCentV0M_MSHinMB; Centrality V0",505,0,101);
 625     fHOutCentV0MMULinMB= new TH1F("fHOutCentV0M_MULinMB","fHOutCentV0M_MULinMB; Centrality V0",505,0,101);
 626     fHOutCentV0MMLLinMB= new TH1F("fHOutCentV0M_MLLinMB","fHOutCentV0M_MLLinMB; Centrality V0",505,0,101);
 627     fHOutCentV0MEJEinMB= new TH1F("fHOutCentV0M_EJEinMB","fHOutCentV0M_EJEinMB; Centrality V0",505,0,101);
 628     fHOutCentV0MEGAinMB= new TH1F("fHOutCentV0M_EGAinMB","fHOutCentV0M_EGAinMB; Centrality V0",505,0,101);
 629     fHOutCentV0MPHSinMB= new TH1F("fHOutCentV0M_PHSinMB","fHOutCentV0M_PHSinMB; Centrality V0",505,0,101);
 630     fHOutCentFMD     = new TH1F("fHOutCentFMD","fHOutCentFMD; Centrality FMD",505,0,101);
 631     fHOutCentTRK     = new TH1F("fHOutCentTRK","fHOutCentTRK; Centrality TPC",505,0,101);
 632     fHOutCentTKL     = new TH1F("fHOutCentTKL","fHOutCentTKL; Centrality tracklets",505,0,101);
 633     fHOutCentCL0     = new TH1F("fHOutCentCL0","fHOutCentCL0; Centrality SPD inner",505,0,101);
 634     fHOutCentCL1     = new TH1F("fHOutCentCL1","fHOutCentCL1; Centrality SPD outer",505,0,101);
 635     fHOutCentCND     = new TH1F("fHOutCentCND","fHOutCentCND; Centrality candle",505,0,101);
 636     fHOutCentV0MvsFMD= new TH1F("fHOutCentV0MvsFMD","fHOutCentV0MvsFMD; Centrality V0 vs FMD",505,0,101);
 637     fHOutCentTKLvsV0M= new TH1F("fHOutCentTKLvsV0M","fHOutCentTKLvsV0M; Centrality tracklets vs V0",505,0,101);
 638     fHOutCentZEMvsZDC= new TH1F("fHOutCentZEMvsZDC","fHOutCentZEMvsZDC; Centrality ZEM vs ZDC",505,0,101);
 639     fHOutCentV0MvsCentCL1= new TH2F("fHOutCentV0MvsCentCL1","fHOutCentV0MvsCentCL1; Cent V0; Cent SPD",505,0,101,505,0,101);
 640     fHOutCentV0MvsCentTRK= new TH2F("fHOutCentV0MvsCentTRK","fHOutCentV0MvsCentTRK; Cent V0; Cent TPC",505,0,101,505,0,101);
 641     fHOutCentTRKvsCentCL1= new TH2F("fHOutCentTRKvsCentCL1","fHOutCentTRKvsCentCL1; Cent TPC; Cent SPD",505,0,101,505,0,101);
 642     fHOutCentV0MvsCentZDC= new TH2F("fHOutCentV0MvsCentZDC","fHOutCentV0MvsCentZDC; Cent V0; Cent ZDC",505,0,101,505,0,101);
 643     fHOutCentV0AvsCentV0C= new TH2F("fHOutCentV0AvsCentV0C","fHOutCentV0AvsCentV0C; Cent V0A; Cent V0C;", 505,0,101,505,0,101);
 644     fHOutCentV0AvsCentTRK= new TH2F("fHOutCentV0AvsCentTRK","fHOutCentV0AvsCentTRK; Cent V0A; Cent TRK;", 505,0,101,505,0,101);
 645     fHOutCentV0AvsCentCND= new TH2F("fHOutCentV0AvsCentCND","fHOutCentV0AvsCentCND; Cent V0A; Cent CND;", 505,0,101,505,0,101);
 646     fHOutCentV0AvsCentCL1= new TH2F("fHOutCentV0AvsCentCL1","fHOutCentV0AvsCentCL1; Cent V0A; Cent CL1;", 505,0,101,505,0,101);
 647     fHOutCentV0CvsCentTRK= new TH2F("fHOutCentV0CvsCentTRK","fHOutCentV0CvsCentTRK; Cent V0C; Cent TRK;", 505,0,101,505,0,101);
 648     fHOutCentV0CvsCentCND= new TH2F("fHOutCentV0CvsCentCND","fHOutCentV0CvsCentCND; Cent V0C; Cent CND;", 505,0,101,505,0,101);
 649     fHOutCentV0CvsCentCL1= new TH2F("fHOutCentV0CvsCentCL1","fHOutCentV0CvsCentCL1; Cent V0C; Cent CL1;", 505,0,101,505,0,101);
 650
 651     fHOutMultV0AC = new TH2F("fHOutMultV0AC","fHOutMultV0AC; Multiplicity V0A; Multiplicity V0C",1000,0,1000,1000,0,1000);
 652     fHOutMultV0M  = new TH1F("fHOutMultV0M","fHOutMultV0M; Multiplicity V0",25000,0,25000);
 653     fHOutMultV0A  = new TH1F("fHOutMultV0A","fHOutMultV0A; Multiplicity V0",25000,0,25000);
 654     fHOutMultV0C  = new TH1F("fHOutMultV0C","fHOutMultV0C; Multiplicity V0",25000,0,25000);
 655     fHOutMultV0O  = new TH1F("fHOutMultV0O","fHOutMultV0O; Multiplicity V0",40000,0,40000);
 656     fHOutMultV0Cells = new TH2F("fHOutMultV0Cells","fHOutMultV0Cells",33,-0.5,32.5,33,-0.5,32.5);
 657     fHOutMultFMD = new TH1F("fHOutMultFMD","fHOutMultFMD; Multiplicity FMD",24000,0,24000);
 658     fHOutMultTRK = new TH1F("fHOutMultTRK","fHOutMultTRK; Multiplicity TPC",4000,0,4000);
 659     fHOutMultTKL = new TH1F("fHOutMultTKL","fHOutMultTKL; Multiplicity tracklets",5000,0,5000);
 660     fHOutMultCL0 = new TH1F("fHOutMultCL0","fHOutMultCL0; Multiplicity SPD inner",7000,0,7000);
 661     fHOutMultCL1 = new TH1F("fHOutMultCL1","fHOutMultCL1; Multiplicity SPD outer",7000,0,7000);
 662     fHOutMultCND = new TH1F("fHOutMultCND","fHOutMultCND; Multiplicity candle",4000,0,4000);
 663
 664     fHOutMultV0MvsZDN = new TH2F("fHOutMultV0MvsZDN","fHOutMultV0MvsZDN; Multiplicity V0; Energy ZDC-N",500,0,30000,500,0,180000);
 665     fHOutMultZEMvsZDN = new TH2F("fHOutMultZEMvsZDN","fHOutMultZEMvsZDN; Energy ZEM; Energy ZDC-N",500,0,2500,500,0,180000);
 666     fHOutMultV0MvsZDC = new TH2F("fHOutMultV0MvsZDC","fHOutMultV0MvsZDC; Multiplicity V0; Energy ZDC",500,0,30000,500,0,200000);
 667     fHOutMultZEMvsZDC = new TH2F("fHOutMultZEMvsZDC","fHOutMultZEMvsZDC; Energy ZEM; Energy ZDC",500,0,2500,500,0,200000);
 668     fHOutMultZEMvsZDCw = new TH2F("fHOutMultZEMvsZDCw","fHOutMultZEMvsZDCw; Energy ZEM; Energy ZDC (weigthed with V0 percentile)",500,0,2500,500,0,200000);
 669     fHOutMultV0MvsCL1 = new TH2F("fHOutMultV0MvsCL1","fHOutMultV0MvsCL1; Multiplicity V0; Multiplicity SPD outer",2500,0,30000,700,0,7000);
 670     fHOutMultV0MvsTRK = new TH2F("fHOutMultV0MvsTRK","fHOutMultV0MvsTRK; Multiplicity V0; Multiplicity TPC",2500,0,30000,400,0,4000);
 671     fHOutMultTRKvsCL1 = new TH2F("fHOutMultTRKvsCL1","fHOutMultTRKvsCL1; Multiplicity TPC; Multiplicity SPD outer",400,0,4000,700,0,7000);
 672     fHOutMultV0MvsV0O = new TH2F("fHOutMultV0MvsV0O","fHOutMultV0MvsV0O; Multiplicity V0; Multiplicity V0 Online",500,0,30000,500,0,40000);
 673     fHOutMultV0OvsCL1 = new TH2F("fHOutMultV0OvsCL1","fHOutMultV0OvsCL1; Multiplicity V0; Multiplicity SPD outer",500,0,40000,700,0,7000);
 674     fHOutMultV0OvsTRK = new TH2F("fHOutMultV0OvsTRK","fHOutMultV0OvsTRK; Multiplicity V0; Multiplicity TPC",500,0,40000,400,0,4000);
 675     fHOutMultV0MvsV0O = new TH2F("fHOutMultV0MvsV0O","fHOutMultV0MvsV0O; Multiplicity V0; Multiplicity V0 Online",500,0,30000,500,0,30000);
 676     fHOutMultV0OvsCL1 = new TH2F("fHOutMultV0OvsCL1","fHOutMultV0OvsCL1; Multiplicity V0; Multiplicity SPD outer",2500,0,30000,700,0,7000);
 677     fHOutMultV0OvsTRK = new TH2F("fHOutMultV0OvsTRK","fHOutMultV0OvsTRK; Multiplicity V0; Multiplicity TPC",2500,0,30000,400,0,4000);
 678     fHOutMultCL1vsTKL = new TH2F ("fHOutMultCL1vsTKL","fHOutMultCL1vsTKL; Multiplicity SPD outer; Multiplicity tracklets",700,0,7000,700,0,7000);
 679
 680     fHOutCentV0Mqual1 = new TH1F("fHOutCentV0M_qual1","fHOutCentV0M_qual1; Centrality V0",505,0,101);
 681     fHOutCentTRKqual1 = new TH1F("fHOutCentTRK_qual1","fHOutCentTRK_qual1; Centrality TPC",505,0,101);
 682     fHOutCentCL1qual1 = new TH1F("fHOutCentCL1_qual1","fHOutCentCL1_qual1; Centrality SPD outer",505,0,101);
 683     fHOutMultV0MvsCL1qual1 = new TH2F("fHOutMultV0MvsCL1_qual1","fHOutMultV0MvsCL1_qual1; Multiplicity V0; Multiplicity SPD outer",2500,0,25000,700,0,7000);
 684     fHOutMultV0MvsTRKqual1 = new TH2F("fHOutMultV0MvsTRK_qual1","fHOutMultV0MvsTRK_qual1; Multiplicity V0; Multiplicity TPC",2500,0,25000,400,0,4000);
 685     fHOutMultTRKvsCL1qual1 = new TH2F("fHOutMultTRKvsCL1_qual1","fHOutMultTRKvsCL1_qual1; Multiplicity TPC; Multiplicity SPD outer",400,0,4000,700,0,7000);
 686
 687     fHOutCentV0Mqual2 = new TH1F("fHOutCentV0M_qual2","fHOutCentV0M_qual2; Centrality V0",505,0,101);
 688     fHOutCentTRKqual2 = new TH1F("fHOutCentTRK_qual2","fHOutCentTRK_qual2; Centrality TPC",505,0,101);
 689     fHOutCentCL1qual2 = new TH1F("fHOutCentCL1_qual2","fHOutCentCL1_qual2; Centrality SPD outer",505,0,101);
 690     fHOutMultV0MvsCL1qual2 = new TH2F("fHOutMultV0MvsCL1_qual2","fHOutMultV0MvsCL1_qual2; Multiplicity V0; Multiplicity SPD outer",2500,0,25000,700,0,7000);
 691     fHOutMultV0MvsTRKqual2 = new TH2F("fHOutMultV0MvsTRK_qual2","fHOutMultV0MvsTRK_qual2; Multiplicity V0; Multiplicity TPC",2500,0,25000,400,0,4000);
 692     fHOutMultTRKvsCL1qual2 = new TH2F("fHOutMultTRKvsCL1_qual2","fHOutMultTRKvsCL1_qual2; Multiplicity TPC; Multiplicity SPD outer",400,0,4000,700,0,7000);
 693
 694     fHOutQuality = new TH1F("fHOutQuality", "fHOutQuality", 100,-0.5,99.5);
 695     fHOutVertex  = new TH1F("fHOutVertex", "fHOutVertex", 100,-20,20);
 696     fHOutVertexT0  = new TH1F("fHOutVertexT0", "fHOutVertexT0", 100,-20,20);
 697
 698     fOutputList->Add(  fHOutCentV0M    );
 699     fOutputList->Add(  fHOutCentV0A    );
 700     fOutputList->Add(  fHOutCentV0C    );
 701     fOutputList->Add(  fHOutCentV0MCVHN);
 702     fOutputList->Add(  fHOutCentV0MCVLN);
 703     fOutputList->Add(  fHOutCentV0MCVHNinMB);
 704     fOutputList->Add(  fHOutCentV0MCVLNinMB);
 705     fOutputList->Add(  fHOutCentV0MCCENT);
 706     fOutputList->Add(  fHOutCentV0MCSEMI);
 707     fOutputList->Add(  fHOutCentV0MCCENTinMB);
 708     fOutputList->Add(  fHOutCentV0MCSEMIinMB);
 709     fOutputList->Add(  fHOutCentV0MMSL    );
 710     fOutputList->Add(  fHOutCentV0MMSH    );
 711     fOutputList->Add(  fHOutCentV0MMUL    );
 712     fOutputList->Add(  fHOutCentV0MMLL    );
 713     fOutputList->Add(  fHOutCentV0MEJE    );
 714     fOutputList->Add(  fHOutCentV0MEGA    );
 715     fOutputList->Add(  fHOutCentV0MPHS   );
 716     fOutputList->Add(  fHOutCentV0MMSLinMB);
 717     fOutputList->Add(  fHOutCentV0MMSHinMB);
 718     fOutputList->Add(  fHOutCentV0MMULinMB);
 719     fOutputList->Add(  fHOutCentV0MMLLinMB);
 720     fOutputList->Add(  fHOutCentV0MEJEinMB);
 721     fOutputList->Add(  fHOutCentV0MEGAinMB);
 722     fOutputList->Add(  fHOutCentV0MPHSinMB);
 723     fOutputList->Add(  fHOutCentFMD     );
 724     fOutputList->Add(  fHOutCentTRK     );
 725     fOutputList->Add(  fHOutCentTKL     );
 726     fOutputList->Add(  fHOutCentCL0     );
 727     fOutputList->Add(  fHOutCentCL1     );
 728     fOutputList->Add(  fHOutCentCND     );
 729     fOutputList->Add(  fHOutCentV0MvsFMD);
 730     fOutputList->Add(  fHOutCentTKLvsV0M);
 731     fOutputList->Add(  fHOutCentZEMvsZDC);
 732     fOutputList->Add(  fHOutCentV0MvsCentCL1);
 733     fOutputList->Add(  fHOutCentV0MvsCentTRK);
 734     fOutputList->Add(  fHOutCentTRKvsCentCL1);
 735     fOutputList->Add(  fHOutCentV0MvsCentZDC);
 736     fOutputList->Add(  fHOutCentV0AvsCentV0C);
 737     fOutputList->Add(  fHOutCentV0AvsCentTRK);
 738     fOutputList->Add(  fHOutCentV0AvsCentCND);
 739     fOutputList->Add(  fHOutCentV0AvsCentCL1);
 740     fOutputList->Add(  fHOutCentV0CvsCentTRK);
 741     fOutputList->Add(  fHOutCentV0CvsCentCND);
 742     fOutputList->Add(  fHOutCentV0CvsCentCL1);
 743     fOutputList->Add(  fHOutMultV0AC);
 744     fOutputList->Add(  fHOutMultV0M);
 745     fOutputList->Add(  fHOutMultV0A);
 746     fOutputList->Add(  fHOutMultV0C);
 747     fOutputList->Add(  fHOutMultV0O);
 748     fOutputList->Add(  fHOutMultV0Cells) ;
 749     fOutputList->Add(  fHOutMultFMD);
 750     fOutputList->Add(  fHOutMultTRK);
 751     fOutputList->Add(  fHOutMultTKL);
 752     fOutputList->Add(  fHOutMultCL0);
 753     fOutputList->Add(  fHOutMultCL1);
 754     fOutputList->Add(  fHOutMultCND);
 755     fOutputList->Add(  fHOutMultV0MvsZDN);
 756     fOutputList->Add(  fHOutMultZEMvsZDN);
 757     fOutputList->Add(  fHOutMultV0MvsZDC);
 758     fOutputList->Add(  fHOutMultZEMvsZDC);
 759     fOutputList->Add(  fHOutMultZEMvsZDCw);
 760     fOutputList->Add(  fHOutMultV0MvsCL1);
 761     fOutputList->Add(  fHOutMultV0MvsTRK);
 762     fOutputList->Add(  fHOutMultTRKvsCL1);
 763     fOutputList->Add(  fHOutMultV0MvsV0O);
 764     fOutputList->Add(  fHOutMultV0OvsCL1);
 765     fOutputList->Add(  fHOutMultV0OvsTRK);
 766     fOutputList->Add(  fHOutMultCL1vsTKL);
 767     fOutputList->Add(  fHOutCentV0Mqual1 );
 768     fOutputList->Add(  fHOutCentTRKqual1 );
 769     fOutputList->Add(  fHOutCentCL1qual1 );
 770     fOutputList->Add(  fHOutMultV0MvsCL1qual1);
 771     fOutputList->Add(  fHOutMultV0MvsTRKqual1);
 772     fOutputList->Add(  fHOutMultTRKvsCL1qual1);
 773     fOutputList->Add(  fHOutCentV0Mqual2 );
 774     fOutputList->Add(  fHOutCentTRKqual2 );
 775     fOutputList->Add(  fHOutCentCL1qual2 );
 776     fOutputList->Add(  fHOutMultV0MvsCL1qual2);
 777     fOutputList->Add(  fHOutMultV0MvsTRKqual2);
 778     fOutputList->Add(  fHOutMultTRKvsCL1qual2);
 779     fOutputList->Add(  fHOutQuality );
 780     fOutputList->Add(  fHOutVertex );
 781     fOutputList->Add(  fHOutVertexT0 );
 782
 783     PostData(1, fOutputList);
 784   }
 785
 786   fTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
 787 }
 788
 789 //________________________________________________________________________
 790 void AliCentralitySelectionTask::UserExec(Option_t */*option*/)
 791 {
 792   // Execute analysis for current event:
 793   if(fDebug>1) printf(" **** AliCentralitySelectionTask::UserExec() \n");
 794
 795   Float_t  zncEnergy = 0.;          //  ZNC Energy
 796   Float_t  zpcEnergy = 0.;          //  ZPC Energy
 797   Float_t  znaEnergy = 0.;          //  ZNA Energy
 798   Float_t  zpaEnergy = 0.;          //  ZPA Energy
 799   Float_t  zem1Energy = 0.;         //  ZEM1 Energy
 800   Float_t  zem2Energy = 0.;         //  ZEM2 Energy
 801   Bool_t   zdcEnergyCal = kFALSE;   // if zdc is calibrated (in pass2)
 802
 803   Int_t    nTracks = 0;             //  no. tracks
 804   Int_t    nTracklets = 0;          //  no. tracklets
 805   Int_t    nClusters[6] = {0};      //  no. clusters on 6 ITS layers
 806   Int_t    nChips[2];               //  no. chips on 2 SPD layers
 807   Float_t  spdCorr =0;              //  corrected spd2 multiplicity
 808   Int_t    multCND = 0;             //  no. tracks (candle condition)
 809
 810   Float_t  multV0A  = 0;            //  multiplicity from V0 reco side A
 811   Float_t  multV0C  = 0;            //  multiplicity from V0 reco side C
 812   Short_t  multV0AOnline  = 0;      //  multiplicity from V0 reco side A
 813   Short_t  multV0COnline  = 0;      //  multiplicity from V0 reco side C
 814   Float_t  v0Corr = 0;               // corrected V0 multiplicity (used for MC)
 815   Int_t nV0A = 0;
 816   Int_t nV0C = 0;
 817
 818   Float_t  multFMDA = 0;            //  multiplicity from FMD on detector A
 819   Float_t  multFMDC = 0;            //  multiplicity from FMD on detector C
 820
 821   Float_t zvtx =0;                  // z-vertex SPD
 822   Int_t zvtxNcont =0;               // contributors to z-vertex SPD
 823
 824   Float_t zvtxT0 =0;                // z-vertex T0
 825
 826
 827   AliCentrality *esdCent = 0;
 828
 829   if(fAnalysisInput.CompareTo("ESD")==0){
 830
 831     AliVEvent* event = InputEvent();
 832     AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
 833     if (!esd) {
 834       AliError("No ESD Event");
 835       return;
 836     }
 837
 838     LoadBranches();
 839
 840     if (SetupRun(esd)<0) {
 841       AliError("Centrality File not available for this run");
 842       return;
 843     }
 844
 845     esdCent = esd->GetCentrality();
 846
 847     // ***** V0 info
 848     AliESDVZERO* esdV0 = esd->GetVZEROData();
 849     if (!esdV0)
 850       {
 851         AliError("AliESDVZERO not available");
 852         return;
 853       }
 854     multV0A=esdV0->GetMTotV0A();
 855     multV0C=esdV0->GetMTotV0C();
 856     v0Corr = multV0A+multV0C;
 857
 858     multV0AOnline=esdV0->GetTriggerChargeA();
 859     multV0COnline=esdV0->GetTriggerChargeC();
 860
 861     // Count V0 flags
 862     for(Int_t i = 0; i < 32; ++i) {
 863       if (esdV0->GetBBFlag(i)) nV0C++;
 864       if (esdV0->GetBBFlag(i+32)) nV0A++;
 865     }
 866
 867     // ***** T0 info
 868     const AliESDTZERO* esdT0 = esd->GetESDTZERO();
 869     if (!esdT0)
 870       {
 871         AliError("AliESDTZERO not available");
 872         return;
 873       }
 874     Int_t trig=esdT0->GetT0Trig();
 875     Bool_t kT0BB = kFALSE;
 876     if(trig&1) kT0BB=kTRUE;
 877     zvtxT0=esdT0->GetT0zVertex();
 878
 879
 880     // ***** Trigger info
 881     fIsSelected = ((esdV0->GetV0ADecision()==1) && (esdV0->GetV0CDecision()==1));
 882     TString trigStr(esd->GetFiredTriggerClasses());
 883
 884     fMB=kFALSE;
 885     fCVHN=kFALSE; fCVLN=kFALSE; fCCENT=kFALSE; fCSEMI=kFALSE;
 886     fMSL=kFALSE;  fMSH=kFALSE;  fMUL=kFALSE;   fMLL=kFALSE;
 887     fEJE=kFALSE;  fEGA=kFALSE;  fPHS=kFALSE;
 888
 889     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CPBI")) && (fIsSelected))
 890       fMB=kTRUE;
 891     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CVHN")) && (fIsSelected))
 892       fCVHN=kTRUE;
 893     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CVLN")) && (fIsSelected))
 894       fCVLN=kTRUE;
 895     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CCENT")) && (fIsSelected))
 896       fCCENT=kTRUE;
 897     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CSEMI")) && (fIsSelected))
 898       fCSEMI=kTRUE;
 899
 900     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CPBI1MSL")) && (fIsSelected))
 901       fMSL=kTRUE;
 902     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CPBI1MSH")) && (fIsSelected))
 903       fMSH=kTRUE;
 904     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CPBI1MUL")) && (fIsSelected))
 905       fMUL=kTRUE;
 906     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CPBI1MLL")) && (fIsSelected))
 907       fMLL=kTRUE;
 908     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CPBI1EJE")) && (fIsSelected))
 909       fEJE=kTRUE;
 910     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CPBI1EGA")) && (fIsSelected))
 911       fEGA=kTRUE;
 912     if ( (trigStr.Contains("-B-")) &&  (trigStr.Contains("CPBI1PHS")) && (fIsSelected))
 913       fPHS=kTRUE;
 914
 915     fCVHNbit=kFALSE;    fCVLNbit=kFALSE;       fCCENTbit=kFALSE;    fCSEMIbit=kFALSE;
 916     if (esdV0->GetTriggerBits() & (1<<8))
 917       fCVHNbit=kTRUE;
 918     if (esdV0->GetTriggerBits() & (1<<6))
 919       fCVLNbit=kTRUE;
 920
 921     if (kT0BB && fCVHNbit)
 922       fCCENTbit=kTRUE;
 923     if (kT0BB && fCVLNbit)
 924       fCSEMIbit=kTRUE;
 925
 926
 927     // ***** Vertex Info
 928     const AliESDVertex* vtxESD = esd->GetPrimaryVertexSPD();
 929     zvtx        = vtxESD->GetZ();
 930     zvtxNcont   = vtxESD->GetNContributors();
 931
 932     // ***** CB info (tracklets, clusters, chips)
 933     //nTracks    = event->GetNumberOfTracks();
 934     nTracks    = fTrackCuts ? (Short_t)fTrackCuts->GetReferenceMultiplicity(esd,kTRUE):-1;
 935     Short_t nTrTPCcandle = 0;
 936     for (Int_t iTracks = 0; iTracks < esd->GetNumberOfTracks(); iTracks++) {
 937       AliESDtrack* track = esd->GetTrack(iTracks);
 938       if (!track) continue;
 939       if (track->Pt() > 0.5 && TMath::Abs(track->Eta()) < 0.8)  nTrTPCcandle++;
 940     }
 941     multCND = nTrTPCcandle;
 942
 943     const AliMultiplicity *mult = esd->GetMultiplicity();
 944     nTracklets = mult->GetNumberOfTracklets();
 945
 946     for(Int_t ilay=0; ilay<6; ilay++){
 947       nClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
 948     }
 949
 950     for(Int_t ilay=0; ilay<2; ilay++){
 951       nChips[ilay] = mult->GetNumberOfFiredChips(ilay);
 952     }
 953
 954     spdCorr = AliESDUtils::GetCorrSPD2(nClusters[1],zvtx);
 955
 956     // ***** FMD info
 957     AliESDFMD *fmd = esd->GetFMDData();
 958     Float_t totalMultA = 0;
 959     Float_t totalMultC = 0;
 960     const Float_t fFMDLowCut = 0.4;
 961
 962     for(UShort_t det=1;det<=3;det++) {
 963       Int_t nRings = (det==1 ? 1 : 2);
 964       for (UShort_t ir = 0; ir < nRings; ir++) {
 965         Char_t   ring = (ir == 0 ? 'I' : 'O');
 966         UShort_t nsec = (ir == 0 ? 20  : 40);
 967         UShort_t nstr = (ir == 0 ? 512 : 256);
 968         for(UShort_t sec =0; sec < nsec;  sec++)  {
 969           for(UShort_t strip = 0; strip < nstr; strip++) {
 970
 971             Float_t fmdMult = fmd->Multiplicity(det,ring,sec,strip);
 972             if(fmdMult == 0 || fmdMult == AliESDFMD::kInvalidMult) continue;
 973
 974             Float_t nParticles=0;
 975
 976             if(fmdMult > fFMDLowCut) {
 977               nParticles = 1.;
 978             }
 979
 980             if (det<3) totalMultA = totalMultA + nParticles;
 981             else totalMultC = totalMultC + nParticles;
 982
 983           }
 984         }
 985       }
 986     }
 987     multFMDA = totalMultA;
 988     multFMDC = totalMultC;
 989
 990     // ***** ZDC info
 991     AliESDZDC *esdZDC = esd->GetESDZDC();
 992     zdcEnergyCal = esdZDC->AliESDZDC::TestBit(AliESDZDC::kEnergyCalibratedSignal);
 993     if (zdcEnergyCal) {
 994       zncEnergy = (Float_t) (esdZDC->GetZDCN1Energy());
 995       zpcEnergy = (Float_t) (esdZDC->GetZDCP1Energy());
 996       znaEnergy = (Float_t) (esdZDC->GetZDCN2Energy());
 997       zpaEnergy = (Float_t) (esdZDC->GetZDCP2Energy());
 998     } else {
 999       zncEnergy = (Float_t) (esdZDC->GetZDCN1Energy())/8.;
1000       zpcEnergy = (Float_t) (esdZDC->GetZDCP1Energy())/8.;
1001       znaEnergy = (Float_t) (esdZDC->GetZDCN2Energy())/8.;
1002       zpaEnergy = (Float_t) (esdZDC->GetZDCP2Energy())/8.;
1003     }
1004     zem1Energy = (Float_t) (esdZDC->GetZDCEMEnergy(0))/8.;
1005     zem2Energy = (Float_t) (esdZDC->GetZDCEMEnergy(1))/8.;
1006
1007   }
1008
1009   else if(fAnalysisInput.CompareTo("AOD")==0){
1010     //AliAODEvent *aod =  dynamic_cast<AliAODEvent*> (InputEvent());
1011     // to be implemented
1012     printf("  AOD analysis not yet implemented!!!\n\n");
1013     return;
1014   }
1015
1016   // ***** Scaling for MC
1017   if (fIsMCInput) {
1018     fUseScaling=kFALSE;
1019     v0Corr  = Short_t((multV0A+multV0C)  * fV0MScaleFactorMC);
1020   }
1021   // ***** Scaling for Data
1022   if (fUseScaling) {
1023     v0Corr  = Short_t(v0Corr /   fV0MScaleFactor);
1024     spdCorr = spdCorr / fSPDScaleFactor;
1025     nTracks = Int_t(nTracks /   fTPCScaleFactor);
1026   }
1027
1028   // ***** Centrality Selection
1029   if(fHtempV0M) fCentV0M = fHtempV0M->GetBinContent(fHtempV0M->FindBin((v0Corr)));
1030   if(fHtempV0A) fCentV0A = fHtempV0A->GetBinContent(fHtempV0A->FindBin((multV0A)));
1031   if(fHtempV0C) fCentV0C = fHtempV0C->GetBinContent(fHtempV0C->FindBin((multV0C)));
1032   if(fHtempFMD) fCentFMD = fHtempFMD->GetBinContent(fHtempFMD->FindBin((multFMDA+multFMDC)));
1033   if(fHtempTRK) fCentTRK = fHtempTRK->GetBinContent(fHtempTRK->FindBin(nTracks));
1034   if(fHtempTKL) fCentTKL = fHtempTKL->GetBinContent(fHtempTKL->FindBin(nTracklets));
1035   if(fHtempCL0) fCentCL0 = fHtempCL0->GetBinContent(fHtempCL0->FindBin(nClusters[0]));
1036   if(fHtempCL1) fCentCL1 = fHtempCL1->GetBinContent(fHtempCL1->FindBin(spdCorr));
1037   if(fHtempCND) fCentCND = fHtempCND->GetBinContent(fHtempCND->FindBin(multCND));
1038
1039   if(fHtempV0MvsFMD) fCentV0MvsFMD = fHtempV0MvsFMD->GetBinContent(fHtempV0MvsFMD->FindBin((multV0A+multV0C)));
1040   if(fHtempTKLvsV0M) fCentTKLvsV0M = fHtempTKLvsV0M->GetBinContent(fHtempTKLvsV0M->FindBin(nTracklets));
1041   if(fHtempZEMvsZDC) fCentZEMvsZDC = fHtempZEMvsZDC->GetBinContent(fHtempZEMvsZDC->FindBin(zem1Energy+zem2Energy,zncEnergy+znaEnergy+zpcEnergy+zpaEnergy));
1042
1043
1044   // ***** Cleaning
1045   if (fUseCleaning) {
1046     fQuality=0;
1047
1048     // ***** vertex
1049     if (TMath::Abs(zvtx)>fZVCut || zvtxNcont<1) fQuality += 1;
1050
1051     // ***** outliers, skip in case of MC input
1052     if (!fIsMCInput) {
1053       // **** V0 vs SPD
1054       if (IsOutlierV0MSPD(spdCorr, v0Corr, int(fCentV0M))) fQuality  += 2;
1055       // ***** V0 vs TPC
1056       if (IsOutlierV0MTPC(nTracks, v0Corr, int(fCentV0M))) fQuality  += 4;
1057       // ***** V0 vs ZDC
1058       if (IsOutlierV0MZDC((zncEnergy+znaEnergy+zpcEnergy+zpaEnergy), v0Corr) &&
1059           (zdcEnergyCal==kFALSE) ) fQuality  += 8;
1060       if (IsOutlierV0MZDCECal((zncEnergy+znaEnergy+zpcEnergy+zpaEnergy), v0Corr) &&
1061           (zdcEnergyCal==kTRUE) ) fQuality  += 8;
1062     }
1063   } else {
1064     fQuality = 0;
1065   }
1066
1067
1068   if (esdCent) {
1069     esdCent->SetQuality(fQuality);
1070     esdCent->SetCentralityV0M(fCentV0M);
1071     esdCent->SetCentralityV0A(fCentV0A);
1072     esdCent->SetCentralityV0C(fCentV0C);
1073     esdCent->SetCentralityFMD(fCentFMD);
1074     esdCent->SetCentralityTRK(fCentTRK);
1075     esdCent->SetCentralityTKL(fCentTKL);
1076     esdCent->SetCentralityCL0(fCentCL0);
1077     esdCent->SetCentralityCL1(fCentCL1);
1078     esdCent->SetCentralityCND(fCentCND);
1079     esdCent->SetCentralityV0MvsFMD(fCentV0MvsFMD);
1080     esdCent->SetCentralityTKLvsV0M(fCentTKLvsV0M);
1081     esdCent->SetCentralityZEMvsZDC(fCentZEMvsZDC);
1082   }
1083
1084   // filling QA histograms
1085   if (fFillHistos) {
1086     if ((fMB) && (abs(zvtx)<10))        fHOutMultCL1vsTKL->Fill(spdCorr,nTracklets);
1087
1088     if (fCVHN)   fHOutCentV0MCVHN->Fill(fCentV0M);
1089     if (fCVLN)   fHOutCentV0MCVLN->Fill(fCentV0M);
1090     if (fCCENT)  fHOutCentV0MCCENT->Fill(fCentV0M);
1091     if (fCSEMI)  fHOutCentV0MCSEMI->Fill(fCentV0M);
1092     if (fMSL) fHOutCentV0MMSL->Fill(fCentV0M);
1093     if (fMSH) fHOutCentV0MMSH->Fill(fCentV0M);
1094     if (fMUL) fHOutCentV0MMUL->Fill(fCentV0M);
1095     if (fMLL) fHOutCentV0MMLL->Fill(fCentV0M);
1096     if (fEJE) fHOutCentV0MEJE->Fill(fCentV0M);
1097     if (fEGA) fHOutCentV0MEGA->Fill(fCentV0M);
1098     if (fPHS) fHOutCentV0MPHS->Fill(fCentV0M);
1099
1100     if (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB) { // fill the QA histograms only for MB events!
1101       fHOutQuality->Fill(fQuality);
1102       fHOutVertex->Fill(zvtx);
1103       fHOutVertexT0->Fill(zvtxT0);
1104
1105       if (fQuality==0) {
1106         fHOutCentV0M->Fill(fCentV0M);
1107         fHOutCentV0A->Fill(fCentV0A);
1108         fHOutCentV0C->Fill(fCentV0C);
1109
1110         if (fCVHNbit)  fHOutCentV0MCVHNinMB->Fill(fCentV0M);
1111         if (fCVLNbit)  fHOutCentV0MCVLNinMB->Fill(fCentV0M);
1112         if (fCCENTbit) fHOutCentV0MCCENTinMB->Fill(fCentV0M);
1113         if (fCSEMIbit) fHOutCentV0MCSEMIinMB->Fill(fCentV0M);
1114         if (fMSL) fHOutCentV0MMSLinMB->Fill(fCentV0M);
1115         if (fMSH) fHOutCentV0MMSHinMB->Fill(fCentV0M);
1116         if (fMUL) fHOutCentV0MMULinMB->Fill(fCentV0M);
1117         if (fMLL) fHOutCentV0MMLLinMB->Fill(fCentV0M);
1118         if (fEJE) fHOutCentV0MEJEinMB->Fill(fCentV0M);
1119         if (fEGA) fHOutCentV0MEGAinMB->Fill(fCentV0M);
1120         if (fPHS) fHOutCentV0MPHSinMB->Fill(fCentV0M);
1121
1122         fHOutCentFMD->Fill(fCentFMD);
1123         fHOutCentTRK->Fill(fCentTRK);
1124         fHOutCentTKL->Fill(fCentTKL);
1125         fHOutCentCL0->Fill(fCentCL0);
1126         fHOutCentCL1->Fill(fCentCL1);
1127         fHOutCentCND->Fill(fCentCND);
1128         fHOutCentV0MvsFMD->Fill(fCentV0MvsFMD);
1129         fHOutCentTKLvsV0M->Fill(fCentTKLvsV0M);
1130         fHOutCentZEMvsZDC->Fill(fCentZEMvsZDC);
1131         fHOutCentV0MvsCentCL1->Fill(fCentV0M,fCentCL1);
1132         fHOutCentV0MvsCentTRK->Fill(fCentV0M,fCentTRK);
1133         fHOutCentTRKvsCentCL1->Fill(fCentTRK,fCentCL1);
1134         fHOutCentV0MvsCentZDC->Fill(fCentV0M,fCentZEMvsZDC);
1135         fHOutCentV0AvsCentV0C->Fill(fCentV0A,fCentV0C);
1136         fHOutCentV0AvsCentTRK->Fill(fCentV0A,fCentTRK);
1137         fHOutCentV0AvsCentCND->Fill(fCentV0A,fCentCND);
1138         fHOutCentV0AvsCentCL1->Fill(fCentV0A,fCentCL1);
1139         fHOutCentV0CvsCentTRK->Fill(fCentV0C,fCentTRK);
1140         fHOutCentV0CvsCentCND->Fill(fCentV0C,fCentCND);
1141         fHOutCentV0CvsCentCL1->Fill(fCentV0C,fCentCL1);
1142
1143         fHOutMultV0AC->Fill(multV0A,multV0C);
1144         fHOutMultV0M->Fill(multV0A+multV0C);
1145         fHOutMultV0A->Fill(multV0A);
1146         fHOutMultV0C->Fill(multV0C);
1147         fHOutMultV0O->Fill(multV0AOnline+multV0COnline);
1148         fHOutMultV0Cells->Fill(nV0A,nV0C);
1149         fHOutMultFMD->Fill(multFMDA+multFMDC);
1150         fHOutMultTRK->Fill(nTracks);
1151         fHOutMultTKL->Fill(nTracklets);
1152         fHOutMultCL0->Fill(nClusters[0]);
1153         fHOutMultCL1->Fill(spdCorr);
1154         fHOutMultCND->Fill(multCND);
1155
1156         fHOutMultV0MvsZDN->Fill(v0Corr,(zncEnergy+znaEnergy));
1157         fHOutMultZEMvsZDN->Fill((zem1Energy+zem2Energy),(zncEnergy+znaEnergy));
1158         fHOutMultV0MvsZDC->Fill(v0Corr,(zncEnergy+znaEnergy+zpcEnergy+zpaEnergy));
1159         fHOutMultZEMvsZDC->Fill((zem1Energy+zem2Energy),(zncEnergy+znaEnergy+zpcEnergy+zpaEnergy));
1160         fHOutMultZEMvsZDCw->Fill((zem1Energy+zem2Energy),(zncEnergy+znaEnergy+zpcEnergy+zpaEnergy),fCentV0M);
1161         fHOutMultV0MvsCL1->Fill(v0Corr,spdCorr);
1162         fHOutMultV0MvsTRK->Fill(v0Corr,nTracks);
1163         fHOutMultTRKvsCL1->Fill(nTracks,spdCorr);
1164         fHOutMultV0MvsV0O->Fill(v0Corr,(multV0AOnline+multV0COnline));
1165         fHOutMultV0OvsCL1->Fill((multV0AOnline+multV0COnline),spdCorr);
1166         fHOutMultV0OvsTRK->Fill((multV0AOnline+multV0COnline),nTracks);
1167       } else if (fQuality%2 == 0) {
1168         fHOutCentV0Mqual1->Fill(fCentV0M);
1169         fHOutCentTRKqual1->Fill(fCentTRK);
1170         fHOutCentCL1qual1->Fill(fCentCL1);
1171         fHOutMultV0MvsCL1qual1->Fill(v0Corr,spdCorr);
1172         fHOutMultV0MvsTRKqual1->Fill(v0Corr,nTracks);
1173         fHOutMultTRKvsCL1qual1->Fill(nTracks,spdCorr);
1174       } else {
1175         fHOutCentV0Mqual2->Fill(fCentV0M);
1176         fHOutCentTRKqual2->Fill(fCentTRK);
1177         fHOutCentCL1qual2->Fill(fCentCL1);
1178         fHOutMultV0MvsCL1qual2->Fill(v0Corr,spdCorr);
1179         fHOutMultV0MvsTRKqual2->Fill(v0Corr,nTracks);
1180         fHOutMultTRKvsCL1qual2->Fill(nTracks,spdCorr);
1181       }
1182     }
1183     PostData(1, fOutputList);
1184   }
1185 }
1186 //________________________________________________________________________
1187 void AliCentralitySelectionTask::Terminate(Option_t */*option*/)
1188 {
1189   // Terminate analysis
1190 }
1191 //________________________________________________________________________
1192 Int_t AliCentralitySelectionTask::SetupRun(const AliESDEvent* const esd)
1193 {
1194   // Setup files for run
1195
1196   if (!esd)
1197     return -1;
1198
1199   // check if something to be done
1200   if (fCurrentRun == esd->GetRunNumber())
1201     return 0;
1202   else
1203     fCurrentRun = esd->GetRunNumber();
1204
1205   TString fileName =(Form("%s/COMMON/CENTRALITY/data/centrality.root", AliAnalysisManager::GetOADBPath()));
1206   AliInfo(Form("Setup Centrality Selection for run %d with file %s\n",fCurrentRun,fileName.Data()));
1207
1208   AliOADBContainer *con = new AliOADBContainer("OADB");
1209   con->InitFromFile(fileName,"Centrality");
1210
1211   AliOADBCentrality*  centOADB = 0;
1212   centOADB = (AliOADBCentrality*)(con->GetObject(fCurrentRun));
1213   if (!centOADB) {
1214     AliWarning(Form("Centrality OADB does not exist for run %d, using Default \n",fCurrentRun ));
1215     centOADB  = (AliOADBCentrality*)(con->GetDefaultObject("oadbDefault"));
1216   }
1217
1218   // modes
1219   fUseScaling   = centOADB->UseScaling();
1220   fUseCleaning  = centOADB->UseCleaning();
1221
1222   // cuts
1223   fZVCut        = centOADB->ZVCut();
1224   fOutliersCut  = centOADB->OutliersCut();
1225
1226   // centrality histos
1227   fHtempV0M       = centOADB->V0hist();
1228   fHtempV0A       = centOADB->V0Ahist();
1229   fHtempV0C       = centOADB->V0Chist();
1230   fHtempTRK       = centOADB->TPChist();
1231   fHtempCL1       = centOADB->SPDhist();
1232   fHtempCND       = centOADB->CNDhist();
1233   fHtempZEMvsZDC  = centOADB->ZEMvsZDChist();
1234
1235   TString path = gSystem->ExpandPathName(fileName.Data());
1236   if (!fHtempV0M) AliWarning(Form("Calibration for V0M does not exist in %s", path.Data()));
1237   if (!fHtempV0A) AliWarning(Form("Calibration for V0A does not exist in %s", path.Data()));
1238   if (!fHtempV0C) AliWarning(Form("Calibration for V0C does not exist in %s", path.Data()));
1239   if (!fHtempTRK) AliWarning(Form("Calibration for TRK does not exist in %s", path.Data()));
1240   if (!fHtempCL1) AliWarning(Form("Calibration for CL1 does not exist in %s", path.Data()));
1241   if (!fHtempCND) AliWarning(Form("Calibration for CND does not exist in %s", path.Data()));
1242   if (!fHtempZEMvsZDC) AliWarning(Form("Calibration for ZEMvsZDC does not exist in %s", path.Data()));
1243
1244   // scale factors
1245   fV0MScaleFactor    = centOADB->V0MScaleFactor();
1246   fSPDScaleFactor    = centOADB->SPDScaleFactor();
1247   fTPCScaleFactor    = centOADB->TPCScaleFactor();
1248   fV0MScaleFactorMC  = centOADB->V0MScaleFactorMC();
1249
1250   // outliers parameters
1251   fV0MSPDOutlierPar0 = centOADB->V0MSPDOutlierPar0();
1252   fV0MSPDOutlierPar1 = centOADB->V0MSPDOutlierPar1();
1253   fV0MTPCOutlierPar0 = centOADB->V0MTPCOutlierPar0();
1254   fV0MTPCOutlierPar1 = centOADB->V0MTPCOutlierPar1();
1255
1256   fV0MSPDSigmaOutlierPar0 = centOADB->V0MSPDSigmaOutlierPar0();
1257   fV0MSPDSigmaOutlierPar1 = centOADB->V0MSPDSigmaOutlierPar1();
1258   fV0MSPDSigmaOutlierPar2 = centOADB->V0MSPDSigmaOutlierPar2();
1259   fV0MTPCSigmaOutlierPar0 = centOADB->V0MTPCSigmaOutlierPar0();
1260   fV0MTPCSigmaOutlierPar1 = centOADB->V0MTPCSigmaOutlierPar1();
1261   fV0MTPCSigmaOutlierPar2 = centOADB->V0MTPCSigmaOutlierPar2();
1262
1263   fV0MZDCOutlierPar0 =      centOADB->V0MZDCOutlierPar0();
1264   fV0MZDCOutlierPar1 =      centOADB->V0MZDCOutlierPar1();
1265   fV0MZDCEcalOutlierPar0 =  centOADB->V0MZDCEcalOutlierPar0();
1266   fV0MZDCEcalOutlierPar1 =  centOADB->V0MZDCEcalOutlierPar1();
1267
1268
1269
1270   return 0;
1271 }
1272
1273
1274
1275 //________________________________________________________________________
1276 Bool_t AliCentralitySelectionTask::IsOutlierV0MSPD(Float_t spd, Float_t v0, Int_t cent) const
1277 {
1278   // Clean outliers
1279   Float_t val = fV0MSPDOutlierPar0 +  fV0MSPDOutlierPar1 * v0;
1280   Float_t spdSigma = fV0MSPDSigmaOutlierPar0 + fV0MSPDSigmaOutlierPar1*cent + fV0MSPDSigmaOutlierPar2*cent*cent;
1281   if ( TMath::Abs(spd-val) > fOutliersCut*spdSigma )
1282     return kTRUE;
1283   else
1284     return kFALSE;
1285 }
1286
1287 //________________________________________________________________________
1288 Bool_t AliCentralitySelectionTask::IsOutlierV0MTPC(Int_t tracks, Float_t v0, Int_t cent) const
1289 {
1290   // Clean outliers
1291   Float_t val = fV0MTPCOutlierPar0 +  fV0MTPCOutlierPar1 * v0;
1292   Float_t tpcSigma = fV0MTPCSigmaOutlierPar0 + fV0MTPCSigmaOutlierPar1*cent + fV0MTPCSigmaOutlierPar2*cent*cent;
1293   if ( TMath::Abs(tracks-val) > fOutliersCut*tpcSigma )
1294     return kTRUE;
1295   else
1296     return kFALSE;
1297 }
1298
1299 //________________________________________________________________________
1300 Bool_t AliCentralitySelectionTask::IsOutlierV0MZDC(Float_t zdc, Float_t v0) const
1301 {
1302   // Clean outliers
1303   Float_t val = fV0MZDCOutlierPar0 + fV0MZDCOutlierPar1 * v0;
1304   if (zdc >  val)
1305     return kTRUE;
1306   else
1307   return kFALSE;
1308 }
1309
1310 //________________________________________________________________________
1311 Bool_t AliCentralitySelectionTask::IsOutlierV0MZDCECal(Float_t zdc, Float_t v0) const
1312 {
1313   // Clean outliers
1314   Float_t val = fV0MZDCEcalOutlierPar0 + fV0MZDCEcalOutlierPar1 * v0;
1315   if (zdc >  val)
1316     return kTRUE;
1317   else
1318     return kFALSE;
1319 }
1320
1321