[u/mrichter/AliRoot.git] / PWGHF / hfe / AliAnalysisTaskHFE.h

/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/
//
// Task for Heavy Flavour Electron Analysis
// Fills a single-inclusive electron pt-spectrum
// For further information see implementation file
//
#ifndef ALIANALYSISTASKHFE_H
#define ALIANALYSISTASKHFE_H

#ifndef ALIANALYSISTASKSE_H
#include "AliAnalysisTaskSE.h"
#endif

#ifndef ROOT_TString
#include <TString.h>
#endif

#ifndef ROOT_TBits
#include <TBits.h>
#endif

class AliAnalysisUtils;
class AliESDtrackCuts;
class AliHFEcontainer;
class AliHFEcollection;
class AliHFEcuts;
class AliHFEextraCuts;
class AliHFEelecbackground;
class AliHFENonPhotonicElectron;
class AliHFEmcQA;
class AliHFEpid;
class AliHFEpidQAmanager;
class AliHFEsecVtx;
class AliHFEsignalCuts;
class AliHFEvarManager;
class AliHFEtaggedTrackAnalysis;
class AliHFEV0taginfo;
class AliCFManager;
class AliMCEvent;
class AliOADBContainer;
class AliAODMCHeader;
class AliVEvent;
class AliVParticle;
class AliTriggerAnalysis;
class AliTRDTriggerAnalysis;
class TH1I; 
class TList;
class TClonesArray;

class AliAnalysisTaskHFE : public AliAnalysisTaskSE{
  public:
    enum{
      kPIDqa = 0,
      kMCqa =1 
    };
    enum{
      kPriVtx = 0,
      kSecVtx = 1,
      kIsElecBackGround = 2,
      kPostProcess = 3,
      kDEstep = 4,
      kTaggedTrackAnalysis = 5,
      kNonPhotonicElectron = 6,
      kNonPhotonicElectronBeauty = 7
    };
    enum CreationProcess_t{
      kSignalCharm = 0,
      kSignalBeauty = 1,
      kGammaConv = 2,
      kOther = 3
    };
    enum{
      kBgPtBins = 44,
      kElecBgSpecies = 6,
      kCentBins = 11,
      kBgLevels = 3
    };
    typedef enum{
      kpp = 0,
      kpPb = 1,
      kPbPb = 2
    } ECollisionSystem_t;

