Index: trunk/SophyaLib/NTools/generalfit.cc
===================================================================
--- trunk/SophyaLib/NTools/generalfit.cc	(revision 774)
+++ trunk/SophyaLib/NTools/generalfit.cc	(revision 914)
@@ -21,20 +21,10 @@
 //================================================================
 
-//++
-// Class	GeneralFunction
-// Lib	Outils++ 
-// include	generalfit.h
-//
-//	Classe de fonctions parametrees a plusieurs variables.
-//|           F[x1,x2,x3,...:a1,a2,a3,...]
-//--
-
-//////////////////////////////////////////////////////////////////////
-//++
+//////////////////////////////////////////////////////////////////////
+/*!
+ Creation d'une fonction de `nVar' variables et `nPar' parametres:
+ \f$ F[x(1),x(2),x(3),...x(nVar) : a(1),a(2),a(3),...,a(nPar)] \f$
+*/
 GeneralFunction::GeneralFunction(unsigned int nVar, unsigned int nPar)
-//
-//	Creation d'une fonction de `nVar' variables et `nPar' parametres.
-//|  F[x(1),x(2),x(3),...x(nVar) : a(1),a(2),a(3),...,a(nPar)]
-//--
   : mNVar(nVar), mNPar(nPar)
 {
@@ -45,8 +35,5 @@
 }
 
-//++
 GeneralFunction::~GeneralFunction()
