PWGHF/hfe/AliAnalysisTaskHFE.cxx

   1 /**************************************************************************\r
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
   3 *                                                                        *\r
   4 * Author: The ALICE Off-line Project.                                    *\r
   5 * Contributors are mentioned in the code where appropriate.              *\r
   6 *                                                                        *\r
   7 * Permission to use, copy, modify and distribute this software and its   *\r
   8 * documentation strictly for non-commercial purposes is hereby granted   *\r
   9 * without fee, provided that the above copyright notice appears in all   *\r
  10 * copies and that both the copyright notice and this permission notice   *\r
  11 * appear in the supporting documentation. The authors make no claims     *\r
  12 * about the suitability of this software for any purpose. It is          *\r
  13 * provided "as is" without express or implied warranty.                  *\r
  14 **************************************************************************/\r
  15 //\r
  16 // The analysis task:\r
  17 // Filling an AliCFContainer with the quantities pt, eta and phi\r
  18 // for tracks which survivied the particle cuts (MC resp. ESD tracks)\r
  19 // Track selection is done using the AliHFE package\r
  20 // \r
  21 // Author:\r
  22 //  Raphaelle Bailhache <R.Bailhache@gsi.de>\r
  23 //  Markus Fasel <M.Fasel@gsi.de>\r
  24 //  Matus Kalisky <matus.kalisky@cern.ch>\r
  25 //  MinJung Kweon <minjung@physi.uni-heidelberg.de>\r
  26 //\r
  27 #include <TAxis.h>\r
  28 #include <TBits.h>\r
  29 #include <TCanvas.h>\r
  30 #include <TChain.h>\r
  31 #include <TDirectory.h>\r
  32 #include <TFile.h>\r
  33 #include <TH3D.h>\r
  34 #include <TIterator.h>\r
  35 #include <TList.h>\r
  36 #include <TLegend.h>\r
  37 #include <TMath.h>\r
  38 #include <TObjArray.h>\r
  39 #include <TObjString.h>\r
  40 #include <TParticle.h>\r
  41 #include <TProfile.h>\r
  42 #include <TString.h>\r
  43 #include <TF1.h>\r
  44 #include <TTree.h>\r
  45 \r
  46 #include "AliESDtrackCuts.h"\r
  47 #include "AliAnalysisManager.h"\r
  48 #include "AliAnalysisUtils.h"\r
  49 #include "AliAODInputHandler.h"\r
  50 #include "AliAODMCParticle.h"\r
  51 #include "AliAODTrack.h"\r
  52 #include "AliAODVertex.h"\r
  53 #include "AliCentrality.h"\r
  54 #include "AliCFContainer.h"\r
  55 #include "AliCFManager.h"\r
  56 #include "AliESDEvent.h"\r
  57 #include "AliESDInputHandler.h"\r
  58 #include "AliESDtrack.h"\r
  59 #include "AliLog.h"\r
  60 #include "AliMCEvent.h"\r
  61 #include "AliMCEventHandler.h"\r
  62 #include "AliMCParticle.h"\r
  63 #include "AliMultiplicity.h"\r
  64 #include "AliPID.h"\r
  65 #include "AliPIDResponse.h"\r
  66 #include "AliOADBContainer.h"\r
  67 #include "AliStack.h"\r
  68 #include "AliTriggerAnalysis.h"\r
  69 #include "AliVVertex.h"\r
  70 \r
  71 #include "AliHFEcollection.h"\r
  72 #include "AliHFEcontainer.h"\r
  73 #include "AliHFEcuts.h"\r
  74 #include "AliHFEelecbackground.h"\r
  75 #include "AliHFENonPhotonicElectron.h"\r
  76 #include "AliHFEmcQA.h"\r
  77 #include "AliHFEpairs.h"\r
  78 #include "AliHFEpid.h"\r
  79 #include "AliHFEpidQAmanager.h"\r
  80 #include "AliHFEsecVtxs.h"\r
  81 #include "AliHFEsecVtx.h"\r
  82 #include "AliHFEsignalCuts.h"\r
  83 #include "AliHFEtaggedTrackAnalysis.h"\r
  84 #include "AliHFEtools.h"\r
  85 #include "AliHFEvarManager.h"\r
  86 #include "AliAnalysisTaskHFE.h"\r
  87 #include "AliAODMCHeader.h"\r
  88 #include "TClonesArray.h"\r
  89 \r
  90 ClassImp(AliAnalysisTaskHFE)\r
  91 \r
  92 //____________________________________________________________\r
  93 AliAnalysisTaskHFE::AliAnalysisTaskHFE():\r
  94 AliAnalysisTaskSE("PID efficiency Analysis")\r
  95   , fAODMCHeader(NULL)\r
  96   , fAODArrayMCInfo(NULL)\r
  97   , fQAlevel(0)\r
  98   , fPlugins(0)\r
  99   , fCollisionSystem(3)\r
 100   , fFillSignalOnly(kTRUE)\r
 101   , fFillNoCuts(kFALSE)\r
 102   , fApplyCutAOD(kTRUE)\r
 103   , fBackGroundFactorApply(kFALSE)\r
 104   , fRemovePileUp(kFALSE)\r
 105   , fIdentifiedAsPileUp(kFALSE)\r
 106   , fIdentifiedAsOutInz(kFALSE)\r
 107   , fPassTheEventCut(kFALSE)\r
 108   , fRejectKinkMother(kTRUE)\r
 109   , fisppMultiBin(kFALSE)\r
 110   , fPbPbUserCentralityBinning(kFALSE)\r
 111   , fRemoveFirstEvent(kFALSE)\r
 112   , fisNonHFEsystematics(kFALSE)\r
 113   , fSpecialTrigger(NULL)\r
 114   , fCentralityF(-1)\r
 115   , fCentralityPercent(-1)\r
 116   , fContributors(0.5)\r
 117   , fWeightBackGround(0.)\r
 118   , fVz(0.0)\r
 119   , fContainer(NULL)\r
 120   , fVarManager(NULL)\r
 121   , fSignalCuts(NULL)\r
 122   , fCFM(NULL)\r
 123   , fTriggerAnalysis(NULL)\r
 124   , fPID(NULL)\r
 125   , fPIDqa(NULL)\r
 126   , fPIDpreselect(NULL)\r
 127   , fCuts(NULL)\r
 128   , fTaggedTrackCuts(NULL)\r
 129   , fCleanTaggedTrack(kFALSE)\r
 130   , fVariablesTRDTaggedTrack(kFALSE)\r
 131   , fAnalysisUtils(NULL)\r
 132   , fCutspreselect(NULL)\r
 133   , fSecVtx(NULL)\r
 134   , fElecBackGround(NULL)\r
 135   , fMCQA(NULL)\r
 136   , fTaggedTrackAnalysis(NULL)\r
 137   , fExtraCuts(NULL)\r
 138   , fBackgroundSubtraction(NULL)\r
 139   , fQA(NULL)\r
 140   , fOutput(NULL)\r
 141   , fHistMCQA(NULL)\r
 142   , fHistSECVTX(NULL)\r
 143   , fHistELECBACKGROUND(NULL)\r
 144   , fQACollection(NULL)\r
 145 {\r
 146   //\r
 147   // Dummy constructor\r
 148   //\r
 149   memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);\r
 150   memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);\r
 151   memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));\r
 152   memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));\r
 153   memset(fCentralityLimits, 0, sizeof(Float_t) * 12);\r
 154 \r
 155   SetppAnalysis();\r
 156 }\r
 157 \r
 158 //____________________________________________________________\r
 159 AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):\r
 160   AliAnalysisTaskSE(name)\r
 161   , fAODMCHeader(NULL)\r
 162   , fAODArrayMCInfo(NULL)\r
 163   , fQAlevel(0)\r
 164   , fPlugins(0)\r
 165   , fCollisionSystem(3)\r
 166   , fFillSignalOnly(kTRUE)\r
 167   , fFillNoCuts(kFALSE)\r
 168   , fApplyCutAOD(kTRUE)\r
 169   , fBackGroundFactorApply(kFALSE)\r
 170   , fRemovePileUp(kFALSE)\r
 171   , fIdentifiedAsPileUp(kFALSE)\r
 172   , fIdentifiedAsOutInz(kFALSE)\r
 173   , fPassTheEventCut(kFALSE)  \r
 174   , fRejectKinkMother(kTRUE)\r
 175   , fisppMultiBin(kFALSE)\r
 176   , fPbPbUserCentralityBinning(kFALSE)\r
 177   , fRemoveFirstEvent(kFALSE)\r
 178   , fisNonHFEsystematics(kFALSE)\r
 179   , fSpecialTrigger(NULL)\r
 180   , fCentralityF(-1)\r
 181   , fCentralityPercent(-1)\r
 182   , fContributors(0.5)\r
 183   , fWeightBackGround(0.)\r
 184   , fVz(0.0)\r
 185   , fContainer(NULL)\r
 186   , fVarManager(NULL)\r
 187   , fSignalCuts(NULL)\r
 188   , fCFM(NULL)\r
 189   , fTriggerAnalysis(NULL)\r
 190   , fPID(NULL)\r
 191   , fPIDqa(NULL)\r
 192   , fPIDpreselect(NULL)\r
 193   , fCuts(NULL)\r
 194   , fTaggedTrackCuts(NULL)\r
 195   , fCleanTaggedTrack(kFALSE)\r
 196   , fVariablesTRDTaggedTrack(kFALSE)\r
 197   , fAnalysisUtils(NULL)\r
 198   , fCutspreselect(NULL)\r
 199   , fSecVtx(NULL)\r
 200   , fElecBackGround(NULL)\r
 201   , fMCQA(NULL)\r
 202   , fTaggedTrackAnalysis(NULL)\r
 203   , fExtraCuts(NULL)\r
 204   , fBackgroundSubtraction(NULL)\r
 205   , fQA(NULL)\r
 206   , fOutput(NULL)\r
 207   , fHistMCQA(NULL)\r
 208   , fHistSECVTX(NULL)\r
 209   , fHistELECBACKGROUND(NULL)\r
 210   , fQACollection(0x0)\r
 211 {\r
 212   //\r
 213   // Default constructor\r
 214   // \r
 215   DefineOutput(1, TList::Class());\r
 216   DefineOutput(2, TList::Class());\r
 217 \r
 218   fPID = new AliHFEpid("hfePid");\r
 219   fPIDqa = new AliHFEpidQAmanager;\r
 220   fVarManager = new AliHFEvarManager("hfeVarManager");\r
 221   fAnalysisUtils = new AliAnalysisUtils;\r
 222 \r
 223   memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);\r
 224   memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);\r
 225   memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));\r
 226   memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));\r
 227   memset(fCentralityLimits, 0, sizeof(Float_t) * 12);\r
 228 \r
 229   SetppAnalysis();\r
 230 }\r
 231 \r
 232 //____________________________________________________________\r
 233 AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):\r
 234   AliAnalysisTaskSE(ref)\r
 235   , fAODMCHeader(NULL)\r
 236   , fAODArrayMCInfo(NULL)\r
 237   , fQAlevel(0)\r
 238   , fPlugins(0)\r
 239   , fCollisionSystem(ref.fCollisionSystem)\r
 240   , fFillSignalOnly(ref.fFillSignalOnly)\r
 241   , fFillNoCuts(ref.fFillNoCuts)\r
 242   , fApplyCutAOD(ref.fApplyCutAOD)\r
 243   , fBackGroundFactorApply(ref.fBackGroundFactorApply)\r
 244   , fRemovePileUp(ref.fRemovePileUp)\r
 245   , fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp)\r
 246   , fIdentifiedAsOutInz(ref.fIdentifiedAsOutInz)\r
 247   , fPassTheEventCut(ref.fPassTheEventCut)\r
 248   , fRejectKinkMother(ref.fRejectKinkMother)\r
 249   , fisppMultiBin(ref.fisppMultiBin)\r
 250   , fPbPbUserCentralityBinning(ref.fPbPbUserCentralityBinning)\r
 251   , fRemoveFirstEvent(ref.fRemoveFirstEvent)\r
 252   , fisNonHFEsystematics(ref.fisNonHFEsystematics)\r
 253   , fSpecialTrigger(ref.fSpecialTrigger)\r
 254   , fCentralityF(ref.fCentralityF)\r
 255   , fCentralityPercent(ref.fCentralityPercent)\r
 256   , fContributors(ref.fContributors)\r
 257   , fWeightBackGround(ref.fWeightBackGround)\r
 258   , fVz(ref.fVz)\r
 259   , fContainer(NULL)\r
 260   , fVarManager(NULL)\r
 261   , fSignalCuts(NULL)\r
 262   , fCFM(NULL)\r
 263   , fTriggerAnalysis(NULL)\r
 264   , fPID(NULL)\r
 265   , fPIDqa(NULL)\r
 266   , fPIDpreselect(NULL)\r
 267   , fCuts(NULL)\r
 268   , fTaggedTrackCuts(NULL)\r
 269   , fCleanTaggedTrack(ref.fCleanTaggedTrack)\r
 270   , fVariablesTRDTaggedTrack(ref.fVariablesTRDTaggedTrack)\r
 271   , fAnalysisUtils(NULL)\r
 272   , fCutspreselect(NULL)\r
 273   , fSecVtx(NULL)\r
 274   , fElecBackGround(NULL)\r
 275   , fMCQA(NULL)\r
 276   , fTaggedTrackAnalysis(NULL)\r
 277   , fExtraCuts(NULL)\r
 278   , fBackgroundSubtraction(NULL)\r
 279   , fQA(NULL)\r
 280   , fOutput(NULL)\r
 281   , fHistMCQA(NULL)\r
 282   , fHistSECVTX(NULL)\r
 283   , fHistELECBACKGROUND(NULL)\r
 284   , fQACollection(NULL)\r
 285 {\r
 286   //\r
 287   // Copy Constructor\r
 288   //\r
 289   ref.Copy(*this);\r
 290 }\r
 291 \r
 292 //____________________________________________________________\r
 293 AliAnalysisTaskHFE &AliAnalysisTaskHFE::operator=(const AliAnalysisTaskHFE &ref){\r
 294   //\r
 295   // Assignment operator\r
 296   //\r
 297   if(this == &ref) \r
 298     ref.Copy(*this);\r
 299   return *this;\r
 300 }\r
 301 \r
 302 //____________________________________________________________\r
 303 void AliAnalysisTaskHFE::Copy(TObject &o) const {\r
 304   // \r
 305   // Copy into object o\r
 306   //\r
 307   AliAnalysisTaskHFE &target = dynamic_cast<AliAnalysisTaskHFE &>(o);\r
 308   target.fAODMCHeader = fAODMCHeader;\r
 309   target.fAODArrayMCInfo = fAODArrayMCInfo;\r
 310   target.fQAlevel = fQAlevel;\r
 311   target.fPlugins = fPlugins;\r
 312   target.fCollisionSystem = fCollisionSystem;\r
 313   target.fFillSignalOnly = fFillSignalOnly;\r
 314   target.fFillNoCuts = fFillNoCuts;\r
 315   target.fApplyCutAOD = fApplyCutAOD;\r
 316   target.fBackGroundFactorApply = fBackGroundFactorApply;\r
 317   target.fRemovePileUp = fRemovePileUp;\r
 318   target.fIdentifiedAsPileUp = fIdentifiedAsPileUp;\r
 319   target.fIdentifiedAsOutInz = fIdentifiedAsOutInz;\r
 320   target.fPassTheEventCut = fPassTheEventCut;\r
 321   target.fRejectKinkMother = fRejectKinkMother;\r
 322   target.fisppMultiBin =   fisppMultiBin;\r
 323   target.fPbPbUserCentralityBinning = fPbPbUserCentralityBinning;\r
 324   target.fRemoveFirstEvent = fRemoveFirstEvent;\r
 325   target.fisNonHFEsystematics = fisNonHFEsystematics;\r
 326   target.fSpecialTrigger = fSpecialTrigger;\r
 327   target.fCentralityF = fCentralityF;\r
 328   target.fCentralityPercent = fCentralityPercent;\r
 329   target.fContributors = fContributors;\r
 330   target.fWeightBackGround = fWeightBackGround;\r
 331   target.fVz = fVz;\r
 332   target.fContainer = fContainer;\r
 333   target.fVarManager = fVarManager;\r
 334   target.fSignalCuts = fSignalCuts;\r
 335   target.fCFM = fCFM;\r
 336   target.fTriggerAnalysis = fTriggerAnalysis;\r
 337   target.fPID = fPID;\r
 338   target.fPIDqa = fPIDqa;\r
 339   target.fPIDpreselect = fPIDpreselect;\r
 340   target.fCuts = fCuts;\r
 341   target.fTaggedTrackCuts = fTaggedTrackCuts;\r
 342   target.fCleanTaggedTrack = fCleanTaggedTrack;\r
 343   target.fVariablesTRDTaggedTrack = fVariablesTRDTaggedTrack;\r
 344   target.fAnalysisUtils = fAnalysisUtils;\r
 345   target.fCutspreselect = fCutspreselect;\r
 346   target.fSecVtx = fSecVtx;\r
 347   target.fElecBackGround = fElecBackGround;\r
 348   target.fMCQA = fMCQA;\r
 349   target.fTaggedTrackAnalysis = fTaggedTrackAnalysis;\r
 350   target.fExtraCuts = fExtraCuts;\r
 351   target.fBackgroundSubtraction = fBackgroundSubtraction;\r
 352   target.fQA = fQA;\r
 353   target.fOutput = fOutput;\r
 354   target.fHistMCQA = fHistMCQA;\r
 355   target.fHistSECVTX = fHistSECVTX;\r
 356   target.fHistELECBACKGROUND = fHistELECBACKGROUND;\r
 357   target.fQACollection = fQACollection;\r
 358 }\r
 359 \r
 360 //____________________________________________________________\r
 361 AliAnalysisTaskHFE::~AliAnalysisTaskHFE(){\r
 362   //\r
 363   // Destructor\r
 364   //\r
 365   if(fPID) delete fPID;\r
 366   if(fPIDpreselect) delete fPIDpreselect;\r
 367   if(fVarManager) delete fVarManager;\r
 368   if(fCFM) delete fCFM;\r
 369   if(fTriggerAnalysis) delete fTriggerAnalysis;\r
 370   if(fSignalCuts) delete fSignalCuts;\r
 371   if(fSecVtx) delete fSecVtx;\r
 372   if(fMCQA) delete fMCQA;\r
 373   if(fElecBackGround) delete fElecBackGround;\r
 374   if(fBackgroundSubtraction) delete fBackgroundSubtraction;\r
 375   if(fSpecialTrigger) delete fSpecialTrigger;\r
 376   if(fAnalysisUtils) delete fAnalysisUtils;\r
 377   // Delete output objects only if we are not running in PROOF mode because otherwise this produces a crash during merging\r
 378   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();\r
 379   if(mgr && mgr->GetAnalysisType() != AliAnalysisManager::kProofAnalysis){\r
 380     if(fPIDqa) delete fPIDqa;\r
 381     if(fOutput) delete fOutput;\r
 382     if(fQA) delete fQA;\r
 383   }\r
 384 }\r
 385 \r
 386 //____________________________________________________________\r
 387 void AliAnalysisTaskHFE::UserCreateOutputObjects(){\r
 388   //\r
 389   // Creating output container and output objects\r
 390   // Here we also Initialize the correction framework container and \r
 391   // the objects for\r
 392   // - PID\r
 393   // - MC QA\r
 394   // - SecVtx\r
 395   // QA histograms are created if requested\r
 396   // Called once per worker\r
 397   //\r
 398   AliDebug(3, "Creating Output Objects");\r
 399   \r
 400   // Make lists for Output\r
 401   if(!fQA) fQA = new TList;\r
 402   fQA->SetOwner();\r
 403   if(!fOutput) fOutput = new TList;\r
 404   fOutput->SetOwner();\r
 405   \r
 406   // Automatic determination of the analysis mode\r
 407   AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
 408   if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){\r
 409     SetAODAnalysis();\r
 410   } else {\r
 411     SetESDAnalysis();\r
 412     if(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler())\r
 413       SetHasMCData();\r
 414   }\r
 415   printf("Analysis Mode: %s Analysis\n", IsAODanalysis() ? "AOD" : "ESD");\r
 416   printf("MC Data available %s\n", HasMCData() ? "Yes" : "No");\r
 417 \r
 418   // Enable Trigger Analysis\r
 419   fTriggerAnalysis = new AliTriggerAnalysis;\r
 420   fTriggerAnalysis->EnableHistograms();\r
 421   fTriggerAnalysis->SetAnalyzeMC(HasMCData());\r
 422 \r
 423   // First Part: Make QA histograms\r
 424   fQACollection = new AliHFEcollection("TaskQA", "QA histos from the Electron Task");\r
 425   fQACollection->CreateTH1F("nElectronTracksEvent", "Number of Electron Candidates", 100, 0, 100);\r
 426   fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100);\r
 427   fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);\r
 428 \r
 429   if(IsAODanalysis()){\r
 430     fQACollection->CreateTH1F("Filterorigin","AOD filter of tracks at origin", 21,-1, 20);\r
 431     fQACollection->CreateTH1F("Filterend","AOD filter of tracks after all cuts", 21, -1, 20);\r
 432   }\r
 433  \r
 434   InitHistoITScluster();\r
 435   InitContaminationQA();\r
 436   fQA->Add(fQACollection);\r
 437 \r
 438   // Initialize PID\r
 439   fPID->SetHasMCData(HasMCData());\r
 440   if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0);\r
 441   if(IsQAOn(kPIDqa)){\r
 442     AliInfo("PID QA switched on");\r
 443     fPIDqa->Initialize(fPID);\r
 444     fQA->Add(fPIDqa->MakeList("HFEpidQA"));\r
 445   }\r
 446   fPID->SortDetectors();\r
 447 \r
 448   // Background subtraction-------------------------------------------------------------------\r
 449   if (GetPlugin(kNonPhotonicElectron)) {\r
 450     if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();\r
 451     if(IsAODanalysis()) fBackgroundSubtraction->SetAOD(kTRUE);\r
 452     fBackgroundSubtraction->Init();\r
 453     fOutput->Add(fBackgroundSubtraction->GetListOutput());\r
 454   }\r
 455   //------------------------------------------------------------------------------------------\r
 456 \r
 457 \r
 458   // Initialize correction Framework and Cuts\r
 459   const Int_t kNcutSteps = AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack + AliHFEcuts::kNcutStepsDETrack + AliHFEcuts::kNcutStepsSecvtxTrack;\r
 460   fCFM = new AliCFManager;\r
 461   fCFM->SetNStepParticle(kNcutSteps);\r
 462   MakeParticleContainer();\r
 463   MakeEventContainer();\r
 464   // Temporary fix: Initialize particle cuts with NULL\r
 465   for(Int_t istep = 0; istep < kNcutSteps; istep++)\r
 466     fCFM->SetParticleCutsList(istep, NULL);\r
 467   if(!fCuts){\r
 468     AliWarning("Cuts not available. Default cuts will be used");\r
 469     fCuts = new AliHFEcuts;\r
 470     fCuts->CreateStandardCuts();\r
 471   }\r
 472   if(IsAODanalysis()) fCuts->SetAOD();\r
 473   // Make clone for V0 tagging step\r
 474   fCuts->Initialize(fCFM);\r
 475   if(fCuts->IsQAOn()) fQA->Add(fCuts->GetQAhistograms());\r
 476   fSignalCuts = new AliHFEsignalCuts("HFEsignalCuts", "HFE MC Signal definition");\r
 477   fVarManager->SetSignalCuts(fSignalCuts);\r
 478  \r
 479   // add output objects to the List\r
 480   fOutput->AddAt(fContainer, 0);\r
 481   fOutput->AddAt(fCFM->GetEventContainer(), 1);\r
 482   \r
 483   // mcQA----------------------------------\r
 484   if (HasMCData() && IsQAOn(kMCqa)) {\r
 485     AliInfo("MC QA on");\r
 486     if(!fMCQA) fMCQA = new AliHFEmcQA;\r
 487     if(!fHistMCQA) fHistMCQA = new TList();\r
 488     fHistMCQA->SetOwner();\r
 489     if(IsPbPb()) fMCQA->SetPbPb();\r
 490     if(fisppMultiBin) fMCQA->SetPPMultiBin();\r
 491     if(TestBit(kTreeStream)){\r
 492       fMCQA->EnableDebugStreamer();\r
 493     }\r
 494     fMCQA->CreatDefaultHistograms(fHistMCQA);\r
 495     fMCQA->SetBackgroundWeightFactor(fElecBackgroundFactor[0][0][0],fBinLimit);\r
 496     fQA->Add(fHistMCQA);\r
 497   } \r
 498 \r
 499   // secvtx----------------------------------\r
 500   if (GetPlugin(kSecVtx)) {\r
 501     AliInfo("Secondary Vertex Analysis on");\r
 502     if(!fSecVtx) fSecVtx = new AliHFEsecVtx;\r
 503     fSecVtx->SetHasMCData(HasMCData());\r
 504 \r
 505     if(!fHistSECVTX) fHistSECVTX = new TList();\r
 506     fHistSECVTX->SetOwner();\r
 507     fSecVtx->CreateHistograms(fHistSECVTX);\r
 508     fOutput->Add(fHistSECVTX);\r
 509   }\r
 510 \r
 511   // background----------------------------------\r
 512   if (GetPlugin(kIsElecBackGround)) {\r
 513     AliInfo("Electron BackGround Analysis on");\r
 514     if(!fElecBackGround){\r
 515       AliWarning("ElecBackGround not available. Default elecbackground will be used");\r
 516       fElecBackGround = new AliHFEelecbackground;\r
 517     }\r
 518     fElecBackGround->SetHasMCData(HasMCData());\r
 519 \r
 520     if(!fHistELECBACKGROUND) fHistELECBACKGROUND = new TList();\r
 521     fHistELECBACKGROUND->SetOwner();\r
 522     fElecBackGround->CreateHistograms(fHistELECBACKGROUND);\r
 523     fOutput->Add(fHistELECBACKGROUND);\r
 524   }  \r
 525 \r
 526   // tagged tracks\r
 527   if(GetPlugin(kTaggedTrackAnalysis)){\r
 528     AliInfo("Analysis on V0-tagged tracks enabled");\r
 529     fTaggedTrackAnalysis = new AliHFEtaggedTrackAnalysis(Form("taggedTrackAnalysis%s", GetName()));\r
 530     fTaggedTrackAnalysis->SetCuts(fTaggedTrackCuts);\r
 531     fTaggedTrackAnalysis->SetClean(fCleanTaggedTrack);\r
 532     AliHFEvarManager *varManager = fTaggedTrackAnalysis->GetVarManager();\r
 533     TObjArray *array = fVarManager->GetVariables();\r
 534     Int_t nvars = array->GetEntriesFast();\r
 535     TString namee;\r
 536     for(Int_t v = 0; v < nvars; v++) {\r
 537       AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);\r
 538       if(!variable) continue;\r
 539       TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());\r
 540       if(!name.CompareTo("source")) namee = TString("species");\r
 541       else namee = TString(name);\r
 542       Int_t nbins = variable->GetNumberOfBins();\r
 543       if(variable->HasUserDefinedBinning()){\r
 544         varManager->AddVariable(namee, nbins, variable->GetBinning());\r
 545       } else {\r
 546         varManager->AddVariable(namee, nbins, variable->GetMinimum(), variable->GetMaximum());\r
 547       }\r
 548       //printf("For AliTaggedTrackAnalysis, had the variable %s and the one used %s\n",(const char*)variable->GetName(),(const char*) namee);\r
 549     }\r
 550     if(fPIDqa->HasHighResolutionHistos()) \r
 551       fTaggedTrackAnalysis->GetPIDqa()->SetHighResolutionHistos();\r
 552     fTaggedTrackAnalysis->SetPID(fPID);\r
 553     fTaggedTrackAnalysis->SetVariablesTRD(fVariablesTRDTaggedTrack);\r
 554     fTaggedTrackAnalysis->InitContainer();\r
 555     fOutput->Add(fTaggedTrackAnalysis->GetContainer());\r
 556     fQA->Add(fTaggedTrackAnalysis->GetPIDQA());\r
 557     fQA->Add(fTaggedTrackAnalysis->GetCutQA());\r
 558     fQA->Add(fTaggedTrackAnalysis->GetQAcollection());\r
 559   }\r
 560 \r
 561   //fQA->Print();\r
 562 \r
 563   PrintStatus();\r
 564   // Done!!!\r
 565   PostData(1, fOutput);\r
 566   PostData(2, fQA);\r
 567 }\r
 568 \r
 569 //____________________________________________________________\r
 570 void AliAnalysisTaskHFE::UserExec(Option_t *){\r
 571   //\r
 572   // Run the analysis\r
 573   // \r
 574 \r
 575   //printf("test00\n");\r
 576 \r
 577   AliDebug(3, "Starting Single Event Analysis");\r
 578   if(!fInputEvent){\r
 579     AliError("Reconstructed Event not available");\r
 580     //printf("Reconstructed Event not available");\r
 581     return;\r
 582   }\r
 583   if(HasMCData() && IsESDanalysis()){\r
 584     AliDebug(4, Form("MC Event: %p", fMCEvent));\r
 585     if(!fMCEvent){\r
 586       AliError("No MC Event, but MC Data required");\r
 587       //printf("No MC Event, but MC Data required");\r
 588       return;\r
 589     }\r
 590   }\r
 591   if(!fCuts){\r
 592     AliError("HFE cuts not available");\r
 593     //printf("HFE cuts not available");\r
 594     return;\r
 595   }\r
 596   if(!fPID->IsInitialized()){\r
 597     // Initialize PID with the given run number\r
 598     fPID->InitializePID(fInputEvent->GetRunNumber());\r
 599   }\r
 600 \r
 601   if(fRemoveFirstEvent){\r
 602     if(fAnalysisUtils->IsFirstEventInChunk(fInputEvent)) return;\r
 603   }\r
 604 \r
 605   if(IsESDanalysis() && HasMCData()){\r
 606     // Protect against missing MC trees\r
 607     AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());\r
 608     if(!mcH){ \r
 609       AliError("No MC Event Handler available");\r
 610       return;\r
 611     }\r
 612     /*\r
 613     if(!mcH->InitOk()) return;\r
 614     if(!mcH->TreeK()) return;\r
 615     if(!mcH->TreeTR()) return;\r
 616     */\r
 617 \r
 618     // Background subtraction-------------------------------------------------------------------\r
 619     if(GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetMCEvent(fMCEvent);\r
 620     //------------------------------------------------------------------------------------------\r
 621   }\r
 622 \r
 623   if(IsAODanalysis() && HasMCData()){\r
 624     // take MC info\r
 625     AliAODEvent *aodE = dynamic_cast<AliAODEvent *>(fInputEvent);\r
 626     if(!aodE){ \r
 627       AliError("No AOD Event");\r
 628       return;\r
 629     }\r
 630     fAODMCHeader = dynamic_cast<AliAODMCHeader *>(fInputEvent->FindListObject(AliAODMCHeader::StdBranchName()));\r
 631     if(!fAODMCHeader){ \r
 632       AliError("No AliAODMCHeader");\r
 633       //printf("No AliAODMCHeader");\r
 634       return;\r
 635     }\r
 636     fAODArrayMCInfo = dynamic_cast<TClonesArray *>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));\r
 637     if(!fAODArrayMCInfo){ \r
 638       AliError("No AOD MC particles");\r
 639       //printf("No AOD MC particles");\r
 640       return;\r
 641     }\r
 642     fSignalCuts->SetMCAODInfo(fAODArrayMCInfo);\r
 643     // Background subtraction-------------------------------------------------------------------\r
 644     if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);\r
 645     //------------------------------------------------------------------------------------------\r
 646   }\r
 647 \r
 648   //printf("test2\n");\r
 649 \r
 650   // need the centrality for everything (MC also)\r
 651   fCentralityF = -1;\r
 652   if(!ReadCentrality()) fCentralityF = -1;\r
 653   //printf("pass centrality\n");\r
 654   //printf("Reading fCentralityF %d\n",fCentralityF);\r
 655   \r
 656   // See if pile up and z in the range\r
 657   RejectionPileUpVertexRangeEventCut();\r
 658 \r
 659   //printf("test3\n");\r
 660 \r
 661   // Protect agains missing \r
 662   if(HasMCData()){\r
 663     //printf("Has MC data\n");\r
 664     fSignalCuts->SetMCEvent(fMCEvent);\r
 665     ProcessMC();  // Run the MC loop + MC QA in case MC Data are available\r
 666   }\r
 667   \r
 668   AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();\r
 669   if(!pidResponse){\r
 670     AliDebug(1, "Using default PID Response");\r
 671     pidResponse = AliHFEtools::GetDefaultPID(HasMCData(), fInputEvent->IsA() == AliESDEvent::Class());\r
 672   }\r
 673   fPID->SetPIDResponse(pidResponse);\r
 674   if(fPIDpreselect) fPIDpreselect->SetPIDResponse(pidResponse);\r
 675 \r
 676   // Background subtraction-------------------------------------------------------------------\r
 677   if(GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->InitRun(fInputEvent,pidResponse);\r
 678   //------------------------------------------------------------------------------------------\r
 679 \r
 680   // Event loop\r
 681   if(IsAODanalysis()){\r
 682     //printf("test4\n");\r
 683     ProcessAOD();\r
 684   } else {\r
 685     const char *specialTrigger = GetSpecialTrigger(fInputEvent->GetRunNumber());\r
 686     // Check Trigger selection\r
 687     if(specialTrigger){\r
 688       AliDebug(2, Form("Special Trigger requested: %s", specialTrigger));\r
 689       AliESDEvent *ev = dynamic_cast<AliESDEvent *>(fInputEvent);\r
 690       if(!(ev && ev->IsTriggerClassFired(specialTrigger))){\r
 691         AliDebug(2, "Event not selected"); \r
 692         return;\r
 693       } else AliDebug(2, "Event Selected");\r
 694     } else AliDebug(2, "No Special Trigger requested");\r
 695     \r
 696     ProcessESD();\r
 697   }\r
 698   // Done!!!\r
 699   PostData(1, fOutput);\r
 700   PostData(2, fQA);\r
 701 }\r
 702 \r
 703 //____________________________________________________________\r
 704 void AliAnalysisTaskHFE::Terminate(Option_t *){\r
 705   //\r
 706   // Terminate not implemented at the moment\r
 707   //\r
 708 }\r
 709 \r
 710 //_______________________________________________________________\r
 711 Bool_t AliAnalysisTaskHFE::IsEventInBinZero() {\r
 712   //\r
 713   //\r
 714   //\r
 715 \r
 716   //printf("test in IsEventInBinZero\n");\r
 717   if(!fInputEvent){\r
 718     AliError("Reconstructed Event not available");\r
 719     return kFALSE;\r
 720   }\r
 721 \r
 722   // check vertex\r
 723   const AliVVertex *vertex = fInputEvent->GetPrimaryVertex();\r
 724   if(!vertex) return kTRUE;\r
 725   //if(vertex) return kTRUE;\r
 726 \r
 727   // check tracks\r
 728   if(fInputEvent->GetNumberOfTracks()<=0) return kTRUE;\r
 729   //if(fInputEvent->GetNumberOfTracks()>0) return kTRUE;\r
 730   \r
 731   \r
 732   return kFALSE;\r
 733   \r
 734 }\r
 735 //____________________________________________________________\r
 736 void AliAnalysisTaskHFE::ProcessMC(){\r
 737   //\r
 738   // Runs the MC Loop (filling the container for the MC Cut Steps with the observables pt, eta and phi)\r
 739   // In case MC QA is on also MC QA loop is done\r
 740   //\r
 741   AliDebug(3, "Processing MC Information");\r
 742   Double_t eventContainer [4] = {0., 0., 0., 0.};\r
 743   if(IsESDanalysis()) eventContainer[0] = fMCEvent->GetPrimaryVertex()->GetZ();\r
 744   else eventContainer[0] = fAODMCHeader->GetVtxZ();\r
 745   eventContainer[2] = fCentralityF;\r
 746   eventContainer[3] = fContributors;\r
 747   fVz = eventContainer[0];\r
 748   //printf("z position is %f\n",eventContainer[0]);\r
 749   //if(fCFM->CheckEventCuts(AliHFEcuts::kEventStepGenerated, fMCEvent)) \r
 750   fCFM->GetEventContainer()->Fill(eventContainer,AliHFEcuts::kEventStepGenerated);\r
 751   Int_t nElectrons = 0;\r
 752   if(IsESDanalysis()){\r
 753    if(!((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0))){ //kStepMCGeneratedZOutNoPileUpCentralityFine\r
 754     if (HasMCData() && IsQAOn(kMCqa)) {\r
 755       AliDebug(2, "Running MC QA");\r
 756 \r
 757       if(fMCEvent->Stack()){\r
 758         fMCQA->SetMCEvent(fMCEvent);\r
 759         fMCQA->SetGenEventHeader(fMCEvent->GenEventHeader());\r
 760         fMCQA->SetCentrality(fCentralityF);\r
 761         fMCQA->SetPercentrality(fCentralityPercent);\r
 762         if(IsPbPb()) { fMCQA->SetPbPb();}\r
 763         else\r
 764         {\r
 765             if(fisppMultiBin) fMCQA->SetPPMultiBin();\r
 766             else fMCQA->SetPP();\r
 767         }\r
 768         fMCQA->Init();\r
 769 \r
 770         fMCQA->GetMesonKine();\r
 771 \r
 772         // loop over all tracks for decayed electrons\r
 773         for (Int_t igen = 0; igen < fMCEvent->GetNumberOfTracks(); igen++){\r
 774           TParticle* mcpart = fMCEvent->Stack()->Particle(igen);\r
 775           if(!mcpart) continue;\r
 776           fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kCharm);\r
 777           fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kBeauty);\r
 778           fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kCharm);\r
 779           fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kBeauty);\r
 780           fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm,  AliHFEmcQA::kElectronPDG); // no accept cut\r
 781           fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG); // no accept cut\r
 782           fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG); // no accept cut\r
 783         }\r
 784         //fMCQA->EndOfEventAna(AliHFEmcQA::kCharm);\r
 785         //fMCQA->EndOfEventAna(AliHFEmcQA::kBeauty);\r
 786       }\r
 787 \r
 788     } // end of MC QA loop\r
 789    }\r
 790    // -----------------------------------------------------------------\r
 791    fCFM->SetMCEventInfo(fMCEvent);\r
 792    // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);\r
 793   } else {\r
 794     fCFM->SetMCEventInfo(fInputEvent);\r
 795   }\r
 796   // Run MC loop\r
 797   AliVParticle *mctrack = NULL;\r
 798   Int_t numberofmctracks = 0;\r
 799   if(IsESDanalysis()){\r
 800     numberofmctracks = fMCEvent->GetNumberOfTracks();\r
 801   }\r
 802   else {\r
 803     numberofmctracks = fAODArrayMCInfo->GetEntriesFast();\r
 804   }\r
 805   AliDebug(3, Form("Number of Tracks: %d",numberofmctracks));\r
 806   //printf("Number of MC track %d\n",numberofmctracks);\r
 807   for(Int_t imc = 0; imc <numberofmctracks; imc++){\r
 808     if(IsESDanalysis()) {\r
 809       if(!(mctrack = fMCEvent->GetTrack(imc))) continue;\r
 810     }\r
 811     else {\r
 812       if(!(mctrack = (AliVParticle *) fAODArrayMCInfo->At(imc))) continue;\r
 813     }\r
 814     //printf("Test in ProcessMC\n");\r
 815     AliDebug(4, "Next MC Track");\r
 816     if(ProcessMCtrack(mctrack)) nElectrons++;\r
 817   }\r
 818 \r
 819   // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);\r
 820   fQACollection->Fill("nElectron", nElectrons);\r
 821 }\r
 822 \r
 823 //____________________________________________________________\r
 824 void AliAnalysisTaskHFE::ProcessESD(){\r
 825   //\r
 826   // Run Analysis of reconstructed event in ESD Mode\r
 827   // Loop over Tracks, filter according cut steps defined in AliHFEcuts\r
 828   //\r
 829   AliDebug(1, Form("Task %s", GetName()));\r
 830   AliDebug(3, "Processing ESD Event");\r
 831   AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);\r
 832   if(!fESD){\r
 833     AliError("ESD Event required for ESD Analysis");\r
 834     return;\r
 835   }\r
 836 \r
 837   // Set magnetic field if V0 task on\r
 838   if(fTaggedTrackAnalysis) {\r
 839     fTaggedTrackAnalysis->SetMagneticField(fESD->GetMagneticField());\r
 840     fTaggedTrackAnalysis->SetCentrality(fCentralityF);\r
 841     if(IsHeavyIon()) fTaggedTrackAnalysis->SetPbPb();\r
 842     else fTaggedTrackAnalysis->SetPP();\r
 843   }\r
 844 \r
 845   // Do event Normalization\r
 846   Double_t eventContainer[4];\r
 847   eventContainer[0] = 0.; \r
 848   if(HasMCData()) eventContainer[0] = fVz;\r
 849   else {\r
 850     const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();\r
 851     if(vtxESD) eventContainer[0] = vtxESD->GetZ();\r
 852   }\r
 853   eventContainer[1] = 0.;\r
 854   eventContainer[2] = fCentralityF;\r
 855   eventContainer[3] = fContributors;\r
 856   if(fTriggerAnalysis->IsOfflineTriggerFired(fESD, AliTriggerAnalysis::kV0AND))\r
 857     eventContainer[1] = 1.;\r
 858 \r
 859   //\r
 860   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);\r
 861 \r
 862   //\r
 863   if(fIdentifiedAsPileUp) return; \r
 864   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);\r
 865 \r
 866   //\r
 867   if(TMath::Abs(fCentralityF) < 0) return; \r
 868   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecCentralityOk);\r
 869   //printf("In ProcessESD %f\n",fCentralityF);\r
 870 \r
 871   //\r
 872   if(fIdentifiedAsOutInz) return;\r
 873   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange);  \r
 874 \r
 875   //\r
 876   if(!fPassTheEventCut) return;\r
 877   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);\r
 878 \r
 879 \r
 880   fContainer->NewEvent();\r
 881 \r
 882   if (GetPlugin(kIsElecBackGround)) { \r
 883     fElecBackGround->SetEvent(fESD);\r
 884   }\r
 885   if (GetPlugin(kSecVtx)) {\r
 886     fSecVtx->SetEvent(fESD);\r
 887     fSecVtx->GetPrimaryCondition();\r
 888   }\r
 889 \r
 890   if(HasMCData()){\r
 891     if (GetPlugin(kSecVtx)) { \r
 892       fSecVtx->SetMCEvent(fMCEvent);\r
 893       fSecVtx->SetMCQA(fMCQA); \r
 894     }\r
 895     if (GetPlugin(kIsElecBackGround)) { \r
 896       fElecBackGround->SetMCEvent(fMCEvent);\r
 897     }\r
 898   }\r
 899 \r
 900   Double_t container[10];\r
 901   memset(container, 0, sizeof(Double_t) * 10);\r
 902   // container for the output THnSparse\r
 903   Double_t dataDca[6]; // [source, pT, dca, centrality]\r
 904   Int_t nElectronCandidates = 0;\r
 905   AliESDtrack *track = NULL, *htrack = NULL;\r
 906   AliMCParticle *mctrack = NULL;\r
 907   AliMCParticle *mctrackmother = NULL;\r
 908 \r
 909   Bool_t signal = kTRUE;\r
 910 \r
 911   fCFM->SetRecEventInfo(fESD);\r
 912 \r
 913   // Get Number of contributors to the primary vertex for multiplicity-dependent correction\r
 914   Int_t ncontribVtx = 0;\r
 915   const AliESDVertex *priVtx = fESD->GetPrimaryVertexTracks();\r
 916   if(priVtx){\r
 917     ncontribVtx = priVtx->GetNContributors();\r
 918   }\r
 919 \r
 920   // minjung for IP QA(temporary ~ 2weeks)\r
 921   if(!fExtraCuts){\r
 922     fExtraCuts = new AliHFEextraCuts("hfetmpCuts","HFE tmp Cuts");\r
 923   }\r
 924   fExtraCuts->SetRecEventInfo(fESD);\r
 925 \r
 926   // Electron background analysis \r
 927   if (GetPlugin(kIsElecBackGround)) {\r
 928 \r
 929     AliDebug(2, "Running BackGround Analysis");\r
 930 \r
 931     fElecBackGround->Reset();\r
 932 \r
 933   } // end of electron background analysis\r
 934 \r
 935 \r
 936   // Background subtraction-------------------------------------------------------------------\r
 937   if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);\r
 938   //------------------------------------------------------------------------------------------\r
 939 \r
 940   //\r
 941   // Loop ESD\r
 942   //\r
 943   AliDebug(3, Form("Number of Tracks: %d", fESD->GetNumberOfTracks()));\r
 944   for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){\r
 945     AliDebug(4, "New ESD track");\r
 946     track = fESD->GetTrack(itrack);\r
 947     track->SetESDEvent(fESD);\r
 948 \r
 949     // fill counts of v0-identified particles\r
 950     Int_t v0pid = -1;\r
 951     if(track->TestBit(BIT(14))) v0pid = AliPID::kElectron;\r
 952     else if(track->TestBit(BIT(15))) v0pid = AliPID::kPion;\r
 953     else if(track->TestBit(BIT(16))) v0pid = AliPID::kProton;\r
 954     // here the tagged track analysis will run\r
 955     if(fTaggedTrackAnalysis && v0pid > -1){ \r
 956       AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));\r
 957       fTaggedTrackAnalysis->ProcessTrack(track, v0pid);\r
 958       AliDebug(1, "V0 PID done");\r
 959     }\r
 960  \r
 961 \r
 962     //Fill non-HFE source containers at reconstructed events cut step\r
 963     AliDebug(3, Form("Doing track %d, %p", itrack, track));\r
 964 \r
 965 \r
 966     //////////////////////////////////////\r
 967     // preselect\r
 968     //////////////////////////////////////\r
 969     if(fPIDpreselect || fCutspreselect) {\r
 970       if(!PreSelectTrack(track)) continue;\r
 971     }\r
 972 \r
 973     signal = kTRUE;\r
 974     \r
 975     // Fill step without any cut\r
 976           \r
 977     if(HasMCData()){\r
 978       // Check if it is electrons near the vertex\r
 979       if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(track->GetLabel()))))) continue;\r
 980 \r
 981       if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE; \r
 982       else AliDebug(3, "Signal Electron");\r
 983 \r
 984       // Fill K pt for Ke3 contributions\r
 985       if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==321)) fQACollection->Fill("Kptspectra",mctrack->Pt());\r
 986       else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==130)) fQACollection->Fill("K0Lptspectra",mctrack->Pt());\r
 987     } \r
 988     // Cache new Track information inside the var manager\r
 989     fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);\r
 990 \r
 991     if(fFillNoCuts) {\r
 992       if(signal || !fFillSignalOnly){\r
 993         fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);\r
 994         fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);\r
 995       }\r
 996     }\r
 997   \r
 998     // RecKine: ITSTPC cuts  \r
 999     if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;\r