    AliAnalysisTaskHFE();
    AliAnalysisTaskHFE(const char * name);
    AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref);
    AliAnalysisTaskHFE& operator=(const AliAnalysisTaskHFE &ref);
    virtual void Copy(TObject &o) const;
    virtual ~AliAnalysisTaskHFE();

    virtual void UserCreateOutputObjects();
    virtual void UserExec(Option_t *);
    virtual void Terminate(Option_t *);

    virtual Bool_t IsEventInBinZero();

    Bool_t IsQAOn(Int_t qaLevel) const { return TESTBIT(fQAlevel, qaLevel); };
    Bool_t IsAODanalysis() const { return TestBit(kAODanalysis); };
    Bool_t IsESDanalysis() const { return !TestBit(kAODanalysis); };
    Bool_t HasMCData() const { return TestBit(kHasMCdata); }
    Bool_t Ispp() const { return fCollisionSystem.TestBitNumber(kpp); }
    Bool_t IsPbPb() const { return fCollisionSystem.TestBitNumber(kPbPb); }
    Bool_t IspPb() const { return fCollisionSystem.TestBitNumber(kpPb); }
    Bool_t IsHeavyIon() const { return IsPbPb(); }
    Bool_t GetPlugin(Int_t plug) const { return TESTBIT(fPlugins, plug); };

    // Get Components for configuration
    AliHFEvarManager *GetVarManager() const { return fVarManager; }
    AliHFEpidQAmanager *GetPIDQAManager() const { return fPIDqa; }
    AliHFEpid *GetPID() const { return fPID; }
    AliHFENonPhotonicElectron *GetHFEBackgroundSubtraction() const { return fBackgroundSubtraction; }

    void SetHFECuts(AliHFEcuts * const cuts) { fCuts = cuts; };
    void SetTaggedTrackCuts(AliHFEcuts * const cuts) { fTaggedTrackCuts = cuts; }
    void SetCleanTaggedTrack(Bool_t clean) { fCleanTaggedTrack = clean; };
    void SetVariablesTRDTaggedTrack(Bool_t variablesTRD) { fVariablesTRDTaggedTrack = variablesTRD; };
    void SetHFECutsPreselect(AliESDtrackCuts * const cuts) { fCutspreselect = cuts; };
    void SetHFEElecBackGround(AliHFEelecbackground * const elecBackGround) { fElecBackGround = elecBackGround; };
    void SetHFEBackgroundSubtraction(AliHFENonPhotonicElectron * const backgroundSubtraction) { fBackgroundSubtraction = backgroundSubtraction; };
    void SetQAOn(Int_t qaLevel) { SETBIT(fQAlevel, qaLevel); };
    void SwitchOnPlugin(Int_t plug);
    void SetHasMCData(Bool_t hasMC = kTRUE) { SetBit(kHasMCdata, hasMC); };
    void SetFillSignalOnly(Bool_t signalOnly) { fFillSignalOnly = signalOnly; }
   
    void SetFillNoCuts(Bool_t fillNoCuts) { fFillNoCuts = fillNoCuts; }
    void SetRemovePileUp(Bool_t removePileUp) { fRemovePileUp = removePileUp; }
    void SetRemoveFirstEventInChunk() {fRemoveFirstEvent = kTRUE;}
    void SetPIDPreselect(AliHFEpid * const cuts) { fPIDpreselect = cuts; };
    void SetAODAnalysis() { SetBit(kAODanalysis, kTRUE); };
    void SetESDAnalysis() { SetBit(kAODanalysis, kFALSE); };
    void SetTRDTrigger(Bool_t activateTRDTrigger, Int_t trdtrigger) {fTRDTrigger=activateTRDTrigger; fWhichTRDTrigger=trdtrigger;};
    void SetCollisionSystem(ECollisionSystem_t system){
      fCollisionSystem.Clear();
      fCollisionSystem.SetBitNumber(system, kTRUE);
    }
    void SetppAnalysis(){
      fCollisionSystem.SetBitNumber(kpPb, kFALSE); 
      fCollisionSystem.SetBitNumber(kPbPb, kFALSE); 
      fCollisionSystem.SetBitNumber(kpp, kTRUE); 
    }
    void SetpPbAnalysis() {
      fCollisionSystem.SetBitNumber(kpp, kFALSE); 
      fCollisionSystem.SetBitNumber(kPbPb, kFALSE); 
      fCollisionSystem.SetBitNumber(kpPb, kTRUE); 
    }
    void SetPbPbAnalysis() { 
      fCollisionSystem.SetBitNumber(kpp, kFALSE); 
      fCollisionSystem.SetBitNumber(kpPb, kFALSE); 
      fCollisionSystem.SetBitNumber(kPbPb, kTRUE); 
    };
    void SetCentralityEstimator(const char *estimator) { fCentralityEstimator = estimator; }
    void SetPbPbUserCentralityLimit(Bool_t isPbPbUserBinning = kFALSE){fPbPbUserCentralityBinning = isPbPbUserBinning; };
    void SetPbPbUserCentralityArray(Int_t icentr, Float_t valuecentr) {fCentralityLimits[icentr] = valuecentr;};
    void SetPPMultiBinAnalysis(Bool_t isppMultiBin) { fisppMultiBin = isppMultiBin; };
    void SetNonHFEsystematics(Bool_t isSystematics) {fisNonHFEsystematics = isSystematics; };
    void SetRejectKinkMother(Bool_t rejectKinkMother = kFALSE) { fRejectKinkMother = rejectKinkMother; };
    void SetRejectMCFakeTracks(Bool_t rejectFakes = kTRUE) { fRejectMCFakeTracks = rejectFakes; };
    void SetBackGroundFactorsFunction(const TF1 * const backGroundFactorsFunction, Int_t centralitybin=0){  
      fkBackGroundFactorArray[centralitybin]=backGroundFactorsFunction;
      fBackGroundFactorApply=kTRUE;
      SetBit(kBackgroundInitialized);
    };
    void SetElecBackGroundFactors(Int_t iPt, Int_t iType, Int_t iCent, Int_t iError, Double_t elecBackGroundFactor) {fElecBackgroundFactor[iError][iCent][iType][iPt] = elecBackGroundFactor; };
    void SetBinLimits(Int_t iPt, Double_t momentum){fBinLimit[iPt] = momentum;};
    void PrintStatus() const;
    Bool_t ReadCentrality();
    void RejectionPileUpVertexRangeEventCut();  
    void SelectSpecialTrigger(const Char_t *trgclust, Int_t runMin = 0, Int_t runMax = 999999999); 
    void SetDebugStreaming() {SetBit(kTreeStream);};
    Bool_t CheckTRDTriggerESD(AliESDEvent *ev);
    Bool_t CheckTRDTrigger(AliVEvent *ev);
    void DrawTRDTrigger(AliESDEvent *ev);
    void DrawTRDTriggerAnalysis(AliVEvent *ev);

  private:
    enum{
      kHasMCdata = BIT(19),
      kAODanalysis = BIT(20),
      kBackgroundInitialized = BIT(21),
      kTreeStream = BIT(22)
    };

    Bool_t FillProductionVertex(const AliVParticle * const track) const;
    void MakeParticleContainer();
    void MakeEventContainer();
    void InitHistoITScluster();
    void InitContaminationQA();
    const Char_t *GetSpecialTrigger(Int_t run);
    void ProcessMC();
    void ProcessESD();
    void ProcessAOD();
    Int_t GetITSMultiplicity(AliVEvent *ev);
    Bool_t IsMCFakeTrack(const AliVTrack * const trk) const;
    Bool_t PreSelectTrack(AliESDtrack *track) const;
    Bool_t ProcessMCtrack(AliVParticle *track);
    Bool_t ProcessCutStep(Int_t cutStep, AliVParticle *track);
    AliAODMCHeader *fAODMCHeader;         // ! MC info AOD
    TClonesArray *fAODArrayMCInfo;        // ! MC info particle AOD
    ULong_t fQAlevel;                     // QA level
    UShort_t fPlugins;                    // Enabled Plugins
    TBits fCollisionSystem;              // Collision System;
    Bool_t fFillSignalOnly;               // Fill container only with MC Signal Tracks
    Bool_t fRejectMCFakeTracks;           // Reject fake tracks in MC using the sign of the Label
    Bool_t fFillNoCuts;                   // Fill container before any cut
    Bool_t fBackGroundFactorApply;        // Apply Background Function Subtraction,   MF: To be removed when transition to OADB container is finished
    Bool_t fRemovePileUp;                 // Remove Pile Up
    Bool_t fIdentifiedAsPileUp;           // Identified as pile-up
    Bool_t fIdentifiedAsOutInz;           // Out Of Range in z
    Bool_t fPassTheEventCut;              // Pass The Event Cut
    Bool_t fRejectKinkMother;             // Reject Kink Mother
    Bool_t fisppMultiBin;                 // pp Multiplicity Bin analysis
    Bool_t fPbPbUserCentralityBinning;    // PbPb user centrality binning
    Bool_t fRemoveFirstEvent;             // Remove first event from chunk
    Bool_t fisNonHFEsystematics;          // Non-HFE background systematics analysis
    AliOADBContainer *fSpecialTrigger;    // Special trigger selection
    Int_t   fCentralityF;                 // Centrality bin
    Float_t fCentralityPercent;           // Centrality percentile
    TString fCentralityEstimator;         // Centrality Estimator
    Float_t fContributors;                // Contributors
    Double_t fWeightBackGround;            // weight background function
    Double_t fVz;                         // z position of the primary vertex
    const TF1  *fkBackGroundFactorArray[12];   // Array of BackGround factors for each centrality bin, bin0 = min bias
    Double_t fElecBackgroundFactor[kBgLevels][kCentBins][kElecBgSpecies][kBgPtBins];     // Electron background factors
    Double_t fBinLimit[kBgPtBins+1];      // Electron pt bin edges
    Float_t fCentralityLimits[12];        // Limits for centrality bins
    AliHFEcontainer *fContainer;          //! The HFE container
    AliHFEvarManager *fVarManager;        // The var manager as the backbone of the analysis
    AliHFEsignalCuts *fSignalCuts;        //! MC true signal (electron coming from certain source) 
    AliCFManager *fCFM;                   //! Correction Framework Manager
    AliTriggerAnalysis *fTriggerAnalysis; //! Trigger Analysis for Normalisation
    AliHFEpid *fPID;                      // PID
    AliHFEpidQAmanager *fPIDqa;           // PID QA
    AliTRDTriggerAnalysis *fTRDTriggerAnalysismb; //! TRD Trigger Analysis for mb analysis
    AliTRDTriggerAnalysis *fTRDTriggerAnalysistrg; //! TRD Trigger Analysis for trg sample analysis
    AliHFEpid *fPIDpreselect;             // PID oject for pre-selected tracks (without QA)
    AliHFEcuts *fCuts;                    // Cut Collection
    AliHFEcuts *fTaggedTrackCuts;         // Cut Collection for V0 tagged tracks
    Bool_t fCleanTaggedTrack;             // Loose cleaning of the V0 tagged tracks electron
    Bool_t fVariablesTRDTaggedTrack;      // Take the variables at the TRD for the V0 tagged tracks electron
    AliAnalysisUtils *fAnalysisUtils;     // Utility object to remove the first event of a chunk from the analysis
    AliESDtrackCuts *fCutspreselect;      // Cut Collection for pre-selected tracks
    AliHFEsecVtx *fSecVtx;                //! Secondary Vertex Analysis
    AliHFEelecbackground *fElecBackGround;//! Background analysis
    AliHFEmcQA *fMCQA;                    //! MC QA
    AliHFEtaggedTrackAnalysis *fTaggedTrackAnalysis;     //!Analyse V0-tagged tracks
    AliHFEextraCuts *fExtraCuts;          //! temporary implementation for IP QA
    AliHFENonPhotonicElectron *fBackgroundSubtraction; // Background subtraction
    Bool_t fTRDTrigger;                   // Check if event is TRD triggered event
    Int_t  fWhichTRDTrigger;               // Select type of TRD trigger

    AliHFEV0taginfo *fV0Tagger;           // Tags v0 tracks per Event 

    //-----------QA and output---------------
    TList *fQA;                           //! QA histos for the cuts
    TList *fOutput;                       //! Container for Task Output
    TList *fHistMCQA;                     //! Output container for MC QA histograms 
    TList *fHistSECVTX;                   //! Output container for sec. vertexing results
    TList *fHistELECBACKGROUND;           //! Output container for electron background analysis
    AliHFEcollection *fQACollection;      //! Tasks own QA collection
    //---------------------------------------

    ClassDef(AliAnalysisTaskHFE, 2)       // The electron Analysis Task
};
#endif
Commit	Line	Data
01745870	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	// Task for Heavy Flavour Electron Analysis
	17	// Fills a single-inclusive electron pt-spectrum
	18	// For further information see implementation file
	19	//
	20	#ifndef ALIANALYSISTASKHFE_H
	21	#define ALIANALYSISTASKHFE_H
	22
	23	#ifndef ALIANALYSISTASKSE_H
	24	#include "AliAnalysisTaskSE.h"
	25	#endif
	26
	27	#ifndef ROOT_TString
	28	#include <TString.h>
	29	#endif
	30
	31	#ifndef ROOT_TBits
	32	#include <TBits.h>
	33	#endif
	34
	35	class AliAnalysisUtils;
	36	class AliESDtrackCuts;
	37	class AliHFEcontainer;
	38	class AliHFEcollection;
	39	class AliHFEcuts;
	40	class AliHFEextraCuts;
	41	class AliHFEelecbackground;
	42	class AliHFENonPhotonicElectron;
	43	class AliHFEmcQA;
	44	class AliHFEpid;
	45	class AliHFEpidQAmanager;
	46	class AliHFEsecVtx;
	47	class AliHFEsignalCuts;
	48	class AliHFEvarManager;
	49	class AliHFEtaggedTrackAnalysis;
