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