]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - PWGHF/hfe/AliAnalysisTaskHFE.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Updates for TRD HFE analysis
[u/mrichter/AliRoot.git] / PWGHF / hfe / AliAnalysisTaskHFE.cxx
diff --git a/PWGHF/hfe/AliAnalysisTaskHFE.cxx b/PWGHF/hfe/AliAnalysisTaskHFE.cxx
index 5408818bddef8fef33086e123107ac033cb3af7f..3ee5f60bc2cb311030593ee5a2e2636f905918d9 100644 (file)
--- a/PWGHF/hfe/AliAnalysisTaskHFE.cxx
+++ b/PWGHF/hfe/AliAnalysisTaskHFE.cxx
@@ -45,6 +45,7 @@
 
 #include "AliESDtrackCuts.h"
 #include "AliAnalysisManager.h"
 
 #include "AliESDtrackCuts.h"
 #include "AliAnalysisManager.h"
+#include "AliAnalysisUtils.h"
 #include "AliAODInputHandler.h"
 #include "AliAODMCParticle.h"
 #include "AliAODTrack.h"
 #include "AliAODInputHandler.h"
 #include "AliAODMCParticle.h"
 #include "AliAODTrack.h"
@@ -65,6 +66,7 @@
 #include "AliOADBContainer.h"
 #include "AliStack.h"
 #include "AliTriggerAnalysis.h"
 #include "AliOADBContainer.h"
 #include "AliStack.h"
 #include "AliTriggerAnalysis.h"
+#include "AliTRDTriggerAnalysis.h" 
 #include "AliVVertex.h"
 
 #include "AliHFEcollection.h"
 #include "AliVVertex.h"
 
 #include "AliHFEcollection.h"
@@ -76,7 +78,6 @@
 #include "AliHFEpairs.h"
 #include "AliHFEpid.h"
 #include "AliHFEpidQAmanager.h"
 #include "AliHFEpairs.h"
 #include "AliHFEpid.h"
 #include "AliHFEpidQAmanager.h"
-#include "AliHFEpostAnalysis.h"
 #include "AliHFEsecVtxs.h"
 #include "AliHFEsecVtx.h"
 #include "AliHFEsignalCuts.h"
 #include "AliHFEsecVtxs.h"
 #include "AliHFEsecVtx.h"
 #include "AliHFEsignalCuts.h"
@@ -96,11 +97,10 @@ AliAnalysisTaskSE("PID efficiency Analysis")
   , fAODArrayMCInfo(NULL)
   , fQAlevel(0)
   , fPlugins(0)
   , fAODArrayMCInfo(NULL)
   , fQAlevel(0)
   , fPlugins(0)
+  , fCollisionSystem(3)
   , fFillSignalOnly(kTRUE)
   , fFillNoCuts(kFALSE)
   , fFillSignalOnly(kTRUE)
   , fFillNoCuts(kFALSE)
-  , fUseFilterAOD(kTRUE)
   , fApplyCutAOD(kFALSE)
   , fApplyCutAOD(kFALSE)
-  , fFilter(1<<4)
   , fBackGroundFactorApply(kFALSE)
   , fRemovePileUp(kFALSE)
   , fIdentifiedAsPileUp(kFALSE)
   , fBackGroundFactorApply(kFALSE)
   , fRemovePileUp(kFALSE)
   , fIdentifiedAsPileUp(kFALSE)
@@ -109,14 +109,15 @@ AliAnalysisTaskSE("PID efficiency Analysis")
   , fRejectKinkMother(kTRUE)
   , fisppMultiBin(kFALSE)
   , fPbPbUserCentralityBinning(kFALSE)
   , fRejectKinkMother(kTRUE)
   , fisppMultiBin(kFALSE)
   , fPbPbUserCentralityBinning(kFALSE)
+  , fRemoveFirstEvent(kFALSE)
   , fisNonHFEsystematics(kFALSE)
   , fSpecialTrigger(NULL)
   , fCentralityF(-1)
   , fCentralityPercent(-1)
   , fisNonHFEsystematics(kFALSE)
   , fSpecialTrigger(NULL)
   , fCentralityF(-1)
   , fCentralityPercent(-1)
+  , fCentralityEstimator("V0M")
   , fContributors(0.5)
   , fWeightBackGround(0.)
   , fVz(0.0)
   , fContributors(0.5)
   , fWeightBackGround(0.)
   , fVz(0.0)
-  , fHadronBackgroundOADB(NULL)
   , fContainer(NULL)
   , fVarManager(NULL)
   , fSignalCuts(NULL)
   , fContainer(NULL)
   , fVarManager(NULL)
   , fSignalCuts(NULL)
@@ -124,11 +125,13 @@ AliAnalysisTaskSE("PID efficiency Analysis")
   , fTriggerAnalysis(NULL)
   , fPID(NULL)
   , fPIDqa(NULL)
   , fTriggerAnalysis(NULL)
   , fPID(NULL)
   , fPIDqa(NULL)
+  , fTRDTriggerAnalysis(NULL)
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
   , fCleanTaggedTrack(kFALSE)
   , fVariablesTRDTaggedTrack(kFALSE)
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
   , fCleanTaggedTrack(kFALSE)
   , fVariablesTRDTaggedTrack(kFALSE)
+  , fAnalysisUtils(NULL)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
@@ -136,13 +139,14 @@ AliAnalysisTaskSE("PID efficiency Analysis")
   , fTaggedTrackAnalysis(NULL)
   , fExtraCuts(NULL)
   , fBackgroundSubtraction(NULL)
   , fTaggedTrackAnalysis(NULL)
   , fExtraCuts(NULL)
   , fBackgroundSubtraction(NULL)
+  , fTRDTrigger(kFALSE)
+  , fWhichTRDTrigger(0)
   , fQA(NULL)
   , fOutput(NULL)
   , fHistMCQA(NULL)
   , fHistSECVTX(NULL)
   , fHistELECBACKGROUND(NULL)
   , fQACollection(NULL)
   , fQA(NULL)
   , fOutput(NULL)
   , fHistMCQA(NULL)
   , fHistSECVTX(NULL)
   , fHistELECBACKGROUND(NULL)
   , fQACollection(NULL)
-  , fQAAODCollection(NULL)
 {
   //
   // Dummy constructor
 {
   //
   // Dummy constructor
@@ -153,7 +157,7 @@ AliAnalysisTaskSE("PID efficiency Analysis")
   memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
   memset(fCentralityLimits, 0, sizeof(Float_t) * 12);
 
   memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
   memset(fCentralityLimits, 0, sizeof(Float_t) * 12);
 
-
+  SetppAnalysis();
 }
 
 //____________________________________________________________
 }
 
 //____________________________________________________________
@@ -163,11 +167,10 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
   , fAODArrayMCInfo(NULL)
   , fQAlevel(0)
   , fPlugins(0)
   , fAODArrayMCInfo(NULL)
   , fQAlevel(0)
   , fPlugins(0)
+  , fCollisionSystem(3)
   , fFillSignalOnly(kTRUE)
   , fFillNoCuts(kFALSE)
   , fFillSignalOnly(kTRUE)
   , fFillNoCuts(kFALSE)
-  , fUseFilterAOD(kTRUE)
   , fApplyCutAOD(kFALSE)
   , fApplyCutAOD(kFALSE)
-  , fFilter(1<<4)
   , fBackGroundFactorApply(kFALSE)
   , fRemovePileUp(kFALSE)
   , fIdentifiedAsPileUp(kFALSE)
   , fBackGroundFactorApply(kFALSE)
   , fRemovePileUp(kFALSE)
   , fIdentifiedAsPileUp(kFALSE)
@@ -176,14 +179,15 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
   , fRejectKinkMother(kTRUE)
   , fisppMultiBin(kFALSE)
   , fPbPbUserCentralityBinning(kFALSE)
   , fRejectKinkMother(kTRUE)
   , fisppMultiBin(kFALSE)
   , fPbPbUserCentralityBinning(kFALSE)
+  , fRemoveFirstEvent(kFALSE)
   , fisNonHFEsystematics(kFALSE)
   , fSpecialTrigger(NULL)
   , fCentralityF(-1)
   , fCentralityPercent(-1)
   , fisNonHFEsystematics(kFALSE)
   , fSpecialTrigger(NULL)
   , fCentralityF(-1)
   , fCentralityPercent(-1)
+  , fCentralityEstimator("V0M")
   , fContributors(0.5)
   , fWeightBackGround(0.)
   , fVz(0.0)
   , fContributors(0.5)
   , fWeightBackGround(0.)
   , fVz(0.0)
