[u/mrichter/AliRoot.git] / CORRFW / AliCFUnfolding.h


#ifndef ALICFUNFOLDING_H
#define ALICFUNFOLDING_H

//--------------------------------------------------------------------//
//                                                                    //
// AliCFUnfolding Class                                               //
// Class to handle general unfolding procedure using bayesian method  //
//                                                                    //
// Author : renaud.vernet@cern.ch                                     //
//--------------------------------------------------------------------//

#include "TNamed.h"
#include "THnSparse.h"
#include "AliLog.h"

class TF1;
class TRandom3;

class AliCFUnfolding : public TNamed {

 public :
  enum EUnfoldingErrorStatus {
    kNotDone   = BIT(0), // Doing the normal unfolding, before errors are calculated
    kBeingDone = BIT(1), // In the process of calculating errors
    kDone      = BIT(2)  // Errors have been calculated
  };

  AliCFUnfolding();
  AliCFUnfolding(const Char_t* name, const Char_t* title, const Int_t nVar, 
		 const THnSparse* response, const THnSparse* efficiency, const THnSparse* measured, const THnSparse* prior=0x0, 
		 Double_t maxConvergencePerDOF = 1.e-06, UInt_t randomSeed = 0,
		 Int_t maxNumIterations = 10);
  AliCFUnfolding(const AliCFUnfolding& c);
  AliCFUnfolding& operator= (const AliCFUnfolding& c);
  ~AliCFUnfolding();
  void UnsetCorrelatedErrors()  {AliError("===================> DEPRECATED <=====================");}
  void SetUseCorrelatedErrors() {AliError("===================> DEPRECATED <=====================");}
  void SetMaxNumberOfIterations(Int_t n = 10)  {
    AliError("===================> DEPRECATED : should be set in constructor <=====================");
    AliError("===================> DEPRECATED : will be removed soon         <=====================");
    fMaxNumIterations = n;
  }

  void UseSmoothing(TF1* fcn=0x0, Option_t* opt="iremn") { // if fcn=0x0 then smooth using neighbouring bins 
    fUseSmoothing=kTRUE;                                   // this function must NOT be used if fNVariables > 3
    fSmoothFunction=fcn;                                   // the option "opt" is used if "fcn" is specified
    fSmoothOption=opt;
  } 
                                                                                                
  void Unfold();

  THnSparse* GetResponse()             const {return fResponse;}
  THnSparse* GetInverseResponse()      const {return fInverseResponse;}
  THnSparse* GetPrior()                const {return fPrior;}
  THnSparse* GetOriginalPrior()        const {return fOriginalPrior;}
  THnSparse* GetEfficiency()           const {return fEfficiency;}
  THnSparse* GetUnfolded()             const {return fUnfoldedFinal;}
  THnSparse* GetEstMeasured()          const {return fMeasuredEstimate;}
  THnSparse* GetMeasured()             const {return fMeasured;}
  THnSparse* GetConditional()          const {return fConditional;}
  TF1*       GetSmoothFunction()       const {return fSmoothFunction;}
  THnSparse* GetDeltaUnfoldedProfile() const {return fDeltaUnfoldedP;}
  Int_t      GetDOF();                 // Returns number of degrees of freedom

  static Short_t  SmoothUsingNeighbours(THnSparse*); // smoothes the unfolded spectrum using the neighbouring cells

 private :
  
  // user-related settings
  THnSparse     *fResponse;           // Response matrix : dimensions must be 2N = 2 x (number of variables)
                                      // dimensions 0 ->  N-1 must be filled with reconstructed values
                                      // dimensions N -> 2N-1 must be filled with generated values
  THnSparse     *fPrior;              // This is the assumed generated distribution : dimensions must be N = number of variables
                                      // it will be used at the first step 
                                      // then will be updated automatically at each iteration
  THnSparse     *fEfficiency;         // Efficiency map : dimensions must be N = number of variables
                                      // this map must be filled only with "true" values of the variables (should not include resolution effects)
  THnSparse     *fMeasured;           // Measured spectrum to be unfolded : dimensions must be N = number of variables (modified)
  THnSparse     *fMeasuredOrig;       // Measured spectrum to be unfolded : dimensions must be N = number of variables (not modified)
  Int_t          fMaxNumIterations;   // Maximum  number of iterations to be performed
  Int_t          fNVariables;         // Number of variables used in analysis spectra (pt, y, ...)
  Bool_t         fUseSmoothing;       // Smooth the unfolded sectrum at each iteration; default is kFALSE
  TF1           *fSmoothFunction;     // Function used to smooth the unfolded spectrum
  Option_t      *fSmoothOption;       // Option to use during the fit (with fSmoothFunction) ; default is "iremn"