7986e54e	50	class AliHFEV0taginfo;
01745870	51	class AliCFManager;
	52	class AliMCEvent;
	53	class AliOADBContainer;
	54	class AliAODMCHeader;
	55	class AliVEvent;
	56	class AliVParticle;
	57	class AliTriggerAnalysis;
618038b6	58	class AliTRDTriggerAnalysis;
01745870	59	class TH1I;
	60	class TList;
	61	class TClonesArray;
	62
	63	class AliAnalysisTaskHFE : public AliAnalysisTaskSE{
	64	public:
	65	enum{
	66	kPIDqa = 0,
	67	kMCqa =1
	68	};
	69	enum{
	70	kPriVtx = 0,
	71	kSecVtx = 1,
	72	kIsElecBackGround = 2,
	73	kPostProcess = 3,
	74	kDEstep = 4,
	75	kTaggedTrackAnalysis = 5,
afb48e1d	76	kNonPhotonicElectron = 6,
afb48e1d	77	kNonPhotonicElectronBeauty = 7
01745870	78	};
	79	enum CreationProcess_t{
	80	kSignalCharm = 0,
	81	kSignalBeauty = 1,
	82	kGammaConv = 2,
	83	kOther = 3
	84	};
	85	enum{
	86	kBgPtBins = 44,
	87	kElecBgSpecies = 6,
	88	kCentBins = 11,
	89	kBgLevels = 3
	90	};
	91	typedef enum{
	92	kpp = 0,
	93	kpPb = 1,
	94	kPbPb = 2
	95	} ECollisionSystem_t;
	96
	97	AliAnalysisTaskHFE();
	98	AliAnalysisTaskHFE(const char * name);
	99	AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref);
	100	AliAnalysisTaskHFE& operator=(const AliAnalysisTaskHFE &ref);
	101	virtual void Copy(TObject &o) const;
	102	virtual ~AliAnalysisTaskHFE();
	103
	104	virtual void UserCreateOutputObjects();
	105	virtual void UserExec(Option_t *);
	106	virtual void Terminate(Option_t *);
	107
	108	virtual Bool_t IsEventInBinZero();
	109
	110	Bool_t IsQAOn(Int_t qaLevel) const { return TESTBIT(fQAlevel, qaLevel); };
	111	Bool_t IsAODanalysis() const { return TestBit(kAODanalysis); };
	112	Bool_t IsESDanalysis() const { return !TestBit(kAODanalysis); };
	113	Bool_t HasMCData() const { return TestBit(kHasMCdata); }
	114	Bool_t Ispp() const { return fCollisionSystem.TestBitNumber(kpp); }
	115	Bool_t IsPbPb() const { return fCollisionSystem.TestBitNumber(kPbPb); }
	116	Bool_t IspPb() const { return fCollisionSystem.TestBitNumber(kpPb); }