-  , fHadronBackgroundOADB(NULL)
   , fContainer(NULL)
   , fVarManager(NULL)
   , fSignalCuts(NULL)
   , fContainer(NULL)
   , fVarManager(NULL)
   , fSignalCuts(NULL)
@@ -191,11 +195,13 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
   , fTriggerAnalysis(NULL)
   , fPID(NULL)
   , fPIDqa(NULL)
   , fTriggerAnalysis(NULL)
   , fPID(NULL)
   , fPIDqa(NULL)
+  , fTRDTriggerAnalysis(NULL)
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
   , fCleanTaggedTrack(kFALSE)
   , fVariablesTRDTaggedTrack(kFALSE)
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
   , fCleanTaggedTrack(kFALSE)
   , fVariablesTRDTaggedTrack(kFALSE)
+  , fAnalysisUtils(NULL)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
@@ -203,13 +209,14 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
   , fTaggedTrackAnalysis(NULL)
   , fExtraCuts(NULL)
   , fBackgroundSubtraction(NULL)
   , fTaggedTrackAnalysis(NULL)
   , fExtraCuts(NULL)
   , fBackgroundSubtraction(NULL)
+  , fTRDTrigger(kFALSE)
+  , fWhichTRDTrigger(0)
   , fQA(NULL)
   , fOutput(NULL)
   , fHistMCQA(NULL)
   , fHistSECVTX(NULL)
   , fHistELECBACKGROUND(NULL)
   , fQACollection(0x0)
   , fQA(NULL)
   , fOutput(NULL)
   , fHistMCQA(NULL)
   , fHistSECVTX(NULL)
   , fHistELECBACKGROUND(NULL)
   , fQACollection(0x0)
-  , fQAAODCollection(NULL)
 {
   //
   // Default constructor
 {
   //
   // Default constructor
@@ -220,6 +227,8 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
   fPID = new AliHFEpid("hfePid");
   fPIDqa = new AliHFEpidQAmanager;
   fVarManager = new AliHFEvarManager("hfeVarManager");
   fPID = new AliHFEpid("hfePid");
   fPIDqa = new AliHFEpidQAmanager;
   fVarManager = new AliHFEvarManager("hfeVarManager");
+  fAnalysisUtils = new AliAnalysisUtils;
+  fTRDTriggerAnalysis = new AliTRDTriggerAnalysis();
 
   memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
   memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
 
   memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
   memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
@@ -227,6 +236,7 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
   memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
   memset(fCentralityLimits, 0, sizeof(Float_t) * 12);
 
   memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
   memset(fCentralityLimits, 0, sizeof(Float_t) * 12);
 
+  SetppAnalysis();
 }
 
 //____________________________________________________________
 }
 
 //____________________________________________________________
@@ -236,11 +246,10 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):
   , fAODArrayMCInfo(NULL)
   , fQAlevel(0)
   , fPlugins(0)
   , fAODArrayMCInfo(NULL)
   , fQAlevel(0)
   , fPlugins(0)
+  , fCollisionSystem(ref.fCollisionSystem)
   , fFillSignalOnly(ref.fFillSignalOnly)
   , fFillNoCuts(ref.fFillNoCuts)
   , fFillSignalOnly(ref.fFillSignalOnly)
   , fFillNoCuts(ref.fFillNoCuts)
-  , fUseFilterAOD(ref.fUseFilterAOD)
   , fApplyCutAOD(ref.fApplyCutAOD)
   , fApplyCutAOD(ref.fApplyCutAOD)
-  , fFilter(ref.fFilter) 
   , fBackGroundFactorApply(ref.fBackGroundFactorApply)
   , fRemovePileUp(ref.fRemovePileUp)
   , fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp)
   , fBackGroundFactorApply(ref.fBackGroundFactorApply)
   , fRemovePileUp(ref.fRemovePileUp)
   , fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp)
@@ -249,14 +258,15 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):
   , fRejectKinkMother(ref.fRejectKinkMother)
   , fisppMultiBin(ref.fisppMultiBin)
   , fPbPbUserCentralityBinning(ref.fPbPbUserCentralityBinning)
   , fRejectKinkMother(ref.fRejectKinkMother)
   , fisppMultiBin(ref.fisppMultiBin)
   , fPbPbUserCentralityBinning(ref.fPbPbUserCentralityBinning)
+  , fRemoveFirstEvent(ref.fRemoveFirstEvent)
   , fisNonHFEsystematics(ref.fisNonHFEsystematics)
   , fSpecialTrigger(ref.fSpecialTrigger)
   , fCentralityF(ref.fCentralityF)
   , fCentralityPercent(ref.fCentralityPercent)
   , fisNonHFEsystematics(ref.fisNonHFEsystematics)
   , fSpecialTrigger(ref.fSpecialTrigger)
   , fCentralityF(ref.fCentralityF)
   , fCentralityPercent(ref.fCentralityPercent)
+  , fCentralityEstimator(ref.fCentralityEstimator)
   , fContributors(ref.fContributors)
   , fWeightBackGround(ref.fWeightBackGround)
   , fVz(ref.fVz)
   , fContributors(ref.fContributors)
   , fWeightBackGround(ref.fWeightBackGround)
   , fVz(ref.fVz)
-  , fHadronBackgroundOADB(ref.fHadronBackgroundOADB)
   , fContainer(NULL)
   , fVarManager(NULL)
   , fSignalCuts(NULL)
   , fContainer(NULL)
   , fVarManager(NULL)
   , fSignalCuts(NULL)
@@ -264,11 +274,13 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):
   , fTriggerAnalysis(NULL)
   , fPID(NULL)
   , fPIDqa(NULL)
   , fTriggerAnalysis(NULL)
   , fPID(NULL)
   , fPIDqa(NULL)
+  , fTRDTriggerAnalysis(NULL)
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
   , fCleanTaggedTrack(ref.fCleanTaggedTrack)
   , fVariablesTRDTaggedTrack(ref.fVariablesTRDTaggedTrack)
   , fPIDpreselect(NULL)
   , fCuts(NULL)
   , fTaggedTrackCuts(NULL)
   , fCleanTaggedTrack(ref.fCleanTaggedTrack)
   , fVariablesTRDTaggedTrack(ref.fVariablesTRDTaggedTrack)
+  , fAnalysisUtils(NULL)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
   , fCutspreselect(NULL)
   , fSecVtx(NULL)
   , fElecBackGround(NULL)
@@ -276,13 +288,14 @@ AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):
   , fTaggedTrackAnalysis(NULL)
   , fExtraCuts(NULL)
   , fBackgroundSubtraction(NULL)
   , fTaggedTrackAnalysis(NULL)
   , fExtraCuts(NULL)
   , fBackgroundSubtraction(NULL)
+  , fTRDTrigger(ref.fTRDTrigger)
+  , fWhichTRDTrigger(ref.fWhichTRDTrigger)
   , fQA(NULL)
   , fOutput(NULL)
   , fHistMCQA(NULL)
   , fHistSECVTX(NULL)
   , fHistELECBACKGROUND(NULL)
   , fQACollection(NULL)
   , fQA(NULL)
   , fOutput(NULL)
   , fHistMCQA(NULL)
   , fHistSECVTX(NULL)
   , fHistELECBACKGROUND(NULL)
   , fQACollection(NULL)
