[u/mrichter/AliRoot.git] / PWGHF / hfe / AliHFEspectrum.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.                  *
**************************************************************************/
//
// Class for spectrum correction
// Subtraction of hadronic background, Unfolding of the data and
// Renormalization done here
// For more information see the implementation file
//
#ifndef ALIHFESPECTRUM_H
#define ALIHFESPECTRUM_H

#ifndef ROOT_TNamed
#include <TNamed.h>
#endif

class TGraphErrors;
class TObject;
class TH1;
class TF1;
class TList;
class TObjArray;
class AliCFContainer;
class AliHFEcontainer;
class AliCFDataGrid;
class AliCFEffGrid;

class AliHFEspectrum : public TNamed{
  public:
    enum CFContainer_t{
      kDataContainer  = 0,
      kBackgroundData = 1,
      kMCContainerMC = 2,
      kMCContainerESD = 3,
      kMCContainerCharmMC = 4,
      kMCWeightedContainerNonHFEESD =5,
      kMCWeightedContainerConversionESD = 6,
      kDataContainerV0 = 7
    };

    enum{
      kElecBgSources = 6,
      kBgLevels = 3,
      kBgPtBins = 44,
      kCentrality = 12
	};

   enum Chargetype_t{
     kNegCharge = -1,
     kPosCharge = 1,
     kAllCharge = 0
   };
   
    AliHFEspectrum(const char* name);
    ~AliHFEspectrum();
    

    Bool_t Init(const AliHFEcontainer *datahfecontainer, const AliHFEcontainer *mchfecontainer, const AliHFEcontainer *v0hfecontainer=0x0, const AliHFEcontainer *bghfecontainer=0x0);
    Bool_t Correct(Bool_t subtractcontamination=kTRUE);
    Bool_t CorrectBeauty(Bool_t subtractcontamination=kTRUE);
   
    AliCFDataGrid *SubtractBackground(Bool_t setBackground = kFALSE);
    
    AliCFDataGrid *CorrectV0Efficiency(AliCFDataGrid* const bgsubpectrum = 0x0);
    AliCFDataGrid *CorrectParametrizedEfficiency(AliCFDataGrid* const bgsubpectrum = 0x0);
   
    TList *Unfold(AliCFDataGrid* const bgsubpectrum = 0x0);
    void UnfoldBG(AliCFDataGrid* const bgsubpectrum);
    AliCFDataGrid *CorrectForEfficiency(AliCFDataGrid* const bgsubpectrum = 0x0);
   
    TGraphErrors *Normalize(THnSparse * const spectrum,Int_t i = 0) const;
    TGraphErrors *Normalize(AliCFDataGrid * const spectrum,Int_t i = 0) const;
    TGraphErrors *NormalizeTH1N(TH1 *input,Int_t normalization) const;
    void CorrectFromTheWidth(TH1D *h1) const;
    void CorrectStatErr(AliCFDataGrid *backgroundGrid) const;
    
    void SetCorrelation(THnSparseF * const correlation) {fCorrelation = correlation; };
    void SetContainer(AliCFContainer *cont, AliHFEspectrum::CFContainer_t type);
    void SetEfficiencyFunction(TF1 *efficiencyFunction) { fEfficiencyFunction = efficiencyFunction; };
    void SetPbPbAnalysis(Bool_t isPbPb = kFALSE) { fBeamType=(Char_t) isPbPb; };
    void SetEtaSyst(Bool_t etaSyst = kTRUE) { fEtaSyst = etaSyst; };

    void SetParameterizedEff(AliCFContainer *container, AliCFContainer *containermb, AliCFContainer *containeresd, AliCFContainer *containeresdmb, Int_t *dimensions);
    