4437a0d2	117	Bool_t IsHeavyIon() const { return IsPbPb(); }
01745870	118	Bool_t GetPlugin(Int_t plug) const { return TESTBIT(fPlugins, plug); };
	119
	120	// Get Components for configuration
	121	AliHFEvarManager *GetVarManager() const { return fVarManager; }
	122	AliHFEpidQAmanager *GetPIDQAManager() const { return fPIDqa; }
	123	AliHFEpid *GetPID() const { return fPID; }
	124	AliHFENonPhotonicElectron *GetHFEBackgroundSubtraction() const { return fBackgroundSubtraction; }
	125
	126	void SetHFECuts(AliHFEcuts * const cuts) { fCuts = cuts; };
	127	void SetTaggedTrackCuts(AliHFEcuts * const cuts) { fTaggedTrackCuts = cuts; }
	128	void SetCleanTaggedTrack(Bool_t clean) { fCleanTaggedTrack = clean; };
	129	void SetVariablesTRDTaggedTrack(Bool_t variablesTRD) { fVariablesTRDTaggedTrack = variablesTRD; };
	130	void SetHFECutsPreselect(AliESDtrackCuts * const cuts) { fCutspreselect = cuts; };
	131	void SetHFEElecBackGround(AliHFEelecbackground * const elecBackGround) { fElecBackGround = elecBackGround; };
	132	void SetHFEBackgroundSubtraction(AliHFENonPhotonicElectron * const backgroundSubtraction) { fBackgroundSubtraction = backgroundSubtraction; };
	133	void SetQAOn(Int_t qaLevel) { SETBIT(fQAlevel, qaLevel); };
	134	void SwitchOnPlugin(Int_t plug);
	135	void SetHasMCData(Bool_t hasMC = kTRUE) { SetBit(kHasMCdata, hasMC); };
	136	void SetFillSignalOnly(Bool_t signalOnly) { fFillSignalOnly = signalOnly; }
	137
	138	void SetFillNoCuts(Bool_t fillNoCuts) { fFillNoCuts = fillNoCuts; }