-  , fQAAODCollection(NULL)
 {
   //
   // Copy Constructor
 {
   //
   // Copy Constructor
@@ -310,11 +323,10 @@ void AliAnalysisTaskHFE::Copy(TObject &o) const {
   target.fAODArrayMCInfo = fAODArrayMCInfo;
   target.fQAlevel = fQAlevel;
   target.fPlugins = fPlugins;
   target.fAODArrayMCInfo = fAODArrayMCInfo;
   target.fQAlevel = fQAlevel;
   target.fPlugins = fPlugins;
+  target.fCollisionSystem = fCollisionSystem;
   target.fFillSignalOnly = fFillSignalOnly;
   target.fFillNoCuts = fFillNoCuts;
   target.fFillSignalOnly = fFillSignalOnly;
   target.fFillNoCuts = fFillNoCuts;
-  target.fUseFilterAOD = fUseFilterAOD;
   target.fApplyCutAOD = fApplyCutAOD;
   target.fApplyCutAOD = fApplyCutAOD;
-  target.fFilter = fFilter;
   target.fBackGroundFactorApply = fBackGroundFactorApply;
   target.fRemovePileUp = fRemovePileUp;
   target.fIdentifiedAsPileUp = fIdentifiedAsPileUp;
   target.fBackGroundFactorApply = fBackGroundFactorApply;
   target.fRemovePileUp = fRemovePileUp;
   target.fIdentifiedAsPileUp = fIdentifiedAsPileUp;
@@ -323,14 +335,15 @@ void AliAnalysisTaskHFE::Copy(TObject &o) const {
   target.fRejectKinkMother = fRejectKinkMother;
   target.fisppMultiBin =   fisppMultiBin;
   target.fPbPbUserCentralityBinning = fPbPbUserCentralityBinning;
   target.fRejectKinkMother = fRejectKinkMother;
   target.fisppMultiBin =   fisppMultiBin;
   target.fPbPbUserCentralityBinning = fPbPbUserCentralityBinning;
+  target.fRemoveFirstEvent = fRemoveFirstEvent;
   target.fisNonHFEsystematics = fisNonHFEsystematics;
   target.fSpecialTrigger = fSpecialTrigger;
   target.fCentralityF = fCentralityF;
   target.fCentralityPercent = fCentralityPercent;
   target.fisNonHFEsystematics = fisNonHFEsystematics;
   target.fSpecialTrigger = fSpecialTrigger;
   target.fCentralityF = fCentralityF;
   target.fCentralityPercent = fCentralityPercent;
+  target.fCentralityEstimator = fCentralityEstimator;
   target.fContributors = fContributors;
   target.fWeightBackGround = fWeightBackGround;
   target.fVz = fVz;
   target.fContributors = fContributors;
   target.fWeightBackGround = fWeightBackGround;
   target.fVz = fVz;
-  target.fHadronBackgroundOADB = fHadronBackgroundOADB;
   target.fContainer = fContainer;
   target.fVarManager = fVarManager;
   target.fSignalCuts = fSignalCuts;
   target.fContainer = fContainer;
   target.fVarManager = fVarManager;
   target.fSignalCuts = fSignalCuts;
@@ -338,11 +351,13 @@ void AliAnalysisTaskHFE::Copy(TObject &o) const {
   target.fTriggerAnalysis = fTriggerAnalysis;
   target.fPID = fPID;
   target.fPIDqa = fPIDqa;
   target.fTriggerAnalysis = fTriggerAnalysis;
   target.fPID = fPID;
   target.fPIDqa = fPIDqa;
+  target.fTRDTriggerAnalysis = fTRDTriggerAnalysis;
   target.fPIDpreselect = fPIDpreselect;
   target.fCuts = fCuts;
   target.fTaggedTrackCuts = fTaggedTrackCuts;
   target.fCleanTaggedTrack = fCleanTaggedTrack;
   target.fVariablesTRDTaggedTrack = fVariablesTRDTaggedTrack;
   target.fPIDpreselect = fPIDpreselect;
   target.fCuts = fCuts;
   target.fTaggedTrackCuts = fTaggedTrackCuts;
   target.fCleanTaggedTrack = fCleanTaggedTrack;
   target.fVariablesTRDTaggedTrack = fVariablesTRDTaggedTrack;
+  target.fAnalysisUtils = fAnalysisUtils;
   target.fCutspreselect = fCutspreselect;
   target.fSecVtx = fSecVtx;
   target.fElecBackGround = fElecBackGround;
   target.fCutspreselect = fCutspreselect;
   target.fSecVtx = fSecVtx;
   target.fElecBackGround = fElecBackGround;
@@ -350,13 +365,14 @@ void AliAnalysisTaskHFE::Copy(TObject &o) const {
   target.fTaggedTrackAnalysis = fTaggedTrackAnalysis;
   target.fExtraCuts = fExtraCuts;
   target.fBackgroundSubtraction = fBackgroundSubtraction;
   target.fTaggedTrackAnalysis = fTaggedTrackAnalysis;
   target.fExtraCuts = fExtraCuts;
   target.fBackgroundSubtraction = fBackgroundSubtraction;
+  target.fTRDTrigger = fTRDTrigger;
+  target.fWhichTRDTrigger = fWhichTRDTrigger;
   target.fQA = fQA;
   target.fOutput = fOutput;
   target.fHistMCQA = fHistMCQA;
   target.fHistSECVTX = fHistSECVTX;
   target.fHistELECBACKGROUND = fHistELECBACKGROUND;
   target.fQACollection = fQACollection;
   target.fQA = fQA;
   target.fOutput = fOutput;
   target.fHistMCQA = fHistMCQA;
   target.fHistSECVTX = fHistSECVTX;
   target.fHistELECBACKGROUND = fHistELECBACKGROUND;
   target.fQACollection = fQACollection;
-  target.fQAAODCollection = fQAAODCollection;
 }
 
 //____________________________________________________________
 }
 
 //____________________________________________________________
@@ -367,6 +383,7 @@ AliAnalysisTaskHFE::~AliAnalysisTaskHFE(){
   if(fPID) delete fPID;
   if(fPIDpreselect) delete fPIDpreselect;
   if(fVarManager) delete fVarManager;
   if(fPID) delete fPID;
   if(fPIDpreselect) delete fPIDpreselect;
   if(fVarManager) delete fVarManager;
+  if(fTRDTriggerAnalysis) delete fTRDTriggerAnalysis;
   if(fCFM) delete fCFM;
   if(fTriggerAnalysis) delete fTriggerAnalysis;
   if(fSignalCuts) delete fSignalCuts;
   if(fCFM) delete fCFM;
   if(fTriggerAnalysis) delete fTriggerAnalysis;
   if(fSignalCuts) delete fSignalCuts;
@@ -375,6 +392,7 @@ AliAnalysisTaskHFE::~AliAnalysisTaskHFE(){
   if(fElecBackGround) delete fElecBackGround;
   if(fBackgroundSubtraction) delete fBackgroundSubtraction;
   if(fSpecialTrigger) delete fSpecialTrigger;
   if(fElecBackGround) delete fElecBackGround;
   if(fBackgroundSubtraction) delete fBackgroundSubtraction;
   if(fSpecialTrigger) delete fSpecialTrigger;
+  if(fAnalysisUtils) delete fAnalysisUtils;
   // Delete output objects only if we are not running in PROOF mode because otherwise this produces a crash during merging
   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
   if(mgr && mgr->GetAnalysisType() != AliAnalysisManager::kProofAnalysis){
   // Delete output objects only if we are not running in PROOF mode because otherwise this produces a crash during merging
   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
   if(mgr && mgr->GetAnalysisType() != AliAnalysisManager::kProofAnalysis){
@@ -414,15 +432,6 @@ void AliAnalysisTaskHFE::UserCreateOutputObjects(){
       SetHasMCData();
   }
   printf("Analysis Mode: %s Analysis\n", IsAODanalysis() ? "AOD" : "ESD");
       SetHasMCData();
   }
   printf("Analysis Mode: %s Analysis\n", IsAODanalysis() ? "AOD" : "ESD");
-  if(IsAODanalysis()) {
-    printf("AOD filter: %s \n", fUseFilterAOD ? "Yes" : "No");
-    if(fUseFilterAOD) printf("AOD filter used: %d \n", fFilter);
-    // First Part: Make QA histograms
-    fQAAODCollection = new AliHFEcollection("TaskQAAOD", "QA histos from the AOD Electron Task");
-    fQAAODCollection->CreateTH1F("Filterorigin", "AOD filter of tracks at the origin", 21, -1, 20);
-    fQAAODCollection->CreateTH1F("Filterend", "AOD filter of tracks after all cuts", 21, -1, 20);
-    fQA->Add(fQAAODCollection);
-  }
   printf("MC Data available %s\n", HasMCData() ? "Yes" : "No");
 
   // Enable Trigger Analysis
   printf("MC Data available %s\n", HasMCData() ? "Yes" : "No");
 
   // Enable Trigger Analysis
@@ -435,12 +444,10 @@ void AliAnalysisTaskHFE::UserCreateOutputObjects(){
   fQACollection->CreateTH1F("nElectronTracksEvent", "Number of Electron Candidates", 100, 0, 100);
   fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100);
   fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);
   fQACollection->CreateTH1F("nElectronTracksEvent", "Number of Electron Candidates", 100, 0, 100);
   fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100);
   fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);
-  fQACollection->CreateTH2F("TPCdEdxBeforePID", "TPC dE/dx; p (GeV/c); TPC dE/dx (a.u.)", 1000, 0., 10., 200, 0., 200.); 
-  fQACollection->CreateTH2F("TPCnSigmaBeforePID", "TPC dE/dx; p (GeV/c); TPC dE/dx - <TPC dE/dx>|_{el} (#sigma)", 1000, 0., 10., 1000, -10., 10.);
+  fQACollection->CreateTH1F("nTriggerBit", "Histo Trigger Bit", 22, 0, 22);
  
  
-  InitPIDperformanceQA();
-  InitContaminationQA();
   InitHistoITScluster();
   InitHistoITScluster();
+  InitContaminationQA();
   fQA->Add(fQACollection);
 
   // Initialize PID
   fQA->Add(fQACollection);
 
   // Initialize PID
@@ -456,6 +463,7 @@ void AliAnalysisTaskHFE::UserCreateOutputObjects(){
   // Background subtraction-------------------------------------------------------------------
   if (GetPlugin(kNonPhotonicElectron)) {
     if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();
   // Background subtraction-------------------------------------------------------------------
   if (GetPlugin(kNonPhotonicElectron)) {
     if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();
+    if(IsAODanalysis()) fBackgroundSubtraction->SetAOD(kTRUE);
     fBackgroundSubtraction->Init();
     fOutput->Add(fBackgroundSubtraction->GetListOutput());
   }
     fBackgroundSubtraction->Init();
     fOutput->Add(fBackgroundSubtraction->GetListOutput());
   }
@@ -565,6 +573,8 @@ void AliAnalysisTaskHFE::UserCreateOutputObjects(){
     fQA->Add(fTaggedTrackAnalysis->GetQAcollection());
   }
 
     fQA->Add(fTaggedTrackAnalysis->GetQAcollection());
   }
 
+  //fQA->Print();
+
   PrintStatus();
   // Done!!!
   PostData(1, fOutput);
   PrintStatus();
   // Done!!!
   PostData(1, fOutput);
@@ -603,18 +613,16 @@ void AliAnalysisTaskHFE::UserExec(Option_t *){
     fPID->InitializePID(fInputEvent->GetRunNumber());
   }
 
     fPID->InitializePID(fInputEvent->GetRunNumber());
   }
 
-  //printf("test0\n");
+  if(fRemoveFirstEvent){
+    if(fAnalysisUtils->IsFirstEventInChunk(fInputEvent)) return;
+  }
 
 
-  // Initialize hadronic background from OADB Container
-  AliDebug(2, Form("Apply background factors: %s, OADB Container %p", fBackGroundFactorApply ? "Yes" : "No", fHadronBackgroundOADB));
-  if(fBackGroundFactorApply && !TestBit(kBackgroundInitialized)){ 
-    AliDebug(2, "Initializing Background from OADB");
-    if(!InitializeHadronBackground(fInputEvent->GetRunNumber())) AliError("Failed initializing hadronic background parameterization from OADB");
-    else AliDebug(2, "Successfully loaded Background from OADB");
-    SetBit(kBackgroundInitialized); 
+  AliESDEvent *ev = dynamic_cast<AliESDEvent *>(fInputEvent);
+  if(ev && fTRDTrigger)
+  {
+      if(!CheckTRDTrigger(ev)) return;
   }
 
   }
 
-  //printf("test1\n");
 
   if(IsESDanalysis() && HasMCData()){
     // Protect against missing MC trees
 
   if(IsESDanalysis() && HasMCData()){
     // Protect against missing MC trees
@@ -626,10 +634,9 @@ void AliAnalysisTaskHFE::UserExec(Option_t *){
     if(!mcH->InitOk()) return;
     if(!mcH->TreeK()) return;
     if(!mcH->TreeTR()) return;
     if(!mcH->InitOk()) return;
     if(!mcH->TreeK()) return;
     if(!mcH->TreeTR()) return;
+
     // Background subtraction-------------------------------------------------------------------
     // Background subtraction-------------------------------------------------------------------
-    if(GetPlugin(kNonPhotonicElectron)){
-      fBackgroundSubtraction->SetMCEvent(fMCEvent);
-    }
+    if(GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetMCEvent(fMCEvent);
     //------------------------------------------------------------------------------------------
   }
 
     //------------------------------------------------------------------------------------------
   }
 
@@ -654,9 +661,7 @@ void AliAnalysisTaskHFE::UserExec(Option_t *){
     }
     fSignalCuts->SetMCAODInfo(fAODArrayMCInfo);
     // Background subtraction-------------------------------------------------------------------
     }
     fSignalCuts->SetMCAODInfo(fAODArrayMCInfo);
     // Background subtraction-------------------------------------------------------------------
-    if (GetPlugin(kNonPhotonicElectron)) {
-      fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);
-    }
+    if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);
     //------------------------------------------------------------------------------------------
   }
 
     //------------------------------------------------------------------------------------------
   }
 