1000     \r
1001     \r
1002     // RecPrim\r
1003     if(fRejectKinkMother) { \r
1004       if(track->GetKinkIndex(0) != 0) continue; } // Quick and dirty fix to reject both kink mothers and daughters\r
1005     if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;\r
1006 \r
1007     // HFEcuts: ITS layers cuts\r
1008     if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;\r
1009   \r
1010     // HFE cuts: TOF PID and mismatch flag\r
1011     if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;\r
1012 \r
1013     // HFE cuts: TPC PID cleanup\r
1014     if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;\r
1015 \r
1016     // HFEcuts: Nb of tracklets TRD0\r
1017     if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;\r
1018 \r
1019     // Fill correlation maps before PID\r
1020     if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {\r
1021       //printf("Fill correlation maps before PID\n");\r
1022       fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));\r
1023     }\r
1024 \r
1025     if(HasMCData()){\r
1026       FillProductionVertex(track);\r
1027 \r
1028       if(fMCQA && signal){\r
1029         fMCQA->SetCentrality(fCentralityF);\r
1030         if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){\r
1031          Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};\r
1032          Double_t hfeimpactRtmp=0., hfeimpactnsigmaRtmp=0.;\r
1033          fExtraCuts->GetHFEImpactParameters(track, hfeimpactRtmp, hfeimpactnsigmaRtmp);\r
1034          UChar_t itsPixel = track->GetITSClusterMap();\r
1035          Double_t ilyrhit=0, ilyrstat=0;\r
1036          for(Int_t ilyr=0; ilyr<6; ilyr++){\r
1037            if(TESTBIT(itsPixel, ilyr)) ilyrhit += TMath::Power(2,ilyr);\r
1038            if(fExtraCuts->CheckITSstatus(fExtraCuts->GetITSstatus(track,ilyr))) ilyrstat += TMath::Power(2,ilyr);\r
1039          }\r
1040          fMCQA->SetITSInfo(ilyrhit,ilyrstat);\r
1041          fMCQA->SetHFEImpactParameters(hfeimpactRtmp, hfeimpactnsigmaRtmp);\r
1042          fMCQA->SetTrkKine(track->Pt(),track->Eta(), track->Phi());\r
1043          fMCQA->SetContainerStep(3);\r
1044          for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
1045            weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE \r
1046            if(!fisNonHFEsystematics || IsPbPb())break;   \r
1047          }\r
1048          \r
1049          if(fisNonHFEsystematics){\r
1050            //Fill additional containers for electron source distinction\r
1051            Int_t elecSource = 0;\r
1052            elecSource = fMCQA->GetElecSource(mctrack->Particle());\r
1053            const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};\r
1054            const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};\r
1055            Int_t iName = 0;\r
1056            for(Int_t iSource = AliHFEmcQA::kPi0; iSource <=  AliHFEmcQA::kGammaRho0; iSource++){\r
1057              if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;\r
1058              if(elecSource == iSource){\r
1059                for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
1060                  if(weightElecBgV0[iLevel]>0){ \r
1061                    fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, weightElecBgV0[iLevel]);\r
1062                  } \r
1063                  else if(weightElecBgV0[iLevel]<0){ \r
1064                    fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, -1*weightElecBgV0[iLevel]);\r
1065                  }\r
1066                  if(IsPbPb())break;\r
1067                }\r
1068                break;\r
1069              }\r
1070              iName++;\r
1071              if(iName == kElecBgSpecies)iName = 0;\r
1072            }\r
1073          }\r
1074          //else{\r
1075            if(weightElecBgV0[0]>0) {\r
1076              fVarManager->FillContainer(fContainer, "conversionElecs", 3, kFALSE, weightElecBgV0[0]);\r
1077              fVarManager->FillContainer(fContainer, "conversionElecs", 4, kTRUE, weightElecBgV0[0]);\r
1078            }\r
1079            else if(weightElecBgV0[0]<0) {\r
1080              fVarManager->FillContainer(fContainer, "mesonElecs", 3, kFALSE, -1*weightElecBgV0[0]);\r
1081              fVarManager->FillContainer(fContainer, "mesonElecs", 4, kTRUE, -1*weightElecBgV0[0]);\r
1082            }\r
1083            //}\r
1084         }\r
1085       }\r
1086 \r
1087       Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;\r
1088       Int_t sourceDca =-1;\r
1089       if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 211)){\r
1090         if(track->Pt()>4.){\r
1091           fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);\r
1092           dataDca[0]=0; //pion\r
1093           dataDca[1]=track->Pt();\r
1094           dataDca[2]=hfeimpactR4all;\r
1095           dataDca[3]=fCentralityF;\r
1096           dataDca[4] = v0pid;\r
1097           dataDca[5] = double(track->Charge());\r
1098           fQACollection->Fill("Dca", dataDca);\r
1099         }\r
1100       }\r
1101       else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){ // to increas statistics for Martin\r
1102         if(signal){\r
1103           fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);\r
1104           if(fSignalCuts->IsCharmElectron(track)){\r
1105             sourceDca=1;\r
1106           }\r
1107           else if(fSignalCuts->IsBeautyElectron(track)){\r
1108             sourceDca=2;\r
1109           }\r
1110           else if(fSignalCuts->IsGammaElectron(track)){\r
1111             sourceDca=3;\r
1112           }\r
1113           else if(fSignalCuts->IsNonHFElectron(track)){\r
1114             sourceDca=4;\r
1115           }\r
1116           else if(fSignalCuts->IsJpsiElectron(track)){\r
1117             sourceDca=5;\r
1118           }\r
1119           else {\r
1120             sourceDca=6;\r
1121           }\r
1122           dataDca[0]=sourceDca;\r
1123           dataDca[1]=track->Pt();\r
1124           dataDca[2]=hfeimpactR4all;\r
1125           dataDca[3]=fCentralityF;\r
1126           dataDca[4] = v0pid;\r
1127           dataDca[5] = double(track->Charge());\r
1128           if(signal) fQACollection->Fill("Dca", dataDca);\r
1129         }\r
1130       }\r
1131     }\r
1132 \r
1133     AliHFEpidObject hfetrack;\r
1134     hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);\r
1135     hfetrack.SetRecTrack(track);\r
1136     if(HasMCData()) hfetrack.SetMCTrack(mctrack);\r
1137     hfetrack.SetCentrality(fCentralityF);\r
1138     hfetrack.SetMulitplicity(ncontribVtx);\r
1139     if(IsHeavyIon()) hfetrack.SetPbPb();\r
1140     else hfetrack.SetPP();\r
1141     fPID->SetVarManager(fVarManager);\r
1142     if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;\r
1143     nElectronCandidates++;\r
1144     \r
1145     // Background subtraction------------------------------------------------------------------------------------------\r
1146     if (GetPlugin(kNonPhotonicElectron)) {\r
1147       Int_t indexmother = -1;\r
1148       Int_t mcsource = -1;\r
1149       if(HasMCData()){\r
1150         mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);\r
1151       }\r
1152       fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1, mcsource, indexmother);\r
1153     }\r
1154     //-----------------------------------------------------------------------------------------------------------------\r
1155 \r
1156     // Temporary histogram for chi2/ITS cluster\r
1157     if(IsPbPb()) {\r
1158       TBits shared = track->GetTPCSharedMap();\r
1159             Int_t sharebit=0;\r
1160       if(shared.CountBits() >= 2) sharebit=1;\r
1161 \r
1162             Double_t itschi2percluster = 0.0;\r
1163             Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));\r
1164             if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;\r
1165 \r
1166       Double_t itsChi2[7] = {track->Pt(),track->Eta(), track->Phi(),\r
1167                         fCentralityF,track->GetTPCsignalN(), sharebit,itschi2percluster};\r
1168       fQACollection->Fill("fChi2perITScluster", itsChi2);\r
1169     }\r
1170     else{\r
1171 \r
1172       Double_t itschi2percluster = 0.0;\r
1173       Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));\r
1174       if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;\r
1175 \r
1176       Double_t itsChi2[3] = {track->Pt(), fCentralityF, itschi2percluster};\r
1177       fQACollection->Fill("fChi2perITScluster", itsChi2);\r
1178     }\r
1179 \r
1180     // Fill Histogram for Hadronic Background\r
1181     if(HasMCData()){\r
1182       if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11))\r
1183         fVarManager->FillContainer(fContainer, "hadronicBackground", UInt_t(0), kFALSE);\r
1184       else if(mctrack){\r
1185         // Fill Ke3 contributions\r
1186         Int_t glabel=TMath::Abs(mctrack->GetMother());\r
1187         if((mctrackmother = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(glabel)))){\r
1188           if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==321)\r
1189             fQACollection->Fill("Ke3Kecorr",mctrack->Pt(),mctrackmother->Pt());\r
1190           else if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==130)\r
1191             fQACollection->Fill("Ke3K0Lecorr",mctrack->Pt(),mctrackmother->Pt());\r
1192         }\r
1193       }\r
1194     }\r
1195 \r
1196     // Fill Containers\r
1197     if(signal) {\r
1198       // Apply weight for background contamination\r
1199       if(fBackGroundFactorApply) {\r
1200         if(IsHeavyIon() && fCentralityF >= 0) fWeightBackGround =  fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));\r
1201         else    fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case\r
1202 \r
1203         if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;\r
1204         else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;\r
1205         // weightBackGround as special weight\r
1206         fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);\r
1207       }\r
1208       fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));\r
1209     }\r
1210 \r
1211     Bool_t bTagged=kFALSE;\r
1212     if(GetPlugin(kSecVtx)) {\r
1213       AliDebug(2, "Running Secondary Vertex Analysis");\r
1214       if(fSecVtx->Process(track) && signal) {\r
1215         fVarManager->FillContainer(fContainer, "recTrackContSecvtxReco", AliHFEcuts::kStepHFEcutsSecvtx, kFALSE);\r
1216         fVarManager->FillContainer(fContainer, "recTrackContSecvtxMC", AliHFEcuts::kStepHFEcutsSecvtx, kTRUE);\r
1217         bTagged=kTRUE;\r
1218       }\r
1219     }\r
1220 \r
1221     // Electron background analysis \r
1222     if (GetPlugin(kIsElecBackGround)) {\r
1223       \r
1224       AliDebug(2, "Running BackGround Analysis");\r
1225       \r
1226       for(Int_t jtrack = 0; jtrack < fESD->GetNumberOfTracks(); jtrack++){\r
1227         htrack = fESD->GetTrack(jtrack);\r
1228         if ( itrack == jtrack ) continue;  \r
1229         fElecBackGround->PairAnalysis(track, htrack); \r
1230       }\r
1231     } // end of electron background analysis\r
1232 \r
1233     if (GetPlugin(kDEstep)) { \r
1234       Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.,};\r
1235       Int_t elecSource = 0;\r
1236       Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;\r
1237       fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);\r
1238       if(HasMCData())\r
1239       {\r
1240         if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){\r
1241             fQACollection->Fill("hadronsBeforeIPcut",track->Pt());\r
1242         } \r
1243         if(fMCQA && signal) {\r
1244           \r
1245           fMCQA->SetContainerStep(0);\r
1246           for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
1247             weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE \r
1248             if(!fisNonHFEsystematics || IsPbPb())break;        \r
1249           }\r
1250           \r
1251           if(fisNonHFEsystematics){\r
1252             //Fill additional containers for electron source distinction           \r
1253             elecSource = fMCQA->GetElecSource(mctrack->Particle());\r
1254             const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};\r
1255             const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};\r
1256             Int_t iName = 0;\r
1257             for(Int_t iSource = AliHFEmcQA::kPi0; iSource <=  AliHFEmcQA::kGammaRho0; iSource++){\r
1258               if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;\r
1259               if(elecSource == iSource){\r
1260                 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
1261                   if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, weightElecBgV0[iLevel]);\r
1262                   else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, -1*weightElecBgV0[iLevel]);\r
1263                   if(IsPbPb())break;\r
1264                 }\r
1265                 break;\r
1266               }\r
1267               iName++;\r
1268               if(iName == kElecBgSpecies)iName = 0;\r
1269             }\r
1270           }\r
1271           //else{\r
1272           if(weightElecBgV0[0]>0) {\r
1273             fVarManager->FillContainer(fContainer, "conversionElecs", 0, kFALSE, weightElecBgV0[0]);\r
1274             fVarManager->FillContainer(fContainer, "conversionElecs", 5, kTRUE, weightElecBgV0[0]);\r
1275           }\r
1276           else if(weightElecBgV0[0]<0) {\r
1277             fVarManager->FillContainer(fContainer, "mesonElecs", 0, kFALSE, -1*weightElecBgV0[0]);\r
1278             fVarManager->FillContainer(fContainer, "mesonElecs", 5, kTRUE, -1*weightElecBgV0[0]);\r
1279           }  \r
1280           //}\r
1281           if(bTagged){ // bg estimation for the secondary vertex tagged signals\r
1282             if(weightElecBgV0[0]>0) fVarManager->FillContainer(fContainer, "conversionElecs", 2, kFALSE, weightElecBgV0[0]);\r
1283             else if(weightElecBgV0[0]<0) fVarManager->FillContainer(fContainer, "mesonElecs", 2, kFALSE, -1*weightElecBgV0[0]);\r
1284           }\r
1285         }\r
1286       } // end of MC\r
1287 \r
1288       dataDca[0]=-1; //for data, don't know the origin\r
1289       dataDca[1]=track->Pt();\r
1290       dataDca[2]=hfeimpactR;\r
1291       dataDca[3]=fCentralityF;\r
1292       dataDca[4] = v0pid;\r
1293       dataDca[5] = double(track->Charge());\r
1294       if (!HasMCData()) fQACollection->Fill("Dca", dataDca);\r
1295 \r
1296       // Fill Containers for impact parameter analysis\r
1297       if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;\r
1298       if(signal) {\r
1299         // Apply weight for background contamination after ip cut\r
1300         if(fBackGroundFactorApply) {\r
1301               fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case\r
1302               if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;\r
1303               else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;\r
1304               // weightBackGround as special weight\r
1305               fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);\r
1306         }\r
1307       }\r
1308 \r
1309       if(HasMCData()){\r
1310         if(fMCQA && signal) {\r
1311           fMCQA->SetContainerStep(1);\r
1312           for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
1313             weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE \r
1314             if(!fisNonHFEsystematics || IsPbPb())break;        \r
1315           }       \r
1316           if(fisNonHFEsystematics){\r
1317             //Fill additional containers for electron source distinction             \r
1318             elecSource = fMCQA->GetElecSource(mctrack->Particle());\r
1319             const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};\r
1320             const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};\r
1321             Int_t iName = 0;\r
1322             for(Int_t iSource = AliHFEmcQA::kPi0; iSource <=  AliHFEmcQA::kGammaRho0; iSource++){\r
1323               if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;\r
1324               if(elecSource == iSource){\r
1325                 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
1326                   if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, weightElecBgV0[iLevel]);\r
1327                   else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, -1*weightElecBgV0[iLevel]);\r
1328                   if(IsPbPb())break;\r
1329                 }\r
1330                 break;\r
1331               }\r
1332               iName++;\r
1333               if(iName == kElecBgSpecies)iName = 0;\r
1334             }\r
1335           }\r
1336           // else{\r
1337             if(weightElecBgV0[0]>0) {\r
1338               fVarManager->FillContainer(fContainer, "conversionElecs", 1, kFALSE, weightElecBgV0[0]);\r
1339               fVarManager->FillContainer(fContainer, "conversionElecs", 6, kTRUE, weightElecBgV0[0]);\r
1340             }\r
1341             else if(weightElecBgV0[0]<0) {\r
1342               fVarManager->FillContainer(fContainer, "mesonElecs", 1, kFALSE, -1*weightElecBgV0[0]);\r
1343               fVarManager->FillContainer(fContainer, "mesonElecs", 6, kTRUE, -1*weightElecBgV0[0]);\r
1344             }\r
1345             //}\r
1346         }\r
1347       }\r
1348       if(signal) {\r
1349         fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE);\r
1350         fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE);\r
1351         fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));\r
1352       }\r
1353       if(HasMCData()){\r
1354         if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){\r
1355           fQACollection->Fill("hadronsAfterIPcut",track->Pt());\r
1356         }\r
1357       }\r
1358     }\r
1359 \r
1360   }\r
1361 \r
1362   // Background subtraction-------------------------------------------------------------------\r
1363   if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);\r
1364   //------------------------------------------------------------------------------------------\r
1365 \r
1366   fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);\r
1367 }\r
1368 \r
1369 //____________________________________________________________\r
1370 void AliAnalysisTaskHFE::ProcessAOD(){\r
1371   //\r
1372   // Run Analysis in AOD Mode\r
1373   // Function is still in development\r
1374   //\r
1375   //printf("Process AOD\n");\r
1376   AliDebug(3, "Processing AOD Event");\r
1377   Double_t eventContainer[4];\r
1378   eventContainer[0] = 0.0;\r
1379   if(HasMCData()) eventContainer[0] = fVz;\r
1380   else {\r
1381     if(fInputEvent->GetPrimaryVertex()) eventContainer[0] = fInputEvent->GetPrimaryVertex()->GetZ();\r
1382   }\r
1383   eventContainer[1] = 1.; // No Information available in AOD analysis, assume all events have V0AND\r
1384   eventContainer[2] = fCentralityF; \r
1385   eventContainer[3] = fContributors; \r
1386   \r
1387   //printf("value event container %f, %f, %f, %f\n",eventContainer[0],eventContainer[1],eventContainer[2],eventContainer[3]);\r
1388 \r
1389   AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);\r
1390   if(!fAOD){\r
1391     AliError("AOD Event required for AOD Analysis");\r
1392       return;\r
1393   }\r
1394   \r
1395   //printf("Will fill\n");\r
1396   //\r
1397   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);\r
1398   //printf("Fill\n");\r
1399   //\r
1400   if(fIdentifiedAsPileUp) return; \r
1401   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);\r
1402 \r
1403   //\r
1404   if(fIdentifiedAsOutInz) return;\r
1405   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange);  \r
1406 \r
1407   //\r
1408   if(!fPassTheEventCut) return;\r
1409   fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);\r
1410   //printf("pass\n");\r
1411 \r
1412   fContainer->NewEvent();\r
1413 \r
1414   fCFM->SetRecEventInfo(fAOD);\r
1415 \r
1416   if(!fExtraCuts){\r
1417     fExtraCuts = new AliHFEextraCuts("hfeExtraCuts","HFE Extra Cuts");\r
1418   }\r
1419   fExtraCuts->SetRecEventInfo(fAOD);\r
1420 \r
1421   // Get Number of contributors to the primary vertex for multiplicity-dependent correction\r
1422   Int_t ncontribVtx = 0;\r
1423   AliAODVertex *priVtx = fAOD->GetPrimaryVertex();\r
1424   if(priVtx){\r
1425     ncontribVtx = priVtx->GetNContributors();\r
1426   }\r
1427 \r
1428   // Look for kink mother\r
1429   Int_t numberofvertices = fAOD->GetNumberOfVertices();\r
1430   Double_t listofmotherkink[numberofvertices];\r
1431   Int_t numberofmotherkink = 0;\r
1432   for(Int_t ivertex=0; ivertex < numberofvertices; ivertex++) {\r
1433     AliAODVertex *aodvertex = fAOD->GetVertex(ivertex);\r
1434     if(!aodvertex) continue;\r
1435     if(aodvertex->GetType()==AliAODVertex::kKink) {\r
1436       AliAODTrack *mother = (AliAODTrack *) aodvertex->GetParent();\r
1437       if(!mother) continue;\r
1438       Int_t idmother = mother->GetID();\r
1439       listofmotherkink[numberofmotherkink] = idmother;\r
1440       //printf("ID %d\n",idmother);\r
1441       numberofmotherkink++;\r
1442     }\r
1443   }\r
1444   //printf("Number of kink mother in the events %d\n",numberofmotherkink);\r
1445 \r
1446   // Background subtraction-------------------------------------------------------------------\r
1447   if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);\r
1448   //------------------------------------------------------------------------------------------\r
1449 \r
1450   // Loop over tracks\r
1451   AliAODTrack *track = NULL;\r
1452   AliAODMCParticle *mctrack = NULL;\r
1453   Double_t dataDca[6]; // [source, pT, dca, centrality]\r
1454   Int_t nElectronCandidates = 0;\r
1455   Bool_t signal;\r
1456 \r
1457   //printf("Number of track %d\n",(Int_t) fAOD->GetNumberOfTracks());\r
1458   for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){\r
1459     track = fAOD->GetTrack(itrack); mctrack = NULL;\r
1460     if(!track) continue;\r
1461     \r
1462     signal = kTRUE;\r
1463     if(HasMCData()){\r
1464 \r
1465       Int_t label = TMath::Abs(track->GetLabel());\r
1466       if(label && label < fAODArrayMCInfo->GetEntriesFast())\r
1467         mctrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(label));\r
1468         if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;\r
1469     }\r
1470     \r
1471     fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);\r
1472     \r
1473     if(fFillNoCuts) {\r
1474       if(signal || !fFillSignalOnly){\r
1475         fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);\r
1476         fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);\r
1477       }\r
1478     }\r
1479 \r
1480     fQACollection->Fill("Filterorigin", -1);  \r
1481     for(Int_t k=0; k<20; k++) {\r
1482       Int_t u = 1<<k;\r
1483       if((track->TestFilterBit(u))) {\r
1484               fQACollection->Fill("Filterorigin", k);\r
1485       }\r
1486     }\r
1487 \r
1488     if(fApplyCutAOD) {\r
1489       //printf("Apply cuts\n");\r
1490       // RecKine: ITSTPC cuts  \r
1491       if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;\r
1492 \r
1493       // Reject kink mother\r
1494       if(fRejectKinkMother) {\r
1495             Bool_t kinkmotherpass = kTRUE;\r
1496             for(Int_t kinkmother = 0; kinkmother < numberofmotherkink; kinkmother++) {\r
1497               if(track->GetID() == listofmotherkink[kinkmother]) {\r
1498                 kinkmotherpass = kFALSE;\r
1499                 continue;\r
1500               }\r
1501             }\r
1502             if(!kinkmotherpass) continue;\r
1503       }\r
1504       \r
1505       // RecPrim\r
1506       if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;\r
1507       \r
1508       // HFEcuts: ITS layers cuts\r
1509       if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;\r
1510       \r
1511       // HFE cuts: TOF PID and mismatch flag\r
1512       if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;\r
1513       \r
1514       // HFE cuts: TPC PID cleanup\r
1515       if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;\r
1516       \r
1517       // HFEcuts: Nb of tracklets TRD0\r
1518       if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;\r
1519     }\r
1520 \r
1521     // Fill correlation maps before PID\r
1522     if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {\r
1523       //printf("Fill correlation maps before PID\n");\r
1524       fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));\r
1525     }\r
1526 \r
1527     if(HasMCData()){\r
1528       Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;\r
1529       Int_t sourceDca =-1;\r
1530       if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 211)){\r
1531         if(track->Pt()>4.){\r
1532           fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);\r
1533           dataDca[0]=0; //pion\r
1534           dataDca[1]=track->Pt();\r
1535           dataDca[2]=hfeimpactR4all;\r
1536           dataDca[3]=fCentralityF;\r
1537           dataDca[4] = -1; // not store V0 for the moment\r
1538           dataDca[5] = double(track->Charge());\r
1539           fQACollection->Fill("Dca", dataDca);\r
1540         }\r
1541       }\r
1542       else if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 11)){ // to increas statistics for Martin\r
1543         if(signal){\r
1544           fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);\r
1545           if(fSignalCuts->IsCharmElectron(track)){\r
1546             sourceDca=1;\r
1547           }\r
1548           else if(fSignalCuts->IsBeautyElectron(track)){\r
1549             sourceDca=2;\r
1550           }\r
1551           else if(fSignalCuts->IsGammaElectron(track)){\r
1552             sourceDca=3;\r
1553           }\r
1554           else if(fSignalCuts->IsNonHFElectron(track)){\r
1555             sourceDca=4;\r
1556           }\r
1557           else if(fSignalCuts->IsJpsiElectron(track)){\r
1558             sourceDca=5;\r
1559           }\r
1560           else {\r
1561             sourceDca=6;\r
1562           }\r
1563           dataDca[0]=sourceDca;\r
1564           dataDca[1]=track->Pt();\r
1565           dataDca[2]=hfeimpactR4all;\r
1566           dataDca[3]=fCentralityF;\r
1567           dataDca[4] = -1; // not store V0 for the moment\r
1568           dataDca[5] = double(track->Charge());\r
1569           if(signal) fQACollection->Fill("Dca", dataDca);\r
1570         }\r
1571       }\r
1572     }\r
1573 \r
1574     //printf("Will process to PID\n");\r
1575 \r
1576     // track accepted, do PID\r
1577     AliHFEpidObject hfetrack;\r
1578     hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis);\r
1579     hfetrack.SetRecTrack(track);\r
1580     if(HasMCData()) hfetrack.SetMCTrack(mctrack);\r
1581     hfetrack.SetCentrality(fCentralityF);\r
1582     hfetrack.SetMulitplicity(ncontribVtx); // for correction\r
1583     if(IsHeavyIon()) hfetrack.SetPbPb();\r
1584     else hfetrack.SetPP();\r
1585     fPID->SetVarManager(fVarManager);\r
1586     if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;   \r
1587     // we will do PID here as soon as possible\r
1588 \r
1589     // Background subtraction----------------------------------------------------------------------------------------------\r
1590     if (GetPlugin(kNonPhotonicElectron)) {\r
1591       Int_t indexmother = -1;\r
1592       Int_t mcsource = -1;\r
1593       if(HasMCData() && mctrack)  mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);\r
1594       fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1,mcsource, indexmother);\r
1595     }\r
1596     //---------------------------------------------------------------------------------------------------------------------\r
1597 \r
1598     // end AOD QA\r
1599     fQACollection->Fill("Filterend", -1);  \r
1600     for(Int_t k=0; k<20; k++) {\r
1601       Int_t u = 1<<k;\r
1602       if((track->TestFilterBit(u))) {\r
1603               fQACollection->Fill("Filterend", k);\r
1604       }\r
1605     }\r
1606        \r
1607     // Apply weight for background contamination\r
1608     //Double_t weightBackGround = 1.0;\r
1609     if(signal) {\r
1610       // Apply weight for background contamination\r
1611       if(fBackGroundFactorApply) {\r
1612               if(IsHeavyIon() && fCentralityF >= 0) fWeightBackGround =  fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));\r
1613               else    fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case\r
1614         \r
1615               if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;\r
1616               else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;\r
1617         // weightBackGround as special weight\r
1618         fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);\r
1619       }\r
1620       fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));\r
1621     }\r
1622     \r
1623     nElectronCandidates++;    \r
1624 \r
1625     if (GetPlugin(kDEstep)) {\r
1626       if (!HasMCData()){\r
1627         Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;\r
1628         fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);\r
1629         dataDca[0]=-1; //for data, don't know the origin\r
1630         dataDca[1]=track->Pt();\r
1631         dataDca[2]=hfeimpactR;\r
1632         dataDca[3]=fCentralityF;\r
1633         dataDca[4] = -1; // not store V0 for the moment\r
1634         dataDca[5] = double(track->Charge());\r
1635         fQACollection->Fill("Dca", dataDca);\r
1636       }\r
1637 \r
1638       // Fill Containers for impact parameter analysis\r
1639       if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;\r
1640       if(signal) {\r
1641         // Apply weight for background contamination after ip cut\r
1642         if(fBackGroundFactorApply) {\r
1643               fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case\r
1644               if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;\r
1645               else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;\r
1646               // weightBackGround as special weight\r
1647               fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);\r
1648         }\r
1649       }\r
1650     }\r
1651   }\r
1652 \r
1653   // Background subtraction-------------------------------------------------------------------\r
1654   if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);\r
1655   //------------------------------------------------------------------------------------------\r
1656 \r
1657   fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);\r
1658 }\r
1659 \r
1660 //____________________________________________________________\r
1661 Bool_t AliAnalysisTaskHFE::ProcessMCtrack(AliVParticle *track){\r
1662   //\r
1663   // Filter the Monte Carlo Track\r
1664   // Additionally Fill a THnSparse for Signal To Background Studies\r
1665   // Works for AOD and MC analysis Type\r
1666   //\r
1667   fVarManager->NewTrack(track, NULL, fCentralityF, -1, kTRUE);\r
1668 \r
1669 \r
1670   Double_t vertex[3] = {0.,0.,0.}; // Production vertex cut to mask gammas which are NOT supposed to have hits in the first ITS layer(s)\r
1671   if(IsESDanalysis()){\r
1672     AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(track);\r
1673     if(mctrack){\r
1674       vertex[0] = mctrack->Particle()->Vx();\r
1675       vertex[1] = mctrack->Particle()->Vy();\r
1676     }\r
1677   } else {\r
1678     AliAODMCParticle *aodmctrack = dynamic_cast<AliAODMCParticle *>(track);\r
1679     if(aodmctrack) aodmctrack->XvYvZv(vertex);\r
1680   }\r
1681 \r
1682   //printf("MC Generated\n");\r
1683   if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, track)) return kFALSE;\r
1684   //printf("MC Generated pass\n");\r
1685   fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGenerated, kFALSE);\r
1686 \r
1687   // Step GeneratedZOutNoPileUp\r
1688   if((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0)) return kFALSE;\r
1689   fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedZOutNoPileUpCentralityFine, kFALSE);\r
1690   //printf("In ProcessMCtrack %f\n",fCentralityF);\r
1691 \r
1692   // Step Generated Event Cut\r
1693   if(!fPassTheEventCut) return kFALSE;\r
1694   fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedEventCut, kFALSE);\r
1695 \r
1696   if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCInAcceptance, track)) return kFALSE;\r
1697   fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCInAcceptance, kFALSE);\r
1698   return kTRUE;\r
1699 }\r
1700 \r
1701 //____________________________________________________________\r
1702 Bool_t AliAnalysisTaskHFE::PreSelectTrack(AliESDtrack *track) const {\r
1703   //\r
1704   // Preselect tracks\r
1705   //\r
1706   \r
1707 \r
1708   Bool_t survived = kTRUE;\r
1709 \r
1710   if(fCutspreselect) {\r
1711     //printf("test preselect\n");\r
1712     if(!fCutspreselect->IsSelected(track)) survived=kFALSE;\r
1713   }\r
1714   //printf("survived %d\n",(Int_t)survived);\r
1715   \r
1716   if(survived && fPIDpreselect){\r
1717     // Apply PID\r
1718     AliHFEpidObject hfetrack;\r
1719     hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);\r
1720     hfetrack.SetRecTrack(track);\r
1721     if(!fPIDpreselect->IsSelected(&hfetrack)) {\r
1722       //printf("Did not pass AliHFEcuts::kPID\n");\r
1723       survived = kFALSE;\r
1724     }\r
1725     //else printf("Pass AliHFEcuts::kPID\n");\r
1726   }\r
1727 \r
1728   return survived; \r
1729       \r
1730 }\r
1731 //____________________________________________________________\r
1732 void AliAnalysisTaskHFE::MakeEventContainer(){\r
1733   //\r
1734   // Create the event container for the correction framework and link it\r
1735   // 1st bin: Vertex z-position\r
1736   // 2nd bin: V0AND decision (normalization to sigma_inel)\r
1737   // 3rd bin: Centrality class (for pp defined as number of contributors in vertex.)\r
1738   // 4th bin: Number of contributors > 0\r
1739   //\r
1740   \r
1741   const Int_t kNvar = 4;  // number of variables on the grid: \r
1742   Int_t nBins[kNvar] = {120, 2, 11, 2};\r
1743   Double_t binMin[kNvar] = {-30. , 0., 0.0, 0.};\r
1744   Double_t binMax[kNvar] = {30., 2., 11.0, 2.};\r
1745   \r
1746   AliCFContainer *evCont = new AliCFContainer("eventContainer", "Container for events", AliHFEcuts::kNcutStepsEvent, kNvar, nBins);\r
1747   \r
1748   Double_t *vertexBins = AliHFEtools::MakeLinearBinning(nBins[0], binMin[0], binMax[0]);\r
1749   Double_t *v0andBins = AliHFEtools::MakeLinearBinning(nBins[1], binMin[1], binMax[1]);\r
1750   Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBins[2], binMin[2], binMax[2]);\r
1751   Double_t *contributorsBins = AliHFEtools::MakeLinearBinning(nBins[3], binMin[3], binMax[3]);\r
1752   evCont->SetBinLimits(0, vertexBins);\r
1753   evCont->SetBinLimits(1, v0andBins);\r
1754   evCont->SetBinLimits(2, centralityBins);\r
1755   evCont->SetBinLimits(3, contributorsBins);\r
1756   delete[] vertexBins; delete[] v0andBins; delete[] centralityBins; delete[] contributorsBins;\r
1757     \r
1758   fCFM->SetEventContainer(evCont);\r
1759 }\r
1760 \r
1761 //____________________________________________________________\r
1762 void AliAnalysisTaskHFE::MakeParticleContainer(){\r
1763   //\r
1764   // Create the particle container for the correction framework manager and \r
1765   // link it\r
1766   //\r
1767   if(!fContainer) fContainer = new AliHFEcontainer("trackContainer");\r
1768   fVarManager->DefineVariables(fContainer);\r
1769 \r
1770   // Create Correction Framework containers\r
1771   fContainer->CreateContainer("MCTrackCont", "Track Container filled with MC information", AliHFEcuts::kNcutStepsMCTrack);\r
1772   fContainer->CreateContainer("recTrackContReco", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());\r
1773   fContainer->CreateContainer("recTrackContMC", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());\r
1774   \r
1775   fContainer->CreateContainer("hadronicBackground", "Container for Hadronic Background", 3);\r
1776   fContainer->CreateContainer("recTrackContDEReco", "Container for displaced electron analysis with Reco information", 1);\r
1777   fContainer->CreateContainer("recTrackContDEMC", "Container for displaced electron analysis with MC information", 1);\r
1778   fContainer->CreateContainer("recTrackContSecvtxReco", "Container for secondary vertexing analysis with Reco information", 1);\r
1779   fContainer->CreateContainer("recTrackContSecvtxMC", "Container for secondary vertexing analysis with MC information", 1);\r
1780 \r
1781   if(HasMCData()){\r
1782     fContainer->CreateContainer("conversionElecs", "Container for weighted conversion electrons",7);\r
1783     fContainer->CreateContainer("mesonElecs", "Container for weighted electrons from meson decays",7);\r
1784     fContainer->Sumw2("conversionElecs");\r
1785     fContainer->Sumw2("mesonElecs");\r
1786    \r
1787     if(fisNonHFEsystematics){\r
1788       const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};\r
1789       const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};\r
1790       for(Int_t iSource = 0; iSource < kElecBgSpecies; iSource++){\r
1791         for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){\r
1792           fContainer->CreateContainer(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted conversion electrons from %s grandm., %s level",sourceName[iSource],levelName[iLevel]),5);\r
1793           fContainer->CreateContainer(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted electrons from %s decays, %s level",sourceName[iSource],levelName[iLevel]),5);\r
1794           fContainer->Sumw2(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]));\r
1795           fContainer->Sumw2(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]));\r
1796           if(IsPbPb())break;\r
1797         }\r
1798       }\r
1799     }\r
1800     //fContainer->CreateContainer("charmElecs", "Container for weighted charm electrons",2);\r
1801   }\r
1802 \r
1803   fContainer->CreateCorrelationMatrix("correlationstepafterPID","THnSparse with correlations");\r
1804   fContainer->CreateCorrelationMatrix("correlationstepafterDE","THnSparse with correlations");\r
1805   if(!fVarManager->IsVariableDefined("centrality")) {\r
1806     //printf("Create the two other correlation maps\n");\r
1807     fContainer->CreateCorrelationMatrix("correlationstepbeforePID","THnSparse with correlations");\r
1808     fContainer->CreateCorrelationMatrix("correlationstepafterTOF","THnSparse with correlations");\r
1809   }\r
1810 \r
1811   // Define the step names\r
1812   for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsMCTrack; istep++){\r
1813     fContainer->SetStepTitle("MCTrackCont", AliHFEcuts::MCCutName(istep), istep);\r
1814   }\r
1815   for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsRecTrack; istep++){\r
1816     fContainer->SetStepTitle("recTrackContReco", AliHFEcuts::RecoCutName(istep), istep);\r
1817     fContainer->SetStepTitle("recTrackContMC", AliHFEcuts::RecoCutName(istep), istep);\r
1818   }\r
1819   for(UInt_t ipid = 0; ipid < fPID->GetNumberOfPIDdetectors(); ipid++){\r
1820     fContainer->SetStepTitle("recTrackContReco", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);\r
1821     fContainer->SetStepTitle("recTrackContMC", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);\r
1822   }\r
1823 }\r
1824 //____________________________________________________________\r
1825 void AliAnalysisTaskHFE::InitContaminationQA(){\r
1826   // \r
1827   // Add QA for Impact Parameter cut\r
1828   //\r
1829 \r
1830   TObjArray *array = fVarManager->GetVariables();\r
1831   Int_t nvars = array->GetEntriesFast();\r
1832   for(Int_t v = 0; v < nvars; v++) {\r
1833     AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);\r
1834     if(!variable) continue;\r
1835     TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());\r
1836     if(!name.CompareTo("pt")) {\r
1837       const Int_t nBinPt  = variable->GetNumberOfBins();\r
1838       const Double_t *kPtRange = variable->GetBinning();\r
1839 \r
1840       fQACollection->CreateTH1Farray("hadronsBeforeIPcut", "Hadrons before IP cut", nBinPt, kPtRange);\r
1841       fQACollection->CreateTH1Farray("hadronsAfterIPcut", "Hadrons after IP cut", nBinPt, kPtRange);\r
1842 \r
1843       fQACollection->CreateTH2Farray("Ke3Kecorr", "Ke3 decay e and K correlation; Ke3K p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);\r
1844       fQACollection->CreateTH2Farray("Ke3K0Lecorr", "Ke3 decay e and K0L correlation; Ke3K0L p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);\r
1845       fQACollection->CreateTH1Farray("Kptspectra", "Charged Kaons: MC p_{t} ", nBinPt, kPtRange);\r
1846       fQACollection->CreateTH1Farray("K0Lptspectra", "K0L: MC p_{t} ", nBinPt, kPtRange);\r
1847 \r
1848       const Double_t kDCAbound[2] = {-0.2, 0.2};\r
1849 \r
1850       const Int_t nDimDca=6;\r
1851       const Int_t nBinDca[nDimDca] = { 8, nBinPt, 800, 12,  6, 2};\r
1852       Double_t minimaDca[nDimDca]  = { -1., 0., kDCAbound[0], -1., -1, -1.1};\r
1853       Double_t maximaDca[nDimDca]  = { 7., 20., kDCAbound[1], 11.,  5, 1.1};\r
1854 \r
1855       Double_t *sourceBins = AliHFEtools::MakeLinearBinning(nBinDca[0], minimaDca[0], maximaDca[0]);\r
1856       Double_t *dcaBins = AliHFEtools::MakeLinearBinning(nBinDca[2], minimaDca[2], maximaDca[2]);\r
1857       Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBinDca[3], minimaDca[3], maximaDca[3]);\r
1858       Double_t *v0PIDBins = AliHFEtools::MakeLinearBinning(nBinDca[4], minimaDca[4], maximaDca[4]);\r
1859       Double_t *chargeBins = AliHFEtools::MakeLinearBinning(nBinDca[5], minimaDca[5], maximaDca[5]);\r
1860 \r
1861       fQACollection->CreateTHnSparseNoLimits("Dca", "Dca; source (0-all, 1-charm,etc); pT [GeV/c]; dca; centrality bin; v0pid; charge", nDimDca, nBinDca);\r
1862       ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(0, sourceBins);\r
1863       ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(1, kPtRange);\r
1864       ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(2, dcaBins);\r
1865       ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(3, centralityBins);\r
1866       ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(4, v0PIDBins);\r
1867       ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(5, chargeBins);\r
1868 \r
1869       break;\r
1870     }  \r
1871   }\r
1872 \r
1873 }\r
1874 \r
1875 //____________________________________________________________\r
1876 void AliAnalysisTaskHFE::InitHistoITScluster(){\r
1877   //\r
1878     // Initialize a temporary histogram to monitor the chi2/ITS cluster\r
1879     if(IsPbPb()) {\r
1880         const Int_t kNDim = 7;\r
1881         const Int_t kNBins[kNDim] = {88, 20,90,11, 160, 2, 1000};\r
1882         const Double_t kMin[kNDim] = {0.1, -1,0,  0.,0., 0,  0.};\r
1883         const Double_t kMax[kNDim] = {20., 1, 2.*TMath::Pi(), 11.,160, 2, 100.};\r
1884         fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c);eta;phi; centrality class;nclus;sharebit; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);\r
1885         fQACollection->BinLogAxis("fChi2perITScluster", 0);\r
1886     }\r
1887     else\r
1888     {\r
1889         const Int_t kNDim = 3;\r
1890         const Int_t kNBins[kNDim] = {44, 11, 1000};\r
1891         const Double_t kMin[kNDim] = {0.1, 0., 0.};\r
1892         const Double_t kMax[kNDim] = {20., 11., 100.};\r
1893         fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c); centrality class; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);\r
1894         fQACollection->BinLogAxis("fChi2perITScluster", 0);\r
1895     }\r
1896 }\r
1897 \r
1898 //____________________________________________________________\r
1899 void AliAnalysisTaskHFE::SelectSpecialTrigger(const Char_t *trgclust, Int_t runMin, Int_t runMax){\r
1900   //\r
1901   // Select only events triggered by a special trigeer cluster\r
1902   //\r
1903   if(!fSpecialTrigger) fSpecialTrigger = new AliOADBContainer("SpecialTrigger");\r
1904   fSpecialTrigger->AppendObject(new TObjString(trgclust), runMin, runMax);\r
1905 }\r
1906 \r
1907 //____________________________________________________________\r
1908 const Char_t * AliAnalysisTaskHFE::GetSpecialTrigger(Int_t run){\r
1909   //\r
1910   // Derive selected trigger string for given run\r
1911   //\r
1912   if(!fSpecialTrigger) return NULL;\r
1913   TObjString *trg = dynamic_cast<TObjString *>(fSpecialTrigger->GetObject(run));\r
1914   if(!trg) return NULL;\r
1915   return trg->String().Data();\r
1916 }\r
1917 \r
1918 //____________________________________________________________\r
1919 void AliAnalysisTaskHFE::PrintStatus() const {\r
1920   //\r
1921   // Print Analysis status\r
1922   //\r
1923   printf("\n\tAnalysis Settings\n\t========================================\n\n");\r
1924   printf("\tSecondary Vertex finding: %s\n", GetPlugin(kSecVtx) ? "YES" : "NO");\r
1925   printf("\tPrimary Vertex resolution: %s\n", GetPlugin(kPriVtx) ? "YES" : "NO");\r
1926   printf("\tDisplaced electron analysis step: %s\n", GetPlugin(kDEstep) ? "YES" : "NO");\r
1927   printf("\tTagged Track Analysis: %s\n", GetPlugin(kTaggedTrackAnalysis) ? "YES" : "NO");\r
1928   printf("\n");\r
1929   printf("\tParticle Identification Detectors:\n");\r
1930   fPID->PrintStatus();\r
1931   printf("\n");\r
1932   printf("\tQA: \n");\r
1933   printf("\t\tPID: %s\n", IsQAOn(kPIDqa) ? "YES" :  "NO");\r
1934   printf("\t\tCUTS: %s\n", (fCuts != NULL && fCuts->IsQAOn()) ? "YES" : "NO");\r
1935   printf("\t\tMC: %s\n", IsQAOn(kMCqa) ? "YES" : "NO");\r
1936   printf("\n");\r
1937 }\r
1938 \r
1939 //____________________________________________________________\r
1940 Bool_t AliAnalysisTaskHFE::FillProductionVertex(const AliVParticle * const track) const{\r
1941   //\r
1942   // Find the production vertex of the associated MC track\r
1943   //\r
1944   if(!fMCEvent) return kFALSE;\r
1945   const AliVParticle *mctrack = NULL;\r
1946   TString objectType = track->IsA()->GetName();\r
1947   if(objectType.CompareTo("AliESDtrack") == 0 || objectType.CompareTo("AliAODTrack") == 0){\r
1948     // Reconstructed track\r
1949     mctrack = fMCEvent->GetTrack(TMath::Abs(track->GetLabel()));\r
1950   } else {\r
1951     // MCParticle\r
1952     mctrack = track;\r
1953   }\r
1954 \r
1955   if(!mctrack) return kFALSE;\r
1956 \r
1957   Double_t xv = 0.0;\r
1958   Double_t yv = 0.0;\r
1959  \r
1960   if(TString(mctrack->IsA()->GetName()).CompareTo("AliMCParticle") == 0){\r
1961     // case MCParticle\r
1962     const AliMCParticle *mcpart = dynamic_cast<const AliMCParticle *>(mctrack);\r
1963     if(mcpart){\r
1964       xv =  mcpart->Xv();\r
1965       yv =  mcpart->Yv();\r
1966     }\r
1967   } else {\r
1968     // case AODMCParticle\r
1969     const AliAODMCParticle *mcpart = dynamic_cast<const AliAODMCParticle *>(mctrack);\r
1970     if(mcpart){\r
1971       xv =  mcpart->Xv();\r
1972       yv =  mcpart->Yv();\r
1973     }\r
1974   }\r
1975 \r
1976   //printf("xv %f, yv %f\n",xv,yv);\r
1977   fQACollection->Fill("radius", TMath::Abs(xv),TMath::Abs(yv));\r
1978 \r
1979   return kTRUE;\r
1980 \r
1981 }\r
1982 //__________________________________________\r
1983 void AliAnalysisTaskHFE::SwitchOnPlugin(Int_t plug){\r
1984   //\r
1985   // Switch on Plugin\r
1986   // Available:\r
1987   //  - Primary vertex studies\r
1988   //  - Secondary vertex Studies\r
1989   //  - Post Processing\r
1990   //\r
1991   switch(plug){\r
1992     case kPriVtx: SETBIT(fPlugins, plug); break;\r
1993     case kSecVtx: SETBIT(fPlugins, plug); break;\r
1994     case kIsElecBackGround: SETBIT(fPlugins, plug); break;\r
1995     case kPostProcess: SETBIT(fPlugins, plug); break;\r
1996     case kDEstep: SETBIT(fPlugins, plug); break;\r
1997     case kTaggedTrackAnalysis: SETBIT(fPlugins, plug); break;\r
1998     case kNonPhotonicElectron: SETBIT(fPlugins, plug); break; \r
1999     default: AliError("Unknown Plugin");\r
2000   };\r
2001 }\r
2002 //__________________________________________\r
2003 Bool_t AliAnalysisTaskHFE::ProcessCutStep(Int_t cutStep, AliVParticle *track){\r
2004   //\r
2005   // Check single track cuts for a given cut step\r
2006   // Fill the particle container\r
2007   //\r
2008   const Int_t kMCOffset = AliHFEcuts::kNcutStepsMCTrack;\r
2009   if(!fCFM->CheckParticleCuts(cutStep + kMCOffset, track)) return kFALSE;\r
2010   if(fVarManager->IsSignalTrack()) {\r
2011     fVarManager->FillContainer(fContainer, "recTrackContReco", cutStep, kFALSE);\r
2012     fVarManager->FillContainer(fContainer, "recTrackContMC", cutStep, kTRUE);\r
2013   }\r
2014   return kTRUE;\r
2015 }\r
2016 //___________________________________________________\r
2017 Bool_t AliAnalysisTaskHFE::ReadCentrality() {\r
2018   //\r
2019   // Recover the centrality of the event from ESD or AOD\r
2020   //\r
2021   \r
2022   Float_t fCentralityLimitstemp[12];\r
2023   Float_t fCentralityLimitsdefault[12]= {0.,5.,10., 20., 30., 40., 50., 60.,70.,80., 90., 100.};\r
2024   if(!fPbPbUserCentralityBinning) memcpy(fCentralityLimitstemp,fCentralityLimitsdefault,sizeof(fCentralityLimitsdefault));\r
2025   else memcpy(fCentralityLimitstemp,fCentralityLimits,sizeof(fCentralityLimitsdefault));\r
2026   \r
2027 \r
2028   Int_t bin = -1;\r
2029   if(IsHeavyIon()) {\r
2030     // Centrality\r
2031     AliCentrality *centrality = fInputEvent->GetCentrality();\r
2032     fCentralityPercent = centrality->GetCentralityPercentile("V0M");\r
2033     //printf("centrality %f\n",fCentralityPercent);\r
2034 \r
2035     for(Int_t ibin = 0; ibin < 11; ibin++){\r
2036       if(fCentralityPercent >= fCentralityLimitstemp[ibin] && fCentralityPercent < fCentralityLimitstemp[ibin+1]){\r
2037         bin = ibin;\r
2038         //printf("test bin %f, low %f, high %f, %d\n",fCentralityPercent,fCentralityLimitstemp[ibin],fCentralityLimitstemp[ibin+1],ibin);\r
2039         break;\r
2040       }\r
2041     }\r
2042     \r
2043     if(bin == -1) bin = 11; // Overflow\r
2044   } else {\r
2045     // PP: Tracklet multiplicity, use common definition\r
2046     Int_t itsMultiplicity = GetITSMultiplicity(fInputEvent);\r
2047     Int_t multiplicityLimits[8] = {0, 1, 9, 17, 25, 36, 60, 500};\r
2048     for(Int_t ibin = 0; ibin < 7; ibin++){  \r
2049       if(itsMultiplicity >= multiplicityLimits[ibin] && itsMultiplicity < multiplicityLimits[ibin + 1]){\r
2050         bin = ibin;\r
2051         break;\r
2052       }\r
2053     }\r
2054     if(bin == -1) bin = 7;  // Overflow\r
2055   }\r
2056   fCentralityF = bin;\r
2057   AliDebug(2, Form("Centrality class %d\n", fCentralityF));\r
2058 \r
2059  \r
2060   // contributors, to be outsourced\r
2061   const AliVVertex *vtx;\r
2062   if(IsAODanalysis()){\r
2063     AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);\r
2064     if(!fAOD){\r
2065       AliError("AOD Event required for AOD Analysis");\r
2066       return kFALSE;\r
2067     }\r
2068     vtx = fAOD->GetPrimaryVertex();\r
2069   } else {\r
2070     AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);\r
2071     if(!fESD){\r
2072       AliError("ESD Event required for ESD Analysis");\r
2073       return kFALSE;\r
2074     }\r
2075     vtx = fESD->GetPrimaryVertex() ;\r
2076   }\r
2077   if(!vtx){ \r
2078     fContributors = 0.5;\r
2079     return kFALSE;\r
2080   }\r
2081   else {\r
2082     Int_t contributorstemp = vtx->GetNContributors();\r
2083     if( contributorstemp <=  0) {\r
2084       fContributors =  0.5;\r
2085       //printf("Number of contributors %d and vz %f\n",contributorstemp,vtx->GetZ());\r
2086     }\r
2087     else fContributors = 1.5;\r
2088     //printf("Number of contributors %d\n",contributorstemp);\r
2089   }\r
2090   return kTRUE;\r
2091 }\r
2092 \r
2093 //___________________________________________________\r
2094 Int_t AliAnalysisTaskHFE::GetITSMultiplicity(AliVEvent *ev){\r
2095   //\r
2096   // Definition of the Multiplicity according to the JPSI group (F. Kramer)\r
2097   //\r
2098   Int_t nTracklets = 0;\r
2099   Int_t nAcc = 0;\r
2100   Double_t etaRange = 1.6;\r
2101 \r
2102   if (ev->IsA() == AliAODEvent::Class()) {\r
2103     AliAODTracklets *tracklets = ((AliAODEvent*)ev)->GetTracklets();\r
2104     nTracklets = tracklets->GetNumberOfTracklets();\r
2105     for (Int_t nn = 0; nn < nTracklets; nn++) {\r
2106       Double_t theta = tracklets->GetTheta(nn);\r
2107       Double_t eta = -TMath::Log(TMath::Tan(theta/2.0));\r
2108       if (TMath::Abs(eta) < etaRange) nAcc++;\r
2109     }\r
2110   } else if (ev->IsA() == AliESDEvent::Class()) {\r
2111     nTracklets = ((AliESDEvent*)ev)->GetMultiplicity()->GetNumberOfTracklets();\r
2112     for (Int_t nn = 0; nn < nTracklets; nn++) {\r
2113        Double_t eta = ((AliESDEvent*)ev)->GetMultiplicity()->GetEta(nn);\r
2114       if (TMath::Abs(eta) < etaRange) nAcc++;\r
2115     }\r
2116   } else return -1;\r
2117 \r
2118   return nAcc;\r
2119 }\r
2120 \r
2121 //___________________________________________________\r
2122 void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() {\r
2123   //\r
2124   // Recover the centrality of the event from ESD or AOD\r
2125   //\r
2126  if(IsAODanalysis()){\r
2127 \r
2128    AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);\r
2129    if(!fAOD){\r
2130      AliError("AOD Event required for AOD Analysis");\r
2131        return;\r
2132    }\r
2133    // PileUp\r
2134    fIdentifiedAsPileUp = kFALSE;\r
2135    if(fRemovePileUp && fAOD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; \r
2136    // Z vertex\r
2137    fIdentifiedAsOutInz = kFALSE;\r
2138    //printf("Z vertex %f and out %f\n",fAOD->GetPrimaryVertex()->GetZ(),fCuts->GetVertexRange());\r
2139    if(TMath::Abs(fAOD->GetPrimaryVertex()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;\r
2140    // Event Cut\r
2141    fPassTheEventCut = kTRUE;\r
2142    if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fAOD)) fPassTheEventCut = kFALSE; \r
2143    \r
2144    \r
2145  } else {\r
2146    \r
2147    AliDebug(3, "Processing ESD Centrality");\r
2148    AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);\r
2149    if(!fESD){\r
2150      AliError("ESD Event required for ESD Analysis");\r
2151        return;\r
2152    }\r
2153    // PileUp\r
2154    fIdentifiedAsPileUp = kFALSE;\r
2155    if(fRemovePileUp && fESD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; \r
2156    \r
2157 \r
2158 \r
2159    // Z vertex\r
2160    fIdentifiedAsOutInz = kFALSE;\r
2161    Bool_t findvertex = kTRUE;\r
2162    const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();\r
2163    if((!vtxESD) || (vtxESD->GetNContributors() <= 0)) findvertex = kFALSE;\r
2164    if(findvertex) {\r
2165      if(TMath::Abs(vtxESD->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;\r
2166    }\r
2167    \r
2168    //Event Cut\r
2169    fPassTheEventCut = kTRUE;\r
2170    if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) fPassTheEventCut = kFALSE;   \r
2171   \r
2172  }\r
2173 \r
2174 }\r
2175 \r