[u/mrichter/AliRoot.git] / PWG4 / totEt / AliAnalysisHadEtCorrections.h

//Create by Christine Nattrass, Rebecca Scott, Irakli Martashvili
//University of Tennessee at Knoxville
//This is a container class for the correction factors for the hadronic component of transverse energy
//It is filled by the output of AliAnalysisTaskHadEt from spinning over Monte Carlo data (using AliAnalysisHadEtMonteCarlo)
//It is used by AliAnalysisTaskHadEt while spinning over reconstructed data (using AliAnalysisHadEtReconstructed)
//Please see https://twiki.cern.ch/twiki/bin/view/ALICE/ETCaloAnalysis
#ifndef ALIANALYSISHADETCORRECTIONS_H
#define ALIANALYSISHADETCORRECTIONS_H

#include "Rtypes.h"
#include "TString.h"
#include "TNamed.h"
#include "TH1D.h"

class AliAnalysisHadEtCorrections : public TNamed
{
public:
   
  AliAnalysisHadEtCorrections();
    virtual ~AliAnalysisHadEtCorrections();

    Float_t GetEtaCut() const {return fEtaCut;}
    Float_t GetAcceptanceCorrectionFull() const {return fAcceptanceCorrectionFull;}
    Float_t GetAcceptanceCorrectionEMCAL() const {return fAcceptanceCorrectionEMCAL;}
    Float_t GetAcceptanceCorrectionPHOS() const {return fAcceptanceCorrectionPHOS;}
    Float_t GetNeutralCorrection() const {return fNeutralCorrection;}
    Float_t GetNotHadronicCorrection() const {return fNotHadronicCorrection;}
    Float_t GetpTCutCorrectionTPC() const {return fpTcutCorrectionTPC;}
    Float_t GetpTCutCorrectionITS() const {return fpTcutCorrectionITS;}
    Float_t GetNeutralCorrectionLowBound() const {return fNeutralCorrectionLow;}
    Float_t GetNotHadronicCorrectionLowBound() const {return fNotHadronicCorrectionLow;}
    Float_t GetpTCutCorrectionTPCLowBound() const {return ffpTcutCorrectionTPCLow;}
    Float_t GetpTCutCorrectionITSLowBound() const {return ffpTcutCorrectionITSLow;}
    Float_t GetNeutralCorrectionHighBound() const {return fNeutralCorrectionHigh;}
    Float_t GetNotHadronicCorrectionHighBound() const {return fNotHadronicCorrectionHigh;}
    Float_t GetpTCutCorrectionTPCHighBound() const {return ffpTcutCorrectionTPCHigh;}
    Float_t GetpTCutCorrectionITSHighBound() const {return ffpTcutCorrectionITSHigh;}
    TH1D *GetNotIDCorrectionTPC() const {return fnotIDTPC;}
    TH1D *GetNotIDCorrectionITS() const {return fnotIDITS;}
    TH1D *GetNotIDCorrectionNoPID() const {return fnotIDNoID;}
    TH1D *GetEfficiencyPionTPC() const {return fEfficiencyPionTPC;}
    TH1D *GetEfficiencyKaonTPC() const {return fEfficiencyKaonTPC;}
    TH1D *GetEfficiencyProtonTPC() const {return fEfficiencyProtonTPC;}
    TH1D *GetEfficiencyHadronTPC() const {return fEfficiencyHadronTPC;}
    TH1D *GetEfficiencyPionITS() const {return fEfficiencyPionITS;}
    TH1D *GetEfficiencyKaonITS() const {return fEfficiencyKaonITS;}
    TH1D *GetEfficiencyProtonITS() const {return fEfficiencyProtonITS;}
    TH1D *GetEfficiencyHadronITS() const {return fEfficiencyHadronITS;}
    TH1D *GetBackgroundCorrectionTPC() const {return fBackgroundTPC;}
    TH1D *GetBackgroundCorrectionITS() const {return fBackgroundITS;}