@@ -701,7 +706,6 @@ void AliAnalysisTaskHFE::UserExec(Option_t *){
     // Check Trigger selection
     if(specialTrigger){
       AliDebug(2, Form("Special Trigger requested: %s", specialTrigger));
     // Check Trigger selection
     if(specialTrigger){
       AliDebug(2, Form("Special Trigger requested: %s", specialTrigger));
-      AliESDEvent *ev = dynamic_cast<AliESDEvent *>(fInputEvent);
       if(!(ev && ev->IsTriggerClassFired(specialTrigger))){
         AliDebug(2, "Event not selected"); 
         return;
       if(!(ev && ev->IsTriggerClassFired(specialTrigger))){
         AliDebug(2, "Event not selected"); 
         return;
@@ -720,49 +724,8 @@ void AliAnalysisTaskHFE::Terminate(Option_t *){
   //
   // Terminate not implemented at the moment
   //
   //
   // Terminate not implemented at the moment
   //
-  if(GetPlugin(kPostProcess)){
-    fOutput = dynamic_cast<TList *>(GetOutputData(1));
-    fQA = dynamic_cast<TList *>(GetOutputData(2));
-    if(!fOutput){
-      AliError("Results not available");
-      return;
-    }
-    if(!fQA){
-      AliError("QA output not available");
-      return;
-    }
-    fContainer = dynamic_cast<AliHFEcontainer *>(fOutput->FindObject("trackContainer")); 
-    if(!fContainer){
-      AliError("Track container not found");
-      return;
-    }
-    AliHFEpostAnalysis postanalysis;
-    postanalysis.SetTaskResults(fContainer);
-    TList *qalist = dynamic_cast<TList *>(fQA->FindObject("list_TaskQA"));
-    if(!qalist){
-      AliError("QA List not found");
-      return;
-    }
-    postanalysis.SetTaskQA(qalist);
-    //printf("Running post analysis\n");
-    //if(HasMCData())
-    postanalysis.DrawMCSignal2Background();
-    postanalysis.DrawEfficiency();
-    postanalysis.DrawPIDperformance();
-    postanalysis.DrawCutEfficiency();
-
-    if (GetPlugin(kIsElecBackGround)) {
-      AliHFEelecbackground elecBackGround;
-      TList *oe = 0x0;
-      if(!(oe = (TList*)dynamic_cast<TList *>(fOutput->FindObject("HFEelecbackground")))){
-        return;
-      }
-      elecBackGround.Load(oe);
-      elecBackGround.Plot();
-      elecBackGround.PostProcess();      
-    }
-  }
 }
 }
+
 //_______________________________________________________________
 Bool_t AliAnalysisTaskHFE::IsEventInBinZero() {
   //
 //_______________________________________________________________
 Bool_t AliAnalysisTaskHFE::IsEventInBinZero() {
   //
@@ -795,7 +758,7 @@ void AliAnalysisTaskHFE::ProcessMC(){
   // In case MC QA is on also MC QA loop is done
   //
   AliDebug(3, "Processing MC Information");
   // In case MC QA is on also MC QA loop is done
   //
   AliDebug(3, "Processing MC Information");
-  Double_t eventContainer [4];
+  Double_t eventContainer [4] = {0., 0., 0., 0.};
   if(IsESDanalysis()) eventContainer[0] = fMCEvent->GetPrimaryVertex()->GetZ();
   else eventContainer[0] = fAODMCHeader->GetVtxZ();
   eventContainer[2] = fCentralityF;
   if(IsESDanalysis()) eventContainer[0] = fMCEvent->GetPrimaryVertex()->GetZ();
   else eventContainer[0] = fAODMCHeader->GetVtxZ();
   eventContainer[2] = fCentralityF;
@@ -814,7 +777,7 @@ void AliAnalysisTaskHFE::ProcessMC(){
         fMCQA->SetMCEvent(fMCEvent);
         fMCQA->SetGenEventHeader(fMCEvent->GenEventHeader());
         fMCQA->SetCentrality(fCentralityF);
         fMCQA->SetMCEvent(fMCEvent);
         fMCQA->SetGenEventHeader(fMCEvent->GenEventHeader());
         fMCQA->SetCentrality(fCentralityF);
-        fMCQA->SetPercentrality(fCentralityPercent);
+        fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
         if(IsPbPb()) { fMCQA->SetPbPb();}
         else
         {
         if(IsPbPb()) { fMCQA->SetPbPb();}
         else
         {
@@ -894,7 +857,7 @@ void AliAnalysisTaskHFE::ProcessESD(){
   if(fTaggedTrackAnalysis) {
     fTaggedTrackAnalysis->SetMagneticField(fESD->GetMagneticField());
     fTaggedTrackAnalysis->SetCentrality(fCentralityF);
   if(fTaggedTrackAnalysis) {
     fTaggedTrackAnalysis->SetMagneticField(fESD->GetMagneticField());
     fTaggedTrackAnalysis->SetCentrality(fCentralityF);
-    if(IsPbPb()) fTaggedTrackAnalysis->SetPbPb();
+    if(IsHeavyIon()) fTaggedTrackAnalysis->SetPbPb();
     else fTaggedTrackAnalysis->SetPP();
   }
 
     else fTaggedTrackAnalysis->SetPP();
   }
 
@@ -903,7 +866,8 @@ void AliAnalysisTaskHFE::ProcessESD(){
   eventContainer[0] = 0.; 
   if(HasMCData()) eventContainer[0] = fVz;
   else {
   eventContainer[0] = 0.; 
   if(HasMCData()) eventContainer[0] = fVz;
   else {
-    if(fESD->GetPrimaryVertexSPD()) eventContainer[0] = fESD->GetPrimaryVertexSPD()->GetZ();
+    const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();
+    if(vtxESD) eventContainer[0] = vtxESD->GetZ();
   }
   eventContainer[1] = 0.;
   eventContainer[2] = fCentralityF;
   }
   eventContainer[1] = 0.;
   eventContainer[2] = fCentralityF;
@@ -955,13 +919,11 @@ void AliAnalysisTaskHFE::ProcessESD(){
   Double_t container[10];
   memset(container, 0, sizeof(Double_t) * 10);
   // container for the output THnSparse
   Double_t container[10];
   memset(container, 0, sizeof(Double_t) * 10);
   // container for the output THnSparse
-  Double_t dataE[6]; // [pT, eta, Phi, type, 'C' or 'B']
   Double_t dataDca[6]; // [source, pT, dca, centrality]
   Int_t nElectronCandidates = 0;
   AliESDtrack *track = NULL, *htrack = NULL;
   AliMCParticle *mctrack = NULL;
   AliMCParticle *mctrackmother = NULL;
   Double_t dataDca[6]; // [source, pT, dca, centrality]
   Int_t nElectronCandidates = 0;
   AliESDtrack *track = NULL, *htrack = NULL;
   AliMCParticle *mctrack = NULL;
   AliMCParticle *mctrackmother = NULL;
-  Int_t pid = 0;
 
   Bool_t signal = kTRUE;
 
 
   Bool_t signal = kTRUE;
 
@@ -977,23 +939,21 @@ void AliAnalysisTaskHFE::ProcessESD(){
   // minjung for IP QA(temporary ~ 2weeks)
   if(!fExtraCuts){
     fExtraCuts = new AliHFEextraCuts("hfetmpCuts","HFE tmp Cuts");
   // minjung for IP QA(temporary ~ 2weeks)
   if(!fExtraCuts){
     fExtraCuts = new AliHFEextraCuts("hfetmpCuts","HFE tmp Cuts");
-  }   
+  }
   fExtraCuts->SetRecEventInfo(fESD);
 
   // Electron background analysis 
   if (GetPlugin(kIsElecBackGround)) {
   fExtraCuts->SetRecEventInfo(fESD);
 
   // Electron background analysis 
   if (GetPlugin(kIsElecBackGround)) {
-    
+
     AliDebug(2, "Running BackGround Analysis");
     AliDebug(2, "Running BackGround Analysis");
-    
+
     fElecBackGround->Reset();
     fElecBackGround->Reset();
-    
+
   } // end of electron background analysis
   } // end of electron background analysis
-  
+
 
   // Background subtraction-------------------------------------------------------------------
 
   // Background subtraction-------------------------------------------------------------------
-  if (GetPlugin(kNonPhotonicElectron)) {
-    fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent,fCentralityF);
-  }
+  if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
   //------------------------------------------------------------------------------------------
 
   //
   //------------------------------------------------------------------------------------------
 
   //
@@ -1004,7 +964,7 @@ void AliAnalysisTaskHFE::ProcessESD(){
     AliDebug(4, "New ESD track");
     track = fESD->GetTrack(itrack);
     track->SetESDEvent(fESD);
     AliDebug(4, "New ESD track");
     track = fESD->GetTrack(itrack);
     track->SetESDEvent(fESD);
-
+    
     // fill counts of v0-identified particles
     Int_t v0pid = -1;
     if(track->TestBit(BIT(14))) v0pid = AliPID::kElectron;
     // fill counts of v0-identified particles
     Int_t v0pid = -1;
     if(track->TestBit(BIT(14))) v0pid = AliPID::kElectron;
@@ -1053,43 +1013,6 @@ void AliAnalysisTaskHFE::ProcessESD(){
         fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);
       }
     }
         fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);
       }
     }
-        
-    if(fisNonHFEsystematics && IsPbPb())  {
-      //FillProductionVertex(track);     
-      if(fMCQA && signal){ 
-       fMCQA->SetCentrality(fCentralityF);
-       if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){
-         Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};
-          
-         fMCQA->SetTrkKine(track->Pt(),track->Eta(), track->Phi());
-         fMCQA->SetContainerStep(4);
-          
-         weightElecBgV0[0] = fMCQA->GetWeightFactor(mctrack, 0); // positive:conversion e, negative: nonHFE 
-          
-         //Fill additional containers for electron source distinction
-         Int_t elecSource = 0;
-         elecSource = fMCQA->GetElecSource(mctrack->Particle());
-         const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
-         const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
-         Int_t iName = 0;
-         for(Int_t iSource = AliHFEmcQA::kPi0; iSource <=  AliHFEmcQA::kGammaRho0; iSource++){
-           if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
-           if(elecSource == iSource){
-             
-             if(weightElecBgV0[0]>0){ 
-               fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[0]), 4, kTRUE, weightElecBgV0[0]);
-             } 
-             else if(weightElecBgV0[0]<0){ 
-               fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[0]), 4, kTRUE, -1*weightElecBgV0[0]);
-             }           
-             break;
-           }
-           iName++;
-           if(iName == kElecBgSpecies)iName = 0;
-         }
-       }
-      }
-    }
   
     // RecKine: ITSTPC cuts  
     if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
   
     // RecKine: ITSTPC cuts  
     if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
@@ -1226,19 +1149,13 @@ void AliAnalysisTaskHFE::ProcessESD(){
       }
     }
 
       }
     }
 