01745870	139	void SetRemovePileUp(Bool_t removePileUp) { fRemovePileUp = removePileUp; }
	140	void SetRemoveFirstEventInChunk() {fRemoveFirstEvent = kTRUE;}
	141	void SetPIDPreselect(AliHFEpid * const cuts) { fPIDpreselect = cuts; };
	142	void SetAODAnalysis() { SetBit(kAODanalysis, kTRUE); };
	143	void SetESDAnalysis() { SetBit(kAODanalysis, kFALSE); };
	144	void SetTRDTrigger(Bool_t activateTRDTrigger, Int_t trdtrigger) {fTRDTrigger=activateTRDTrigger; fWhichTRDTrigger=trdtrigger;};
	145	void SetCollisionSystem(ECollisionSystem_t system){
	146	fCollisionSystem.Clear();
	147	fCollisionSystem.SetBitNumber(system, kTRUE);
	148	}
	149	void SetppAnalysis(){
	150	fCollisionSystem.SetBitNumber(kpPb, kFALSE);
	151	fCollisionSystem.SetBitNumber(kPbPb, kFALSE);
	152	fCollisionSystem.SetBitNumber(kpp, kTRUE);
	153	}
	154	void SetpPbAnalysis() {
	155	fCollisionSystem.SetBitNumber(kpp, kFALSE);
	156	fCollisionSystem.SetBitNumber(kPbPb, kFALSE);
	157	fCollisionSystem.SetBitNumber(kpPb, kTRUE);
	158	}
	159	void SetPbPbAnalysis() {
	160	fCollisionSystem.SetBitNumber(kpp, kFALSE);
	161	fCollisionSystem.SetBitNumber(kpPb, kFALSE);
	162	fCollisionSystem.SetBitNumber(kPbPb, kTRUE);
	163	};
	164	void SetCentralityEstimator(const char *estimator) { fCentralityEstimator = estimator; }
	165	void SetPbPbUserCentralityLimit(Bool_t isPbPbUserBinning = kFALSE){fPbPbUserCentralityBinning = isPbPbUserBinning; };
	166	void SetPbPbUserCentralityArray(Int_t icentr, Float_t valuecentr) {fCentralityLimits[icentr] = valuecentr;};
	167	void SetPPMultiBinAnalysis(Bool_t isppMultiBin) { fisppMultiBin = isppMultiBin; };
	168	void SetNonHFEsystematics(Bool_t isSystematics) {fisNonHFEsystematics = isSystematics; };
	169	void SetRejectKinkMother(Bool_t rejectKinkMother = kFALSE) { fRejectKinkMother = rejectKinkMother; };