-//
-//--
 {
  delete[] deltaParm;
@@ -55,10 +42,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Valeur et Derivees de la fonction (fct virtuelle par defaut).
+*/
 double GeneralFunction::Val_Der(double const xp[], double const* parm
                                , double *DgDpar)
-//
-//	Valeur et Derivees de la fonction (fct virtuelle par defaut).
-//--
 {
  for(int i=0;i<mNPar;i++) tmpParm[i] = parm[i];
@@ -77,10 +63,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition de la variation du parametre numPar
+  pour calculer la derivee automatiquement.
+*/
 void GeneralFunction::SetDeltaParm(int numPar, double d)
-//
-//	Definition de la variation du parametre numPar
-//	pour calculer la derivee automatiquement.
-//--
 {
  ASSERT(numPar >= 0 && numPar < mNPar);
@@ -88,27 +73,12 @@
 }
 
-//++
+
+/*!
+  Idem precedente fonction mais pour tous les parametres
+*/
 void GeneralFunction::SetDeltaParm(double const* dparam)
-//
-//	Idem precedente fonction mais pour tous les parametres
-//--
 {
  for(int i=0;i<mNPar;i++) deltaParm[i] = dparam[i];
 }
-
-//////////////////////////////////////////////////////////////////////
-// Rappel des inline functions pour commentaires
-//++
-// virtual double Value(double const xp[], double const* parm)=0;
-//	Valeur de la fonction a definir par l'utilisateur (fct virtuelle pure)
-//--
-//++
-// inline int     NVar() const
-//	Retourne le nombre de variables Xi
-//--
-//++
-// inline int     NPar() const
-//	Retourne le nombre de parametres Ai
-//--
 
 //================================================================
@@ -116,71 +86,56 @@
 //================================================================
 
-//++
-// Class	GeneralFunc
-// Lib	Outils++ 
-// include	generalfit.h
-//
-//	Classe de fonctions parametrees a plusieurs variables
-//	derivant de ``GeneralFunction''. Permet de definir
-//	une fonction a fiter sans passer par une classe derivee
-//	en utilisant l'ecriture courante du C. La fonction
-//	retournant les derivees par rapport aux parametres du fit
-//	peut etre egalement fournie (optionnel).
-//--
-
 /////////////////////////////////////////////////////////////////
-//++
-GeneralFunc::GeneralFunc(unsigned int nvar, unsigned int npar, double (*fun) (double const*, double const*)
-                        , double (*funder) (double const*, double const*, double*) )
-//
-//	Createur, on passe le nom ``fun'' de la fonction a la mode C.
-//	On peut optionellement egalement passer le nom de la fonction
-//	``funder'' qui retourne les valeurs des derivees par rapport
-//	aux parametres du fit.
-//--
-//++
-//| ----------------------
-//| Exemple d'utilisation:
-//| ----------------------
-//| include "generalfit.h"
-//| ...
-//| double   gaussc(double const* x,double const* p);
-//| double d_gaussc(double const* x,double const* p,double* dp);
-//| ...
-//| main {
-//|  ...
-//|  // Fit SANS calcul automatique des derivees
-//|  GeneralFunc      myfunc(2,7,gaussc);
-//|  GeneralFit       myfit(&myfunc);
-//|  ...
-//|  myfit.Fit();
-//|  ...
-//|  // Fit AVEC calcul automatique des derivees
-//|  GeneralFunc      myfunc(2,7,gaussc,d_gaussc);
-//|  GeneralFit       myfit(&myfunc);
-//|  ...
-//|  myfit.Fit();
-//| }
-//--
-//++
-//| // Definition de la fonction a fitter a la mode C
-//| double gaussc(double const* x,double const* p)
-//| // Fonction: X=(x[0]-p[1])/p[3], Y=(x[1]-p[2])/p[4],
-//| //  f = p[0]*exp{-0.5*[X^2+Y^2-2*p[5]*X*Y]} + p[6]
-//| {
-//|  double X = (x[0]-p[1])/p[3];
-//|  double Y = (x[1]-p[2])/p[4];
-//|  return p[0]*exp(-(X*X+Y*Y-2*p[5]*X*Y)/2)+p[6];
-//| }
-//| // Definition de la fonction des derivees / parametres
-//| // Cette fonction retourne aussi la valeur de la fonction a fitter.
-//| double d_gaussc(double const* x,double const* p,double* dp)
-//| {
-//|  dp[0] = derivee de gaussc par rapport au parametre p[0]
-//|  ...
-//|  dp[6] = derivee de gaussc par rapport au parametre p[6]
-//|  return gaussc(x,p);
-//| }
-//--
+/*!
+  Createur, on passe le nom ``fun'' de la fonction a la mode C.
+  On peut optionellement egalement passer le nom de la fonction
+  ``funder'' qui retourne les valeurs des derivees par rapport
+  aux parametres du fit.
+  \verbatim
+    ----------------------
+    Exemple d'utilisation:
+    ----------------------
+    include "generalfit.h"
+    ...
+    double   gaussc(double const* x,double const* p);
+    double d_gaussc(double const* x,double const* p,double* dp);
+    ...
+    main {
+     ...
+     // Fit SANS calcul automatique des derivees
+     GeneralFunc      myfunc(2,7,gaussc);
+     GeneralFit       myfit(&myfunc);
+     ...
+     myfit.Fit();
+     ...
+     // Fit AVEC calcul automatique des derivees
+     GeneralFunc      myfunc(2,7,gaussc,d_gaussc);
+     GeneralFit       myfit(&myfunc);
+     ...
+     myfit.Fit();
+    }
+    // Definition de la fonction a fitter a la mode C
+    double gaussc(double const* x,double const* p)
+    // Fonction: X=(x[0]-p[1])/p[3], Y=(x[1]-p[2])/p[4],
+    //  f = p[0]*exp{-0.5*[X^2+Y^2-2*p[5]*X*Y]} + p[6]
+    {
+     double X = (x[0]-p[1])/p[3];
+     double Y = (x[1]-p[2])/p[4];
+     return p[0]*exp(-(X*X+Y*Y-2*p[5]*X*Y)/2)+p[6];
+    }
+    // Definition de la fonction des derivees / parametres
+    // Cette fonction retourne aussi la valeur de la fonction a fitter.
+    double d_gaussc(double const* x,double const* p,double* dp)
+    {
+     dp[0] = derivee de gaussc par rapport au parametre p[0]
+     ...
+     dp[6] = derivee de gaussc par rapport au parametre p[6]
+     return gaussc(x,p);
+    }
+  \endverbatim
+*/
+GeneralFunc::GeneralFunc(unsigned int nvar, unsigned int npar
+             , double (*fun) (double const*, double const*)
+             , double (*funder) (double const*, double const*, double*) )
 : GeneralFunction(nvar,npar), tmpFun(fun), tmpFunDer(funder)
 {
@@ -206,20 +161,11 @@
 //================================================================
 
-//++
-// Class	GeneralXi2
-// Lib	Outils++ 
-// include	generalfit.h
+//////////////////////////////////////////////////////////////////////
+/*!
 //
-//	Classe de Xi2 a plusieurs parametres.
-//|           Xi2[a1,a2,a3,...]
-//--
-
-//////////////////////////////////////////////////////////////////////
-//++
+  Creation d'un Xi2 de `nPar' parametres.
+  \f$ Xi2[a(1),a(2),a(3),...,a(nPar)] \f$
+*/
 GeneralXi2::GeneralXi2(unsigned int nPar)
-//
-//	Creation d'un Xi2 de `nPar' parametres.
-//|  Xi2[a(1),a(2),a(3),...,a(nPar)]
-//--
   : mNPar(nPar)
 { 
@@ -229,8 +175,5 @@
 }
 
-//++
 GeneralXi2::~GeneralXi2()
-//
-//--
 {
  delete[] deltaParm;
@@ -238,10 +181,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Derivee du Xi2 par rapport au parametre `i'
+  pour les valeurs `parm' des parametres.
+*/
 double GeneralXi2::Derivee(GeneralFitData& data, int i, double* parm)
-//
-//	Derivee du Xi2 par rapport au parametre `i'
-//	pour les valeurs `parm' des parametres.
-//--
 {
  int dum;
@@ -255,35 +197,34 @@
 }
 
-//++
+/*!
+  Derivee seconde du Xi2 par rapport aux parametres `i' et `j'
+  pour les valeurs `parm' des parametres. Attention, cette fonction
+  calcule d/di(dC2/dj), valeur qui est numeriquement differente
+  de d/dj(dC2/di).
+  \verbatim
+   
+    **** Remarque: Derivee2 = dXi2/dPi.dPj represente le Hessien.
+    Derivee2(k,l)= dXi2/dPk.dPl
+                 = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]
+                          + [yi-f(xi;P)] * df(xi;P)/dPk.dPl }
+    ou (xi,yi) sont les points de mesure. "Si" l'erreur sur le point i
+       SUMi represente la somme sur les points de mesure
+       f(x;P) represente le modele parametrique a fitter
+       "P" represente l'ensemble des parametres et "Pi" le ieme parametre
+    Les composantes du Hessien dependent des derivees 1ere et 2sd du modele
+    a fitter f(x;P) selon les parametres "Pi". La prise en compte des derivees
+    secondes est un facteur destabilisant. De plus le facteur [yi-f(xi;P)]
+    devant la derivee 2sd est seulement l'erreur de mesure aleatoire qui
+    n'est pas correlee avec le modele. Le terme avec la derivee 2sd
+    tend donc a s'annuler et peut donc etre omis.
+    (cf. Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
+     Calculation of the Gradient and Hessian p682,683)
+   
+    **** Conseil: Il est conseille a l'utilisateur de sur-ecrire
+    la fonction virtuelle Derivee2 et de la remplacer par:
+    Derivee2(k,l) = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]}
+  \endverbatim
+*/
 double GeneralXi2::Derivee2(GeneralFitData& data, int i, int j, double* parm)
-//
-//	Derivee seconde du Xi2 par rapport aux parametres `i' et `j'
-//	pour les valeurs `parm' des parametres. Attention, cette fonction
-//	calcule d/di(dC2/dj), valeur qui est numeriquement differente
-//	de d/dj(dC2/di).
-//--
-//++
-//|
-//| **** Remarque: Derivee2 = dXi2/dPi.dPj represente le Hessien.
-//| Derivee2(k,l)= dXi2/dPk.dPl
-//|              = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]
-//|                       + [yi-f(xi;P)] * df(xi;P)/dPk.dPl }
-//| ou (xi,yi) sont les points de mesure. "Si" l'erreur sur le point i
-//|    SUMi represente la somme sur les points de mesure
-//|    f(x;P) represente le modele parametrique a fitter
-//|    "P" represente l'ensemble des parametres et "Pi" le ieme parametre
-//| Les composantes du Hessien dependent des derivees 1ere et 2sd du modele
-//| a fitter f(x;P) selon les parametres "Pi". La prise en compte des derivees
-//| secondes est un facteur destabilisant. De plus le facteur [yi-f(xi;P)]
-//| devant la derivee 2sd est seulement l'erreur de mesure aleatoire qui
-//| n'est pas correlee avec le modele. Le terme avec la derivee 2sd
-//| tend donc a s'annuler et peut donc etre omis.
-//| (cf. Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
-//|  Calculation of the Gradient and Hessian p682,683)
-//|
-//| **** Conseil: Il est conseille a l'utilisateur de sur-ecrire
-//| la fonction virtuelle Derivee2 et de la remplacer par:
-//| Derivee2(k,l) = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]}
-//--
 {
  double d = deltaParm[i];
@@ -298,10 +239,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition de la variation 'd' du parametre 'numPar'
+  pour calculer la derivee automatiquement.
+*/
 void GeneralXi2::SetDeltaParm(int numPar, double d)
-//
-//	Definition de la variation du parametre numPar
-//	pour calculer la derivee automatiquement.
-//--
 {
  ASSERT(numPar >= 0 && numPar < mNPar);
@@ -310,26 +250,11 @@
 }
 
-//++
+/*!
+  Idem precedente fonction mais pour tous les parametres.
+*/
 void GeneralXi2::SetDeltaParm(double const* dparam)
-//
-//	Idem precedente fonction mais pour tous les parametres.
-//--
 {
  for(int i=0;i<mNPar;i++) deltaParm[i] = dparam[i];
 }
-
-//////////////////////////////////////////////////////////////////////
-// Rappel des inline functions pour commentaires
-//++
-// virtual double Value(GeneralFitData& data, double const* parm, int& ndataused)=0;
-//	Valeur du Xi2 a definir par l'utilisateur (fct virtuelle pure)
-//	a partir des donnees de `data'. l'utilisateur doit egalement
-//	retourner le nombre de points de mesure utilises dans le calcul
-//	du Xi2 (`ndataused').
-//--
-//++
-// inline int     NPar() const
-//	Retourne le nombre de parametres Ai.
-//--
 
 //================================================================
@@ -338,19 +263,9 @@
 //                                Christophe 8/11/93 La Silla
 //                                re-codage C++ 16/01/96 Saclay
-
-//++
-// Class	GeneralFit
-// Lib		Outils++
-// include	generalfit.h
-//
-//	Classe de fit d'une GeneralFunction sur une GeneralFitData
-//--
-
-//////////////////////////////////////////////////////////////////////
-//++
+//////////////////////////////////////////////////////////////////////
+/*!
+  Creation d'une classe de fit pour la `GeneralFunction f'.
+*/
 GeneralFit::GeneralFit(GeneralFunction* f)
-//
-//	Creation d'une classe de fit pour la `GeneralFunction f'.
-//--
   : mNVar         (f->NVar()),
     mNPar         (f->NPar()),
@@ -385,15 +300,14 @@
 }
 
-//++
+/*!
+  Creation d'une classe de fit pour le `GeneralXi2 f'.
+  L'emploi de cette methode n'est pas conseillee car elle
+  calcule automatiquement la derivee 2sd du Xi2 par rapport
+  aux parametres, ce qui entraine un manque de robustesse
+  et qui ne garanti pas que la matrice de covariance soit
+  definie positive (il est possible de surecrire
+  la methode virtuelle Derivee2 pour palier ce probleme).
+*/
 GeneralFit::GeneralFit(GeneralXi2* f)
-//
-//	Creation d'une classe de fit pour le `GeneralXi2 f'.
-//	L'emploi de cette methode n'est pas conseillee car elle
-//	calcule automatiquement la derivee 2sd du Xi2 par rapport
-//	aux parametres, ce qui entraine un manque de robustesse
-//	et qui ne garanti pas que la matrice de covariance soit
-//	definie positive (il est possible de surecrire
-//	la methode virtuelle Derivee2 pour palier ce probleme).
-//--
   : mNVar         (0),
     mNPar         (f->NPar()),
@@ -485,8 +399,5 @@
 }
 
-//++
 GeneralFit::~GeneralFit()
-//
-//--
 {
  delete[] fixParam;
@@ -497,9 +408,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour ecrire les iterations dans le fichier filename
+*/
 void GeneralFit::WriteStep(char *filename)
-//
-//	Pour ecrire les iterations dans le fichier filename
-//--
 {
 
@@ -513,10 +423,9 @@
 }
 
-//++
+/*!
+  Niveau de debug
+  (voir aussi la variable d'environnement PDEBUG_GENERALFIT).
+*/
 void GeneralFit::SetDebug(int level)
-//
-//	Niveau de debug
-//	(voir aussi la variable d'environnement PDEBUG_GENERALFIT).
-//--
 {
  debugLevel = ( level < 0 ) ? 0: level;
@@ -524,9 +433,8 @@
 }
 
-//++
+/*!
+  Nombre maximum d'iterations permis.
+*/
 void GeneralFit::SetMaxStep(int n)
-//
-//	Nombre maximum d'iterations permis.
-//--
 {
  maxStep = ( n <= 1 ) ? 100: n;
@@ -534,19 +442,17 @@
 }
 
-//++
+/*!
+  Facteur de multiplication/division de Lambda selon
+  que le Chi2 a augmente ou diminue.
+*/
 void GeneralFit::SetLambda_Fac(double fac)
-//
-//	Facteur de multiplication/division de Lambda selon
-//	que le Chi2 a augmente ou diminue.
-//--
 {
   Lambda_Fac = (fac>1.) ? fac : 10.;
 }
 
-//++
+/*!
+  Critere de convergence sur le Chi2.
+*/
 void GeneralFit::SetStopChi2(double s)
-//
-//	Critere de convergence sur le Chi2.
-//--
 {
  stopChi2 = ( s <= 0. ) ? 0.01: s;
@@ -554,9 +460,8 @@
 }
 
-//++
+/*!
+  Precision des calculs (cf \ref GeneralFit_Fit "descriptif general").
+*/
 void GeneralFit::SetEps(double ep)
-//
-//	Precision des calculs (cf descriptif general).
-//--
 {
  ep = (ep<=0.) ? EPS_FIT_MIN: ep;
@@ -565,9 +470,8 @@
 }
 
-//++
+/*!
+  Precision des calculs pour le parametre n.
+*/
 void GeneralFit::SetEps(int n,double ep)
-//
-//	Precision des calculs pour le parametre n.
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -576,14 +480,15 @@
 }
 
-//++
+/*!
+  Critere de convergence sur le nombre de stop en chi2
+  dans le cas ou le chi2 augmente de moins de stopchi2
+  (cf \ref GeneralFit_Fit "descriptif general").
+
+  Si nstopmx<=0, alors ce critere de convergence n'est pas applique.
+
+  Si stopchi2<=0, alors la valeur generale mise par SetStopChi2()
+  est utilisee.
+*/
 void GeneralFit::SetStopMx(int nstopmx,double stopchi2)
-//
-//	Critere de convergence sur le nombre de stop en chi2
-//	dans le cas ou le chi2 augmente de moins de stopchi2
-//	(cf descriptif general).
-//	Si nstopmx<=0, alors ce critere de convergence n'est pas applique.
-//	Si stopchi2<=0, alors la valeur generale mise par SetStopChi2()
-//	est utilisee.
-//--
 {
  nStopMx = (nstopmx>0) ? nstopmx : 0;
@@ -593,11 +498,11 @@
 }
 
-//++
+/*!
+  Critere de convergence sur le nombre de stop en chi2
+  dans le cas ou le chi2 diminue (cf \ref GeneralFit_Fit "descriptif general").
+
+  Si nstopl<=0, alors ce critere de convergence n'est pas applique.
+*/
 void GeneralFit::SetStopLent(int nstoplent)
-//
-//	Critere de convergence sur le nombre de stop en chi2
-//	dans le cas ou le chi2 diminue (cf descriptif general).
-//	Si nstopl<=0, alors ce critere de convergence n'est pas applique.
-//--
 {
  nStopLent = (nstoplent>0) ? nstoplent : 0;
@@ -606,11 +511,10 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour changer la fonction a fitter en cours de route
+  (On ne peut passer d'un fit sur une GeneralFunction
+  a un fit sur un GeneralXi2 sans recreer la classe).
+*/
 void GeneralFit::SetFunction(GeneralFunction* f)
-//
-//	Pour changer la fonction a fitter en cours de route
-//	(On ne peut passer d'un fit sur une GeneralFunction
-//	a un fit sur un GeneralXi2 sans recreer la classe).
-//--
 {
  ASSERT( mFuncXi2  == NULL );
@@ -622,11 +526,10 @@
 }
 
-//++
+/*!
+  Pour changer le Xi2 a fitter en cours de route
+  (On ne peut passer d'un fit sur une GeneralFunction
+  a un fit sur un GeneralXi2 sans recreer la classe).
+*/
 void GeneralFit::SetFuncXi2(GeneralXi2* f)
-//
-//	Pour changer le Xi2 a fitter en cours de route
-//	(On ne peut passer d'un fit sur une GeneralFunction
-//	a un fit sur un GeneralXi2 sans recreer la classe).
-//--
 {
  ASSERT( mFunction == NULL );
@@ -638,9 +541,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour connecter une structure de donnees.
+*/
 void GeneralFit::SetData(GeneralFitData* data)
-//
-//	Pour connecter une structure de donnees.
-//--
 {
  ASSERT( data->NVar()==mNVar );
@@ -652,10 +554,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition du parametre "n" a fitter.
+*/
 void GeneralFit::SetParam(int n,double value,double step
                          ,double min,double max)
-//
-//	Definition du parametre "n" a fitter.
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -679,10 +580,9 @@
 }
 
-//++
+/*!
+  Definition du parametre "n" a fitter
+*/
 void GeneralFit::SetParam(int n, string const& name
                         ,double value,double step,double min,double max)
-//
-//	Definition du parametre "n" a fitter
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -692,9 +592,8 @@
 }
 
-//++
+/*!
+  Definition du parametre "n" a fitter
+*/
 void GeneralFit::SetParam(int n,double value)
-//
-//	Definition du parametre "n" a fitter
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -704,10 +603,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition du pas de depart du parametre "n"
+  Si negatif ou nul, parametre fixe.
+*/
 void GeneralFit::SetStep(int n,double step)
-//
-//	Definition du pas de depart du parametre "n"
-//	Si negatif ou nul, parametre fixe.
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -721,14 +619,13 @@
 }
 
-//++
+/*!
+  Definition du pas minimum `val' pour le parametre `i'
+  pouvant etre utilise dans le calcul automatique des derivees
+  (soit de la fonction, soit du Xi2 selon les parametres du fit).
+  Si nul pas de limite, si negatif alors `EPS(i)' (cf SetEps).
+  Inutile dans le cas ou les derivees sont donnees
+  par l'utilisateur.
+*/
 void GeneralFit::SetMinStepDeriv(int i,double val)
-//
-//	Definition du pas minimum `val' pour le parametre `i'
-//	pouvant etre utilise dans le calcul automatique des derivees
-//	(soit de la fonction, soit du Xi2 selon les parametres du fit).
-//	Si nul pas de limite, si negatif alors `EPS(i)' (cf SetEps).
-//	Inutile dans le cas ou les derivees sont donnees
-//	par l'utilisateur.
-//--
 {
  ASSERT(i>=0 && i<mNPar);
@@ -738,10 +635,9 @@
 }
 
-//++
+/*!
+  Definition du pas minimum `val' pour tout les parametres
+  (voir description SetMinStepDeriv ci-dessus).
+*/
 void GeneralFit::SetMinStepDeriv(double val)
-//
-//	Definition du pas minimum `val' pour tout les parametres
-//	(voir description SetMinStepDeriv ci-dessus).
-//--
 {
  if(debugLevel>0) cout<<"SetMinStepDeriv "<<val<<endl;
@@ -750,10 +646,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition des bornes du parametre "n"
+  Si max<=min, parametre non-borne.
+*/
 void GeneralFit::SetBound(int n, double min, double max)
-//
-//	Definition des bornes du parametre "n"
-//	Si max<=min, parametre non-borne.
-//--
 {
  ASSERT(n>=0 && n<mNPar && max>min);
@@ -770,9 +665,8 @@
 }
 
-//++
+/*!
+  Pour re-borner le parametre "n" aux bornes par defaut
+*/
 void GeneralFit::SetBound(int n)
-//
-//	Pour re-borner le parametre "n" aux bornes par defaut
-//--
 {
  ASSERT(n>=0 && n<mNPar && maxParam(n)>minParam(n));
@@ -780,9 +674,8 @@
 }
 
-//++
+/*!
+  Pour ne plus borner le parametre "n"
+*/
 void GeneralFit::SetUnBound(int n)
-//
-//	Pour ne plus borner le parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -796,9 +689,8 @@
 }
 
-//++
+/*!
+  Pour ne plus borner tous les parametres
+*/
 void GeneralFit::SetUnBound()
-//
-//	Pour ne plus borner tous les parametres
-//--
 {
  for(int i=0;i<mNPar;i++) SetUnBound(i);
@@ -806,9 +698,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour fixer le parametre "n" a la valeur "v"
+*/
 void GeneralFit::SetFix(int n,double v)
-//
-//	Pour fixer le parametre "n" a la valeur "v"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -825,9 +716,8 @@
 }
 
-//++
+/*!
+  Pour fixer le parametre "n" a la valeur par defaut
+*/
 void GeneralFit::SetFix(int n)
-//
-//	Pour fixer le parametre "n" a la valeur par defaut
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -835,9 +725,8 @@
 }
 
-//++
+/*!
+  Pour liberer le parametre "n"
+*/
 void GeneralFit::SetFree(int n)
-//
-//	Pour liberer le parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -855,9 +744,8 @@
 }
 
-//++
+/*!
+  Pour liberer tous les parametres
+*/
 void GeneralFit::SetFree()
-//
-//	Pour liberer tous les parametres
-//--
 {
  for(int i=0;i<mNPar;i++) SetFree(i);
@@ -865,9 +753,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne la valeur du parametre "n"
+*/
 double GeneralFit::GetParm(int n)
-//
-//	Retourne la valeur du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -875,18 +762,16 @@
 }
 
-//++
+/*!
+  Retourne les valeurs des parametres dans un vecteur.
+*/
 Vector GeneralFit::GetParm()
-//
-//	Retourne les valeurs des parametres dans un vecteur.
-//--
 {
 return Param;
 }
 
-//++
+/*!
+  Retourne la valeur de l'erreur du parametre "n"
+*/
 double GeneralFit::GetParmErr(int n)
-//
-//	Retourne la valeur de l'erreur du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -894,9 +779,8 @@
 }
 
