PWGHF/hfe/AliAnalysisTaskHFE.cxx

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