[u/mrichter/AliRoot.git] / PWGJE / AliFragmentationFunctionCorrections.h

// *****************************************************************************
// * Task for corrections to output from AliAnalysisTaskFragmentationFunctions *
//  ****************************************************************************

#ifndef ALIFRAGMENTATIONFUNCTIONCORRECTIONS_H
#define ALIFRAGMENTATIONFUNCTIONCORRECTIONS_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

#include "TObject.h"

class ThnSparse;

class AliFragmentationFunctionCorrections : public TObject {

 public:
  
 //----------------------------------------
  class AliFragFuncCorrHistos : public TObject
  {
    
    public:
    
    AliFragFuncCorrHistos();
    AliFragFuncCorrHistos(const AliFragFuncCorrHistos& copy);
    AliFragFuncCorrHistos& operator=(const AliFragFuncCorrHistos &o);
    virtual ~AliFragFuncCorrHistos();
    AliFragFuncCorrHistos(const char* label,Int_t arraySize);
    void AddCorrHistos(Int_t slice,TH1F* histPt=0,TH1F* histZ=0,TH1F* histXi=0);
    void ReplaceCorrHistos(Int_t slice,TH1F* histPt=0,TH1F* histZ=0,TH1F* histXi=0);

    TH1F* GetTrackPt(const Int_t slice);
    TH1F* GetZ(const Int_t slice);
    TH1F* GetXi(const Int_t slice);

    TString GetLabel() { return fCorrLabel; }

    private:

    Int_t fArraySize;

    TH1F** fh1CorrFFTrackPt;  //! corrected FF histos 
    TH1F** fh1CorrFFZ;        //! corrected FF histos 
    TH1F** fh1CorrFFXi;       //! corrected FF histos 

    TString fCorrLabel;    //! correction label 

    ClassDef(AliFragFuncCorrHistos, 1);
  };

  AliFragmentationFunctionCorrections(); 
  AliFragmentationFunctionCorrections(const  AliFragmentationFunctionCorrections &copy);
  AliFragmentationFunctionCorrections& operator=(const  AliFragmentationFunctionCorrections &o);
  virtual ~AliFragmentationFunctionCorrections();
  
  virtual void SetDebugLevel(Int_t debug){ fDebug = debug; }
  
  void DeleteHistoArray(TH1F** hist) const;
  void DeleteTHnSparseArray(THnSparse** hist) const;
  TH1F** BookHistoArray();
  THnSparse** BookTHnSparseArray();
  void AddCorrectionLevel(const char* label = "");
  void AddCorrectionLevelBgr(const char* label = "");
  void AddCorrectionLevelSinglePt(const char* label = "");
    
  void SetJetPtSlices(Float_t* bins, const Int_t nJetPtSlices);

  void SetHistoBins(const Int_t jetPtSlice, const Int_t sizeBins, Double_t* bins,Int_t type);
  void SetHistoBins(const Int_t jetPtSlice, const Int_t nBinsLimits, Double_t* binsLimits, Double_t* binsWidth,Int_t type);
  TArrayD* GetHistoBins(const Int_t jetPtSlice,  const Int_t type);

  void SetHistoBinsSinglePt(const Int_t sizeBins, Double_t* bins);
  void SetHistoBinsSinglePt(const Int_t nBinsLimits, Double_t* binsLimits, Double_t* binsWidth);

  // set histo bins for inclusive pt spectra 

  void NormalizeTH1(TH1* hist, const Float_t nJets);
  void NormalizeFF();
  void NormalizeBgr();
  void ReadRawFF(TString strfile, TString strID, TString strFFID = "RecCuts");
  void ReadRawFF(TString strfile, TString strdir, TString strlist, TString strFFID);
  void ReadRawBgr(TString strfile, TString strID, TString strBgrID = "Perp", TString strFFID = "RecCuts");
  void ReadRawBgr(TString strfile, TString strdir, TString strlist, TString strBgrID, TString strFFID);
  void ReadRawBgrEmbedding(TString strfile, TString strID, TString strFFID);
  void ReadRawBgrEmbedding(TString strfile, TString strdir, TString strlist, TString strFFID);

  void WriteOutput(TString strfile, TString strdir = "", Bool_t updateOutfile = kTRUE);

  THnSparse* TH1toSparse(const TH1F* hist, TString strName, TString strTit, const Bool_t fillConst = kFALSE);