    void SetNumberOfEvents(Int_t nEvents,Int_t i = 0) { fNEvents[i] = nEvents; };
    void SetNumberOfMCEvents(Int_t nEvents) { fNMCEvents = nEvents; };
    void SetNumberOfMC2Events(Int_t nEvents,Int_t i = 0) { fNMCbgEvents[i] = nEvents; };
    void SetMCEffStep(Int_t step) { fStepMC = step; };
    void SetMCTruthStep(Int_t step) { fStepTrue = step; };
    void SetStepToCorrect(Int_t step) { fStepData = step; };
    void SetStepBeforeCutsV0(Int_t step) { fStepBeforeCutsV0 = step; };
    void SetStepAfterCutsV0(Int_t step) { fStepAfterCutsV0 = step; };
    void SetNbDimensions(Int_t nbDimensions) { fNbDimensions = nbDimensions; };
    void SetChargeChoosen(Chargetype_t chargechoosen) {fChargeChoosen = chargechoosen; };
    void SetEtaRange(Double_t etamin, Double_t etamax) { fEtaRange[0] = etamin; fEtaRange[1] = etamax; fEtaSelected = kTRUE; }
    void SetUnSetCorrelatedErrors(Bool_t unsetcorrelatederrors) {fUnSetCorrelatedErrors = unsetcorrelatederrors;};
    void SetSmoothing(Bool_t setSmoothing) {fSetSmoothing = setSmoothing;};
    void SetTestOneBinCentrality(Double_t centralitymin, Double_t centralitymax) { fTestCentralityLow = centralitymin; fTestCentralityHigh = centralitymax;}
    void SetFillMoreCorrelationMatrix(Bool_t fillMoreCorrelationMatrix) { fFillMoreCorrelationMatrix = fillMoreCorrelationMatrix;}

    void SetNCentralityBinAtTheEnd(Int_t nCentralityBinAtTheEnd) {fNCentralityBinAtTheEnd = nCentralityBinAtTheEnd; };
    void SetLowHighBoundaryCentralityBinAtTheEnd(Int_t low, Int_t high, Int_t i) { fLowBoundaryCentralityBinAtTheEnd[i] = low; fHighBoundaryCentralityBinAtTheEnd[i] = high;};

    void SetBeautyAnalysis() { fInclusiveSpectrum = kFALSE; };
    void CallInputFileForBeauty2ndMethod();
    void SetInputFileForBeauty2ndMethod(const char *filenameb = "BSpectrum2ndmethod.root"){fkBeauty2ndMethodfilename = filenameb; };
    void SetBeautyAnalysis2ndMethod(Bool_t beauty2ndmethod) { fBeauty2ndMethod = beauty2ndmethod; }
    void SetIPEffCombinedSamples(Bool_t ipEffCombinedSamples) { fIPEffCombinedSamples = ipEffCombinedSamples; }
    void SetHadronEffbyIPcut(THnSparseF* hsHadronEffbyIPcut) { fHadronEffbyIPcut = hsHadronEffbyIPcut;};
    void SetNonHFEsyst(Bool_t syst){ fNonHFEsyst = syst; };

    void SetStepGuessedUnfolding(Int_t stepGuessedUnfolding) { fStepGuessedUnfolding = stepGuessedUnfolding; };
    void SetNumberOfIteration(Int_t numberOfIteration) { fNumberOfIterations = numberOfIteration; };
    void SetUnfoldingRandomIterations(Int_t niter) { fNRandomIter = niter; }
    
    void SetDumpToFile(Bool_t dumpToFile) { fDumpToFile=dumpToFile; }; 
  
    void SetDebugLevel(Int_t debugLevel, Bool_t writeToFile = kFALSE) { fDebugLevel = debugLevel; fWriteToFile = writeToFile; };
    void SetUnfoldBG() { fUnfoldBG = kTRUE; };


    AliCFDataGrid* GetRawBspectra2ndMethod();
    AliCFDataGrid* GetCharmBackground();
    AliCFDataGrid* GetConversionBackground();
    AliCFDataGrid* GetNonHFEBackground();
    THnSparse* GetCharmWeights();
    THnSparse* GetBeautyIPEff(Bool_t isMCpt);
    THnSparse* GetPIDxIPEff(Int_t source);
    void CalculateNonHFEsyst(Int_t centrality = 0);

    void EnableIPanaHadronBgSubtract() { fIPanaHadronBgSubtract = kTRUE; };
    void EnableIPanaCharmBgSubtract() { fIPanaCharmBgSubtract = kTRUE; };
    void EnableIPanaConversionBgSubtract() { fIPanaConversionBgSubtract = kTRUE; };
    void EnableIPanaNonHFEBgSubtract() { fIPanaNonHFEBgSubtract = kTRUE; };
    void EnableIPParameterizedEff() { fIPParameterizedEff = kTRUE; };