2e4ed823	170	void SetRejectMCFakeTracks(Bool_t rejectFakes = kTRUE) { fRejectMCFakeTracks = rejectFakes; };
01745870	171	void SetBackGroundFactorsFunction(const TF1 * const backGroundFactorsFunction, Int_t centralitybin=0){
	172	fkBackGroundFactorArray[centralitybin]=backGroundFactorsFunction;
	173	fBackGroundFactorApply=kTRUE;
	174	SetBit(kBackgroundInitialized);
	175	};
	176	void SetElecBackGroundFactors(Int_t iPt, Int_t iType, Int_t iCent, Int_t iError, Double_t elecBackGroundFactor) {fElecBackgroundFactor[iError][iCent][iType][iPt] = elecBackGroundFactor; };
	177	void SetBinLimits(Int_t iPt, Double_t momentum){fBinLimit[iPt] = momentum;};
	178	void PrintStatus() const;
	179	Bool_t ReadCentrality();
	180	void RejectionPileUpVertexRangeEventCut();
	181	void SelectSpecialTrigger(const Char_t *trgclust, Int_t runMin = 0, Int_t runMax = 999999999);
	182	void SetDebugStreaming() {SetBit(kTreeStream);};
4437a0d2	183	Bool_t CheckTRDTriggerESD(AliESDEvent *ev);
4437a0d2	184	Bool_t CheckTRDTrigger(AliVEvent *ev);
8c07fb0d	185	void DrawTRDTrigger(AliESDEvent *ev);
afb48e1d	186	void DrawTRDTriggerAnalysis(AliVEvent *ev);
01745870	187
	188	private:
	189	enum{
	190	kHasMCdata = BIT(19),
	191	kAODanalysis = BIT(20),
	192	kBackgroundInitialized = BIT(21),
	193	kTreeStream = BIT(22)
	194	};
	195
	196	Bool_t FillProductionVertex(const AliVParticle * const track) const;
	197	void MakeParticleContainer();
	198	void MakeEventContainer();
	199	void InitHistoITScluster();
	200	void InitContaminationQA();
	201	const Char_t *GetSpecialTrigger(Int_t run);
	202	void ProcessMC();
	203	void ProcessESD();
	204	void ProcessAOD();
	205	Int_t GetITSMultiplicity(AliVEvent *ev);