    //This is stored as the inverse of the correction
    Float_t GetNotIDCorrectionTPC(float pT){return 1.0/(fnotIDTPC->GetBinContent(fnotIDTPC->FindBin(pT)));}
    Float_t GetNotIDCorrectionITS(float pT){return 1.0/(fnotIDITS->GetBinContent(fnotIDITS->FindBin(pT)));}
    Float_t GetNotIDCorrectionNoPID(float pT){return 1.0/(fnotIDNoID->GetBinContent(fnotIDNoID->FindBin(pT)));}
    //As is this...
    Float_t GetTPCEfficiencyCorrectionPion(float pT){return 1.0/(fEfficiencyPionTPC->GetBinContent(fEfficiencyPionTPC->FindBin(pT)));}
    Float_t GetTPCEfficiencyCorrectionKaon(float pT){return 1.0/(fEfficiencyKaonTPC->GetBinContent(fEfficiencyKaonTPC->FindBin(pT)));}
    Float_t GetTPCEfficiencyCorrectionProton(float pT){return 1.0/(fEfficiencyProtonTPC->GetBinContent(fEfficiencyProtonTPC->FindBin(pT)));}
    Float_t GetTPCEfficiencyCorrectionHadron(float pT){return 1.0/(fEfficiencyHadronTPC->GetBinContent(fEfficiencyHadronTPC->FindBin(pT)));}
    Float_t GetITSEfficiencyCorrectionPion(float pT){return 1.0/(fEfficiencyPionITS->GetBinContent(fEfficiencyPionITS->FindBin(pT)));}
    Float_t GetITSEfficiencyCorrectionKaon(float pT){return 1.0/(fEfficiencyKaonITS->GetBinContent(fEfficiencyKaonITS->FindBin(pT)));}
    Float_t GetITSEfficiencyCorrectionProton(float pT){return 1.0/(fEfficiencyProtonITS->GetBinContent(fEfficiencyProtonITS->FindBin(pT)));}
    Float_t GetITSEfficiencyCorrectionHadron(float pT){return 1.0/(fEfficiencyHadronITS->GetBinContent(fEfficiencyHadronITS->FindBin(pT)));}
    //...and these guys are too
    Float_t GetBackgroundCorrectionTPC(float pT){return 1.0/(fBackgroundTPC->GetBinContent(fBackgroundTPC->FindBin(pT)));}
    Float_t GetBackgroundCorrectionITS(float pT){return 1.0/(fBackgroundITS->GetBinContent(fBackgroundITS->FindBin(pT)));}


    void SetEtaCut(Float_t val){fEtaCut=val;}
    void SetAcceptanceCorrectionFull(Float_t val){fAcceptanceCorrectionFull=val;}
    void SetAcceptanceCorrectionEMCAL(Float_t val){fAcceptanceCorrectionEMCAL=val;}
    void SetAcceptanceCorrectionPHOS(Float_t val){fAcceptanceCorrectionPHOS=val;}
    void SetNeutralCorrection(Float_t val){fNeutralCorrection=val;}
    void SetNotHadronicCorrection(Float_t val){fNotHadronicCorrection=val;}
    void SetpTCutCorrectionTPC(Float_t val){fpTcutCorrectionTPC=val;}
    void SetpTCutCorrectionITS(Float_t val){fpTcutCorrectionITS=val;}
    void SetNeutralCorrectionLowBound(Float_t val){fNeutralCorrectionLow=val;}
    void SetNotHadronicCorrectionLowBound(Float_t val){fNotHadronicCorrectionLow=val;}
    void SetpTCutCorrectionTPCLowBound(Float_t val){ffpTcutCorrectionTPCLow=val;}
    void SetpTCutCorrectionITSLowBound(Float_t val){ffpTcutCorrectionITSLow=val;}
    void SetNeutralCorrectionHighBound(Float_t val){fNeutralCorrectionHigh=val;}
    void SetNotHadronicCorrectionHighBound(Float_t val){fNotHadronicCorrectionHigh=val;}
    void SetpTCutCorrectionTPCHighBound(Float_t val){ffpTcutCorrectionTPCHigh=val;}
    void SetpTCutCorrectionITSHighBound(Float_t val){ffpTcutCorrectionITSHigh=val;}
    void SetNotIDCorrectionTPC(TH1D *histo){fnotIDTPC=histo;}
    void SetNotIDCorrectionITS(TH1D *histo){fnotIDITS=histo;}
    void SetNotIDCorrectionNoPID(TH1D *histo){fnotIDNoID=histo;}
    void SetEfficiencyPionTPC(TH1D *histo){fEfficiencyPionTPC=histo;}
    void SetEfficiencyKaonTPC(TH1D *histo){fEfficiencyKaonTPC=histo;}
    void SetEfficiencyProtonTPC(TH1D *histo){fEfficiencyProtonTPC=histo;}
    void SetEfficiencyHadronTPC(TH1D *histo){fEfficiencyHadronTPC=histo;}
    void SetEfficiencyPionITS(TH1D *histo){fEfficiencyPionITS=histo;}
    void SetEfficiencyKaonITS(TH1D *histo){fEfficiencyKaonITS=histo;}
    void SetEfficiencyProtonITS(TH1D *histo){fEfficiencyProtonITS=histo;}
    void SetEfficiencyHadronITS(TH1D *histo){fEfficiencyHadronITS=histo;}
    void SetBackgroundCorrectionTPC(TH1D *histo){fBackgroundTPC=histo;}
    void SetBackgroundCorrectionITS(TH1D *histo){fBackgroundITS=histo;}