  protected:
       
    AliCFContainer *GetContainer(AliHFEspectrum::CFContainer_t contt);
    AliCFContainer *GetSlicedContainer(AliCFContainer *cont, Int_t ndim, Int_t *dimensions,Int_t source=-1,Chargetype_t charge=kAllCharge,Int_t centralitylow=-1, Int_t centralityhigh=-1);
    THnSparseF *GetSlicedCorrelation(THnSparseF *correlationmatrix,Int_t nDim, Int_t *dimensions,Int_t centralitylow=-1, Int_t centralityhigh=-1) const;
    TObject* GetSpectrum(const AliCFContainer * const c, Int_t step);
    TObject* GetEfficiency(const AliCFContainer * const c, Int_t step, Int_t step0);
 
    void AddTemporaryObject(TObject *cont);
    void ClearObject(TObject *o);
    
    TGraphErrors *NormalizeTH1(TH1 *input,Int_t i = 0) const;


  private:
    AliHFEspectrum(const AliHFEspectrum &);
    AliHFEspectrum &operator=(const AliHFEspectrum &);
 
    TObjArray *fCFContainers;     // List of Correction Framework Containers
    TList *fTemporaryObjects;     // Emulate garbage collection
    THnSparseF *fCorrelation;     // Correlation Matrices
    AliCFDataGrid *fBackground;   // Background Grid
    TF1 *fEfficiencyFunction;     // Efficiency Function
    TF1 *fEfficiencyTOFPIDD[kCentrality];       // TOF PID efficiency parameterized
    TF1 *fEfficiencyesdTOFPIDD[kCentrality];    // TOF PID efficiency parameterized
    TF1 *fEfficiencyIPCharmD[kCentrality];      // IP efficiency parameterized for charm
    TF1 *fEfficiencyIPBeautyD[kCentrality];     // IP efficiency parameterized for beauty 
    TF1 *fEfficiencyIPBeautyesdD[kCentrality];  // IP efficiency parameterized for beauty for esd
    TF1 *fEfficiencyIPConversionD[kCentrality]; // IP efficiency parameterized for conversion
    TF1 *fEfficiencyIPNonhfeD[kCentrality];     // IP efficiency parameterized for nonhfe 

    THnSparseF *fWeightCharm;     // Weight for charm bg

    AliCFContainer *fConvSourceContainer[kElecBgSources][kBgLevels][kCentrality]; //container for conversion electrons, divided into different photon sources
    AliCFContainer *fNonHFESourceContainer[kElecBgSources][kBgLevels][kCentrality]; //container for non-HF electrons, divided into different sources

    Bool_t fInclusiveSpectrum;     // Inclusive Spectrum
    Bool_t fDumpToFile;           // Write Result in a file

    Bool_t fEtaSelected;              // Switch for eta selection
    Bool_t fUnSetCorrelatedErrors;    // Unset correlated errors
    Bool_t fSetSmoothing;             // Set smoothing

    Bool_t fIPanaHadronBgSubtract;     // Hadron background subtraction
    Bool_t fIPanaCharmBgSubtract;      // Charm background subtraction 
    Bool_t fIPanaConversionBgSubtract; // Conversion background subtraction
    Bool_t fIPanaNonHFEBgSubtract;     // nonHFE except for conversion background subtraction
    Bool_t fIPParameterizedEff;        // switch to use parameterized efficiency for ip analysis
    Bool_t fNonHFEsyst;            // choose NonHFE background level (upper, lower, central)
    Bool_t fBeauty2ndMethod;      // 2nd method to get beauty spectrum
    Bool_t fIPEffCombinedSamples; // flag to combine two different samples

    Int_t fNbDimensions;          // Number of dimensions for the correction
    Int_t fNEvents[20];           // Number of Events
    Int_t fNMCEvents;             // Number of MC Events
    Int_t fNMCbgEvents[20];       // Number of BG MC Events
    Int_t fStepMC;                // MC step (for unfolding)
    Int_t fStepTrue;              // MC step of the final spectrum
    Int_t fStepData;              // Data Step (various applications)
    Int_t fStepBeforeCutsV0;      // Before cuts V0
    Int_t fStepAfterCutsV0;       // After cuts V0
    Int_t fStepGuessedUnfolding;  // Step for first guessed unfolding
    Int_t fNumberOfIterations;    // Number of iterations
    Int_t fNRandomIter;           // Number of random iterations
    Chargetype_t fChargeChoosen;         // Select positive or negative electrons