2e4ed823	206	Bool_t IsMCFakeTrack(const AliVTrack * const trk) const;
01745870	207	Bool_t PreSelectTrack(AliESDtrack *track) const;
	208	Bool_t ProcessMCtrack(AliVParticle *track);
	209	Bool_t ProcessCutStep(Int_t cutStep, AliVParticle *track);
	210	AliAODMCHeader *fAODMCHeader; // ! MC info AOD
	211	TClonesArray *fAODArrayMCInfo; // ! MC info particle AOD
	212	ULong_t fQAlevel; // QA level
	213	UShort_t fPlugins; // Enabled Plugins
	214	TBits fCollisionSystem; // Collision System;
	215	Bool_t fFillSignalOnly; // Fill container only with MC Signal Tracks
2e4ed823	216	Bool_t fRejectMCFakeTracks; // Reject fake tracks in MC using the sign of the Label
01745870	217	Bool_t fFillNoCuts; // Fill container before any cut
01745870	218	Bool_t fBackGroundFactorApply; // Apply Background Function Subtraction, MF: To be removed when transition to OADB container is finished
	219	Bool_t fRemovePileUp; // Remove Pile Up
	220	Bool_t fIdentifiedAsPileUp; // Identified as pile-up
	221	Bool_t fIdentifiedAsOutInz; // Out Of Range in z
	222	Bool_t fPassTheEventCut; // Pass The Event Cut
	223	Bool_t fRejectKinkMother; // Reject Kink Mother
	224	Bool_t fisppMultiBin; // pp Multiplicity Bin analysis
	225	Bool_t fPbPbUserCentralityBinning; // PbPb user centrality binning
	226	Bool_t fRemoveFirstEvent; // Remove first event from chunk
	227	Bool_t fisNonHFEsystematics; // Non-HFE background systematics analysis
	228	AliOADBContainer *fSpecialTrigger; // Special trigger selection
	229	Int_t fCentralityF; // Centrality bin
	230	Float_t fCentralityPercent; // Centrality percentile
	231	TString fCentralityEstimator; // Centrality Estimator
	232	Float_t fContributors; // Contributors
	233	Double_t fWeightBackGround; // weight background function
	234	Double_t fVz; // z position of the primary vertex
	235	const TF1 *fkBackGroundFactorArray[12]; // Array of BackGround factors for each centrality bin, bin0 = min bias
	236	Double_t fElecBackgroundFactor[kBgLevels][kCentBins][kElecBgSpecies][kBgPtBins]; // Electron background factors
	237	Double_t fBinLimit[kBgPtBins+1]; // Electron pt bin edges
	238	Float_t fCentralityLimits[12]; // Limits for centrality bins
	239	AliHFEcontainer *fContainer; //! The HFE container
	240	AliHFEvarManager *fVarManager; // The var manager as the backbone of the analysis
	241	AliHFEsignalCuts *fSignalCuts; //! MC true signal (electron coming from certain source)
	242	AliCFManager *fCFM; //! Correction Framework Manager
	243	AliTriggerAnalysis *fTriggerAnalysis; //! Trigger Analysis for Normalisation
	244	AliHFEpid *fPID; // PID
	245	AliHFEpidQAmanager *fPIDqa; // PID QA