  TH1F* Unfold(THnSparse* hnHist, const THnSparse* hnResponse, const THnSparse* hnEff, const Int_t nIter, 
	       const Bool_t useCorrelatedErrors = kTRUE, const THnSparse* hnPrior = 0x0);

  void UnfoldHistos(const Int_t nIter, const Bool_t useCorrelatedErrors, const Int_t type);

  void UnfoldPt(const Int_t nIter=5, const Bool_t useCorrelatedErrors=kTRUE);
  void UnfoldZ(const Int_t nIter=5, const Bool_t useCorrelatedErrors=kTRUE);
  void UnfoldXi(const Int_t nIter=5, const Bool_t useCorrelatedErrors=kTRUE);

  TH1F* ApplyResponse(const TH1F* hist, THnSparse* hnResponse);
  
  void ReadEfficiency(TString strfile, TString strdir = "", TString strlist = "");
  void ReadBgrEfficiency(TString strfile, TString strdir = "", TString strlist = "");

  void EffCorr(); 
  void EffCorrBgr();

  void XiShift(const Int_t corrLevel); 

  void SubtractBgr(Double_t sysErr = 0);

  void WriteSingleTrackEff(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "", TString strPostfix = "");
  void WriteSingleTrackEff(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE, TString strOutDir = "", 
			   TString strPostfix = "");
 