    AliAnalysisHadEtCorrections(const AliAnalysisHadEtCorrections *g) ; // cpy ctor
    //AliAnalysisHadEtCorrections & operator = (const AliAnalysisHadEtCorrections & g) ;//cpy assignment

protected:

    Float_t fEtaCut;//the eta cut used for this analysis
    Float_t fAcceptanceCorrectionFull;//the acceptance correction for full azimuthal acceptance
    Float_t fAcceptanceCorrectionEMCAL;//the acceptance correction for the EMCal azimuthal acceptance
    Float_t fAcceptanceCorrectionPHOS;//the acceptance correction for the PHOS azimuthal acceptance
    //Systematic errors - low value, mean value, high value
    Float_t fNeutralCorrection;//the correction for the fraction of energy from neutral particles (for using both the calorimeters and the tracking detectors)
    Float_t fNotHadronicCorrection;//the correction for the fraction of energy which is not measured by the tracking detectors 
    Float_t fpTcutCorrectionTPC;//the correction for the momentum cut for the tpc (150 MeV/c)
    Float_t fpTcutCorrectionITS;//the correction for the momentum cut for the ITS (100 MeV/c)
    Float_t fNeutralCorrectionLow;//the low bound on the neutral energy fraction correction
    Float_t fNotHadronicCorrectionLow;//the low bound on the hadronic energy fraction correction
    Float_t ffpTcutCorrectionTPCLow;//the low bound on the TPC momentum cut correction
    Float_t ffpTcutCorrectionITSLow;//the low bound on the ITS momentum cut correction
    Float_t fNeutralCorrectionHigh;//the high bound on the neutral energy correcton
    Float_t fNotHadronicCorrectionHigh;//the high bound on the hadronic energy correction
    Float_t ffpTcutCorrectionTPCHigh;//the high bound on the TPC momentum cut correction
    Float_t ffpTcutCorrectionITSHigh;//the high bound on the ITS momentum cut correction

    //Histograms with the pT dependent corrections
    TH1D *fnotIDTPC;//correction for unidentified tracks in the TPC
    TH1D *fnotIDITS;//correction for unidentified tracks in the ITS
    TH1D *fnotIDNoID;//correction for unidentified tracks assuming no ID
    TH1D *fEfficiencyPionTPC;//efficiency correction for pions in the TPC
    TH1D *fEfficiencyKaonTPC;//efficiency correction for kaons in the TPC
    TH1D *fEfficiencyProtonTPC;//efficiency correction for protons in the TPC
    TH1D *fEfficiencyHadronTPC;//efficiency correction for unidentified hadrons in the TPC
    TH1D *fEfficiencyPionITS;//efficiency correction for pions in the ITS
    TH1D *fEfficiencyKaonITS;//efficiency correction for kaons in the ITS
    TH1D *fEfficiencyProtonITS;//efficiency correction for protons in the ITS
    TH1D *fEfficiencyHadronITS;//efficiency correction for unidentified hadrons in the ITS
    TH1D *fBackgroundTPC;//background correction for the TPC
    TH1D *fBackgroundITS;//background correction for the ITS


private:
  //Declare it private to avoid compilation warning
    AliAnalysisHadEtCorrections & operator = (const AliAnalysisHadEtCorrections & g) ;//cpy assignment
    AliAnalysisHadEtCorrections(const AliAnalysisHadEtCorrections & g) ; // cpy ctor

    ClassDef(AliAnalysisHadEtCorrections, 1);
};

