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