  /* correlated error calculation */
  Double_t       fMaxConvergence;     // Convergence criterion in case of correlated error calculation
  Int_t          fNRandomIterations;  // Number of random distributed measured spectra

  // internal settings
  THnSparse     *fOriginalPrior;     // This is the original prior distribution : will not be modified
  THnSparse     *fInverseResponse;   // Inverse response matrix
  THnSparse     *fMeasuredEstimate;  // Estimation of the measured (M) spectrum given the a priori (T) distribution
  THnSparse     *fConditional;       // Matrix holding the conditional probabilities P(M|T)
  THnSparse     *fUnfolded;          // Unfolded spectrum (modified before and during error calculation)
  THnSparse     *fUnfoldedFinal;     // Final unfolded spectrum
  Int_t         *fCoordinates2N;     // Coordinates in 2N (measured,true) space
  Int_t         *fCoordinatesN_M;    // Coordinates in measured space
  Int_t         *fCoordinatesN_T;    // Coordinates in true space


  /* correlated error calculation */
  THnSparse     *fRandomizedDist;    // Randomized distribution for each bin of the measured spectrum to calculate correlated errors
  TRandom3      *fRandom3;           // Object to get random number following Poisson distribution
  THnSparse     *fDeltaUnfoldedP;    // Profile of the delta-unfolded distribution
  THnSparse     *fDeltaUnfoldedN;    // Entries of the delta-unfolded distribution (count for each bin)
  Short_t        fNCalcCorrErrors;   // Book-keeping to prevend infinite loop
  UInt_t         fRandomSeed;        // Random seed


  // functions
  void     Init();                  // initialisation of the internal settings
  void     GetCoordinates();        // gets a cell coordinates in Measured and True space
  void     CreateConditional();     // creates the conditional matrix from the response matrix
  void     CreateEstMeasured();     // creates the measured spectrum estimation from the conditional matrix and the prior distribution
  void     CreateInvResponse();     // creates the inverse response function (Bayes Theorem) from the conditional matrix and the prior distribution
  void     CreateUnfolded();        // creates the unfolded spectrum from the inverse response matrix and the measured distribution
  void     CreateFlatPrior();       // creates a flat a priori distribution in case the one given in the constructor is null
  Double_t GetChi2();               // returns the chi2 between unfolded and prior spectra
  Short_t  Smooth();                // function calling smoothing methods
  Short_t  SmoothUsingFunction();   // smoothes the unfolded spectrum using a fit function

  /* correlated error calculation */
  Double_t GetConvergence();            // Returns convergence criterion
  void     CalculateCorrelatedErrors(); // Calculates correlated errors for the final unfolded spectrum
  void     CreateRandomizedDist();      // Create randomized dist from measured distribution
  void     FillDeltaUnfoldedProfile();  // Fills the fDeltaUnfoldedP profile
  void     SetMaxConvergencePerDOF (Double_t val);

  ClassDef(AliCFUnfolding,1);
};

#endif
Commit	Line	Data
c0b10ad4	1
	2	#ifndef ALICFUNFOLDING_H
	3	#define ALICFUNFOLDING_H
	4
	5	//--------------------------------------------------------------------//
	6	// //
	7	// AliCFUnfolding Class //
fb494025	8	// Class to handle general unfolding procedure using bayesian method //
c0b10ad4	9	// //
	10	// Author : renaud.vernet@cern.ch //
	11	//--------------------------------------------------------------------//
	12
	13	#include "TNamed.h"
	14	#include "THnSparse.h"