#endif // ALIANALYSISHADETCORRECTIONS_H
Commit	Line	Data
020abff0	1	//Create by Christine Nattrass, Rebecca Scott, Irakli Martashvili
	2	//University of Tennessee at Knoxville
	3	//This is a container class for the correction factors for the hadronic component of transverse energy
	4	//It is filled by the output of AliAnalysisTaskHadEt from spinning over Monte Carlo data (using AliAnalysisHadEtMonteCarlo)
	5	//It is used by AliAnalysisTaskHadEt while spinning over reconstructed data (using AliAnalysisHadEtReconstructed)
	6	//Please see https://twiki.cern.ch/twiki/bin/view/ALICE/ETCaloAnalysis
	7	#ifndef ALIANALYSISHADETCORRECTIONS_H
	8	#define ALIANALYSISHADETCORRECTIONS_H
	9
	10	#include "Rtypes.h"
	11	#include "TString.h"
	12	#include "TNamed.h"
	13	#include "TH1D.h"
	14
	15	class AliAnalysisHadEtCorrections : public TNamed
	16	{
	17	public:
	18
	19	AliAnalysisHadEtCorrections();
	20	virtual ~AliAnalysisHadEtCorrections();
	21
	22	Float_t GetEtaCut() const {return fEtaCut;}
	23	Float_t GetAcceptanceCorrectionFull() const {return fAcceptanceCorrectionFull;}
	24	Float_t GetAcceptanceCorrectionEMCAL() const {return fAcceptanceCorrectionEMCAL;}
	25	Float_t GetAcceptanceCorrectionPHOS() const {return fAcceptanceCorrectionPHOS;}
	26	Float_t GetNeutralCorrection() const {return fNeutralCorrection;}
	27	Float_t GetNotHadronicCorrection() const {return fNotHadronicCorrection;}
	28	Float_t GetpTCutCorrectionTPC() const {return fpTcutCorrectionTPC;}
	29	Float_t GetpTCutCorrectionITS() const {return fpTcutCorrectionITS;}
	30	Float_t GetNeutralCorrectionLowBound() const {return fNeutralCorrectionLow;}
	31	Float_t GetNotHadronicCorrectionLowBound() const {return fNotHadronicCorrectionLow;}
	32	Float_t GetpTCutCorrectionTPCLowBound() const {return ffpTcutCorrectionTPCLow;}
	33	Float_t GetpTCutCorrectionITSLowBound() const {return ffpTcutCorrectionITSLow;}
	34	Float_t GetNeutralCorrectionHighBound() const {return fNeutralCorrectionHigh;}
	35	Float_t GetNotHadronicCorrectionHighBound() const {return fNotHadronicCorrectionHigh;}
	36	Float_t GetpTCutCorrectionTPCHighBound() const {return ffpTcutCorrectionTPCHigh;}
	37	Float_t GetpTCutCorrectionITSHighBound() const {return ffpTcutCorrectionITSHigh;}
	38	TH1D *GetNotIDCorrectionTPC() const {return fnotIDTPC;}
	39	TH1D *GetNotIDCorrectionITS() const {return fnotIDITS;}
	40	TH1D *GetNotIDCorrectionNoPID() const {return fnotIDNoID;}
	41	TH1D *GetEfficiencyPionTPC() const {return fEfficiencyPionTPC;}
	42	TH1D *GetEfficiencyKaonTPC() const {return fEfficiencyKaonTPC;}
	43	TH1D *GetEfficiencyProtonTPC() const {return fEfficiencyProtonTPC;}
	44	TH1D *GetEfficiencyHadronTPC() const {return fEfficiencyHadronTPC;}
	45	TH1D *GetEfficiencyPionITS() const {return fEfficiencyPionITS;}
	46	TH1D *GetEfficiencyKaonITS() const {return fEfficiencyKaonITS;}
	47	TH1D *GetEfficiencyProtonITS() const {return fEfficiencyProtonITS;}
	48	TH1D *GetEfficiencyHadronITS() const {return fEfficiencyHadronITS;}
	49	TH1D *GetBackgroundCorrectionTPC() const {return fBackgroundTPC;}
	50	TH1D *GetBackgroundCorrectionITS() const {return fBackgroundITS;}
	51
	52	//This is stored as the inverse of the correction
	53	Float_t GetNotIDCorrectionTPC(float pT){return 1.0/(fnotIDTPC->GetBinContent(fnotIDTPC->FindBin(pT)));}
	54	Float_t GetNotIDCorrectionITS(float pT){return 1.0/(fnotIDITS->GetBinContent(fnotIDITS->FindBin(pT)));}
	55	Float_t GetNotIDCorrectionNoPID(float pT){return 1.0/(fnotIDNoID->GetBinContent(fnotIDNoID->FindBin(pT)));}
	56	//As is this...
	57	Float_t GetTPCEfficiencyCorrectionPion(float pT){return 1.0/(fEfficiencyPionTPC->GetBinContent(fEfficiencyPionTPC->FindBin(pT)));}
	58	Float_t GetTPCEfficiencyCorrectionKaon(float pT){return 1.0/(fEfficiencyKaonTPC->GetBinContent(fEfficiencyKaonTPC->FindBin(pT)));}
	59	Float_t GetTPCEfficiencyCorrectionProton(float pT){return 1.0/(fEfficiencyProtonTPC->GetBinContent(fEfficiencyProtonTPC->FindBin(pT)));}
	60	Float_t GetTPCEfficiencyCorrectionHadron(float pT){return 1.0/(fEfficiencyHadronTPC->GetBinContent(fEfficiencyHadronTPC->FindBin(pT)));}
	61	Float_t GetITSEfficiencyCorrectionPion(float pT){return 1.0/(fEfficiencyPionITS->GetBinContent(fEfficiencyPionITS->FindBin(pT)));}
	62	Float_t GetITSEfficiencyCorrectionKaon(float pT){return 1.0/(fEfficiencyKaonITS->GetBinContent(fEfficiencyKaonITS->FindBin(pT)));}
	63	Float_t GetITSEfficiencyCorrectionProton(float pT){return 1.0/(fEfficiencyProtonITS->GetBinContent(fEfficiencyProtonITS->FindBin(pT)));}
	64	Float_t GetITSEfficiencyCorrectionHadron(float pT){return 1.0/(fEfficiencyHadronITS->GetBinContent(fEfficiencyHadronITS->FindBin(pT)));}
65	//...and these guys are too
66	Float_t GetBackgroundCorrectionTPC(float pT){return 1.0/(fBackgroundTPC->GetBinContent(fBackgroundTPC->FindBin(pT)));}
67	Float_t GetBackgroundCorrectionITS(float pT){return 1.0/(fBackgroundITS->GetBinContent(fBackgroundITS->FindBin(pT)));}
68
69
70	void SetEtaCut(Float_t val){fEtaCut=val;}
71	void SetAcceptanceCorrectionFull(Float_t val){fAcceptanceCorrectionFull=val;}
72	void SetAcceptanceCorrectionEMCAL(Float_t val){fAcceptanceCorrectionEMCAL=val;}
73	void SetAcceptanceCorrectionPHOS(Float_t val){fAcceptanceCorrectionPHOS=val;}
74	void SetNeutralCorrection(Float_t val){fNeutralCorrection=val;}
75	void SetNotHadronicCorrection(Float_t val){fNotHadronicCorrection=val;}
76	void SetpTCutCorrectionTPC(Float_t val){fpTcutCorrectionTPC=val;}
77	void SetpTCutCorrectionITS(Float_t val){fpTcutCorrectionITS=val;}
78	void SetNeutralCorrectionLowBound(Float_t val){fNeutralCorrectionLow=val;}
79	void SetNotHadronicCorrectionLowBound(Float_t val){fNotHadronicCorrectionLow=val;}
80	void SetpTCutCorrectionTPCLowBound(Float_t val){ffpTcutCorrectionTPCLow=val;}
81	void SetpTCutCorrectionITSLowBound(Float_t val){ffpTcutCorrectionITSLow=val;}
82	void SetNeutralCorrectionHighBound(Float_t val){fNeutralCorrectionHigh=val;}
83	void SetNotHadronicCorrectionHighBound(Float_t val){fNotHadronicCorrectionHigh=val;}
84	void SetpTCutCorrectionTPCHighBound(Float_t val){ffpTcutCorrectionTPCHigh=val;}
85	void SetpTCutCorrectionITSHighBound(Float_t val){ffpTcutCorrectionITSHigh=val;}
86	void SetNotIDCorrectionTPC(TH1D *histo){fnotIDTPC=histo;}
87	void SetNotIDCorrectionITS(TH1D *histo){fnotIDITS=histo;}
88	void SetNotIDCorrectionNoPID(TH1D *histo){fnotIDNoID=histo;}
89	void SetEfficiencyPionTPC(TH1D *histo){fEfficiencyPionTPC=histo;}
90	void SetEfficiencyKaonTPC(TH1D *histo){fEfficiencyKaonTPC=histo;}
91	void SetEfficiencyProtonTPC(TH1D *histo){fEfficiencyProtonTPC=histo;}
92	void SetEfficiencyHadronTPC(TH1D *histo){fEfficiencyHadronTPC=histo;}
93	void SetEfficiencyPionITS(TH1D *histo){fEfficiencyPionITS=histo;}
94	void SetEfficiencyKaonITS(TH1D *histo){fEfficiencyKaonITS=histo;}
95	void SetEfficiencyProtonITS(TH1D *histo){fEfficiencyProtonITS=histo;}
96	void SetEfficiencyHadronITS(TH1D *histo){fEfficiencyHadronITS=histo;}
97	void SetBackgroundCorrectionTPC(TH1D *histo){fBackgroundTPC=histo;}
98	void SetBackgroundCorrectionITS(TH1D *histo){fBackgroundITS=histo;}
99
100
101	AliAnalysisHadEtCorrections(const AliAnalysisHadEtCorrections *g) ; // cpy ctor
102	//AliAnalysisHadEtCorrections & operator = (const AliAnalysisHadEtCorrections & g) ;//cpy assignment
103
104	protected:
105
106	Float_t fEtaCut;//the eta cut used for this analysis
107	Float_t fAcceptanceCorrectionFull;//the acceptance correction for full azimuthal acceptance
108	Float_t fAcceptanceCorrectionEMCAL;//the acceptance correction for the EMCal azimuthal acceptance
109	Float_t fAcceptanceCorrectionPHOS;//the acceptance correction for the PHOS azimuthal acceptance
110	//Systematic errors - low value, mean value, high value
111	Float_t fNeutralCorrection;//the correction for the fraction of energy from neutral particles (for using both the calorimeters and the tracking detectors)
112	Float_t fNotHadronicCorrection;//the correction for the fraction of energy which is not measured by the tracking detectors
113	Float_t fpTcutCorrectionTPC;//the correction for the momentum cut for the tpc (150 MeV/c)
114	Float_t fpTcutCorrectionITS;//the correction for the momentum cut for the ITS (100 MeV/c)
115	Float_t fNeutralCorrectionLow;//the low bound on the neutral energy fraction correction
116	Float_t fNotHadronicCorrectionLow;//the low bound on the hadronic energy fraction correction
117	Float_t ffpTcutCorrectionTPCLow;//the low bound on the TPC momentum cut correction
118	Float_t ffpTcutCorrectionITSLow;//the low bound on the ITS momentum cut correction
119	Float_t fNeutralCorrectionHigh;//the high bound on the neutral energy correcton
120	Float_t fNotHadronicCorrectionHigh;//the high bound on the hadronic energy correction
121	Float_t ffpTcutCorrectionTPCHigh;//the high bound on the TPC momentum cut correction
122	Float_t ffpTcutCorrectionITSHigh;//the high bound on the ITS momentum cut correction
123
124	//Histograms with the pT dependent corrections
125	TH1D *fnotIDTPC;//correction for unidentified tracks in the TPC
126	TH1D *fnotIDITS;//correction for unidentified tracks in the ITS
127	TH1D *fnotIDNoID;//correction for unidentified tracks assuming no ID
128	TH1D *fEfficiencyPionTPC;//efficiency correction for pions in the TPC
129	TH1D *fEfficiencyKaonTPC;//efficiency correction for kaons in the TPC
130	TH1D *fEfficiencyProtonTPC;//efficiency correction for protons in the TPC
131	TH1D *fEfficiencyHadronTPC;//efficiency correction for unidentified hadrons in the TPC
132	TH1D *fEfficiencyPionITS;//efficiency correction for pions in the ITS
133	TH1D *fEfficiencyKaonITS;//efficiency correction for kaons in the ITS
134	TH1D *fEfficiencyProtonITS;//efficiency correction for protons in the ITS
135	TH1D *fEfficiencyHadronITS;//efficiency correction for unidentified hadrons in the ITS
136	TH1D *fBackgroundTPC;//background correction for the TPC
137	TH1D *fBackgroundITS;//background correction for the ITS
138
139
140
141	private:
142	//Declare it private to avoid compilation warning
143	AliAnalysisHadEtCorrections & operator = (const AliAnalysisHadEtCorrections & g) ;//cpy assignment
144	AliAnalysisHadEtCorrections(const AliAnalysisHadEtCorrections & g) ; // cpy ctor
145
146	ClassDef(AliAnalysisHadEtCorrections, 1);
147	};
148
149	#endif // ALIANALYSISHADETCORRECTIONS_H