afb48e1d	246	AliTRDTriggerAnalysis *fTRDTriggerAnalysismb; //! TRD Trigger Analysis for mb analysis
afb48e1d	247	AliTRDTriggerAnalysis *fTRDTriggerAnalysistrg; //! TRD Trigger Analysis for trg sample analysis
01745870	248	AliHFEpid *fPIDpreselect; // PID oject for pre-selected tracks (without QA)
	249	AliHFEcuts *fCuts; // Cut Collection
	250	AliHFEcuts *fTaggedTrackCuts; // Cut Collection for V0 tagged tracks
	251	Bool_t fCleanTaggedTrack; // Loose cleaning of the V0 tagged tracks electron
	252	Bool_t fVariablesTRDTaggedTrack; // Take the variables at the TRD for the V0 tagged tracks electron
	253	AliAnalysisUtils *fAnalysisUtils; // Utility object to remove the first event of a chunk from the analysis
	254	AliESDtrackCuts *fCutspreselect; // Cut Collection for pre-selected tracks
	255	AliHFEsecVtx *fSecVtx; //! Secondary Vertex Analysis
	256	AliHFEelecbackground *fElecBackGround;//! Background analysis
	257	AliHFEmcQA *fMCQA; //! MC QA
	258	AliHFEtaggedTrackAnalysis *fTaggedTrackAnalysis; //!Analyse V0-tagged tracks
	259	AliHFEextraCuts *fExtraCuts; //! temporary implementation for IP QA
	260	AliHFENonPhotonicElectron *fBackgroundSubtraction; // Background subtraction
	261	Bool_t fTRDTrigger; // Check if event is TRD triggered event
	262	Int_t fWhichTRDTrigger; // Select type of TRD trigger
7986e54e	263
	264	AliHFEV0taginfo *fV0Tagger; // Tags v0 tracks per Event
	265
01745870	266	//-----------QA and output---------------
	267	TList *fQA; //! QA histos for the cuts
	268	TList *fOutput; //! Container for Task Output
	269	TList *fHistMCQA; //! Output container for MC QA histograms
	270	TList *fHistSECVTX; //! Output container for sec. vertexing results
	271	TList *fHistELECBACKGROUND; //! Output container for electron background analysis
	272	AliHFEcollection *fQACollection; //! Tasks own QA collection
	273	//---------------------------------------
	274
	275	ClassDef(AliAnalysisTaskHFE, 2) // The electron Analysis Task
	276	};
	277	#endif
	278