-//++
+/*!
+  Retourne la covariance pour les parametre `i' et `j'
+*/
 double GeneralFit::GetCoVar(int i,int j)
-//
-//	Retourne la covariance pour les parametre `i' et `j'
-//--
 {
  ASSERT(i>=0 && i<mNPar && j>=0 && j<mNPar);
@@ -905,9 +789,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne la valeur du pas du parametre "n"
+*/
 double GeneralFit::GetStep(int n)
-//
-//	Retourne la valeur du pas du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -915,9 +798,8 @@
 }
 
-//++
+/*!
+  Retourne la valeur de la borne superieure du parametre "n"
+*/
 double GeneralFit::GetMax(int n)
-//
-//	Retourne la valeur de la borne superieure du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -925,9 +807,8 @@
 }
 
-//++
+/*!
+  Retourne la valeur de la borne inferieure du parametre "n"
+*/
 double GeneralFit::GetMin(int n)
-//
-//	Retourne la valeur de la borne inferieure du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -936,9 +817,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Impression du status du fit
+*/
 void GeneralFit::PrintStatus()
-//
-//	Impression du status du fit
-//--
 {
  cout<<"GeneralFit::PrintStatus"
@@ -962,9 +842,8 @@
 }
 
-//++
+/*!
+  Impression des resultats du fit
+*/
 void GeneralFit::PrintFit()