    Double_t fEtaRange[2];        // Eta range 
    Double_t fEtaRangeNorm[2];    // Eta range used in the normalization

    Int_t fNCentralityBinAtTheEnd;// Number of centrality class at the end
    Int_t fLowBoundaryCentralityBinAtTheEnd[20];  // Boundary of the bins
    Int_t fHighBoundaryCentralityBinAtTheEnd[20];  // Boundary of the bins
    Int_t fTestCentralityLow;                      // To test one bin in centrality only
    Int_t fTestCentralityHigh;                     // To test one bin in centrality only
    Bool_t fFillMoreCorrelationMatrix;             // For low stats to have reasonable errors

    THnSparseF *fHadronEffbyIPcut;// container for hadron efficiency by IP cut
    TH1D *fEfficiencyCharmSigD[kCentrality]; // charm IP cut eff from signal enhanced MC
    TH1D *fEfficiencyBeautySigD[kCentrality]; // beauty IP cut eff from signal enhanced MC
    TH1D *fEfficiencyBeautySigesdD[kCentrality]; // beauty IP cut eff from signal enhanced MC for esd
    TH1D *fConversionEff[kCentrality];     // conversion IP cut eff
    TH1D *fNonHFEEff[kCentrality];         // nonhfe IP cut eff
    TH1D *fCharmEff[kCentrality];          // charm IP cut eff
    TH1D *fBeautyEff[kCentrality];         // beauty IP cut eff
    TH1D *fConversionEffbgc;      // conversion IP cut eff
    TH1D *fNonHFEEffbgc;          // nonhfe IP cut eff
    TH1D *fBSpectrum2ndMethod;             // beauty spectrum for 2nd method
    const char *fkBeauty2ndMethodfilename;      // name of file, which contains beauty spectrum for 2ndmethod
    Char_t fBeamType;             // beamtype; default -1; pp =0; PbPb=1
    Bool_t fEtaSyst;              // pp 2.76 TeV (= kTRUE) or 7 TeV (= kFALSE)


    Int_t fDebugLevel;            // Debug Level
    Bool_t fWriteToFile;           // Write plots to eps files
    Bool_t fUnfoldBG;             // flag to unfold backgroud