-    if(TMath::Abs(track->Eta()) < 0.5){
-      if(track->GetInnerParam())
-        fQACollection->Fill("TPCdEdxBeforePID", track->GetInnerParam()->P(), track->GetTPCsignal());
-      fQACollection->Fill("TPCnSigmaBeforePID", track->P(), fInputHandler->GetPIDResponse()->NumberOfSigmasTPC(track, AliPID::kElectron));
-    }
-
     AliHFEpidObject hfetrack;
     hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
     hfetrack.SetRecTrack(track);
     if(HasMCData()) hfetrack.SetMCTrack(mctrack);
     hfetrack.SetCentrality(fCentralityF);
     hfetrack.SetMulitplicity(ncontribVtx);
     AliHFEpidObject hfetrack;
     hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
     hfetrack.SetRecTrack(track);
     if(HasMCData()) hfetrack.SetMCTrack(mctrack);
     hfetrack.SetCentrality(fCentralityF);
     hfetrack.SetMulitplicity(ncontribVtx);
-    if(IsPbPb()) hfetrack.SetPbPb();
+    if(IsHeavyIon()) hfetrack.SetPbPb();
     else hfetrack.SetPP();
     fPID->SetVarManager(fVarManager);
     if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;
     else hfetrack.SetPP();
     fPID->SetVarManager(fVarManager);
     if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;