-//
-//	Impression des resultats du fit
-//--
 {
  cout<<"PrintFit: Chi2="<<Chi2
@@ -978,9 +857,8 @@
 }
 
-//++
+/*!
+  Impression des informations relatives au parametre "n"
+*/
 void GeneralFit::PrintParm(int n)
-//
-//	Impression des informations relatives au parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -999,9 +877,8 @@
 }
 
-//++
+/*!
+  Impression des informations relatives a tous les parametres
+*/
 void GeneralFit::PrintParm()
-//
-//	Impression des informations relatives a tous les parametres
-//--
 {
  cout<<"*** Parametres : fix bnd : par err : step min max : eps dmin\n";
@@ -1011,89 +888,85 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Methode de fit.
+  \anchor GeneralFit_Fit
+  \verbatim
+     Fonction de fit de la fonction f(x,y,z,...:p1,p2,...,pn)
+             sur les donnees x[i],y[i],z[i],...,F[i],ErrF[i]
+     - Methode:   fit des moindres carres dans le cas non lineaire
+     - Reference: Statistical and Computational Methods in Data Analysis
+                 Siegmund Brandt, North-Holland 1970  p 204-206.
+                 Introduction des limites pour la variation des parametres (cmv).
+                 Increment des parametres selon la methode de Levenberg-Marquardt
+     (Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
+      Levenberg-Marquardt Method p683)
+     - Gestion des parametres bornes:
+        si p est un parametre borne entre pmin et pmax, le parametre fitte est q
+        tel que     q = tang((p-C)/D)    ....   p = C + D*atan(q)
+        ou   C = (pmin+pmax)/2.  et   D = (pmax-pmin)/Pi
+        On a  dq = (1+q**2)/D * dp    ....   dp = D/(1+q**2) * dq
+        et    dF/dq = dF/dp * dp/dq = D/(1+q**2) * dF/dp
+              dF/dp = dF/dq * dq/dp = (1+q**2)/D * dF/dp
+                                      ^ q
+                      |               |              *| "tang()"
+                      |               |              *|
+                      |               |              *|
+                      |               |             * |
+                      |               |            *  |
+                      |               |          *    |
+                      |               |       *       |
+                  Pmin|              C|   *           |Pmax
+        --------------|---------------*---------------|--------------> p
+                 -Pi/2|           *   |0              |Pi/2
+                      |       *       |               |
+                      |    *          |               |
+                      |  *            |               |
+                      | *             |               |
+                      |*              |               |
+                      |*              |               |
+                      |*              |               |
+                      <------------------- D --------->
+   
+     - Criteres de convergence, arrets standards:
+       - SOIT: le Chi2 est descendu de moins de stopChi2
+               entre l'iteration n et n+1
+               (stopChi2 est change par SetStopChi2)
+       - SOIT: 1. le chi2 est remonte de moins de stopChi2SMx et
+               2. les parametres libres ont varie de moins de Eps(i)
+                  pendant les nStopmx dernieres iterations
+               Si nStopmx<=0, alors ce critere n'est pas applique (def=3).
+               (nStopmx,stopChi2SMx sont changes par SetStopMx, Eps par SetEps)
+   
+     - Criteres de convergence, arrets par non-convergence:
+       - plus de "maxStep" iterations.
+   
+     - Criteres de convergence, arrets speciaux:
+       - Si l'utilisateur a demande explicitement la methode d'arret
+         "SetStopLent()", arret si :
+           1. le Chi2 est descendu et
+           2. les parametres libres ont varies de moins de Eps
+              pendant les nStopLent dernieres iterations.
+              (nStopLent est change par SetStopLent, Eps par SetEps)
+   
+     - Remarques diverses:
+        Les points avec erreurs <=0 ne sont pas utilises dans le fit.
+        Les bornes des parametres ne peuvent etre atteintes
+     - entrees:
+        la fonction est definie par une classe GeneralFunction
+        les donnees sont passees par une classe GeneralFitData
+        le nombre de parametres et le nombre de variables doivent etre
+           coherents entre GeneralFunction GeneralFitData GeneralFit
+     - Return: 
+          la function elle meme retourne le nombre d'iterations  du fit si succes
+          -1  : si le nombre de degre de liberte est <0
+          -10 : si l'inversion de la matrice des erreurs n'a pas ete possible
+          -11 : si un element diagonal de la matrice des covariances est <=0
+          -20 : si le fit n'a pas converge (nstep>nNstepMX)
+          -100-N : si le parametre "N" est initialise hors limites
+          -200-N : si le parametre "N" atteint sa limite inferieure
+          -300-N : si le parametre "N" atteint sa limite superieure
+  \endverbatim
+*/
 int GeneralFit::Fit()
-//
-//--
-//++
-//|  Fonction de fit de la fonction f(x,y,z,...:p1,p2,...,pn)
-//|          sur les donnees x[i],y[i],z[i],...,F[i],ErrF[i]
-//|  - Methode:   fit des moindres carres dans le cas non lineaire
-//|  - Reference: Statistical and Computational Methods in Data Analysis
-//|              Siegmund Brandt, North-Holland 1970  p 204-206.
-//|              Introduction des limites pour la variation des parametres (cmv).
-//|              Increment des parametres selon la methode de Levenberg-Marquardt
-//|  (Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
-//|   Levenberg-Marquardt Method p683)
-//--
-//++
-//|  - Gestion des parametres bornes:
-//|     si p est un parametre borne entre pmin et pmax, le parametre fitte est q
-//|     tel que     q = tang((p-C)/D)    ....   p = C + D*atan(q)
-//|     ou   C = (pmin+pmax)/2.  et   D = (pmax-pmin)/Pi
-//|     On a  dq = (1+q**2)/D * dp    ....   dp = D/(1+q**2) * dq
-//|     et    dF/dq = dF/dp * dp/dq = D/(1+q**2) * dF/dp
-//|           dF/dp = dF/dq * dq/dp = (1+q**2)/D * dF/dp
-//|                                   ^ q
-//|                   |               |              *| "tang()"
-//|                   |               |              *|
-//|                   |               |              *|
-//|                   |               |             * |
-//|                   |               |            *  |
-//|                   |               |          *    |
-//|                   |               |       *       |
-//|               Pmin|              C|   *           |Pmax
-//|     --------------|---------------*---------------|--------------> p
-//|              -Pi/2|           *   |0              |Pi/2
-//|                   |       *       |               |
-//|                   |    *          |               |
-//|                   |  *            |               |
-//|                   | *             |               |
-//|                   |*              |               |
-//|                   |*              |               |
-//|                   |*              |               |
-//|                   <------------------- D --------->
-//--
-//++
-//|  - Criteres de convergence, arrets standards:
-//|    - SOIT: le Chi2 est descendu de moins de stopChi2
-//|            entre l'iteration n et n+1
-//|            (stopChi2 est change par SetStopChi2)
-//|    - SOIT: 1. le chi2 est remonte de moins de stopChi2SMx et
-//|            2. les parametres libres ont varie de moins de Eps(i)
-//|               pendant les nStopmx dernieres iterations
-//|            Si nStopmx<=0, alors ce critere n'est pas applique (def=3).
-//|            (nStopmx,stopChi2SMx sont changes par SetStopMx, Eps par SetEps)
-//|
-//|  - Criteres de convergence, arrets par non-convergence:
-//|    - plus de "maxStep" iterations.
-//|
-//|  - Criteres de convergence, arrets speciaux:
-//|    - Si l'utilisateur a demande explicitement la methode d'arret
-//|      "SetStopLent()", arret si :
-//|        1. le Chi2 est descendu et
-//|        2. les parametres libres ont varies de moins de Eps
-//|           pendant les nStopLent dernieres iterations.
-//|           (nStopLent est change par SetStopLent, Eps par SetEps)
-//|
-//--
-//++
-//|  - Remarques diverses:
-//|     Les points avec erreurs <=0 ne sont pas utilises dans le fit.
-//|     Les bornes des parametres ne peuvent etre atteintes
-//|  - entrees:
-//|     la fonction est definie par une classe GeneralFunction
-//|     les donnees sont passees par une classe GeneralFitData
-//|     le nombre de parametres et le nombre de variables doivent etre
-//|        coherents entre GeneralFunction GeneralFitData GeneralFit
-//|  - Return: 
-//|       la function elle meme retourne le nombre d'iterations  du fit si succes
-//|       -1  : si le nombre de degre de liberte est <0
-//|       -10 : si l'inversion de la matrice des erreurs n'a pas ete possible
-//|       -11 : si un element diagonal de la matrice des covariances est <=0
-//|       -20 : si le fit n'a pas converge (nstep>nNstepMX)
-//|       -100-N : si le parametre "N" est initialise hors limites
-//|       -200-N : si le parametre "N" atteint sa limite inferieure
-//|       -300-N : si le parametre "N" atteint sa limite superieure
-//--
 {
  volatile double oldChi2;
@@ -1385,12 +1258,11 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Recalcul du Chi2 a partir des parametres courants (`par==NULL')
+  ou a partir du tableau de parametres `par'.
+  Retourne le chi2 et le nombre de degres de liberte.
+  Si nddl<0 probleme.
+*/
 double GeneralFit::ReCalChi2(int& nddl, double *par)
-//
-//	Recalcul du Chi2 a partir des parametres courants (`par==NULL')
-//	ou a partir du tableau de parametres `par'.
-//	Retourne le chi2 et le nombre de degres de liberte.
-//	Si nddl<0 probleme.
-//--
 {
 double c2 = -1.;
@@ -1430,15 +1302,14 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne une structure ``GeneralFitData'' contenant
+  les residus du fit (val-func) pour les points du fit.
+  Si ``clean'' est ``true''
+  seules les donnees valides de ``data'' sont copiees.
+  Si ``clean'' est ``false'' (defaut) toutes les donnees
+  sont copiees et la taille totale de ``data'' est allouee
+  meme si elle est plus grande que la taille des donnees stoquees.
+*/
 GeneralFitData GeneralFit::DataResidus(bool clean)
-//
-//	Retourne une structure ``GeneralFitData'' contenant
-//	les residus du fit (val-func) pour les points du fit.
-//	Si ``clean'' est ``true''
-//	seules les donnees valides de ``data'' sont copiees.
-//	Si ``clean'' est ``false'' (defaut) toutes les donnees
-//	sont copiees et la taille totale de ``data'' est allouee
-//	meme si elle est plus grande que la taille des donnees stoquees.
-//--
 {
 if(!mData || !mFunction)
@@ -1451,11 +1322,10 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne une structure ``GeneralFitData'' contenant
+  les valeurs de la fonction fittee pour les points du fit.
+  (voir commentaires pour ``clean'' dans ``DataResidus'')
+*/
 GeneralFitData GeneralFit::DataFunction(bool clean)
-//
-//	Retourne une structure ``GeneralFitData'' contenant
-//	les valeurs de la fonction fittee pour les points du fit.
-//	(voir commentaires pour ``clean'' dans ``DataResidus'')
-//--
 {
 if(!mData || !mFunction)
@@ -1468,10 +1338,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Imprime le commentaire lie a l'erreur rc retournee par Fit()
+  (voir le commentaire de la methode `Fit()')
+*/
 void GeneralFit::PrintFitErr(int rc)
-//
-//	Imprime le commentaire lie a l'erreur rc retournee par Fit()
-//	(voir le commentaire de la methode `Fit()')
-//--
 {
 int n;
@@ -1632,7 +1501,11 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  C = (min+max)/2
+  D = (max-min)/Pi
+  \endverbatim
+*/
 void GeneralFit::Set_Bound_C_D(int i)
-// C = (min+max)/2
-// D = (max-min)/Pi
 {
   // ASSERT(i>=0 && i<mNPar);
@@ -1656,6 +1529,10 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  tr = tan( (p-C)/D )
+  \endverbatim
+*/
 double GeneralFit::p_vers_tr(int i,double p)
-// tr = tan( (p-C)/D )
 {
  // ASSERT(i>=0 && i<mNPar);
@@ -1687,6 +1564,10 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  p = C+D*atan(tr)
+  \endverbatim
+*/
 double GeneralFit::tr_vers_p(int i,double tr)
-// p = C+D*atan(tr)
 {
  // ASSERT(i>=0 && i<mNPar);
@@ -1718,7 +1599,11 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  dtr = (1+tr**2)/D * dp = (1+tan( (p-C)/D )**2)/D * dp = coeff * dp
+  attention: df/dp = (1+tr**2)/D * dF/dtr = coeff * dF/dtr
+  \endverbatim
+*/
 double GeneralFit::c_dp_vers_dtr(int i,double tr)
-// dtr = (1+tr**2)/D * dp = (1+tan( (p-C)/D )**2)/D * dp = coeff * dp
-// attention: df/dp = (1+tr**2)/D * dF/dtr = coeff * dF/dtr
 {
  // ASSERT(i>=0 && i<mNPar);
@@ -1750,7 +1635,11 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  dp = D/(1+tr**2) * dtr = coeff * dtr
+  attention: df/dtr = D/(1+tr**2) * dF/dp = coeff * dF/dp
+  \endverbatim
+*/
 double GeneralFit::c_dtr_vers_dp(int i,double tr)
-// dp = D/(1+tr**2) * dtr = coeff * dtr
-// attention: df/dtr = D/(1+tr**2) * dF/dp = coeff * dF/dp
 {
   // ASSERT(i>=0 && i<mNPar);
@@ -1776,10 +1665,14 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  1-/ Redefinit dp pour qu'il soit superieur a minStepDeriv
+  2-/ Redefinit dp pour que p+/-dp reste dans les limites (parametre borne)
+  Si hors limites alors:
+      p-dp <= min_p : dp = (p-min_p)*dist
+      p+dp >= max_p : dp = (max_p-p)*dist
+  \endverbatim
+*/
 int GeneralFit::put_in_limits_for_deriv(Vector const& p,Vector& dp,double dist)
-// 1-/ Redefinit dp pour qu'il soit superieur a minStepDeriv
-// 2-/ Redefinit dp pour que p+/-dp reste dans les limites (parametre borne)
-// Si hors limites alors:
-//     p-dp <= min_p : dp = (p-min_p)*dist
-//     p+dp >= max_p : dp = (max_p-p)*dist
 {
  int nchanged = 0;
@@ -1826,57 +1719,2 @@
 }
 
-
-//////////////////////////////////////////////////////////////////////
-// Rappel des inline functions pour commentaires
-//++
-// inline double   GetChi2()
-//	Retourne le Chi2
-//--
-//++
-// inline double   GetChi2Red() const
-//	Retourne le Chi2 reduit
-//--
-//++
-// inline int      GetNddl()    const
-//	Retourne le nombre de degres de liberte
-//--
-//++
-// inline int      GetNStep()   const
-//	Retourne le nombre d'iterations
-//--
-//++
-// inline int      GetNVar()    const
-//	Retourne le nombre de variables
-//--
-//++
-// inline int      GetNPar()    const
-//	Retourne le nombre de parametres
-//--
-//++
-// inline int      GetNFree()   const
-//	Retourne le nombre de parametres libres
-//--
-//++
-// inline int      GetNBound()  const
-//	Retourne le nombre de parametres bornes
-//--
-//++
-// inline int      GetNStop()   const
-//	Retourne le nstop de convergence
-//--
-//++
-// inline int      GetNStopLent()   const
-//	Retourne le nstop de convergence lente.
-//--
-//++
-// inline double   GetEps(int i)
-//	Retourne la precision de convergence pour le parametre i.
-//--
-//++
-// inline GeneralFunction*  GetFunction()
-//	Retourne le pointeur sur la GeneralFunction utilisee.
-//--
-//++
-// inline GeneralFitData*   GetGData()
-//	Retourne le pointeur sur la GeneralFitData utilisee.
-//--