    ClassDef(AliHFEspectrum, 1) 
};
#endif
Commit	Line	Data
8c1c76e9	1	/**************************************************************************
c04c80e6	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	// Class for spectrum correction
	17	// Subtraction of hadronic background, Unfolding of the data and
	18	// Renormalization done here
	19	// For more information see the implementation file
	20	//
c2690925	21	#ifndef ALIHFESPECTRUM_H
	22	#define ALIHFESPECTRUM_H
	23
c04c80e6	24	#ifndef ROOT_TNamed
	25	#include <TNamed.h>
	26	#endif
	27
	28	class TGraphErrors;
	29	class TObject;
	30	class TH1;
c2690925	31	class TF1;
c04c80e6	32	class TList;
e17c1f86	33	class TObjArray;
c04c80e6	34	class AliCFContainer;
3a72645a	35	class AliHFEcontainer;
c04c80e6	36	class AliCFDataGrid;
	37	class AliCFEffGrid;
	38
	39	class AliHFEspectrum : public TNamed{
	40	public:
	41	enum CFContainer_t{
3a72645a	42	kDataContainer = 0,
	43	kBackgroundData = 1,
	44	kMCContainerMC = 2,
	45	kMCContainerESD = 3,
8c1c76e9	46	kMCContainerCharmMC = 4,
	47	kMCWeightedContainerNonHFEESD =5,
	48	kMCWeightedContainerConversionESD = 6,
	49	kDataContainerV0 = 7
e17c1f86	50	};
	51
	52	enum{
	53	kElecBgSources = 6,
	54	kBgLevels = 3,
a8ef1999	55	kBgPtBins = 44,
a8ef1999	56	kCentrality = 12
e17c1f86	57	};
	58
	59	enum Chargetype_t{
	60	kNegCharge = -1,
	61	kPosCharge = 1,
	62	kAllCharge = 0
8c1c76e9	63	};
3a72645a	64
c04c80e6	65	AliHFEspectrum(const char* name);
c04c80e6	66	~AliHFEspectrum();
3a72645a	67
c04c80e6	68
c2690925	69	Bool_t Init(const AliHFEcontainer datahfecontainer, const AliHFEcontainer mchfecontainer, const AliHFEcontainer v0hfecontainer=0x0, const AliHFEcontainer bghfecontainer=0x0);
3a72645a	70	Bool_t Correct(Bool_t subtractcontamination=kTRUE);
c2690925	71	Bool_t CorrectBeauty(Bool_t subtractcontamination=kTRUE);
3a72645a	72
	73	AliCFDataGrid *SubtractBackground(Bool_t setBackground = kFALSE);
	74
	75	AliCFDataGrid CorrectV0Efficiency(AliCFDataGrid const bgsubpectrum = 0x0);
c2690925	76	AliCFDataGrid CorrectParametrizedEfficiency(AliCFDataGrid const bgsubpectrum = 0x0);
3a72645a	77
3a72645a	78	TList Unfold(AliCFDataGrid const bgsubpectrum = 0x0);
cedf0381	79	void UnfoldBG(AliCFDataGrid* const bgsubpectrum);
3a72645a	80	AliCFDataGrid CorrectForEfficiency(AliCFDataGrid const bgsubpectrum = 0x0);
3a72645a	81
c2690925	82	TGraphErrors Normalize(THnSparse const spectrum,Int_t i = 0) const;
	83	TGraphErrors Normalize(AliCFDataGrid const spectrum,Int_t i = 0) const;
	84	TGraphErrors NormalizeTH1N(TH1 input,Int_t normalization) const;
	85	void CorrectFromTheWidth(TH1D *h1) const;
8c1c76e9	86	void CorrectStatErr(AliCFDataGrid *backgroundGrid) const;
3a72645a	87
c04c80e6	88	void SetCorrelation(THnSparseF * const correlation) {fCorrelation = correlation; };
c04c80e6	89	void SetContainer(AliCFContainer *cont, AliHFEspectrum::CFContainer_t type);
c2690925	90	void SetEfficiencyFunction(TF1 *efficiencyFunction) { fEfficiencyFunction = efficiencyFunction; };
c2690925	91	void SetPbPbAnalysis(Bool_t isPbPb = kFALSE) { fBeamType=(Char_t) isPbPb; };
cedf0381	92	void SetEtaSyst(Bool_t etaSyst = kTRUE) { fEtaSyst = etaSyst; };
a8ef1999	93
11ff28c5	94	void SetParameterizedEff(AliCFContainer container, AliCFContainer containermb, AliCFContainer containeresd, AliCFContainer containeresdmb, Int_t *dimensions);
3a72645a	95
c2690925	96	void SetNumberOfEvents(Int_t nEvents,Int_t i = 0) { fNEvents[i] = nEvents; };
c2690925	97	void SetNumberOfMCEvents(Int_t nEvents) { fNMCEvents = nEvents; };
a8ef1999	98	void SetNumberOfMC2Events(Int_t nEvents,Int_t i = 0) { fNMCbgEvents[i] = nEvents; };
c04c80e6	99	void SetMCEffStep(Int_t step) { fStepMC = step; };
	100	void SetMCTruthStep(Int_t step) { fStepTrue = step; };
	101	void SetStepToCorrect(Int_t step) { fStepData = step; };
3a72645a	102	void SetStepBeforeCutsV0(Int_t step) { fStepBeforeCutsV0 = step; };
3a72645a	103	void SetStepAfterCutsV0(Int_t step) { fStepAfterCutsV0 = step; };
bf892a6a	104	void SetNbDimensions(Int_t nbDimensions) { fNbDimensions = nbDimensions; };
e17c1f86	105	void SetChargeChoosen(Chargetype_t chargechoosen) {fChargeChoosen = chargechoosen; };
8c1c76e9	106	void SetEtaRange(Double_t etamin, Double_t etamax) { fEtaRange[0] = etamin; fEtaRange[1] = etamax; fEtaSelected = kTRUE; }
c2690925	107	void SetUnSetCorrelatedErrors(Bool_t unsetcorrelatederrors) {fUnSetCorrelatedErrors = unsetcorrelatederrors;};
e156c3bb	108	void SetSmoothing(Bool_t setSmoothing) {fSetSmoothing = setSmoothing;};
0e30407a	109	void SetTestOneBinCentrality(Double_t centralitymin, Double_t centralitymax) { fTestCentralityLow = centralitymin; fTestCentralityHigh = centralitymax;}
cedf0381	110	void SetFillMoreCorrelationMatrix(Bool_t fillMoreCorrelationMatrix) { fFillMoreCorrelationMatrix = fillMoreCorrelationMatrix;}
c2690925	111
	112	void SetNCentralityBinAtTheEnd(Int_t nCentralityBinAtTheEnd) {fNCentralityBinAtTheEnd = nCentralityBinAtTheEnd; };
	113	void SetLowHighBoundaryCentralityBinAtTheEnd(Int_t low, Int_t high, Int_t i) { fLowBoundaryCentralityBinAtTheEnd[i] = low; fHighBoundaryCentralityBinAtTheEnd[i] = high;};
	114
	115	void SetBeautyAnalysis() { fInclusiveSpectrum = kFALSE; };
a8ef1999	116	void CallInputFileForBeauty2ndMethod();
	117	void SetInputFileForBeauty2ndMethod(const char *filenameb = "BSpectrum2ndmethod.root"){fkBeauty2ndMethodfilename = filenameb; };
	118	void SetBeautyAnalysis2ndMethod(Bool_t beauty2ndmethod) { fBeauty2ndMethod = beauty2ndmethod; }
11ff28c5	119	void SetIPEffCombinedSamples(Bool_t ipEffCombinedSamples) { fIPEffCombinedSamples = ipEffCombinedSamples; }
c2690925	120	void SetHadronEffbyIPcut(THnSparseF* hsHadronEffbyIPcut) { fHadronEffbyIPcut = hsHadronEffbyIPcut;};
e17c1f86	121	void SetNonHFEsyst(Bool_t syst){ fNonHFEsyst = syst; };
3a72645a	122
c04c80e6	123	void SetStepGuessedUnfolding(Int_t stepGuessedUnfolding) { fStepGuessedUnfolding = stepGuessedUnfolding; };
c04c80e6	124	void SetNumberOfIteration(Int_t numberOfIteration) { fNumberOfIterations = numberOfIteration; };
7bdde22f	125	void SetUnfoldingRandomIterations(Int_t niter) { fNRandomIter = niter; }
3a72645a	126
c04c80e6	127	void SetDumpToFile(Bool_t dumpToFile) { fDumpToFile=dumpToFile; };
c04c80e6	128
e17c1f86	129	void SetDebugLevel(Int_t debugLevel, Bool_t writeToFile = kFALSE) { fDebugLevel = debugLevel; fWriteToFile = writeToFile; };
cedf0381	130	void SetUnfoldBG() { fUnfoldBG = kTRUE; };
c04c80e6	131
a8ef1999	132
a8ef1999	133	AliCFDataGrid* GetRawBspectra2ndMethod();
c2690925	134	AliCFDataGrid* GetCharmBackground();
	135	AliCFDataGrid* GetConversionBackground();
	136	AliCFDataGrid* GetNonHFEBackground();
8c1c76e9	137	THnSparse* GetCharmWeights();
0e30407a	138	THnSparse* GetBeautyIPEff(Bool_t isMCpt);
8c1c76e9	139	THnSparse* GetPIDxIPEff(Int_t source);
a8ef1999	140	void CalculateNonHFEsyst(Int_t centrality = 0);
c2690925	141
	142	void EnableIPanaHadronBgSubtract() { fIPanaHadronBgSubtract = kTRUE; };
	143	void EnableIPanaCharmBgSubtract() { fIPanaCharmBgSubtract = kTRUE; };
	144	void EnableIPanaConversionBgSubtract() { fIPanaConversionBgSubtract = kTRUE; };
	145	void EnableIPanaNonHFEBgSubtract() { fIPanaNonHFEBgSubtract = kTRUE; };
a8ef1999	146	void EnableIPParameterizedEff() { fIPParameterizedEff = kTRUE; };
c2690925	147
c04c80e6	148	protected:
3a72645a	149
c04c80e6	150	AliCFContainer *GetContainer(AliHFEspectrum::CFContainer_t contt);
0e30407a	151	AliCFContainer GetSlicedContainer(AliCFContainer cont, Int_t ndim, Int_t *dimensions,Int_t source=-1,Chargetype_t charge=kAllCharge,Int_t centralitylow=-1, Int_t centralityhigh=-1);
0e30407a	152	THnSparseF GetSlicedCorrelation(THnSparseF correlationmatrix,Int_t nDim, Int_t *dimensions,Int_t centralitylow=-1, Int_t centralityhigh=-1) const;
c2690925	153	TObject* GetSpectrum(const AliCFContainer * const c, Int_t step);
c2690925	154	TObject* GetEfficiency(const AliCFContainer * const c, Int_t step, Int_t step0);
c04c80e6	155
	156	void AddTemporaryObject(TObject *cont);
	157	void ClearObject(TObject *o);
	158
c2690925	159	TGraphErrors NormalizeTH1(TH1 input,Int_t i = 0) const;
c04c80e6	160
	161
	162	private:
	163	AliHFEspectrum(const AliHFEspectrum &);
	164	AliHFEspectrum &operator=(const AliHFEspectrum &);
	165
e17c1f86	166	TObjArray *fCFContainers; // List of Correction Framework Containers
c04c80e6	167	TList *fTemporaryObjects; // Emulate garbage collection
	168	THnSparseF *fCorrelation; // Correlation Matrices
	169	AliCFDataGrid *fBackground; // Background Grid
c2690925	170	TF1 *fEfficiencyFunction; // Efficiency Function
a8ef1999	171	TF1 *fEfficiencyTOFPIDD[kCentrality]; // TOF PID efficiency parameterized
11ff28c5	172	TF1 *fEfficiencyesdTOFPIDD[kCentrality]; // TOF PID efficiency parameterized
a8ef1999	173	TF1 *fEfficiencyIPCharmD[kCentrality]; // IP efficiency parameterized for charm
a8ef1999	174	TF1 *fEfficiencyIPBeautyD[kCentrality]; // IP efficiency parameterized for beauty
0e30407a	175	TF1 *fEfficiencyIPBeautyesdD[kCentrality]; // IP efficiency parameterized for beauty for esd
a8ef1999	176	TF1 *fEfficiencyIPConversionD[kCentrality]; // IP efficiency parameterized for conversion
a8ef1999	177	TF1 *fEfficiencyIPNonhfeD[kCentrality]; // IP efficiency parameterized for nonhfe
c2690925	178
c2690925	179	THnSparseF *fWeightCharm; // Weight for charm bg
c04c80e6	180
a8ef1999	181	AliCFContainer *fConvSourceContainer[kElecBgSources][kBgLevels][kCentrality]; //container for conversion electrons, divided into different photon sources
a8ef1999	182	AliCFContainer *fNonHFESourceContainer[kElecBgSources][kBgLevels][kCentrality]; //container for non-HF electrons, divided into different sources
e17c1f86	183
3a72645a	184	Bool_t fInclusiveSpectrum; // Inclusive Spectrum
c04c80e6	185	Bool_t fDumpToFile; // Write Result in a file
c04c80e6	186
8c1c76e9	187	Bool_t fEtaSelected; // Switch for eta selection
c2690925	188	Bool_t fUnSetCorrelatedErrors; // Unset correlated errors
e156c3bb	189	Bool_t fSetSmoothing; // Set smoothing
c2690925	190
	191	Bool_t fIPanaHadronBgSubtract; // Hadron background subtraction
	192	Bool_t fIPanaCharmBgSubtract; // Charm background subtraction
	193	Bool_t fIPanaConversionBgSubtract; // Conversion background subtraction
	194	Bool_t fIPanaNonHFEBgSubtract; // nonHFE except for conversion background subtraction
a8ef1999	195	Bool_t fIPParameterizedEff; // switch to use parameterized efficiency for ip analysis
e17c1f86	196	Bool_t fNonHFEsyst; // choose NonHFE background level (upper, lower, central)
a8ef1999	197	Bool_t fBeauty2ndMethod; // 2nd method to get beauty spectrum
11ff28c5	198	Bool_t fIPEffCombinedSamples; // flag to combine two different samples
c2690925	199
3a72645a	200	Int_t fNbDimensions; // Number of dimensions for the correction
c2690925	201	Int_t fNEvents[20]; // Number of Events
c2690925	202	Int_t fNMCEvents; // Number of MC Events
a8ef1999	203	Int_t fNMCbgEvents[20]; // Number of BG MC Events
c04c80e6	204	Int_t fStepMC; // MC step (for unfolding)
	205	Int_t fStepTrue; // MC step of the final spectrum
	206	Int_t fStepData; // Data Step (various applications)
3a72645a	207	Int_t fStepBeforeCutsV0; // Before cuts V0
3a72645a	208	Int_t fStepAfterCutsV0; // After cuts V0
c04c80e6	209	Int_t fStepGuessedUnfolding; // Step for first guessed unfolding
c04c80e6	210	Int_t fNumberOfIterations; // Number of iterations
7bdde22f	211	Int_t fNRandomIter; // Number of random iterations
e17c1f86	212	Chargetype_t fChargeChoosen; // Select positive or negative electrons
c2690925	213
8c1c76e9	214	Double_t fEtaRange[2]; // Eta range
e17c1f86	215	Double_t fEtaRangeNorm[2]; // Eta range used in the normalization
8c1c76e9	216
11ff28c5	217	Int_t fNCentralityBinAtTheEnd;// Number of centrality class at the end
c2690925	218	Int_t fLowBoundaryCentralityBinAtTheEnd[20]; // Boundary of the bins
c2690925	219	Int_t fHighBoundaryCentralityBinAtTheEnd[20]; // Boundary of the bins
0e30407a	220	Int_t fTestCentralityLow; // To test one bin in centrality only
0e30407a	221	Int_t fTestCentralityHigh; // To test one bin in centrality only
cedf0381	222	Bool_t fFillMoreCorrelationMatrix; // For low stats to have reasonable errors
c2690925	223
c2690925	224	THnSparseF *fHadronEffbyIPcut;// container for hadron efficiency by IP cut
a8ef1999	225	TH1D *fEfficiencyCharmSigD[kCentrality]; // charm IP cut eff from signal enhanced MC
a8ef1999	226	TH1D *fEfficiencyBeautySigD[kCentrality]; // beauty IP cut eff from signal enhanced MC
0e30407a	227	TH1D *fEfficiencyBeautySigesdD[kCentrality]; // beauty IP cut eff from signal enhanced MC for esd
a8ef1999	228	TH1D *fConversionEff[kCentrality]; // conversion IP cut eff
a8ef1999	229	TH1D *fNonHFEEff[kCentrality]; // nonhfe IP cut eff
11ff28c5	230	TH1D *fCharmEff[kCentrality]; // charm IP cut eff
	231	TH1D *fBeautyEff[kCentrality]; // beauty IP cut eff
	232	TH1D *fConversionEffbgc; // conversion IP cut eff
	233	TH1D *fNonHFEEffbgc; // nonhfe IP cut eff
a8ef1999	234	TH1D *fBSpectrum2ndMethod; // beauty spectrum for 2nd method
a8ef1999	235	const char *fkBeauty2ndMethodfilename; // name of file, which contains beauty spectrum for 2ndmethod
8c1c76e9	236	Char_t fBeamType; // beamtype; default -1; pp =0; PbPb=1
cedf0381	237	Bool_t fEtaSyst; // pp 2.76 TeV (= kTRUE) or 7 TeV (= kFALSE)
c2690925	238
c04c80e6	239
3a72645a	240	Int_t fDebugLevel; // Debug Level
e17c1f86	241	Bool_t fWriteToFile; // Write plots to eps files
cedf0381	242	Bool_t fUnfoldBG; // flag to unfold backgroud
c04c80e6	243
	244	ClassDef(AliHFEspectrum, 1)
	245	};
	246	#endif
	247