@@ -1257,17 +1174,17 @@ void AliAnalysisTaskHFE::ProcessESD(){
 
     // Temporary histogram for chi2/ITS cluster
     if(IsPbPb()) {
 
     // Temporary histogram for chi2/ITS cluster
     if(IsPbPb()) {
-            TBits shared = track->GetTPCSharedMap();
+      TBits shared = track->GetTPCSharedMap();
            Int_t sharebit=0;
            Int_t sharebit=0;
-            if(shared.CountBits() >= 2) sharebit=1;
+      if(shared.CountBits() >= 2) sharebit=1;
 
            Double_t itschi2percluster = 0.0;
            Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
            if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;
 
 
            Double_t itschi2percluster = 0.0;
            Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
            if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;
 
-            Double_t itsChi2[7] = {track->Pt(),track->Eta(), track->Phi(),
-                                  fCentralityF,track->GetTPCsignalN(), sharebit,itschi2percluster};
-            fQACollection->Fill("fChi2perITScluster", itsChi2);
+      Double_t itsChi2[7] = {track->Pt(),track->Eta(), track->Phi(),
+                       static_cast<Double_t>(fCentralityF),static_cast<Double_t>(track->GetTPCsignalN()), static_cast<Double_t>(sharebit),itschi2percluster};
+      fQACollection->Fill("fChi2perITScluster", itsChi2);
     }
     else{
 
     }
     else{
 
@@ -1275,7 +1192,7 @@ void AliAnalysisTaskHFE::ProcessESD(){
       Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
       if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;
 
       Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
       if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;
 
-      Double_t itsChi2[3] = {track->Pt(), fCentralityF, itschi2percluster};
+      Double_t itsChi2[3] = {track->Pt(), static_cast<Double_t>(fCentralityF), itschi2percluster};
       fQACollection->Fill("fChi2perITScluster", itsChi2);
     }
 
       fQACollection->Fill("fChi2perITScluster", itsChi2);
     }
 
@@ -1298,12 +1215,12 @@ void AliAnalysisTaskHFE::ProcessESD(){
     // Fill Containers
     if(signal) {
       // Apply weight for background contamination
     // Fill Containers
     if(signal) {
       // Apply weight for background contamination
-            if(fBackGroundFactorApply) {
-              if(IsPbPb() && fCentralityF >= 0) fWeightBackGround =  fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
-              else    fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
+      if(fBackGroundFactorApply) {
+        if(IsHeavyIon() && fCentralityF >= 0) fWeightBackGround =  fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
+        else    fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
 
 
-              if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
-              else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
+        if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
+        else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
         // weightBackGround as special weight
         fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
       }
         // weightBackGround as special weight
         fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
       }
@@ -1320,44 +1237,6 @@ void AliAnalysisTaskHFE::ProcessESD(){
       }
     }
 
       }
     }
 
-    if(HasMCData()){
-      dataE[0] = track->Pt();
-      dataE[1] = track->Eta();
-      dataE[2] = track->Phi();
-      dataE[3] = track->Charge();
-      dataE[4] = -1.;
-      dataE[5] = -1.;
-
-      // Track selected: distinguish between true and fake
-      AliDebug(1, Form("Candidate Selected, filling THnSparse, PID: %d\n", mctrack->Particle()->GetPdgCode()));
-      if((pid = TMath::Abs(mctrack->Particle()->GetPdgCode())) == 11){
-        Int_t type = 0;
-        if(fSignalCuts->IsCharmElectron(track))
-          type = 1;
-        else if(fSignalCuts->IsBeautyElectron(track))
-          type = 2;
-        AliDebug(1, Form("Type: %d\n", type));
-        if(type){
-                dataE[5] = type; // beauty[1] or charm[2]
-                dataE[4] = 2;  // signal electron
-        }
-        else{
-                dataE[4] = 1; // not a signal electron
-                dataE[5] = 0;
-        }
-      } 
-      else {
-        // Fill THnSparse with the information for Fake Electrons
-        dataE[4] = 0;
-        dataE[5] = 0;
-      }
-      // fill the performance THnSparse, if the mc origin could be defined
-      if(dataE[4] > -1){
-        AliDebug(1, Form("Entries: [%.3f|%.3f|%.3f|%f|%f|%f]\n", dataE[0],dataE[1],dataE[2],dataE[3],dataE[4],dataE[5]));
-        fQACollection->Fill("PIDperformance", dataE);
-      }
-    }
-
     // Electron background analysis 
     if (GetPlugin(kIsElecBackGround)) {
       
     // Electron background analysis 
     if (GetPlugin(kIsElecBackGround)) {
       
@@ -1498,6 +1377,11 @@ void AliAnalysisTaskHFE::ProcessESD(){
     }
 
   }
     }
 
   }
+
+  // Background subtraction-------------------------------------------------------------------
+  if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
+  //------------------------------------------------------------------------------------------
+
   fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
 }
 
   fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
 }
 
@@ -1579,40 +1463,20 @@ void AliAnalysisTaskHFE::ProcessAOD(){
   //printf("Number of kink mother in the events %d\n",numberofmotherkink);
 
   // Background subtraction-------------------------------------------------------------------
   //printf("Number of kink mother in the events %d\n",numberofmotherkink);
 
   // Background subtraction-------------------------------------------------------------------
-  if (GetPlugin(kNonPhotonicElectron)) {
-    fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent,fCentralityF);
-  }
+  if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
   //------------------------------------------------------------------------------------------
 
   // Loop over tracks
   AliAODTrack *track = NULL;
   AliAODMCParticle *mctrack = NULL;
   //------------------------------------------------------------------------------------------
 
   // Loop over tracks
   AliAODTrack *track = NULL;
   AliAODMCParticle *mctrack = NULL;
-  Double_t dataE[6]; // [pT, eta, Phi, Charge, type, 'C' or 'B']
   Double_t dataDca[6]; // [source, pT, dca, centrality]
   Int_t nElectronCandidates = 0;
   Double_t dataDca[6]; // [source, pT, dca, centrality]
   Int_t nElectronCandidates = 0;
-  Int_t pid;
   Bool_t signal;
   Bool_t signal;
