class AliCFUnfolding: public TNamed

 default constructor

 named constructor

 destructor

 initialisation function : creates internal settings

 This function creates a estimate (M) of the reconstructed spectrum
 given the a priori distribution (T), the efficiency (E) and the conditional matrix (COND)

 --> P(M) = SUM   { P(M|T)    * P(T) }
 --> M(i) = SUM_k { COND(i,k) * T(k) * E (k)}

 This is needed to calculate the inverse response matrix

 Creates the inverse response matrix (INV) with Bayesian method
  : uses the conditional matrix (COND), the prior probabilities (T) and the efficiency map (E)

 --> P(T|M)   = P(M|T)    * P(T) * eff(T) / SUM   { P(M|T)    * P(T) }
 --> INV(i,j) = COND(i,j) * T(j) * E(j)   / SUM_k { COND(i,k) * T(k) }

 Main routine called by the user :
 it calculates the unfolded spectrum from the response matrix, measured spectrum and efficiency
 several iterations are performed until a reasonable chi2 or convergence criterion is reached

 Creates the unfolded (T) spectrum from the measured spectrum (M) and the inverse response matrix (INV)
 We have P(T) = SUM   { P(T|M)   * P(M) }
   -->   T(i) = SUM_k { INV(i,k) * M(k) }

 Create randomized dist from original measured distribution
 This distribution is created several times, each time with a different random number

 Store difference of unfolded spectrum from measured distribution and unfolded spectrum from randomized distribution
 The delta profile has been set to a THnSparse to handle N dimension
 The THnSparse contains in each bin the mean value and spread of the difference
 This function updates the profile wrt to its previous mean and error
 The relation between iterations (n+1) and n is as follows :
  mean_{n+1} = (n*mean_n + value_{n+1}) / (n+1)
 sigma_{n+1} = sqrt { 1/(n+1) * [ n*sigma_n^2 + (n^2+n)*(mean_{n+1}-mean_n)^2 ] }    (can this be optimized?)

 assign coordinates in Measured and True spaces (dim=N) from coordinates in global space (dim=2N)

 creates the conditional probability matrix (R*) holding the P(M|T), given the reponse matrix R

  --> R*(i,j) = R(i,j) / SUM_k{ R(k,j) }

 number of dof = number of bins

 Returns the chi2 between unfolded and a priori spectrum
 This function became absolute with the correlated error calculation.
 Errors on the unfolded distribution are not known until the end
 Use the convergence criterion instead

 Returns convergence criterion = \sum_t ((U_t^{n-1}-U_t^n)/U_t^{n-1})^2
 U is unfolded spectrum, t is the bin, n = current, n-1 = previous

 Max. convergence criterion per degree of freedom : user setting
 convergence criterion = DOF*val; DOF = number of bins
 In Jan-Fiete's multiplicity note: Convergence criterion = DOF*0.001^2

 Smoothes the unfolded spectrum

 By default each cell content is replaced by the average with the neighbouring bins (but not diagonally-neighbouring bins)
 However, if a specific function fcn has been defined in UseSmoothing(fcn), the unfolded will be fit and updated using fcn

 Smoothes the unfolded spectrum using neighouring bins

 Fits the unfolded spectrum using the function fSmoothFunction

 Creates a flat prior distribution