a9500e70	15	#include "AliLog.h"
c0b10ad4	16
85b6bda9	17	class TF1;
769f5114	18	class TRandom3;
85b6bda9	19
c0b10ad4	20	class AliCFUnfolding : public TNamed {
	21
	22	public :
a9500e70	23	enum EUnfoldingErrorStatus {
	24	kNotDone = BIT(0), // Doing the normal unfolding, before errors are calculated
	25	kBeingDone = BIT(1), // In the process of calculating errors
	26	kDone = BIT(2) // Errors have been calculated
	27	};
	28
c0b10ad4	29	AliCFUnfolding();
c0b10ad4	30	AliCFUnfolding(const Char_t* name, const Char_t* title, const Int_t nVar,
a9500e70	31	const THnSparse* response, const THnSparse* efficiency, const THnSparse* measured, const THnSparse* prior=0x0,
	32	Double_t maxConvergencePerDOF = 1.e-06, UInt_t randomSeed = 0,
	33	Int_t maxNumIterations = 10);
c0b10ad4	34	AliCFUnfolding(const AliCFUnfolding& c);
	35	AliCFUnfolding& operator= (const AliCFUnfolding& c);
	36	~AliCFUnfolding();
a9500e70	37	void UnsetCorrelatedErrors() {AliError("===================> DEPRECATED <=====================");}
	38	void SetUseCorrelatedErrors() {AliError("===================> DEPRECATED <=====================");}
	39	void SetMaxNumberOfIterations(Int_t n = 10) {
	40	AliError("===================> DEPRECATED : should be set in constructor <=====================");
	41	AliError("===================> DEPRECATED : will be removed soon <=====================");
	42	fMaxNumIterations = n;
769f5114	43	}
769f5114	44
85b6bda9	45	void UseSmoothing(TF1* fcn=0x0, Option_t* opt="iremn") { // if fcn=0x0 then smooth using neighbouring bins
	46	fUseSmoothing=kTRUE; // this function must NOT be used if fNVariables > 3
	47	fSmoothFunction=fcn; // the option "opt" is used if "fcn" is specified
	48	fSmoothOption=opt;
	49	}
	50
c0b10ad4	51	void Unfold();
c0b10ad4	52
769f5114	53	THnSparse* GetResponse() const {return fResponse;}
	54	THnSparse* GetInverseResponse() const {return fInverseResponse;}
	55	THnSparse* GetPrior() const {return fPrior;}
	56	THnSparse* GetOriginalPrior() const {return fOriginalPrior;}
	57	THnSparse* GetEfficiency() const {return fEfficiency;}
a9500e70	58	THnSparse* GetUnfolded() const {return fUnfoldedFinal;}
769f5114	59	THnSparse* GetEstMeasured() const {return fMeasuredEstimate;}
	60	THnSparse* GetMeasured() const {return fMeasured;}
	61	THnSparse* GetConditional() const {return fConditional;}
	62	TF1* GetSmoothFunction() const {return fSmoothFunction;}
a9500e70	63	THnSparse* GetDeltaUnfoldedProfile() const {return fDeltaUnfoldedP;}
769f5114	64	Int_t GetDOF(); // Returns number of degrees of freedom
c0b10ad4	65
7036630f	66	static Short_t SmoothUsingNeighbours(THnSparse*); // smoothes the unfolded spectrum using the neighbouring cells
7036630f	67
c0b10ad4	68	private :
	69
	70	// user-related settings
	71	THnSparse *fResponse; // Response matrix : dimensions must be 2N = 2 x (number of variables)
85b6bda9	72	// dimensions 0 -> N-1 must be filled with reconstructed values
85b6bda9	73	// dimensions N -> 2N-1 must be filled with generated values
c0b10ad4	74	THnSparse *fPrior; // This is the assumed generated distribution : dimensions must be N = number of variables
	75	// it will be used at the first step
	76	// then will be updated automatically at each iteration
c0b10ad4	77	THnSparse *fEfficiency; // Efficiency map : dimensions must be N = number of variables
c0b10ad4	78	// this map must be filled only with "true" values of the variables (should not include resolution effects)
769f5114	79	THnSparse *fMeasured; // Measured spectrum to be unfolded : dimensions must be N = number of variables (modified)
769f5114	80	THnSparse *fMeasuredOrig; // Measured spectrum to be unfolded : dimensions must be N = number of variables (not modified)
c0b10ad4	81	Int_t fMaxNumIterations; // Maximum number of iterations to be performed
c0b10ad4	82	Int_t fNVariables; // Number of variables used in analysis spectra (pt, y, ...)
769f5114	83	Bool_t fUseSmoothing; // Smooth the unfolded sectrum at each iteration; default is kFALSE
85b6bda9	84	TF1 *fSmoothFunction; // Function used to smooth the unfolded spectrum
85b6bda9	85	Option_t *fSmoothOption; // Option to use during the fit (with fSmoothFunction) ; default is "iremn"
c0b10ad4	86
769f5114	87	/* correlated error calculation */
769f5114	88	Double_t fMaxConvergence; // Convergence criterion in case of correlated error calculation
769f5114	89	Int_t fNRandomIterations; // Number of random distributed measured spectra
769f5114	90
c0b10ad4	91	// internal settings
85b6bda9	92	THnSparse *fOriginalPrior; // This is the original prior distribution : will not be modified
c0b10ad4	93	THnSparse *fInverseResponse; // Inverse response matrix
	94	THnSparse *fMeasuredEstimate; // Estimation of the measured (M) spectrum given the a priori (T) distribution
	95	THnSparse *fConditional; // Matrix holding the conditional probabilities P(M\|T)
a9500e70	96	THnSparse *fUnfolded; // Unfolded spectrum (modified before and during error calculation)
a9500e70	97	THnSparse *fUnfoldedFinal; // Final unfolded spectrum
c0b10ad4	98	Int_t *fCoordinates2N; // Coordinates in 2N (measured,true) space
	99	Int_t *fCoordinatesN_M; // Coordinates in measured space
	100	Int_t *fCoordinatesN_T; // Coordinates in true space
769f5114	101
	102
	103	/* correlated error calculation */
	104	THnSparse *fRandomizedDist; // Randomized distribution for each bin of the measured spectrum to calculate correlated errors
	105	TRandom3 *fRandom3; // Object to get random number following Poisson distribution
a9500e70	106	THnSparse *fDeltaUnfoldedP; // Profile of the delta-unfolded distribution
	107	THnSparse *fDeltaUnfoldedN; // Entries of the delta-unfolded distribution (count for each bin)
	108	Short_t fNCalcCorrErrors; // Book-keeping to prevend infinite loop
769f5114	109	UInt_t fRandomSeed; // Random seed
769f5114	110
c0b10ad4	111
c0b10ad4	112	// functions
85b6bda9	113	void Init(); // initialisation of the internal settings
	114	void GetCoordinates(); // gets a cell coordinates in Measured and True space
	115	void CreateConditional(); // creates the conditional matrix from the response matrix
	116	void CreateEstMeasured(); // creates the measured spectrum estimation from the conditional matrix and the prior distribution
	117	void CreateInvResponse(); // creates the inverse response function (Bayes Theorem) from the conditional matrix and the prior distribution
	118	void CreateUnfolded(); // creates the unfolded spectrum from the inverse response matrix and the measured distribution
	119	void CreateFlatPrior(); // creates a flat a priori distribution in case the one given in the constructor is null
	120	Double_t GetChi2(); // returns the chi2 between unfolded and prior spectra
	121	Short_t Smooth(); // function calling smoothing methods
85b6bda9	122	Short_t SmoothUsingFunction(); // smoothes the unfolded spectrum using a fit function
c0b10ad4	123
769f5114	124	/* correlated error calculation */
	125	Double_t GetConvergence(); // Returns convergence criterion
	126	void CalculateCorrelatedErrors(); // Calculates correlated errors for the final unfolded spectrum
769f5114	127	void CreateRandomizedDist(); // Create randomized dist from measured distribution
	128	void FillDeltaUnfoldedProfile(); // Fills the fDeltaUnfoldedP profile
	129	void SetMaxConvergencePerDOF (Double_t val);
	130
	131	ClassDef(AliCFUnfolding,1);
c0b10ad4	132	};
	133
	134	#endif