+
   //printf("Number of track %d\n",(Int_t) fAOD->GetNumberOfTracks());
   for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){
     track = fAOD->GetTrack(itrack); mctrack = NULL;
     if(!track) continue;
   //printf("Number of track %d\n",(Int_t) fAOD->GetNumberOfTracks());
   for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){
     track = fAOD->GetTrack(itrack); mctrack = NULL;
     if(!track) continue;
-    // Begining
-    Bool_t passone = kFALSE;  
-    fQAAODCollection->Fill("Filterorigin", -1);
-    for(Int_t k=0; k<20; k++) {
-      Int_t u = 1<<k;     
-      if((track->TestFilterBit(u))) {
-       fQAAODCollection->Fill("Filterorigin", k);
-       passone = kTRUE;
-      }
-    }
-    //if(!passone) printf("what is the filter %d\n",track->GetFilterMap());
-
-    if(fUseFilterAOD){
-      //printf("Filter of the track  %d\n",track->GetFilterMap());
-      if(!(track->TestFilterBit(fFilter))) continue;  // Only process AOD tracks where the HFE is set
-    }
-    //printf("Pass the flag\n");
     
     signal = kTRUE;
     if(HasMCData()){
     
     signal = kTRUE;
     if(HasMCData()){
@@ -1727,7 +1591,7 @@ void AliAnalysisTaskHFE::ProcessAOD(){
     if(HasMCData()) hfetrack.SetMCTrack(mctrack);
     hfetrack.SetCentrality(fCentralityF);
     hfetrack.SetMulitplicity(ncontribVtx); // for correction
     if(HasMCData()) hfetrack.SetMCTrack(mctrack);
     hfetrack.SetCentrality(fCentralityF);
     hfetrack.SetMulitplicity(ncontribVtx); // for correction
-    if(IsPbPb()) hfetrack.SetPbPb();
+    if(IsHeavyIon()) hfetrack.SetPbPb();
     else hfetrack.SetPP();
     fPID->SetVarManager(fVarManager);
     if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;   
     else hfetrack.SetPP();
     fPID->SetVarManager(fVarManager);
     if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;   
@@ -1737,17 +1601,17 @@ void AliAnalysisTaskHFE::ProcessAOD(){
     if (GetPlugin(kNonPhotonicElectron)) {
       Int_t indexmother = -1;
       Int_t mcsource = -1;
     if (GetPlugin(kNonPhotonicElectron)) {
       Int_t indexmother = -1;
       Int_t mcsource = -1;
-      if(HasMCData())  mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
+      if(HasMCData() && mctrack)  mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
       fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1,mcsource, indexmother);
     }
     //---------------------------------------------------------------------------------------------------------------------
 
     // end AOD QA
       fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, 1, fCentralityF, -1,mcsource, indexmother);
     }
     //---------------------------------------------------------------------------------------------------------------------
 
     // end AOD QA
-    fQAAODCollection->Fill("Filterend", -1);  
+    fQACollection->Fill("Filterend", -1);  
     for(Int_t k=0; k<20; k++) {
       Int_t u = 1<<k;
       if((track->TestFilterBit(u))) {
     for(Int_t k=0; k<20; k++) {
       Int_t u = 1<<k;
       if((track->TestFilterBit(u))) {
-       fQAAODCollection->Fill("Filterend", k);
+             fQACollection->Fill("Filterend", k);
       }
     }
        
       }
     }
        
@@ -1756,11 +1620,11 @@ void AliAnalysisTaskHFE::ProcessAOD(){
     if(signal) {
       // Apply weight for background contamination
       if(fBackGroundFactorApply) {
     if(signal) {
       // Apply weight for background contamination
       if(fBackGroundFactorApply) {
-       if(IsPbPb() && fCentralityF >= 0) fWeightBackGround =  fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
-       else    fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
+             if(IsHeavyIon() && fCentralityF >= 0) fWeightBackGround =  fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
+             else    fWeightBackGround =  fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
        
        
-       if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
-       else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
+             if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
+             else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
         // weightBackGround as special weight
         fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
       }
         // weightBackGround as special weight
         fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
       }
@@ -1768,43 +1632,6 @@ void AliAnalysisTaskHFE::ProcessAOD(){
     }
     
     nElectronCandidates++;    
     }
     
     nElectronCandidates++;    
-    if(HasMCData()){
-      dataE[0] = track->Pt();
-      dataE[1] = track->Eta();
-      dataE[2] = track->Phi();
-      dataE[3] = track->Charge();
-      dataE[4] = -1;
-      dataE[5] = -1;
-      // Track selected: distinguish between true and fake
-      AliDebug(1, Form("Candidate Selected, filling THnSparse, PID: %d\n", mctrack ? mctrack->GetPdgCode(): -1));
-      if(mctrack && ((pid = TMath::Abs(mctrack->GetPdgCode())) == 11)){
-      
-        Int_t type = 0;
-        if(fSignalCuts->IsCharmElectron(track))
-          type = 1;
-        else if(fSignalCuts->IsBeautyElectron(track))
-          type = 2;
-        AliDebug(1, Form("Type: %d\n", type));
-        if(type){
-                dataE[5] = type; // beauty[1] or charm[2]
-                dataE[4] = 2;  // signal electron
-        }
-        else{
-                dataE[4] = 1; // not a signal electron
-                dataE[5] = 0;
-        }
-      } 
-      else {
-        // Fill THnSparse with the information for Fake Electrons
-        dataE[4] = 0;
-        dataE[5] = 0;
-      }
-      // fill the performance THnSparse, if the mc origin could be defined
-      if(dataE[4] > -1){
-        AliDebug(1, Form("Entries: [%.3f|%.3f|%.3f|%f|%f|%f]\n", dataE[0],dataE[1],dataE[2],dataE[3],dataE[4],dataE[5]));
-        fQACollection->Fill("PIDperformance", dataE);
-      }
-    }
 
     if (GetPlugin(kDEstep)) {
       if (!HasMCData()){
 
     if (GetPlugin(kDEstep)) {
       if (!HasMCData()){
@@ -1833,6 +1660,11 @@ void AliAnalysisTaskHFE::ProcessAOD(){
       }
     }
   }
       }
     }
   }
+
+  // Background subtraction-------------------------------------------------------------------
+  if (GetPlugin(kNonPhotonicElectron)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
+  //------------------------------------------------------------------------------------------
+
   fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
 }
 
   fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
 }
 
@@ -1844,12 +1676,7 @@ Bool_t AliAnalysisTaskHFE::ProcessMCtrack(AliVParticle *track){
   // Works for AOD and MC analysis Type
   //
   fVarManager->NewTrack(track, NULL, fCentralityF, -1, kTRUE);
   // Works for AOD and MC analysis Type
   //
   fVarManager->NewTrack(track, NULL, fCentralityF, -1, kTRUE);
-  Double_t signalContainer[6];
 
 
-  signalContainer[0] = track->Pt();
-  signalContainer[1] = track->Eta();
-  signalContainer[2] = track->Phi();
-  signalContainer[3] = track->Charge()/3;
 
   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)
   if(IsESDanalysis()){
 
   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)
   if(IsESDanalysis()){
@@ -1867,29 +1694,6 @@ Bool_t AliAnalysisTaskHFE::ProcessMCtrack(AliVParticle *track){
   if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, track)) return kFALSE;
   //printf("MC Generated pass\n");
   fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGenerated, kFALSE);
   if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, track)) return kFALSE;
   //printf("MC Generated pass\n");
   fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGenerated, kFALSE);
-  signalContainer[4] = 0;
-  if(fSignalCuts->IsSelected(track)){
-    //fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCsignal, kFALSE);
-    // Filling of the Signal/Background histogram using the 
-    // definition of the codes for charm and beauty as below in
-    // th crearion of the histogram
-    if(fSignalCuts->IsCharmElectron(track))
-      signalContainer[4] = 1;
-    else 
-      signalContainer[4] = 2;
-  } else {
-    signalContainer[4] = 0; // (and other background)
-  }
-  signalContainer[5] = 0;
-  // apply cut on the sqrt of the production vertex
-  Double_t radVertex = TMath::Sqrt(vertex[0]*vertex[0] + vertex[1] * vertex[1]);
-  if(radVertex < 3.5){
-    // Within first ITS layer(2) -> Background we cannot reject by ITS cut, let it pass
-    signalContainer[5] = 1;
-  } else if (radVertex < 7.5){
-    signalContainer[5] = 2;
-  }
-  fQACollection->Fill("SignalToBackgroundMC", signalContainer);
 
   // Step GeneratedZOutNoPileUp
   if((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0)) return kFALSE;
 
   // Step GeneratedZOutNoPileUp
   if((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0)) return kFALSE;
@@ -2028,31 +1832,6 @@ void AliAnalysisTaskHFE::MakeParticleContainer(){
     fContainer->SetStepTitle("recTrackContMC", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);
   }
 }
     fContainer->SetStepTitle("recTrackContMC", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);
   }
 }