  void WriteSingleTrackSecCorr(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
  void WriteSingleTrackSecCorr(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE, TString strOutDir = "");
  
  void WriteSingleResponse(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
  void WriteSingleResponse(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE, TString strOutDir = "");
 
  void WriteJetTrackEff(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE);
  void WriteJetTrackEff(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE);

  void WriteJetSecCorr(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
  void WriteBgrJetSecCorr(TString strInfile, TString strBgrID, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");

  void WriteJetSecCorr(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE, 
		       TString strOutDir = "",Bool_t writeBgr=kFALSE,TString strBgrID="");
 
  void WriteJetResponse(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
  void WriteJetResponse(TString strInfile, TString strdir, TString strlist,TString strOutfile, Bool_t updateOutfile, TString strOutDir = "");

  void ReadResponse(TString strfile, TString strdir="", TString strlist="");
  void ReadPriors(TString strfile,const Int_t type); 

  void ProjectSingleResponseMatrix(TString strOutfile, Bool_t updateOutfile, TString strOutDir = "");
  void ProjectJetResponseMatrices(TString strOutfile);

  void RebinHisto(const Int_t jetPtSlice, const Int_t nBinsLimits, Double_t* binsLimits, Double_t* binsWidth, const Int_t type);

  void WriteJetSpecResponse(TString strInfile, TString strdir, TString strlist /*, TString strOutfile*/ );

  void ReadSingleTrackEfficiency(TString strfile, TString strdir="", TString strlist="", TString strname="hSingleTrackEffPt");
  void ReadSingleTrackResponse(TString strfile, TString strdir="", TString strlist="", TString strname="fhnResponseSinglePt");
  void ReadSingleTrackSecCorr(TString strfile, TString strdir="", TString strlist="", TString strname="hSingleTrackSecCorrPt");
  void ReadSingleTrackCorrection(TString strfile, TString strdir, TString strlist, TString strname, const Int_t type);
  
  void ReadRawPtSpec(TString strInfile, TString strID);
  void ReadRawPtSpec(TString strfile, TString strdir, TString strlist);
  void ReadRawPtSpecQATask(TString strfile, TString strdir, TString strlist); // spectra from Martas QA task
  void EffCorrSinglePt();
  void UnfoldSinglePt(const Int_t nIter, const Bool_t useCorrelatedErrors);
  void SecCorrSinglePt();
  void dNdz2dNdxi();

  void WriteBinShiftCorr(TString strInfile, TString strIDGen,  TString strIDRec,  
			 TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim = kTRUE,  
			 TString strOutDir = "");

  void WriteBgrBinShiftCorr(TString strInfile, TString strBgrID, TString strIDGen,  TString strIDRec,  
			    TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim = kTRUE,  
			    TString strOutDir = "");

  void WriteBinShiftCorr(TString strInfile, TString strdirGen, TString strlistGen, 
			 TString strdirRec, TString strlistRec, 
			 TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim = kTRUE, 
			 TString strOutDir = "",Bool_t writeBgr = kFALSE, TString strBgrID = "");

  void ReadBgrBinShiftCorr(TString strfile,  TString strBgrID, TString strdir="", TString strlist="");
  void ReadBinShiftCorr(TString strfile, TString strdir="", TString strlist="", Bool_t readBgr = kFALSE, TString strBgrID="");

  void ReadFoldingCorr(TString strfile, TString strdir="", TString strlist="");

  void BbBCorr();
  void BbBCorrBgr();

  void FoldingCorr();

  void ReadBgrJetSecCorr(TString strfile, TString strBgrID, TString strdir="", TString strlist="", Bool_t useScaledStrangeness=kTRUE);
  void ReadJetSecCorr(TString strfile, TString strdir="", TString strlist="", Bool_t useScaledStrangeness = kTRUE, 
		      Bool_t readBgr=kFALSE, TString strBgrID="");

  void JetSecCorr();
  void JetSecCorrBgr();


  void WriteBinShiftCorrSinglePt(TString strInfile, TString strIDGen,  TString strIDRec,  
				 TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim, TString strOutDir);

  void WriteBinShiftCorrSinglePt(TString strInfile, TString strdirGen, TString strlistGen, 
				 TString strdirRec, TString strlistRec, 
				 TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim, TString strOutDir = "");
  
  void ReadBinShiftCorrSinglePt(TString strfile, TString strdir = "", TString strlist = "", Bool_t useRecPrim = kTRUE);

  void BbBCorrSinglePt();


  enum {kFlagPt=0,kFlagZ,kFlagXi,kFlagSinglePt};
  enum {kFlagEfficiency=0,kFlagResponse,kFlagSecondaries};


 private:

  static const Int_t fgMaxNCorrectionLevels = 10;  //! max number of corrections 
  
  Int_t fDebug;              //! Debug level
  Int_t fNJetPtSlices;       //! n slices in jet pt
  TArrayF* fJetPtSlices;     //! array to hold slices in jet pt 

  TArrayF* fNJets;           //! nJets per jet pt slice - non-int e.g. for xsec/nTrials scaled spectra
  TArrayF* fNJetsBgr;        //! nJets bgr per jet pt slice - non-int  e.g. for xsec/nTrials scaled spectra
 
  Int_t fNHistoBinsSinglePt;  //! nBins inclusive pt spec histos - leave undefinded to use original binning
  TArrayD* fHistoBinsSinglePt; //! inclusive pt spec histo bins

  Int_t* fNHistoBinsPt;      //! nBins FF histos in each jet pt slice - leave undefinded for any slice to use original binning
  Int_t* fNHistoBinsZ;       //! nBins FF histos in each jet pt slice - leave undefinded for any slice to use original binning
  Int_t* fNHistoBinsXi;      //! nBins FF histos in each jet pt slice - leave undefinded for any slice to use original binning

  TArrayD** fHistoBinsPt;    //! FF histo bins 
  TArrayD** fHistoBinsZ;     //! FF histo bins
  TArrayD** fHistoBinsXi;    //! FF histo bins

  Int_t fNCorrectionLevels;        //! corrections applied: efficiency, secondaries, resolution unfolding, bgr subtraction
  AliFragFuncCorrHistos** fCorrFF; //! array of fragmentation functions, dimensions: jet pt bins, correction steps

  Int_t fNCorrectionLevelsBgr;      //! corrections applied: efficiency, secondaries, resolution unfolding, bgr subtraction
  AliFragFuncCorrHistos** fCorrBgr; //! array of bgr fragmentation functions, dimensions: jet pt bins, correction steps

  Int_t fNCorrectionLevelsSinglePt;      //! corrections applied: efficiency, secondaries, resolution unfolding, bgr subtraction
  AliFragFuncCorrHistos** fCorrSinglePt; //! array to keep single track pt spectra, 1D in jet pt bins dimension 


  // xi shift
  TH1F** fh1FFXiShift;          //! FF: track xi, corrected for shift in jet energy

  // eff correction
  TH1F*  fh1EffSinglePt;       //!  efficiency all tracks

  TH1F** fh1EffPt;             //! reconstruction efficiency track pt
  TH1F** fh1EffZ;              //! reconstruction efficiency z
  TH1F** fh1EffXi;             //! reconstruction efficiency xi

  TH1F** fh1EffBgrPt;          //! reconstruction efficiency bgr track pt
  TH1F** fh1EffBgrZ;  	       //! reconstruction efficiency bgr z
  TH1F** fh1EffBgrXi;	       //! reconstruction efficiency bgr xi

  // bin-by-bin correction
  TH1F*  fh1BbBCorrSinglePt;   //!  BbB corr track pt 

  TH1F** fh1BbBPt;             //! bin-by-bin correction track pt
  TH1F** fh1BbBZ;              //! bin-by-bin correction z
  TH1F** fh1BbBXi;             //! bin-by-bin correction xi

  TH1F** fh1BbBBgrPt;          //! bin-by-bin correction UE track pt
  TH1F** fh1BbBBgrZ;           //! bin-by-bin correction UE z
  TH1F** fh1BbBBgrXi;          //! bin-by-bin correction UE xi

  TH1F** fh1FoldingCorrPt;   //! corr factor rec/folded 
  TH1F** fh1FoldingCorrZ;    //! corr factor rec/folded 
  TH1F** fh1FoldingCorrXi;   //! corr factor rec/folded 


  // secondaries correction
  TH1F** fh1SecCorrPt;             //! secondaries correction track pt
  TH1F** fh1SecCorrZ;              //! secondaries correction z
  TH1F** fh1SecCorrXi;             //! secondaries correction xi

  TH1F** fh1SecCorrBgrPt;          //! secondaries correction track pt
  TH1F** fh1SecCorrBgrZ;           //! secondaries correction z
  TH1F** fh1SecCorrBgrXi;          //! reconstruction efficiency xi

  // unfolding

  TH1F** fh1FFTrackPtBackFolded;  //! FF: track pt backfolded (unfolded + smeared with response matrix)
  TH1F** fh1FFZBackFolded;        //! FF: track z, backfolded (unfolded + smeared with response matrix)
  TH1F** fh1FFXiBackFolded;       //! FF: track xi,backfolded (unfolded + smeared with response matrix)

  TH1F** fh1FFRatioTrackPtFolded;  //! ratio FF: track pt unfolded / original 
  TH1F** fh1FFRatioZFolded;        //! ratio FF: track z  unfolded / original
  TH1F** fh1FFRatioXiFolded;       //! ratio FF: track xi unfolded / original

  TH1F** fh1FFRatioTrackPtBackFolded;  //! ratio FF: track pt backfolded / original
  TH1F** fh1FFRatioZBackFolded;        //! ratio FF: track z  backfolded / original
  TH1F** fh1FFRatioXiBackFolded;       //! ratio FF: track xi backfolded / original

  TH1F*  fh1SingleTrackPtBackFolded;      //! inclusive track pt backfolded (unfolded + smeared with response matrix)
  TH1F*  fh1RatioSingleTrackPtFolded;     //! ratio inclusive track pt unfolded / original 
  TH1F*  fh1RatioSingleTrackPtBackFolded; //! ratio inblusive track pt backfolded / original

  THnSparse*  fhnResponseSinglePt;  //!  response matrix pt gen vs rec all tracks
  THnSparse** fhnResponsePt;        //!  response matrix pt gen vs rec 
  THnSparse** fhnResponseZ;         //!  response matrix z  gen vs rec 
  THnSparse** fhnResponseXi;        //!  response matrix xi gen vs rec 

  TH1F** fh1FFTrackPtPrior;  //! FF: track pt prior 
  TH1F** fh1FFZPrior;        //! FF: track z  prior
  TH1F** fh1FFXiPrior;       //! FF: track xi prior


  // secondaries 
  TH1F*  fh1SecCorrSinglePt;       //!  secondaries correction all tracks


  ClassDef(AliFragmentationFunctionCorrections, 1);
};

#endif
Commit	Line	Data
39e2b057	1	// *****************************************************************************
	2	// * Task for corrections to output from AliAnalysisTaskFragmentationFunctions *
	3	// ****************************************************************************
	4
	5	#ifndef ALIFRAGMENTATIONFUNCTIONCORRECTIONS_H
	6	#define ALIFRAGMENTATIONFUNCTIONCORRECTIONS_H
	7
	8	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	9	* See cxx source for full Copyright notice */
	10
	11	/* $Id$ */
	12
	13	#include "TObject.h"
	14
	15	class ThnSparse;
	16
	17	class AliFragmentationFunctionCorrections : public TObject {
	18
	19	public:
	20
	21	//----------------------------------------
	22	class AliFragFuncCorrHistos : public TObject
	23	{
	24
	25	public:
	26
	27	AliFragFuncCorrHistos();
	28	AliFragFuncCorrHistos(const AliFragFuncCorrHistos& copy);
	29	AliFragFuncCorrHistos& operator=(const AliFragFuncCorrHistos &o);
	30	virtual ~AliFragFuncCorrHistos();
	31	AliFragFuncCorrHistos(const char* label,Int_t arraySize);
	32	void AddCorrHistos(Int_t slice,TH1F* histPt=0,TH1F* histZ=0,TH1F* histXi=0);
	33	void ReplaceCorrHistos(Int_t slice,TH1F* histPt=0,TH1F* histZ=0,TH1F* histXi=0);
	34
	35	TH1F* GetTrackPt(const Int_t slice);
	36	TH1F* GetZ(const Int_t slice);
	37	TH1F* GetXi(const Int_t slice);
	38
	39	TString GetLabel() { return fCorrLabel; }
	40
	41	private:
	42
	43	Int_t fArraySize;
	44
	45	TH1F** fh1CorrFFTrackPt; //! corrected FF histos
	46	TH1F** fh1CorrFFZ; //! corrected FF histos
	47	TH1F** fh1CorrFFXi; //! corrected FF histos
	48
	49	TString fCorrLabel; //! correction label
	50
	51	ClassDef(AliFragFuncCorrHistos, 1);
	52	};
	53
	54	AliFragmentationFunctionCorrections();
	55	AliFragmentationFunctionCorrections(const AliFragmentationFunctionCorrections &copy);
	56	AliFragmentationFunctionCorrections& operator=(const AliFragmentationFunctionCorrections &o);
	57	virtual ~AliFragmentationFunctionCorrections();
	58
	59	virtual void SetDebugLevel(Int_t debug){ fDebug = debug; }
	60
	61	void DeleteHistoArray(TH1F** hist) const;
	62	void DeleteTHnSparseArray(THnSparse** hist) const;
	63	TH1F** BookHistoArray();
	64	THnSparse** BookTHnSparseArray();
65	void AddCorrectionLevel(const char* label = "");
66	void AddCorrectionLevelBgr(const char* label = "");
67	void AddCorrectionLevelSinglePt(const char* label = "");
68
69	void SetJetPtSlices(Float_t* bins, const Int_t nJetPtSlices);
70
71	void SetHistoBins(const Int_t jetPtSlice, const Int_t sizeBins, Double_t* bins,Int_t type);
72	void SetHistoBins(const Int_t jetPtSlice, const Int_t nBinsLimits, Double_t* binsLimits, Double_t* binsWidth,Int_t type);
ce55b926	73	TArrayD* GetHistoBins(const Int_t jetPtSlice, const Int_t type);
ce55b926	74
39e2b057	75	void SetHistoBinsSinglePt(const Int_t sizeBins, Double_t* bins);
	76	void SetHistoBinsSinglePt(const Int_t nBinsLimits, Double_t* binsLimits, Double_t* binsWidth);
	77
	78	// set histo bins for inclusive pt spectra
	79
	80	void NormalizeTH1(TH1* hist, const Float_t nJets);
	81	void NormalizeFF();
	82	void NormalizeBgr();
	83	void ReadRawFF(TString strfile, TString strID, TString strFFID = "RecCuts");
	84	void ReadRawFF(TString strfile, TString strdir, TString strlist, TString strFFID);
	85	void ReadRawBgr(TString strfile, TString strID, TString strBgrID = "Perp", TString strFFID = "RecCuts");
	86	void ReadRawBgr(TString strfile, TString strdir, TString strlist, TString strBgrID, TString strFFID);
	87	void ReadRawBgrEmbedding(TString strfile, TString strID, TString strFFID);
	88	void ReadRawBgrEmbedding(TString strfile, TString strdir, TString strlist, TString strFFID);
	89
	90	void WriteOutput(TString strfile, TString strdir = "", Bool_t updateOutfile = kTRUE);
	91
	92	THnSparse* TH1toSparse(const TH1F* hist, TString strName, TString strTit, const Bool_t fillConst = kFALSE);
	93
ce55b926	94	TH1F* Unfold(THnSparse* hnHist, const THnSparse* hnResponse, const THnSparse* hnEff, const Int_t nIter,
ce55b926	95	const Bool_t useCorrelatedErrors = kTRUE, const THnSparse* hnPrior = 0x0);
39e2b057	96
	97	void UnfoldHistos(const Int_t nIter, const Bool_t useCorrelatedErrors, const Int_t type);
	98
	99	void UnfoldPt(const Int_t nIter=5, const Bool_t useCorrelatedErrors=kTRUE);
	100	void UnfoldZ(const Int_t nIter=5, const Bool_t useCorrelatedErrors=kTRUE);
	101	void UnfoldXi(const Int_t nIter=5, const Bool_t useCorrelatedErrors=kTRUE);
	102
	103	TH1F* ApplyResponse(const TH1F* hist, THnSparse* hnResponse);
	104
	105	void ReadEfficiency(TString strfile, TString strdir = "", TString strlist = "");
	106	void ReadBgrEfficiency(TString strfile, TString strdir = "", TString strlist = "");
	107
	108	void EffCorr();
	109	void EffCorrBgr();
	110
	111	void XiShift(const Int_t corrLevel);
	112
ce55b926	113	void SubtractBgr(Double_t sysErr = 0);
39e2b057	114
	115	void WriteSingleTrackEff(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "", TString strPostfix = "");
	116	void WriteSingleTrackEff(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE, TString strOutDir = "",
	117	TString strPostfix = "");
	118
	119	void WriteSingleTrackSecCorr(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
	120	void WriteSingleTrackSecCorr(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE, TString strOutDir = "");
	121
	122	void WriteSingleResponse(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
	123	void WriteSingleResponse(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE, TString strOutDir = "");
	124
	125	void WriteJetTrackEff(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE);
	126	void WriteJetTrackEff(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE);
	127
ce55b926	128	void WriteJetSecCorr(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
	129	void WriteBgrJetSecCorr(TString strInfile, TString strBgrID, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
	130
	131	void WriteJetSecCorr(TString strInfile, TString strdir, TString strlist, TString strOutfile, Bool_t updateOutfile = kTRUE,
	132	TString strOutDir = "",Bool_t writeBgr=kFALSE,TString strBgrID="");
39e2b057	133
ce55b926	134	void WriteJetResponse(TString strInfile, TString strID, TString strOutfile,Bool_t updateOutfile = kTRUE, TString strOutDir = "");
ce55b926	135	void WriteJetResponse(TString strInfile, TString strdir, TString strlist,TString strOutfile, Bool_t updateOutfile, TString strOutDir = "");
39e2b057	136
	137	void ReadResponse(TString strfile, TString strdir="", TString strlist="");
	138	void ReadPriors(TString strfile,const Int_t type);
	139
	140	void ProjectSingleResponseMatrix(TString strOutfile, Bool_t updateOutfile, TString strOutDir = "");
	141	void ProjectJetResponseMatrices(TString strOutfile);
	142
	143	void RebinHisto(const Int_t jetPtSlice, const Int_t nBinsLimits, Double_t* binsLimits, Double_t* binsWidth, const Int_t type);
	144
633ed180	145	void WriteJetSpecResponse(TString strInfile, TString strdir, TString strlist /, TString strOutfile/ );
39e2b057	146
	147	void ReadSingleTrackEfficiency(TString strfile, TString strdir="", TString strlist="", TString strname="hSingleTrackEffPt");
	148	void ReadSingleTrackResponse(TString strfile, TString strdir="", TString strlist="", TString strname="fhnResponseSinglePt");
	149	void ReadSingleTrackSecCorr(TString strfile, TString strdir="", TString strlist="", TString strname="hSingleTrackSecCorrPt");
	150	void ReadSingleTrackCorrection(TString strfile, TString strdir, TString strlist, TString strname, const Int_t type);
	151
	152	void ReadRawPtSpec(TString strInfile, TString strID);
	153	void ReadRawPtSpec(TString strfile, TString strdir, TString strlist);
	154	void ReadRawPtSpecQATask(TString strfile, TString strdir, TString strlist); // spectra from Martas QA task
	155	void EffCorrSinglePt();
	156	void UnfoldSinglePt(const Int_t nIter, const Bool_t useCorrelatedErrors);
	157	void SecCorrSinglePt();
ce55b926	158	void dNdz2dNdxi();
	159
	160	void WriteBinShiftCorr(TString strInfile, TString strIDGen, TString strIDRec,
	161	TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim = kTRUE,
	162	TString strOutDir = "");
	163
	164	void WriteBgrBinShiftCorr(TString strInfile, TString strBgrID, TString strIDGen, TString strIDRec,
	165	TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim = kTRUE,
	166	TString strOutDir = "");
	167
	168	void WriteBinShiftCorr(TString strInfile, TString strdirGen, TString strlistGen,
	169	TString strdirRec, TString strlistRec,
	170	TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim = kTRUE,
	171	TString strOutDir = "",Bool_t writeBgr = kFALSE, TString strBgrID = "");
	172
	173	void ReadBgrBinShiftCorr(TString strfile, TString strBgrID, TString strdir="", TString strlist="");
	174	void ReadBinShiftCorr(TString strfile, TString strdir="", TString strlist="", Bool_t readBgr = kFALSE, TString strBgrID="");
	175
	176	void ReadFoldingCorr(TString strfile, TString strdir="", TString strlist="");
	177
	178	void BbBCorr();
	179	void BbBCorrBgr();
	180
	181	void FoldingCorr();
	182
	183	void ReadBgrJetSecCorr(TString strfile, TString strBgrID, TString strdir="", TString strlist="", Bool_t useScaledStrangeness=kTRUE);
	184	void ReadJetSecCorr(TString strfile, TString strdir="", TString strlist="", Bool_t useScaledStrangeness = kTRUE,
	185	Bool_t readBgr=kFALSE, TString strBgrID="");
	186
	187	void JetSecCorr();
	188	void JetSecCorrBgr();
	189
	190
	191	void WriteBinShiftCorrSinglePt(TString strInfile, TString strIDGen, TString strIDRec,
	192	TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim, TString strOutDir);
	193
	194	void WriteBinShiftCorrSinglePt(TString strInfile, TString strdirGen, TString strlistGen,
	195	TString strdirRec, TString strlistRec,
	196	TString strOutfile, Bool_t updateOutfile, Bool_t useRecPrim, TString strOutDir = "");
	197
	198	void ReadBinShiftCorrSinglePt(TString strfile, TString strdir = "", TString strlist = "", Bool_t useRecPrim = kTRUE);
	199
	200	void BbBCorrSinglePt();
39e2b057	201
	202
	203	enum {kFlagPt=0,kFlagZ,kFlagXi,kFlagSinglePt};
	204	enum {kFlagEfficiency=0,kFlagResponse,kFlagSecondaries};
	205
	206
	207	private:
	208
	209	static const Int_t fgMaxNCorrectionLevels = 10; //! max number of corrections
	210
	211	Int_t fDebug; //! Debug level
	212	Int_t fNJetPtSlices; //! n slices in jet pt
	213	TArrayF* fJetPtSlices; //! array to hold slices in jet pt
	214
	215	TArrayF* fNJets; //! nJets per jet pt slice - non-int e.g. for xsec/nTrials scaled spectra
	216	TArrayF* fNJetsBgr; //! nJets bgr per jet pt slice - non-int e.g. for xsec/nTrials scaled spectra
	217
	218	Int_t fNHistoBinsSinglePt; //! nBins inclusive pt spec histos - leave undefinded to use original binning
	219	TArrayD* fHistoBinsSinglePt; //! inclusive pt spec histo bins
	220
	221	Int_t* fNHistoBinsPt; //! nBins FF histos in each jet pt slice - leave undefinded for any slice to use original binning
	222	Int_t* fNHistoBinsZ; //! nBins FF histos in each jet pt slice - leave undefinded for any slice to use original binning
	223	Int_t* fNHistoBinsXi; //! nBins FF histos in each jet pt slice - leave undefinded for any slice to use original binning
	224
	225	TArrayD** fHistoBinsPt; //! FF histo bins
	226	TArrayD** fHistoBinsZ; //! FF histo bins
	227	TArrayD** fHistoBinsXi; //! FF histo bins
	228
	229	Int_t fNCorrectionLevels; //! corrections applied: efficiency, secondaries, resolution unfolding, bgr subtraction
	230	AliFragFuncCorrHistos** fCorrFF; //! array of fragmentation functions, dimensions: jet pt bins, correction steps
	231
	232	Int_t fNCorrectionLevelsBgr; //! corrections applied: efficiency, secondaries, resolution unfolding, bgr subtraction
	233	AliFragFuncCorrHistos** fCorrBgr; //! array of bgr fragmentation functions, dimensions: jet pt bins, correction steps
	234
	235	Int_t fNCorrectionLevelsSinglePt; //! corrections applied: efficiency, secondaries, resolution unfolding, bgr subtraction
	236	AliFragFuncCorrHistos** fCorrSinglePt; //! array to keep single track pt spectra, 1D in jet pt bins dimension
	237
	238
	239
	240	// xi shift
	241	TH1F** fh1FFXiShift; //! FF: track xi, corrected for shift in jet energy
	242
	243	// eff correction
	244	TH1F* fh1EffSinglePt; //! efficiency all tracks
	245
	246	TH1F** fh1EffPt; //! reconstruction efficiency track pt
	247	TH1F** fh1EffZ; //! reconstruction efficiency z
	248	TH1F** fh1EffXi; //! reconstruction efficiency xi
	249
	250	TH1F** fh1EffBgrPt; //! reconstruction efficiency bgr track pt
	251	TH1F** fh1EffBgrZ; //! reconstruction efficiency bgr z
	252	TH1F** fh1EffBgrXi; //! reconstruction efficiency bgr xi
	253
ce55b926	254	// bin-by-bin correction
	255	TH1F* fh1BbBCorrSinglePt; //! BbB corr track pt
	256
	257	TH1F** fh1BbBPt; //! bin-by-bin correction track pt
	258	TH1F** fh1BbBZ; //! bin-by-bin correction z
	259	TH1F** fh1BbBXi; //! bin-by-bin correction xi
	260
	261	TH1F** fh1BbBBgrPt; //! bin-by-bin correction UE track pt
	262	TH1F** fh1BbBBgrZ; //! bin-by-bin correction UE z
	263	TH1F** fh1BbBBgrXi; //! bin-by-bin correction UE xi
	264
	265	TH1F** fh1FoldingCorrPt; //! corr factor rec/folded
	266	TH1F** fh1FoldingCorrZ; //! corr factor rec/folded
	267	TH1F** fh1FoldingCorrXi; //! corr factor rec/folded
	268
	269
	270	// secondaries correction
	271	TH1F** fh1SecCorrPt; //! secondaries correction track pt
	272	TH1F** fh1SecCorrZ; //! secondaries correction z
	273	TH1F** fh1SecCorrXi; //! secondaries correction xi
	274
	275	TH1F** fh1SecCorrBgrPt; //! secondaries correction track pt
	276	TH1F** fh1SecCorrBgrZ; //! secondaries correction z
	277	TH1F** fh1SecCorrBgrXi; //! reconstruction efficiency xi
39e2b057	278
	279	// unfolding
	280
	281	TH1F** fh1FFTrackPtBackFolded; //! FF: track pt backfolded (unfolded + smeared with response matrix)
	282	TH1F** fh1FFZBackFolded; //! FF: track z, backfolded (unfolded + smeared with response matrix)
	283	TH1F** fh1FFXiBackFolded; //! FF: track xi,backfolded (unfolded + smeared with response matrix)
	284
	285	TH1F** fh1FFRatioTrackPtFolded; //! ratio FF: track pt unfolded / original
	286	TH1F** fh1FFRatioZFolded; //! ratio FF: track z unfolded / original
	287	TH1F** fh1FFRatioXiFolded; //! ratio FF: track xi unfolded / original
	288
	289	TH1F** fh1FFRatioTrackPtBackFolded; //! ratio FF: track pt backfolded / original
	290	TH1F** fh1FFRatioZBackFolded; //! ratio FF: track z backfolded / original
	291	TH1F** fh1FFRatioXiBackFolded; //! ratio FF: track xi backfolded / original
	292
	293	TH1F* fh1SingleTrackPtBackFolded; //! inclusive track pt backfolded (unfolded + smeared with response matrix)
	294	TH1F* fh1RatioSingleTrackPtFolded; //! ratio inclusive track pt unfolded / original
	295	TH1F* fh1RatioSingleTrackPtBackFolded; //! ratio inblusive track pt backfolded / original
	296
	297	THnSparse* fhnResponseSinglePt; //! response matrix pt gen vs rec all tracks
	298	THnSparse** fhnResponsePt; //! response matrix pt gen vs rec
	299	THnSparse** fhnResponseZ; //! response matrix z gen vs rec
	300	THnSparse** fhnResponseXi; //! response matrix xi gen vs rec
	301
	302	TH1F** fh1FFTrackPtPrior; //! FF: track pt prior
	303	TH1F** fh1FFZPrior; //! FF: track z prior
	304	TH1F** fh1FFXiPrior; //! FF: track xi prior
	305
ce55b926	306
39e2b057	307	// secondaries
39e2b057	308	TH1F* fh1SecCorrSinglePt; //! secondaries correction all tracks
39e2b057	309
	310
	311	ClassDef(AliFragmentationFunctionCorrections, 1);
	312	};
	313
	314	#endif