-
-//____________________________________________________________
-void AliAnalysisTaskHFE::InitPIDperformanceQA(){
-  // Add a histogram for Fake electrons
-  const Int_t nDim=6;
-  Int_t nBin[nDim] = {40, 8, 18, 2, 3, 3};
-  //number of variables on the grid:pt,eta,phi,charge,
-  const Double_t kPtbound[2] = {0.1, 20.};
-  const Double_t kEtabound[2] = {-0.8, 0.8};
-  const Double_t kPhibound[2] = {0., 2. * TMath::Pi()}; 
-  const Double_t kChargebound[2] = {-1.1, 1.1};
-  const Double_t kAddInf1bound[2] = {0., 3.};
-  const Double_t kAddInf2bound[2] = {0., 3.};
-  Double_t minima[nDim] = {kPtbound[0], kEtabound[0], kPhibound[0], kChargebound[0], kAddInf1bound[0], kAddInf2bound[0]}; 
-  Double_t maxima[nDim] = {kPtbound[1], kEtabound[1], kPhibound[1], kChargebound[1], kAddInf1bound[1], kAddInf2bound[1]}; 
-  
-  fQACollection->CreateTHnSparse("PIDperformance", "PID performance; pT [GeV/c]; theta [rad]; phi [rad]; charge; type (0 - not el, 1 - other el, 2 - HF el; flavor (0 - no, 1 - charm, 2 - bottom)", nDim, nBin, minima, maxima);
-  fQACollection->CreateTHnSparse("SignalToBackgroundMC", "PID performance; pT [GeV/c]; theta [rad]; phi [rad]; charge; flavor (0 - no, 1 - charm, 2 - bottom); ITS Cluster (0 - no, 1 - first (and maybe second), 2 - second)", nDim, nBin, minima, maxima);
-
-  fQACollection->BinLogAxis("PIDperformance", 0);
-  fQACollection->BinLogAxis("SignalToBackgroundMC", 0);
-  fQACollection->Sumw2("PIDperformance");
-  fQACollection->Sumw2("SignalToBackgroundMC");
-}
-
 //____________________________________________________________
 void AliAnalysisTaskHFE::InitContaminationQA(){
   // 
 //____________________________________________________________
 void AliAnalysisTaskHFE::InitContaminationQA(){
   // 
@@ -2258,10 +2037,10 @@ Bool_t AliAnalysisTaskHFE::ReadCentrality() {
   
 
   Int_t bin = -1;
   
 
   Int_t bin = -1;
-  if(IsPbPb()) {
+  if(IsHeavyIon()) {
     // Centrality
     AliCentrality *centrality = fInputEvent->GetCentrality();
     // Centrality
     AliCentrality *centrality = fInputEvent->GetCentrality();
-    fCentralityPercent = centrality->GetCentralityPercentile("V0M");
+    fCentralityPercent = centrality->GetCentralityPercentile(fCentralityEstimator.Data());
     //printf("centrality %f\n",fCentralityPercent);
 
     for(Int_t ibin = 0; ibin < 11; ibin++){
     //printf("centrality %f\n",fCentralityPercent);
 
     for(Int_t ibin = 0; ibin < 11; ibin++){
@@ -2304,7 +2083,7 @@ Bool_t AliAnalysisTaskHFE::ReadCentrality() {
       AliError("ESD Event required for ESD Analysis");
       return kFALSE;
     }
       AliError("ESD Event required for ESD Analysis");
       return kFALSE;
     }
-    vtx = fESD->GetPrimaryVertexSPD();
+    vtx = fESD->GetPrimaryVertex() ;
   }
   if(!vtx){ 
     fContributors = 0.5;
   }
   if(!vtx){ 
     fContributors = 0.5;
@@ -2350,29 +2129,6 @@ Int_t AliAnalysisTaskHFE::GetITSMultiplicity(AliVEvent *ev){
   return nAcc;
 }
 
   return nAcc;
 }
 
-//___________________________________________________
-Bool_t AliAnalysisTaskHFE::InitializeHadronBackground(Int_t run){
-  //
-  // Initialize background factors array from the AliOADBContainer
-  // The container is expected to provide a TObjArray with the name
-  // "hadronBackground" and the size 12 for the given run number
-  //
-  AliDebug(1, "Deriving hadronic background parameterization from OADB container");
-  TObjArray *functions = dynamic_cast<TObjArray *>(fHadronBackgroundOADB->GetObject(run, "hadronBackground"));
-  if(!functions){
-    AliDebug(1, "Content in the OADB Container is not a TObjArray");
-    fBackGroundFactorApply = kFALSE;
-    return kFALSE;
-  } 
-  if(functions->GetSize() < 12){
-    AliDebug(1, Form("Size not matching: 12 expected, %d provided", functions->GetSize()));
-    fBackGroundFactorApply = kFALSE;
-    return kFALSE;
-  }
-  for(Int_t icent = 0; icent < 12; icent++) fkBackGroundFactorArray[icent] = dynamic_cast<const TF1 *>(functions->UncheckedAt(icent));
-  return kTRUE;
-}
-
 //___________________________________________________
 void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() {
   //
 //___________________________________________________
 void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() {
   //
@@ -2408,26 +2164,211 @@ void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() {
    // PileUp
    fIdentifiedAsPileUp = kFALSE;
    if(fRemovePileUp && fESD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; 
    // PileUp
    fIdentifiedAsPileUp = kFALSE;
    if(fRemovePileUp && fESD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; 
+   
+
+
    // Z vertex
    fIdentifiedAsOutInz = kFALSE;
    // Z vertex
    fIdentifiedAsOutInz = kFALSE;
-   if (IsPbPb()) {
-     //printf("PbPb\n");
-     if(fESD->GetPrimaryVertex()){
-       if(TMath::Abs(fESD->GetPrimaryVertex()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
-     }
-   }
-   else {
-     //printf("pp\n");
-     if(fESD->GetPrimaryVertexTracks()){
-       if(TMath::Abs(fESD->GetPrimaryVertexTracks()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
-     }
+   Bool_t findvertex = kTRUE;
+   const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();
+   if((!vtxESD) || (vtxESD->GetNContributors() <= 0)) findvertex = kFALSE;
+   if(findvertex) {
+     if(TMath::Abs(vtxESD->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
    }
    }
+   
    //Event Cut
    fPassTheEventCut = kTRUE;
    if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) fPassTheEventCut = kFALSE;   
   
    //Event Cut
    fPassTheEventCut = kTRUE;
    if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) fPassTheEventCut = kFALSE;   
   
-
  }
 
 }
 
  }
 
 }
 
+//___________________________________________________
+Bool_t AliAnalysisTaskHFE::CheckTRDTrigger(AliESDEvent *ev) {
+//
+// Check TRD trigger; pPb settings
+//
+    Bool_t cint8=kFALSE;
+    Bool_t cint7=kFALSE;
+    Bool_t cint5=kFALSE;
+    Bool_t trdtrgevent=kFALSE;
+    fTRDTriggerAnalysis->CalcTriggers(ev); 
+
+    // HSE no cleanup
+    if(fWhichTRDTrigger==1)
+    {
+       cint8= ev->IsTriggerClassFired("CINT8WUHSE-B-NOPF-CENT");
+       cint7= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT");
+       cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
+           (ev->GetHeader()->GetL1TriggerInputs() & (1 << 10));
+       if((cint7==kFALSE)&&(cint8==kFALSE)&&(cint5==kFALSE)) return kFALSE;
+       else
+       {
+           DrawTRDTrigger(ev);
+           return kTRUE;
+       }
+    }
+
+    // HSE cleanup
+    if(fWhichTRDTrigger==2)
+    {
+       if(!fTRDTriggerAnalysis->IsFired(AliTRDTriggerAnalysis::kHSE))
+       {
+           return kFALSE;
+       }
+       else
+       {
+           DrawTRDTrigger(ev);
+           return kTRUE;
+       }
+    }
+
+    //HQU no cleanup
+    if(fWhichTRDTrigger==3)
+    {
+       cint8= ev->IsTriggerClassFired("CINT8WUHQU-B-NOPF-CENT");
+       cint7= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT");
+       cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
+           (ev->GetHeader()->GetL1TriggerInputs() & (1 << 12));
+       if((cint7==kFALSE)&&(cint8==kFALSE)&&(cint5==kFALSE)) return kFALSE;
+       else
+       {
+           DrawTRDTrigger(ev);
+           return kTRUE;
+       }
+    }
+
+    // HQU cleanup
+    if(fWhichTRDTrigger==4)
+    {
+
+       if(!fTRDTriggerAnalysis->IsFired(AliTRDTriggerAnalysis::kHQU))
+       {
+           return kFALSE;
+       }
+       else
+       {
+           DrawTRDTrigger(ev);
+           return kTRUE;
+       }
+    }
+   
+    return trdtrgevent;
+
+}
+
+void AliAnalysisTaskHFE::DrawTRDTrigger(AliESDEvent *ev) {
+
+    Int_t ntriggerbit=0;
+    fQACollection->Fill("nTriggerBit",ntriggerbit);
+    if(ev->IsTriggerClassFired("CINT7-B-NOPF-ALLNOTRD"))
+    {
+       ntriggerbit=2;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+    }
+    if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
+    {
+       ntriggerbit=3;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+       if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+           ntriggerbit=18;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+       }
+       if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
+           ntriggerbit=19;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+       }
+    }
+    if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT"))
+    {
+       ntriggerbit=4;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+
+       if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+           ntriggerbit=13;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+       }
+       if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
+           ntriggerbit=14;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+           if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+               ntriggerbit=17;
+               fQACollection->Fill("nTriggerBit",ntriggerbit);
+           }
+       }
+    }
+    if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT"))
+    {
+       ntriggerbit=5;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+       if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+           ntriggerbit=11;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+       }
+       if((!(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")))&&(!(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT")))) {
+           ntriggerbit=21;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+
+            /*
+           Int_t nTrdTracks = ev->GetNumberOfTrdTracks();
+           for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
+               AliESDTrdTrack* trdTrack = ev->GetTrdTrack(iTrack);
+               printf("GTU track %3i: pt = %5.1f, PID = %3i\n", iTrack, trdTrack->Pt(), trdTrack->GetPID());
+           }*/
+
+
+       }
+
+    }
+    if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT"))
+    {
+       ntriggerbit=6;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+       if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
+           ntriggerbit=12;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+       }
+       if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){
+           ntriggerbit=15;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+
+           if((!(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")))&&(!(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT")))) {
+               ntriggerbit=20;
+               fQACollection->Fill("nTriggerBit",ntriggerbit);
+               /*
+                Int_t nTrdTracks = ev->GetNumberOfTrdTracks();
+                for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
+                AliESDTrdTrack* trdTrack = ev->GetTrdTrack(iTrack);
+                printf("HSE GTU track %3i: pt = %5.1f, PID = %3i\n", iTrack, trdTrack->Pt(), trdTrack->GetPID());
+                }                          */
+
+           }
+
+       }
+
+    }
+    if(ev->IsTriggerClassFired("CEMC7WUHEE-B-NOPF-CENT")) {
+       ntriggerbit=7;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+    }
+    if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-FAST")){
+       ntriggerbit=8;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+    }
+    if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-FAST")){
+       ntriggerbit=9;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+    }
+    if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){
+       ntriggerbit=10;
+       fQACollection->Fill("nTriggerBit",ntriggerbit);
+       if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
+           ntriggerbit=16;
+           fQACollection->Fill("nTriggerBit",ntriggerbit);
+       }
+    }
+    if(ntriggerbit==0) fQACollection->Fill("nTriggerBit",1);
+
+}
+