Index: /trunk/SophyaLib/HiStats/hisprof.cc
===================================================================
--- /trunk/SophyaLib/HiStats/hisprof.cc	(revision 913)
+++ /trunk/SophyaLib/HiStats/hisprof.cc	(revision 914)
@@ -6,22 +6,10 @@
 #include "perrors.h"
 
-//++
-// Class	HProf
-// Lib	Outils++ 
-// include	hisprof.h
-//
-//	Classe de profil d'histogrammes.
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-/********* Methode *********/
-//++
+
+/********* Methode *********/
+/*!
+  Constructeur par defaut.
+*/
 HProf::HProf()
-//
-//	Constructeur par defaut.
-//--
 : Histo()
 , SumY(NULL), SumY2(NULL), SumW(NULL), Ok(false), YMin(1.), YMax(-1.), Opt(0)
@@ -31,13 +19,12 @@
 
 /********* Methode *********/
-//++
+/*!
+  Constructeur. Histogramme de profil de ``nBin'' bins entre ``xMin''
+  et ``xMax'' avec coupure d'acceptance sur y entre ``yMin'' et ``yMax''.
+  Si yMin>=yMax alors pas de coupure d'acceptance sur y.
+  Par defaut l'erreur du profil represente la dispersion dans le bin,
+  SetErrOpt(1) permet de demander de calculer l'erreur sur la moyenne.
+*/
 HProf::HProf(float xMin, float xMax, int nBin, float yMin, float yMax)
-//
-//	Constructeur. Histogramme de profil de ``nBin'' bins entre ``xMin''
-//	et ``xMax'' avec coupure d'acceptance sur y entre ``yMin'' et ``yMax''.
-//	Si yMin>=yMax alors pas de coupure d'acceptance sur y.
-//	Par defaut l'erreur du profil represente la dispersion dans le bin,
-//	SetErrOpt(1) permet de demander de calculer l'erreur sur la moyenne.
-//--
 : Histo(xMin,xMax,nBin)
 , SumY(new double[nBin]), SumY2(new double[nBin]), SumW(new double[nBin])
@@ -50,9 +37,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Constructeur par copie.
+*/
 HProf::HProf(const HProf& H)
-//
-//	Constructeur par copie.
-//--
 : Histo(H)
 , SumY(new double[H.bins]), SumY2(new double[H.bins]), SumW(new double[H.bins])
@@ -66,4 +52,7 @@
 
 /********* Methode *********/
+/*!
+  Des-allocation
+*/
 void HProf::Delete()
 {
@@ -75,4 +64,7 @@
 
 /********* Methode *********/
+/*!
+  Destructeur
+*/
 HProf::~HProf()
 {
@@ -80,14 +72,9 @@
 }
 
-//++
-// Titre	Methodes
-//--
-
-/********* Methode *********/
-//++
+/********* Methode *********/
+/*!
+  Remise a zero
+*/
 void HProf::Zero()
-//
-//	Remise a zero
-//--
 {
   memset(SumY,  0, bins*sizeof(double));
@@ -99,18 +86,19 @@
 
 /********* Methode *********/
-//++
+/*!
+  Pour changer l'option de calcul de l'erreur du profile.
+  Si ``spread'' = true alors l'erreur represente la dispersion
+  des donnees dans le bin, si = false elle represente l'erreur
+  sur la moyenne du bin.
+  \verbatim
+    - Pour le bin (j):
+    H(j) = sum(y), E(j) = sum(y^2), L(j) = sum(w)
+    ->  s(j) = sqrt(E(j)/L(j) - (H(j)/L(j))^2)  dispersion
+    ->  e(j) = s(j)/sqrt(L(j)) erreur sur la moyenne
+    spread=true:  opt=0 : dispersion des donnees dans le bin = s(j)
+    spread=false: opt=1 : erreur sur la moyenne du bin = e(j)
+  \endverbatim
+*/
 void HProf::SetErrOpt(bool spread)
-//
-//	Pour changer l'option de calcul de l'erreur du profile.
-//	Si ``spread'' = true alors l'erreur represente la dispersion
-//	des donnees dans le bin, si = false elle represente l'erreur
-//	sur la moyenne du bin.
-//| - Pour le bin (j):
-//| H(j) = sum(y), E(j) = sum(y^2), L(j) = sum(w)
-//| ->  s(j) = sqrt(E(j)/L(j) - (H(j)/L(j))^2)  dispersion
-//| ->  e(j) = s(j)/sqrt(L(j)) erreur sur la moyenne
-//| spread=true:  opt=0 : dispersion des donnees dans le bin = s(j)
-//| spread=false: opt=1 : erreur sur la moyenne du bin = e(j)
-//--
 {
 int opt = (spread) ? 0 : 1;
@@ -119,17 +107,16 @@
 
 /********* Methode *********/
-//++
+/*!
+  Pour mettre a jour l'histogramme de profil.
+  Il est important d'appeler cette methode si on veut
+  utiliser les methodes de la classe Histo qui ne sont
+  pas redefinies dans la classe HProf.
+  En effet, pour des raisons de precision la classe
+  HProf travaille avec des tableaux en double precision
+  et seulement au moment ou l'on a besoin de l'histogramme
+  ce dernier est rempli avec les valeurs demandees (moyenne
+  et dispersion/erreur sur la moyenne).
+*/
 void HProf::UpdateHisto() const
-//
-//	Pour mettre a jour l'histogramme de profil.
-//	Il est important d'appeler cette methode si on veut
-//	utiliser les methodes de la classe Histo qui ne sont
-//	pas redefinies dans la classe HProf.
-//	En effet, pour des raisons de precision la classe
-//	HProf travaille avec des tableaux en double precision
-//	et seulement au moment ou l'on a besoin de l'histogramme
-//	ce dernier est rempli avec les valeurs demandees (moyenne
-//	et dispersion/erreur sur la moyenne).
-//--
 {
 
@@ -153,9 +140,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Addition au contenu de l'histo pour abscisse x de la valeur y et poids w
+*/
 void HProf::Add(float x, float y, float w)
-//
-//	Addition au contenu de l'histo pour abscisse x de la valeur y et poids w
-//--
 {
   if(YMax>YMin && (y<YMin || YMax<y)) return;
@@ -174,9 +160,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Addition au contenu de l'histo bin numBin de la valeur y poids w
+*/
 void HProf::AddBin(int numBin, float y, float w)
-//
-//	Addition au contenu de l'histo bin numBin de la valeur y poids w
-//--
 {
   if(YMax>YMin && (y<YMin || YMax<y)) return;
@@ -194,8 +179,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H = H1
+*/
 HProf& HProf::operator = (const HProf& h)
-//
-//--
 {
 if(this == &h) return *this;
@@ -218,11 +203,12 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H += H1
+
+  Attention dans cette addition il n'y a pas de gestion
+  des YMin et YMax. L'addition est faite meme si les limites
+  en Y de ``a'' sont differentes de celles de ``this''.
+*/
 HProf& HProf::operator += (const HProf& a)
-//
-//	Attention dans cette addition il n'y a pas de gestion
-//	des YMin et YMax. L'addition est faite meme si les limites
-//	en Y de ``a'' sont differentes de celles de ``this''.
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -240,9 +226,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H = H1 + H2
+  Meme commentaire que pour l'operateur +=
+*/
 HProf operator + (const HProf& a, const HProf& b)
-//
-//	Meme commentaire que pour l'operateur +=
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -250,47 +236,4 @@
 return (c += b);
 }
-
-// Rappel des inlines functions pour commentaires
-//++
-//   inline Histo GetHisto()
-//	Retourne l'histogramme de profil.
-//--
-//++
-// inline void GetMean(Vector& v)
-//	Retourne le contenu de la moyenne dans le vecteur v
-//--
-//++
-// inline void GetError2(Vector& v)
-//	Retourne le contenu au carre de la dispersion/erreur dans le vecteur v
-//--
-//++
-// inline float operator()(int i) const
-//	Retourne le contenu du bin i
-//--
-//++
-// inline float Error2(int i) const
-//	Retourne le carre de la dispersion/erreur du bin i
-//--
-//++
-// inline float Error(int i) const
-//	Retourne la dispersion/erreur du bin i
-//--
-//++
-// inline int Fit(GeneralFit& gfit)
-//	Fit du profile par ``gfit''.
-//--
-//++
-// inline Histo* FitResidus(GeneralFit& gfit)
-//	Retourne l'Histogramme des residus par ``gfit''.
-//--
-//++
-// inline Histo* FitFunction(GeneralFit& gfit)
-//	Retourne l'Histogramme de la fonction fittee par ``gfit''.
-//--
-//++
-// inline void Print(int dyn,float hmin,float hmax,int pflag,int il,int ih)
-//	Print, voir detail dans Histo::Print
-//--
-
 
 ///////////////////////////////////////////////////////////
Index: /trunk/SophyaLib/HiStats/hisprof.h
===================================================================
--- /trunk/SophyaLib/HiStats/hisprof.h	(revision 913)
+++ /trunk/SophyaLib/HiStats/hisprof.h	(revision 914)
@@ -10,4 +10,7 @@
 namespace SOPHYA {
 
+/*!
+  Classe de profil d'histogrammes.
+*/
 class HProf : public Histo {
   friend class ObjFileIO<HProf>;
@@ -28,9 +31,15 @@
   
   // Acces a l information
+  //! Retourne l'histogramme de profil.
   inline Histo GetHisto() {if(!Ok) UpdateHisto(); return (Histo) *this;}
+  //! Retourne le contenu de la moyenne dans le vecteur v
   inline void GetMean(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);}
+  //! Retourne le contenu au carre de la dispersion/erreur dans le vecteur v
   inline void GetError2(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetError2(v);}
+  //! Retourne le contenu du bin i
   inline float operator()(int i) const {if(!Ok) UpdateHisto(); return data[i];}
+  //! Retourne le carre de la dispersion/erreur du bin i
   inline float Error2(int i) const {if(!Ok) UpdateHisto(); return (float) err2[i];}
+  //! Retourne la dispersion/erreur du bin i
   inline float Error(int i) const
          {if(!Ok) UpdateHisto(); return err2[i]>0. ? (float) sqrt(err2[i]) : 0.f;}
@@ -42,12 +51,16 @@
 
   // Fit
+  //! Fit du profile par ``gfit''.
   inline int    Fit(GeneralFit& gfit)
          {if(!Ok) UpdateHisto(); return Histo::Fit(gfit,0);}
+  //! Retourne l'Histogramme des residus par ``gfit''.
   inline Histo  FitResidus(GeneralFit& gfit)
          {if(!Ok) UpdateHisto(); return Histo::FitResidus(gfit);}
+  //! Retourne l'Histogramme de la fonction fittee par ``gfit''.
   inline Histo  FitFunction(GeneralFit& gfit)
          {if(!Ok) UpdateHisto(); return Histo::FitFunction(gfit);}
 
   // Print
+  //! Print, voir detail dans Histo::Print
   inline void Print(int dyn=100,float hmin=1.,float hmax=-1.,int pflag=0,int il=1,int ih=-1)
                            {if(!Ok) UpdateHisto(); Histo::Print(dyn,hmin,hmax,pflag,il,ih);}
@@ -56,11 +69,11 @@
   void Delete();
 
-  double*        SumY;
-  double*        SumY2;
-  double*        SumW;
-  bool           Ok;
-  float          YMin;
-  float          YMax;
-  uint_2         Opt;
+  double*        SumY;  //!< somme
+  double*        SumY2; //!< somme des carres
+  double*        SumW;  //!< somme des poids
+  bool           Ok;    //!< true isiupdate fait
+  float          YMin;  //!< limite minimum Y pour somme
+  float          YMax;  //!< limite maximum Y pour somme
+  uint_2         Opt;   //!< options pour les erreurs
 };
 
Index: /trunk/SophyaLib/HiStats/histos.cc
===================================================================
--- /trunk/SophyaLib/HiStats/histos.cc	(revision 913)
+++ /trunk/SophyaLib/HiStats/histos.cc	(revision 914)
@@ -1,4 +1,4 @@
 //
-// $Id: histos.cc,v 1.1.1.1 2000-03-02 16:51:32 ansari Exp $
+// $Id: histos.cc,v 1.2 2000-04-13 16:04:11 ansari Exp $
 //
 
@@ -13,21 +13,7 @@
 #include "generalfit.h"
 
-//++
-// Class	Histo
-// Lib	Outils++ 
-// include	histos.h
-//
-//	Classe d'histogrammes 1D
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-/********* Methode *********/
-//++
+/********* Methode *********/
+/*! Constructeur par defaut */
 Histo::Histo()
-//
-//--
 : data(NULL), err2(NULL),
   under(0), over(0), nHist(0), nEntries(0),
@@ -39,8 +25,6 @@
 
 /********* Methode *********/
-//++
+/*! Constructeur d'un histo de nBin bins allant de xMin a xMax */
 Histo::Histo(float xMin, float xMax, int nBin)
-//
-//--
 : data(new float[nBin]), err2(NULL),
   under(0), over(0), nHist(0), nEntries(0),
@@ -53,8 +37,6 @@
 
 /********* Methode *********/
-//++
+/*! Constructeur par copie */
 Histo::Histo(const Histo& H)
-//
-//--
 : data(new float[H.bins]), err2(NULL),
   under(H.under), over(H.over), nHist(H.nHist), nEntries(H.nEntries),
@@ -71,4 +53,5 @@
 
 /********* Methode *********/
+/*! Gestion de la des-allocation */
 void Histo::Delete()
 {
@@ -81,4 +64,5 @@
 
 /********* Methode *********/
+/*! Destructeur */
 Histo::~Histo()
 {
@@ -86,14 +70,9 @@
 }
 
-//++
-// Titre	Methodes
-//--
-
-/********* Methode *********/
-//++
+/********* Methode *********/
+/*!
+  Remise a zero
+*/
 void Histo::Zero()
-//
-//	Remise a zero
-//--
 {
   memset(data, 0, bins*sizeof(float));
@@ -105,9 +84,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Pour avoir le calcul des erreurs
+*/
 void Histo::Errors()
-//
-//	Pour avoir le calcul des erreurs
-//--
 {
  if( bins > 0 ) {
@@ -118,8 +96,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur egal
+*/
 Histo& Histo::operator = (const Histo& h)
-//
-//--
 {
   if(this == &h) return *this;
@@ -145,8 +123,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur de multiplication par une constante
+*/
 Histo& Histo::operator *= (double b)
-//
-//--
 {
 double b2 = b*b;
@@ -162,8 +140,8 @@
 }
 
-//++
+/*!
+  Operateur de division par une constante
+*/
 Histo& Histo::operator /= (double b)
-//
-//--
 {
 if (b==0.) THROW(inconsistentErr);
@@ -180,8 +158,8 @@
 }
 
-//++
+/*!
+  Operateur d'addition d'une constante
+*/
 Histo& Histo::operator += (double b)
-//
-//--
 {
 for(int i=0;i<bins;i++) data[i] += b;
@@ -193,8 +171,8 @@
 }
 
-//++
+/*!
+  Operateur de soustraction d'une constante
+*/
 Histo& Histo::operator -= (double b)
-//
-//--
 {
 for(int i=0;i<bins;i++) data[i] -= b;
@@ -207,8 +185,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H2 = H1 * b
+*/
 Histo operator * (const Histo& a, double b)
-//
-//--
 {
   Histo result(a);
@@ -216,8 +194,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b * H1
+*/
 Histo operator * (double b, const Histo& a)
-//
-//--
 {
   Histo result(a);
@@ -225,8 +203,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 / b
+*/
 Histo operator / (const Histo& a, double b)
-//
-//--
 {
   Histo result(a);
@@ -234,8 +212,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 + b
+*/
 Histo operator + (const Histo& a, double b)
-//
-//--
 {
   Histo result(a);
@@ -243,8 +221,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b + H1
+*/
 Histo operator + (double b, const Histo& a)
-//
-//--
 {
   Histo result(a);
@@ -252,8 +230,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 - b
+*/
 Histo operator - (const Histo& a, double b)
-//
-//--
 {
   Histo result(a);
@@ -261,8 +239,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b - H1
+*/
 Histo operator - (double b, const Histo& a)
-//
-//--
 {
   Histo result(a);
@@ -272,8 +250,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H += H1
+*/
 Histo& Histo::operator += (const Histo& a)
-//
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -291,8 +269,8 @@
 }
 
-//++
+/*!
+  Operateur H -= H1
+*/
 Histo& Histo::operator -= (const Histo& a)
-//
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -310,8 +288,8 @@
 }
 
-//++
+/*!
+  Operateur H *= H1
+*/
 Histo& Histo::operator *= (const Histo& a)
-//
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -331,8 +309,8 @@
 }
 
-//++
+/*!
+  Operateur H /= H1
+*/
 Histo& Histo::operator /= (const Histo& a)
-//
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -359,8 +337,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H = H1 + H2
+*/
 Histo operator + (const Histo& a, const Histo& b)
-//
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -369,8 +347,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 - H2
+*/
 Histo operator - (const Histo& a, const Histo& b)
-//
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -379,8 +357,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 * H2
+*/
 Histo operator * (const Histo& a, const Histo& b)
-//
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -389,8 +367,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 / H2
+*/
 Histo operator / (const Histo& a, const Histo& b)
-//
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -400,9 +378,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage d'un tableau avec la valeur des abscisses
+*/
 void Histo::GetAbsc(Vector &v)
-//
-//	Remplissage d'un tableau avec la valeur des abscisses
-//--
 {
 v.Realloc(bins);
@@ -411,9 +388,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec la valeur du contenu
+*/
 void Histo::GetValue(Vector &v)
-//
-//	Remplissage d'un tableau avec la valeur du contenu
-//--
 {
 v.Realloc(bins);
@@ -422,9 +398,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec la valeur des erreurs au carre
+*/
 void Histo::GetError2(Vector &v)
-//
-//	Remplissage d'un tableau avec la valeur des erreurs au carre
-//--
 {
 v.Realloc(bins);
@@ -434,9 +409,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec la valeur des erreurs
+*/
 void Histo::GetError(Vector &v)
-//
-//	Remplissage d'un tableau avec la valeur des erreurs
-//--
 {
 v.Realloc(bins);
@@ -447,9 +421,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage du contenu de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutValue(Vector &v, int ierr)
-//
-//	Remplissage du contenu de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -461,9 +434,8 @@
 }
 
-//++
+/*!
+  Addition du contenu de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutValueAdd(Vector &v, int ierr)
-//
-//	Addition du contenu de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -475,9 +447,8 @@
 }
 
-//++
+/*!
+  Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutError2(Vector &v)
-//
-//	Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -487,9 +458,8 @@
 }
 
-//++
+/*!
+  Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutError2Add(Vector &v)
-//
-//	Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -499,9 +469,8 @@
 }
 
-//++
+/*!
+  Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutError(Vector &v)
-//
-//	Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -513,9 +482,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Addition du contenu de l'histo pour abscisse x poids w
+*/
 void Histo::Add(float x, float w)
-//
-//	Addition du contenu de l'histo pour abscisse x poids w
-//--
 {
   int numBin = FindBin(x);
@@ -531,9 +499,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Addition du contenu de l'histo bin numBin poids w
+*/
 void Histo::AddBin(int numBin, float w)
-//
-//	Addition du contenu de l'histo bin numBin poids w
-//--
 {
   if (numBin<0) under += w;
@@ -548,9 +515,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage du contenu de l'histo pour abscisse x poids w
+*/
 void Histo::SetBin(float x, float w)
-//
-//	Remplissage du contenu de l'histo pour abscisse x poids w
-//--
 {
   int numBin = FindBin(x);
@@ -559,9 +525,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage du contenu de l'histo pour numBin poids w
+*/
 void Histo::SetBin(int numBin, float w)
-//
-//	Remplissage du contenu de l'histo pour numBin poids w
-//--
 {
   if (numBin<0) under = w;
@@ -575,9 +540,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage des erreurs au carre pour abscisse x
+*/
 void Histo::SetErr2(float x, double e2)
-//
-//	Remplissage des erreurs au carre pour abscisse x
-//--
 {
   int numBin = FindBin(x);
@@ -586,9 +550,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage des erreurs au carre pour numBin poids
+*/
 void Histo::SetErr2(int numBin, double e2)
-//
-//	Remplissage des erreurs au carre pour numBin poids
-//--
 {
   if( err2==NULL) return;
@@ -598,9 +561,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage des erreurs pour abscisse x
+*/
 void Histo::SetErr(float x, float e)
-//
-//	Remplissage des erreurs pour abscisse x
-//--
 {
 SetErr2(x, (double) e*e);
@@ -608,9 +570,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage des erreurs pour numBin
+*/
 void Histo::SetErr(int numBin, float e)
-//
-//	Remplissage des erreurs pour numBin
-//--
 {
 SetErr2(numBin, (double) e*e);
@@ -618,9 +579,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Numero du bin ayant le contenu maximum
+*/
 int Histo::IMax() const
-//
-//	Numero du bin ayant le contenu maximum
-//--
 {
   int imx=0;
@@ -633,9 +593,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Numero du bin ayant le contenu minimum
+*/
 int Histo::IMin() const
-//
-//	Numero du bin ayant le contenu minimum
-//--
 {
   int imx=0;
@@ -648,9 +607,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur le contenu maximum
+*/
 float Histo::VMax() const
-//
-//	Valeur le contenu maximum
-//--
 {
   float mx=data[0];
@@ -661,9 +619,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur le contenu minimum
+*/
 float Histo::VMin() const
-//
-//	Valeur le contenu minimum
-//--
 {
   float mx=data[0];
@@ -674,9 +631,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur moyenne
+*/
 float Histo::Mean() const
-//
-//	Valeur moyenne
-//--
 {
   double n = 0;
@@ -691,9 +647,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur du sigma
+*/
 float Histo::Sigma() const
-//
-//	Valeur du sigma
-//--
 {
   double n = 0;
@@ -714,9 +669,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne calculee entre les bin il et ih
+*/
 float Histo::MeanLH(int il,int ih) const
-//
-//	Valeur de la moyenne calculee entre les bin il et ih
-//--
 {
   if( ih < il ) { il = 0; ih = bins-1; }
@@ -734,9 +688,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne calculee entre les bin il et ih
+*/
 float Histo::SigmaLH(int il,int ih) const
-//
-//	Valeur de la moyenne calculee entre les bin il et ih
-//--
 {
   if( ih < il ) { il = 0; ih = bins - 1; }
@@ -759,9 +712,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne calculee entre x0-dx et x0+dx
+*/
 float Histo::Mean(float x0, float dx) const
-//
-//	Valeur de la moyenne calculee entre x0-dx et x0+dx
-//--
 {
   double sdata = 0;
@@ -780,9 +732,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur du sigma calcule entre x0-dx et x0+dx
+*/
 float Histo::Sigma(float x0, float dx) const
-//
-//	Valeur du sigma calcule entre x0-dx et x0+dx
-//--
 {
   double sx = 0;
@@ -804,9 +755,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne et du sigma nettoyes
+*/
 float Histo::CleanedMean(float& sigma) const
-//
-//	Valeur de la moyenne et du sigma nettoyes
-//--
 {
   if (!nHist) return 0;
@@ -825,9 +775,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne nettoyee
+*/
 float Histo::CleanedMean() const
-//
-//	Valeur de la moyenne nettoyee
-//--
 {
   if (!nHist) return 0;
@@ -837,9 +786,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Retourne le nombre de bins non-nul
+*/
 int Histo::BinNonNul() const
-//
-//	Retourne le nombre de bins non-nul
-//--
 {
 int non=0;
@@ -849,9 +797,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Retourne le nombre de bins ayant une erreur non-nulle
+*/
 int Histo::ErrNonNul() const
-//
-//	Retourne le nombre de bins ayant une erreur non-nulle
-//--
 {
 if(err2==NULL) return -1;
@@ -862,10 +809,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Renvoie le numero de bin tel que il y ait "per" pourcent entrees
+  entre le bin 0 et ce bin (y compris le contenu de ce bin).
+*/
 int Histo::BinPercent(float per) const
-//
-//	Renvoie le numero de bin tel que il y ait "per" pourcent entrees
-//	entre le bin 0 et ce bin (y compris le contenu de ce bin).
-//--
 {
 double n = nHist*per;
@@ -881,16 +827,17 @@
 
 /********* Methode *********/
-//++
+/*!
+  Renvoie les numeros de bins imin,imax (0=<i<bins) tels que:
+  \verbatim
+       notons I = bin contenant l'abscisse x
+              N1 = nombre d'entrees entre bin 0 et I compris
+              N2 = nombre d'entrees entre bin I et bins-1 compris
+       imin = bin tel que nombre d'entrees entre imin et I = N1 * per
+       imax = bin tel que nombre d'entrees entre I et imax = N2 * per
+     Return: <0 si echec
+             min(I-imin,imax-I) si ok
+  \endverbatim
+*/
 int Histo::BinPercent(float x,float per,int& imin,int& imax)
-//
-//	Renvoie les numeros de bins imin,imax (0=<i<bins) tels que:
-//|    notons I = bin contenant l'abscisse x
-//|           N1 = nombre d'entrees entre bin 0 et I compris
-//|           N2 = nombre d'entrees entre bin I et bins-1 compris
-//|    imin = bin tel que nombre d'entrees entre imin et I = N1 * per
-//|    imax = bin tel que nombre d'entrees entre I et imax = N2 * per
-//|  Return: <0 si echec
-//|          min(I-imin,imax-I) si ok
-//--
 {
 imin = imax = -1;
@@ -917,9 +864,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Idem precedent mais renvoie xmin et xmax
+*/
 int Histo::BinPercent(float x,float per,float& xmin,float& xmax)
-//
-//	Idem precedent mais renvoie xmin et xmax
-//--
 {
 xmin = xmax = 0.;
@@ -931,10 +877,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplace l'histogramme par son integrale normalise a norm:
+  si norm <= 0 : pas de normalisation, integration seule
+*/
 void Histo::HInteg(float norm)
-//
-//	Remplace l'histogramme par son integrale normalise a norm:
-//	si norm <= 0 : pas de normalisation, integration seule
-//--
 {
 if(bins>1)
@@ -952,9 +897,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplace l'histogramme par sa derivee
+*/
 void Histo::HDeriv()
-//
-//	Remplace l'histogramme par sa derivee
-//--
 {
 if( bins <= 1 ) return;
@@ -970,9 +914,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Pour rebinner l'histogramme sur nbinew bins
+*/
 void Histo::HRebin(int nbinew)
-//
-//	Pour rebinner l'histogramme sur nbinew bins
-//--
 {
   if( nbinew <= 0 ) return;
@@ -1023,13 +966,12 @@
 
 /********* Methode *********/
-//++
+/*!
+  Retourne le nombre de maxima locaux, la valeur du maximum (maxi)
+  et sa position (imax), ainsi que la valeur du second maximum
+  local (maxn) et sa position (imaxn).
+  Attention: si un maximum a la meme valeur sur plusieurs bins
+  consecutifs, le bin le plus a droite est pris.
+*/
 int Histo::MaxiLocal(float& maxi,int& imax,float& maxn,int& imaxn)
-//
-//	Retourne le nombre de maxima locaux, la valeur du maximum (maxi)
-//	et sa position (imax), ainsi que la valeur du second maximum
-//	local (maxn) et sa position (imaxn).
-//	Attention: si un maximum a la meme valeur sur plusieurs bins
-//	consecutifs, le bin le plus a droite est pris.
-//--
 {
 int nml = 0;
@@ -1064,11 +1006,10 @@
 
 /********* Methode *********/
-//++
+/*!
+  Fit de la position du maximum de l'histo par un polynome
+  de degre `degree' a `frac' pourcent du maximum.
+  L'histo est suppose etre remplit de valeurs positives
+*/
 float Histo::FitMax(int degree, float frac, int debug) const
-//
-//	Fit de la position du maximum de l'histo par un polynome
-//	de degre `degree' a `frac' pourcent du maximum.
-//	L'histo est suppose etre remplit de valeurs positives
-//--
 {
   if (degree < 2 || degree > 3) degree = 3;
@@ -1200,11 +1141,10 @@
 
 /********* Methode *********/
-//++
+/*!
+  Calcul de la largeur a frac pourcent du maximum
+  autour du bin du maximum.
+  L'histo est suppose etre remplit de valeurs positives
+*/
 float Histo::FindWidth(float frac, int debug) const
-//
-//	Calcul de la largeur a frac pourcent du maximum
-//	autour du bin du maximum.
-//	L'histo est suppose etre remplit de valeurs positives
-//--
 {
   float xmax = BinCenter( IMax() );
@@ -1213,10 +1153,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Calcul de la largeur a frac pourcent de la valeur du bin xmax.
+  L'histo est suppose etre remplit de valeurs positives
+*/
 float Histo::FindWidth(float xmax,float frac, int debug) const
-//
-//	Calcul de la largeur a frac pourcent de la valeur du bin xmax.
-//	L'histo est suppose etre remplit de valeurs positives
-//--
 {
   if (frac <= 0 || frac >= 1.) frac = 0.5;
@@ -1292,9 +1231,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Cf suivant mais im est le bin du maximum de l'histo
+*/
 int Histo::EstimeMax(float& xm,int SzPav)
-//
-//	Cf suivant mais im est le bin du maximum de l'histo
-//--
 {
 int im = IMax();
@@ -1303,15 +1241,16 @@
 
 /********* Methode *********/
-//++
+/*!
+  Determine l'abscisses du maximum donne par im
+  en moyennant dans un pave SzPav  autour du maximum
+  \verbatim
+     Return:
+        0 = si fit maximum reussi avec SzPav pixels
+        1 = si fit maximum reussi avec moins que SzPav pixels
+        2 = si fit maximum echoue et renvoit BinCenter()
+       -1 = si echec: SzPav <= 0 ou im hors limites
+  \endverbatim
+*/
 int Histo::EstimeMax(int& im,float& xm,int SzPav)
-//
-//	Determine l'abscisses du maximum donne par im
-//	en moyennant dans un pave SzPav  autour du maximum
-//|  Return:
-//|     0 = si fit maximum reussi avec SzPav pixels
-//|     1 = si fit maximum reussi avec moins que SzPav pixels
-//|     2 = si fit maximum echoue et renvoit BinCenter()
-//|    -1 = si echec: SzPav <= 0 ou im hors limites
-//--
 {
 xm = 0;
@@ -1341,10 +1280,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Determine la largeur a frac% du maximum a gauche (widthG)
+  et a droite (widthD)
+*/
 void Histo::EstimeWidthS(float frac,float& widthG,float& widthD)
-//
-//	Determine la largeur a frac% du maximum a gauche (widthG)
-//	et a droite (widthD)
-//--
 {
 int i;
@@ -1385,24 +1323,25 @@
 
 //////////////////////////////////////////////////////////
-//++
+/*!
+  Fit de l'histogramme par ``gfit''.
+  \verbatim
+    typ_err = 0 :
+       - erreur attachee au bin si elle existe
+       - sinon 1
+    typ_err = 1 :
+       - erreur attachee au bin si elle existe
+       - sinon max( sqrt(abs(bin) ,1 )
+    typ_err = 2 :
+       - erreur forcee a 1
+    typ_err = 3 :
+       - erreur forcee a max( sqrt(abs(bin) ,1 )
+    typ_err = 4 :
+       - erreur forcee a 1, nulle si bin a zero.
+    typ_err = 5 :
+       - erreur forcee a max( sqrt(abs(bin) ,1 ),
+         nulle si bin a zero.
+  \endverbatim
+*/
 int  Histo::Fit(GeneralFit& gfit,unsigned short typ_err)
-//
-//	Fit de l'histogramme par ``gfit''.
-//| typ_err = 0 :
-//|    - erreur attachee au bin si elle existe
-//|    - sinon 1
-//| typ_err = 1 :
-//|    - erreur attachee au bin si elle existe
-//|    - sinon max( sqrt(abs(bin) ,1 )
-//| typ_err = 2 :
-//|    - erreur forcee a 1
-//| typ_err = 3 :
-//|    - erreur forcee a max( sqrt(abs(bin) ,1 )
-//| typ_err = 4 :
-//|    - erreur forcee a 1, nulle si bin a zero.
-//| typ_err = 5 :
-//|    - erreur forcee a max( sqrt(abs(bin) ,1 ),
-//|      nulle si bin a zero.
-//--
 {
 if(NBins()<=0) return -1000;
@@ -1430,9 +1369,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant les residus du fit ``gfit''.
+*/
 Histo Histo::FitResidus(GeneralFit& gfit)
-//
-//	Retourne une classe contenant les residus du fit ``gfit''.
-//--
 {
 if(NBins()<=0)
@@ -1450,9 +1388,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant la fonction du fit ``gfit''.
+*/
 Histo Histo::FitFunction(GeneralFit& gfit)
-//
-//	Retourne une classe contenant la fonction du fit ``gfit''.
-//--
 {
 if(NBins()<=0)
@@ -1471,22 +1408,23 @@
 
 /********* Methode *********/
-//++
+/*!
+  Impression de l'histogramme dans le fichier fp
+  \verbatim
+      hdyn = nombre de colonnes pour imprimer les etoiles
+          si =0 alors defaut(100),
+          si <0 pas de print histo seulement infos
+      hmin = minimum de la dynamique
+      hmax = maximum de la dynamique
+          si hmax<=hmin           : hmin=VMin() hmax=VMax()
+          si hmax<=hmin et hmin=0 : hmin=0 hmax=VMax()
+          sinon : hmin hmax
+      pflag < 0 : on imprime les informations (nbin,min,...) sans l'histogramme
+            = 0 : on imprime  "BinCenter(i) data[i]"  (note "... ...")
+            bit 0 on : (v=1): numero_bin "... ..."
+            bit 1 on : (v=2): "... ..." erreur
+  \endverbatim
+*/
 void Histo::PrintF(FILE * fp, int hdyn,float hmin, float hmax,int pflag,
 	      int il, int ih)
-//
-//	Impression de l'histogramme dans le fichier fp
-//|   hdyn = nombre de colonnes pour imprimer les etoiles
-//|       si =0 alors defaut(100),
-//|       si <0 pas de print histo seulement infos
-//|   hmin = minimum de la dynamique
-//|   hmax = maximum de la dynamique
-//|       si hmax<=hmin           : hmin=VMin() hmax=VMax()
-//|       si hmax<=hmin et hmin=0 : hmin=0 hmax=VMax()
-//|       sinon : hmin hmax
-//|   pflag < 0 : on imprime les informations (nbin,min,...) sans l'histogramme
-//|         = 0 : on imprime  "BinCenter(i) data[i]"  (note "... ...")
-//|         bit 0 on : (v=1): numero_bin "... ..."
-//|         bit 1 on : (v=2): "... ..." erreur
-//--
 {
 
@@ -1642,88 +1580,12 @@
 
 /********* Methode *********/
-//++
+/*!
+  Impression de l'histogramme sur stdout
+*/
 void Histo::Print(int hdyn,float hmin, float hmax,int pflag,
 	     int il, int ih)
-//
-//	Impression de l'histogramme sur stdout
-//--
 {
  Histo::PrintF(stdout, hdyn, hmin, hmax, pflag, il, ih);
 }
-
-
-// Rappel des inlines functions pour commentaires
-//++
-// inline float          XMin() const
-//	Retourne l'abscisse minimum
-//--
-//++
-// inline float          XMax() const
-//	Retourne l'abscisse maximum
-//--
-//++
-// inline int            NBins() const
-//	Retourne le nombre de bins
-//--
-//++
-// inline float          BinWidth() const
-//	Retourne la largeur du bin
-//--
-//++
-// inline float*         Bins() const
-//	Retourne le pointeur sur le tableaux des contenus
-//--
-//++
-// inline float          operator()(int i) const
-//	Retourne le contenu du bin i
-//--
-//++
-// inline float&         operator()(int i)
-//	Remplit le contenu du bin i
-//--
-//++
-// inline float          Error(int i) const
-//	Retourne l'erreur du bin i
-//--
-//++
-// inline double         Error2(int i) const
-//	Retourne l'erreur au carre du bin i
-//--
-//++
-// inline double&        Error2(int i)
-//	Remplit l'erreur au carre du bin i
-//--
-//++
-// inline float          NData() const
-//	Retourne la somme ponderee
-//--
-//++
-// inline float          NEntries()
-//	Retourne le nombre d'entrees
-//--
-//++
-// inline float          NOver() const
-//	Retourne le nombre d'overflow
-//--
-//++
-// inline float          NUnder() const
-//	Retourne le nombre d'underflow
-//--
-//++
-// inline float          BinLowEdge(int i)  const
-//	Retourne l'abscisse du bord inferieur du bin i
-//--
-//++
-// inline float          BinCenter(int i)   const
-//	Retourne l'abscisse du centre du bin i
-//--
-//++
-// inline float          BinHighEdge(int i) const
-//	Retourne l'abscisse du bord superieur du bin i
-//--
-//++
-// inline int            FindBin(float x) const   
-//	Retourne le numero du bin contenant l'abscisse x
-//--
 
 
Index: /trunk/SophyaLib/HiStats/histos.h
===================================================================
--- /trunk/SophyaLib/HiStats/histos.h	(revision 913)
+++ /trunk/SophyaLib/HiStats/histos.h	(revision 914)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: histos.h,v 1.1.1.1 2000-03-02 16:51:32 ansari Exp $
+// $Id: histos.h,v 1.2 2000-04-13 16:04:11 ansari Exp $
 //
 
@@ -19,4 +19,8 @@
 class GeneralFit;
 
+
+/*!
+  Classe d'histogrammes 1D
+*/
 class Histo : public AnyDataObj {
   friend class ObjFileIO<Histo>;
@@ -77,26 +81,45 @@
 
   // INLINES
+  //! Retourne l'abscisse minimum
   inline float          XMin() const             {return min;}
+  //! Retourne l'abscisse maximum
   inline float          XMax() const             {return max;}
+  //! Retourne le nombre de bins
   inline int_4          NBins() const            {return bins;}
+  //! Retourne la largeur du bin
   inline float          BinWidth() const         {return binWidth;}
+  //! Retourne le pointeur sur le tableaux des contenus
   inline float*         Bins() const             {return data;}
+  //! Retourne le contenu du bin i
   inline float          operator()(int i) const  {return data[i];}
+  //! Remplit le contenu du bin i
   inline float&         operator()(int i)        {return data[i];}
+  //! retourne "true" si il y a des erreurs stoquees
   inline bool           HasErrors() { if(err2) return true; else return false;}
+  //! Retourne l'erreur du bin i
   inline float          Error(int i) const
                           {if(err2) {if(err2[i]>0.) return sqrt(err2[i]); else return 0.;}
                            else return 0.;}
+  //! Retourne l'erreur au carre du bin i
   inline double         Error2(int i) const
                           {if(err2) return err2[i]; else return 0.;}
+  //! Remplit l'erreur au carre du bin i
   inline double&        Error2(int i) {return err2[i];}
+  //! Retourne la somme ponderee
   inline float          NData() const            {return (float) nHist;}
+  //! Retourne le nombre d'entrees
   inline float          NEntries() const         {return nEntries;}
+  //! Retourne le nombre d'overflow
   inline float          NOver() const            {return over;}
+  //! Retourne le nombre d'underflow
   inline float          NUnder() const           {return under;}
 
+  //! Retourne l'abscisse du bord inferieur du bin i
   inline float          BinLowEdge(int i)  const {return min + i*binWidth;}
+  //! Retourne l'abscisse du centre du bin i
   inline float          BinCenter(int i)   const {return min + (i+0.5)*binWidth;}
+  //! Retourne l'abscisse du bord superieur du bin i
   inline float          BinHighEdge(int i) const {return min + (i+1)*binWidth;} 
+  //! Retourne le numero du bin contenant l'abscisse x
   inline int_4          FindBin(float x) const   
                             {return (int_4) floorf((x - min) / binWidth);}
@@ -146,14 +169,14 @@
   void Delete();
 
-  float*         data;		 
-  double*        err2;		 
-  float          under;
-  float          over;
-  double         nHist;
-  int_4          nEntries;
-  int_4          bins;
-  float          min;
-  float          max;
-  float          binWidth;
+  float*         data;     //!< donnees
+  double*        err2;	   //!< erreurs carrees
+  float          under;    //!< underflow
+  float          over;     //!< overflow
+  double         nHist;    //!< somme ponderee des entrees
+  int_4          nEntries; //!< nombre d'entrees
+  int_4          bins;     //!< nombre de bins
+  float          min;      //!< abscisse minimum
+  float          max;      //!< abscisse maximum
+  float          binWidth; //!< largeur du bin
 };
 
Index: /trunk/SophyaLib/HiStats/histos2.cc
===================================================================
--- /trunk/SophyaLib/HiStats/histos2.cc	(revision 913)
+++ /trunk/SophyaLib/HiStats/histos2.cc	(revision 914)
@@ -16,24 +16,11 @@
 #include "generalfit.h"
 
-//++
-// Class	Histo2D
-// Lib	Outils++ 
-// include	histos2.h
-//
-//	Classe d'histogrammes 2D
-//--
-
-///////////////////////////////////////////////////////////////////
-//++
-// Titre	Constructeurs
-//--
-
-//++
+///////////////////////////////////////////////////////////////////
+/*!
+  Createur d'un histogramme 2D ayant nxBin,nyBin bins
+  entre xMin,xMax et yMin,yMax.
+*/
 Histo2D::Histo2D(float xMin, float xMax, int nxBin
                 ,float yMin, float yMax, int nyBin)
-//
-//	Createur d'un histogramme 2D ayant nxBin,nyBin bins
-//	entre xMin,xMax et yMin,yMax.
-//--
       : data(new float[nxBin*nyBin]), err2(NULL)
       , nHist(0), nEntries(0)
@@ -50,9 +37,8 @@
 }
 
-//++
+/*!
+  Constructeur par copie.
+*/
 Histo2D::Histo2D(const Histo2D& h)
-//
-//	Constructeur par copie.
-//--
 {
 int i,j;
@@ -118,9 +104,8 @@
 }
 
-//++
+/*!
+  Constructeur par defaut.
+*/
 Histo2D::Histo2D()
-//
-//	Constructeur par defaut.
-//--
       : data(NULL), err2(NULL)
       , nHist(0), nEntries(0)
@@ -136,9 +121,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Desallocation de la place de l'histogramme (fct privee).
+*/
 void Histo2D::Delete()
-//
-//	Desallocation de la place de l'histogramme (fct privee).
-//--
 {
   if( data != NULL ) { delete[] data; data = NULL;}
@@ -163,9 +147,8 @@
 }
 
-//++
+/*!
+  Destructeur.
+*/
 Histo2D::~Histo2D()
-//
-//	Destructeur.
-//--
 {
 Delete();
@@ -173,13 +156,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
-// Titre	Methodes generales
-//--
-
-//++
+/*!
+  Remise a zero du contenu, des erreurs et des valeurs.
+*/
 void Histo2D::Zero()
-//
-//	Remise a zero du contenu, des erreurs et des valeurs.
-//--
 {
   nHist = nEntries = 0;
@@ -200,9 +178,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour avoir le calcul des erreurs.
+*/
 void Histo2D::Errors()
-//
-//	Pour avoir le calcul des erreurs.
-//--
 {
  if( nxy > 0 ) {
@@ -213,8 +190,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H2 = H1
+*/
 Histo2D& Histo2D::operator = (const Histo2D& h)
-//
-//--
 {
   int i,j,nb;
@@ -286,8 +263,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H *= b
+*/
 Histo2D& Histo2D::operator *= (double b)
-//
-//--
 {
 int i,j;
@@ -310,8 +287,8 @@
 }
 
-//++
+/*!
+  Operateur H /= b
+*/
 Histo2D& Histo2D::operator /= (double b)
-//
-//--
 {
 int i,j;
@@ -335,8 +312,8 @@
 }
 
-//++
+/*!
+  Operateur H += b
+*/
 Histo2D& Histo2D::operator += (double b)
-//
-//--
 {
 int i,j;
@@ -362,8 +339,8 @@
 }
 
-//++
+/*!
+  Operateur H -= b
+*/
 Histo2D& Histo2D::operator -= (double b)
-//
-//--
 {
 int i,j;
@@ -390,8 +367,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H2 = H1 * b
+*/
 Histo2D operator * (const Histo2D& a, double b)
-//
-//--
 {
   Histo2D result(a);
@@ -399,8 +376,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b * H1
+*/
 Histo2D operator * (double b, const Histo2D& a)
-//
-//--
 {
   Histo2D result(a);
@@ -408,8 +385,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 / b
+*/
 Histo2D operator / (const Histo2D& a, double b)
-//
-//--
 {
   Histo2D result(a);
@@ -417,8 +394,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 + b
+*/
 Histo2D operator + (const Histo2D& a, double b)
-//
-//--
 {
   Histo2D result(a);
@@ -426,8 +403,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b + H1
+*/
 Histo2D operator + (double b, const Histo2D& a)
-//
-//--
 {
   Histo2D result(a);
@@ -435,8 +412,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 - b
+*/
 Histo2D operator - (const Histo2D& a, double b)
-//
-//--
 {
   Histo2D result(a);
@@ -444,8 +421,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b - H1
+*/
 Histo2D operator - (double b, const Histo2D& a)
-//
-//--
 {
   Histo2D result(a);
@@ -455,8 +432,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H += H1
+*/
 Histo2D& Histo2D::operator += (const Histo2D& a)
-//
-//--
 {
 int i,j;
@@ -478,8 +455,8 @@
 }
 
-//++
+/*!
+  Operateur H -= H1
+*/
 Histo2D& Histo2D::operator -= (const Histo2D& a)
-//
-//--
 {
 int i,j;
@@ -501,8 +478,8 @@
 }
 
-//++
+/*!
+  Operateur H *= H1
+*/
 Histo2D& Histo2D::operator *= (const Histo2D& a)
-//
-//--
 {
 int i,j;
@@ -526,8 +503,8 @@
 }
 
-//++
+/*!
+  Operateur H /= H1
+*/
 Histo2D& Histo2D::operator /= (const Histo2D& a)
-//
-//--
 {
 int i,j;
@@ -559,8 +536,9 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H = H1 + H2
+*/
+
 Histo2D operator + (const Histo2D& a, const Histo2D& b)
-//
-//--
 {
 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
@@ -569,8 +547,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 - H2
+*/
 Histo2D operator - (const Histo2D& a, const Histo2D& b)
-//
-//--
 {
 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
@@ -579,8 +557,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 * H2
+*/
 Histo2D operator * (const Histo2D& a, const Histo2D& b)
-//
-//--
 {
 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
@@ -589,8 +567,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 / H2
+*/
 Histo2D operator / (const Histo2D& a, const Histo2D& b)
-//
-//--
 {
 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
@@ -600,9 +578,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs des abscisses.
+*/
 void Histo2D::GetXCoor(Vector &v)
-//
-//	Remplissage d'un tableau avec les valeurs des abscisses.
-//--
 {
 float x,y;
@@ -612,9 +589,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs des ordonnees.
+*/
 void Histo2D::GetYCoor(Vector &v)
-//
-//	Remplissage d'un tableau avec les valeurs des ordonnees.
-//--
 {
 float x,y;
@@ -624,26 +600,8 @@
 }
 
-//++
-//| Remarque sur les indices:
-//|  H(i,j)   -> i  = coord x (0<i<nx),     j  = coord y (0<j<ny)
-//|  v(ii,jj) -> ii = ligne (0<i<NRows()),  jj = colonne (0<i<NCol())
-//|  On fait une correspondance directe i<->ii et j<->jj
-//|  ce qui, en representation classique des histos2D et des matrices
-//|  entraine une inversion x<->y cad une symetrie / diagonale principale
-//|  H(0,...)  represente ^         mais v(0,...) represente
-//|                       |x.......               |xxxxxxxx|
-//|                       |x.......               |........|
-//|                       |x.......               |........|
-//|                       |x.......               |........|
-//|                       |x.......               |........|
-//|                       --------->
-//|                       colonne no 1            ligne no 1
-//--
-
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs du contenu.
+*/
 void Histo2D::GetValue(Matrix &v)
-//
-//	Remplissage d'un tableau avec les valeurs du contenu.
-//--
 {
 v.Realloc(nx,ny);
@@ -653,9 +611,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs du carre des erreurs.
+*/
 void Histo2D::GetError2(Matrix &v)
-//
-//	Remplissage d'un tableau avec les valeurs du carre des erreurs.
-//--
 {
 int i,j;
@@ -667,9 +624,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs des erreurs.
+*/
 void Histo2D::GetError(Matrix &v)
-//
-//	Remplissage d'un tableau avec les valeurs des erreurs.
-//--
 {
 int i,j;
@@ -682,9 +638,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Remplissage du contenu de l'histo avec les valeurs d'un tableau.
+*/
 void Histo2D::PutValue(Matrix &v, int ierr)
-//
-//	Remplissage du contenu de l'histo avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -697,9 +652,8 @@
 }
 
-//++
+/*!
+  Addition du contenu de l'histo avec les valeurs d'un tableau.
+*/
 void Histo2D::PutValueAdd(Matrix &v, int ierr)
-//
-//	Addition du contenu de l'histo avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -712,10 +666,9 @@
 }
 
-//++
+/*!
+  Remplissage des erreurs au carre de l'histo
+  avec les valeurs d'un tableau.
+*/
 void Histo2D::PutError2(Matrix &v)
-//
-//	Remplissage des erreurs au carre de l'histo
-//	avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -726,10 +679,9 @@
 }
 
-//++
+/*!
+  Addition des erreurs au carre de l'histo
+  avec les valeurs d'un tableau.
+*/
 void Histo2D::PutError2Add(Matrix &v)
-//
-//	Addition des erreurs au carre de l'histo
-//	avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -741,9 +693,8 @@
 }
 
-//++
+/*!
+  Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
+*/
 void Histo2D::PutError(Matrix &v)
-//
-//	Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -757,9 +708,8 @@
 ///////////////////////////////////////////////////////////////////
 /********* Methode *********/
-//++
+/*!
+  Addition du contenu de l'histo pour x,y poids w.
+*/
 void Histo2D::Add(float x, float y, float w)
-//
-//	Addition du contenu de l'histo pour x,y poids w.
-//--
 {
 list<bande_slice>::iterator it;
@@ -801,9 +751,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Recherche du bin du maximum dans le pave [il,ih][jl,jh].
+*/
 void Histo2D::IJMax(int& imax,int& jmax,int il,int ih,int jl,int jh)
-//
-//	Recherche du bin du maximum dans le pave [il,ih][jl,jh].
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -823,9 +772,8 @@
 }
 
-//++
+/*!
+  Recherche du bin du minimum dans le pave [il,ih][jl,jh].
+*/
 void Histo2D::IJMin(int& imax,int& jmax,int il,int ih,int jl,int jh)
-//
-//	Recherche du bin du minimum dans le pave [il,ih][jl,jh].
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -846,9 +794,8 @@
 
 
-//++
+/*!
+  Recherche du maximum dans le pave [il,ih][jl,jh].
+*/
 float Histo2D::VMax(int il,int ih,int jl,int jh) const
-//
-//	Recherche du maximum dans le pave [il,ih][jl,jh].
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -867,9 +814,8 @@
 }
 
-//++
+/*!
+  Recherche du minimum dans le pave [il,ih][jl,jh].
+*/
 float Histo2D::VMin(int il,int ih,int jl,int jh) const
-//
-//	Recherche du minimum dans le pave [il,ih][jl,jh].
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -889,18 +835,19 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Renvoie les under.overflow dans les 8 quadrants.
+  \verbatim
+     over[3][3]:        20 | 21 | 22
+                           |    |
+                       --------------
+                           |    |
+                        10 | 11 | 12        11 = all overflow+underflow
+                           |    |
+                       --------------
+                           |    |
+                        00 | 01 | 02
+  \endverbatim
+*/
 float Histo2D::NOver(int i,int j) const
-//
-//	Renvoie les under.overflow dans les 8 quadrants.
-//|  over[3][3]:        20 | 21 | 22
-//|                        |    |
-//|                    --------------
-//|                        |    |
-//|                     10 | 11 | 12        11 = all overflow+underflow
-//|                        |    |
-//|                    --------------
-//|                        |    |
-//|                     00 | 01 | 02
-//--
 {
 if( i < 0 || i>=3 || j < 0 || j>=3 ) return over[1][1];
@@ -910,9 +857,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne le nombre de bins non-nuls.
+*/
 int Histo2D::BinNonNul() const
-//
-//	Retourne le nombre de bins non-nuls.
-//--
 {
 int non=0;
@@ -921,9 +867,8 @@
 }
 
-//++
+/*!
+  Retourne le nombre de bins avec erreurs non-nulles.
+*/
 int Histo2D::ErrNonNul() const
-//
-//	Retourne le nombre de bins avec erreurs non-nulles.
-//--
 {
 if(err2==NULL) return -1;
@@ -934,10 +879,9 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Idem EstimeMax(int...) mais retourne x,y.
+*/
 int Histo2D::EstimeMax(float& xm,float& ym,int SzPav
                       ,int il,int ih,int jl,int jh)
-//
-//	Idem EstimeMax(int...) mais retourne x,y.
-//--
 {
 int im,jm;
@@ -946,16 +890,17 @@
 }
 
-//++
+/*!
+  Determine les abscisses et ordonnees du maximum donne par im,jm
+  en moyennant dans un pave SzPav x SzPav autour du maximum.
+  \verbatim
+     Return:
+       0 = si fit maximum reussi avec SzPav pixels
+       1 = si fit maximum reussi avec moins que SzPav pixels
+                                   dans au moins 1 direction
+       2 = si fit maximum echoue et renvoit BinCenter()
+      -1 = si echec: SzPav <= 0 ou im,jm hors limites
+  \endverbatim
+*/
 int Histo2D::EstimeMax(int im,int jm,float& xm,float& ym,int SzPav)
-//
-//	Determine les abscisses et ordonnees du maximum donne par im,jm
-//	en moyennant dans un pave SzPav x SzPav autour du maximum.
-//|  Return:
-//|    0 = si fit maximum reussi avec SzPav pixels
-//|    1 = si fit maximum reussi avec moins que SzPav pixels
-//|                                dans au moins 1 direction
-//|    2 = si fit maximum echoue et renvoit BinCenter()
-//|   -1 = si echec: SzPav <= 0 ou im,jm hors limites
-//--
 {
 xm = ym = 0;
@@ -992,25 +937,26 @@
 }
 
-//++
+/*!
+  Pour trouver le maximum de l'histogramme en tenant compte
+  des fluctuations.
+  \verbatim
+    Methode:
+    1-/ On recherche le bin maximum MAX de l'histogramme
+    2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX]
+        peuvent etre des pixels maxima.
+    3-/ On identifie le bin maximum en choissisant le pixel du 2-/
+        tel que la somme des pixels dans un pave SzPav x SzPav soit maximale.
+    INPUT:
+     SzPav = taille du pave pour departager
+     Dz    = tolerance pour identifier tous les pixels "maximum"
+    OUTPUT:
+     im,jm = pixel maximum trouve
+    RETURN:
+      <0 =  Echec
+      >0 =  nombre de pixels possibles pour le maximum
+  \endverbatim
+*/
 int Histo2D::FindMax(int& im,int& jm,int SzPav,float Dz
                     ,int il,int ih,int jl,int jh)
-//
-//	Pour trouver le maximum de l'histogramme en tenant compte
-//	des fluctuations.
-//| Methode:
-//| 1-/ On recherche le bin maximum MAX de l'histogramme
-//| 2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX]
-//|     peuvent etre des pixels maxima.
-//| 3-/ On identifie le bin maximum en choissisant le pixel du 2-/
-//|     tel que la somme des pixels dans un pave SzPav x SzPav soit maximale.
-//| INPUT:
-//|  SzPav = taille du pave pour departager
-//|  Dz    = tolerance pour identifier tous les pixels "maximum"
-//| OUTPUT:
-//|  im,jm = pixel maximum trouve
-//| RETURN:
-//|   <0 =  Echec
-//|   >0 =  nombre de pixels possibles pour le maximum
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -1046,24 +992,25 @@
 
 //////////////////////////////////////////////////////////
-//++
+/*!
+  Fit de l'histogramme par ``gfit''.
+  \verbatim
+    typ_err = 0 :
+       - erreur attachee au bin si elle existe
+       - sinon 1
+    typ_err = 1 :
+       - erreur attachee au bin si elle existe
+       - sinon max( sqrt(abs(bin) ,1 )
+    typ_err = 2 :
+       - erreur forcee a 1
+    typ_err = 3 :
+       - erreur forcee a max( sqrt(abs(bin) ,1 )
+    typ_err = 4 :
+       - erreur forcee a 1, nulle si bin a zero.
+    typ_err = 5 :
+       - erreur forcee a max( sqrt(abs(bin) ,1 ),
+         nulle si bin a zero.
+  \endverbatim
+*/
 int  Histo2D::Fit(GeneralFit& gfit,unsigned short typ_err)
-//
-//	Fit de l'histogramme par ``gfit''.
-//| typ_err = 0 :
-//|    - erreur attachee au bin si elle existe
-//|    - sinon 1
-//| typ_err = 1 :
-//|    - erreur attachee au bin si elle existe
-//|    - sinon max( sqrt(abs(bin) ,1 )
-//| typ_err = 2 :
-//|    - erreur forcee a 1
-//| typ_err = 3 :
-//|    - erreur forcee a max( sqrt(abs(bin) ,1 )
-//| typ_err = 4 :
-//|    - erreur forcee a 1, nulle si bin a zero.
-//| typ_err = 5 :
-//|    - erreur forcee a max( sqrt(abs(bin) ,1 ),
-//|      nulle si bin a zero.
-//--
 {
 if(NBinX()*NBinY()<=0) return -1000;
@@ -1092,9 +1039,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant les residus du fit ``gfit''.
+*/
 Histo2D Histo2D::FitResidus(GeneralFit& gfit)
-//
-//	Retourne une classe contenant les residus du fit ``gfit''.
-//--
 {
 if(NBinX()<=0 || NBinY()<=0)
@@ -1114,9 +1060,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant la fonction du fit ``gfit''.
+*/
 Histo2D Histo2D::FitFunction(GeneralFit& gfit)
-//
-//	Retourne une classe contenant la fonction du fit ``gfit''.
-//--
 {
 if(NBinX()<=0 || NBinY()<=0)
@@ -1137,9 +1082,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Impression des informations sur l'histogramme.
+*/
 void Histo2D::PrintStatus()
-//
-//	Impression des informations sur l'histogramme.
-//--
 {
 printf("~Histo::Print    nHist=%g nEntries=%d\n",nHist,nEntries);
@@ -1153,16 +1097,17 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh].
+  \verbatim
+    numero d'index:  00000000001111111111222222222233333
+                     01234567890123456789012345678901234
+    valeur entiere:  00000000001111111111222222222233333
+                     12345678901234567890123456789012345
+  \endverbatim
+*/
 void Histo2D::Print(float min,float max
                    ,int il,int ih,int jl,int jh)
-//
-//	Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh].
-//--
 {
 int ns = 35;
-// numero d'index:  00000000001111111111222222222233333
-//                  01234567890123456789012345678901234
-// valeur entiere:  00000000001111111111222222222233333
-//                  12345678901234567890123456789012345
 const char *s =    "+23456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
@@ -1245,96 +1190,11 @@
 }
 
-// Rappel des inline functions pour commentaires
-//++
-// inline float   XMin()
-//	Retourne l'abscisse minimum.
-//--
-//++
-// inline float   XMax()
-//	Retourne l'abscisse maximum.
-//--
-//++
-// inline float   YMin()
-//	Retourne l'ordonnee minimum.
-//--
-//++
-// inline float   YMax()
-//	Retourne l'ordonnee maximum.
-//--
-//++
-// inline int     NBinX()
-//	Retourne le nombre de bins selon X.
-//--
-//++
-// inline int     NBinY()
-//	Retourne le nombre de bins selon Y.
-//--
-//++
-// inline float   WBinX()
-//	Retourne la largeur du bin selon X.
-//--
-//++
-// inline float   WBinY()
-//	Retourne la largeur du bin selon Y.
-//--
-//++
-// inline float*  Bins() const
-//	Retourne le pointeur sur le tableaux des contenus.
-//--
-//++
-// inline float   operator()(int i,int j) const
-//	Retourne le contenu du bin i,j.
-//--
-//++
-// inline float&  operator()(int i,int j)
-//	Remplit le contenu du bin i,j.
-//--
-//++
-// inline float   Error(int i,int j)  const
-//	Retourne l'erreur du bin i,j.
-//--
-//++
-// inline double  Error2(int i,int j) const
-//	Retourne l'erreur au carre du bin i,j.
-//--
-//++
-// inline double& Error2(int i,int j)
-//	Remplit l'erreur au carre du bin i,j.
-//--
-//++
-// inline float   NData() const
-//	Retourne la somme ponderee.
-//--
-//++
-// inline int     NEntries() const
-//	Retourne le nombre d'entrees.
-//--
-//++
-// inline void BinLowEdge(int i,int j,float& x,float& y)
-//	Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j.
-//--
-//++
-// inline void BinCenter(int i,int j,float& x,float& y)
-//	Retourne l'abscisse et l'ordonnee du centre du bin i,j.
-//--
-//++
-// inline void BinHighEdge(int i,int j,float& x,float& y)
-//	Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j.
-//--
-//++
-// inline void FindBin(float x,float y,int& i,int& j)
-//	Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y.
-//--
-
-///////////////////////////////////////////////////////////////////
-//++
+///////////////////////////////////////////////////////////////////
 // Titre	Methodes pour gerer les projections
-//--
-
-//++
+
+/*!
+  Pour creer la projection X.
+*/
 void Histo2D::SetProjX()
-//
-//	Pour creer la projection X.
-//--
 {
 if( hprojx != NULL ) DelProjX();
@@ -1343,9 +1203,8 @@
 }
 
-//++
+/*!
+  Pour creer la projection Y.
+*/
 void Histo2D::SetProjY()
-//
-//	Pour creer la projection Y.
-//--
 {
 if( hprojy != NULL ) DelProjY();
@@ -1354,9 +1213,8 @@
 }
 
-//++
+/*!
+  Pour creer les projections X et Y.
+*/
 void Histo2D::SetProj()
-//
-//	Pour creer les projections X et Y.
-//--
 {
 SetProjX();
@@ -1364,9 +1222,8 @@
 }
 
-//++
+/*!
+  Informations sur les projections.
+*/
 void Histo2D::ShowProj()
-//
-//	Informations sur les projections.
-//--
 {
 if( hprojx != NULL ) cout << ">>>> Projection X set : "<< hprojx <<endl;
@@ -1376,9 +1233,8 @@
 }
 
-//++
+/*!
+  Destruction de l'histogramme de la projection selon X.
+*/
 void Histo2D::DelProjX()
-//
-//	Destruction de l'histogramme de la projection selon X.
-//--
 {
 if( hprojx == NULL ) return;
@@ -1387,9 +1243,8 @@
 }
 
-//++
+/*!
+  Destruction de l'histogramme de la projection selon X.
+*/
 void Histo2D::DelProjY()
-//
-//	Destruction de l'histogramme de la projection selon X.
-//--
 {
 if( hprojy == NULL ) return;
@@ -1398,9 +1253,8 @@
 }
 
-//++
+/*!
+  Destruction des histogrammes des projections selon X et Y.
+*/
 void Histo2D::DelProj()
-//
-//	Destruction des histogrammes des projections selon X et Y.
-//--
 {
 DelProjX();
@@ -1408,9 +1262,8 @@
 }
 
-//++
+/*!
+  Remise a zero de la projection selon X.
+*/
 void Histo2D::ZeroProjX()
-//
-//	Remise a zero de la projection selon X.
-//--
 {
 if( hprojx == NULL ) return;
@@ -1418,9 +1271,8 @@
 }
 
-//++
+/*!
+  Remise a zero de la projection selon Y.
+*/
 void Histo2D::ZeroProjY()
-//
-//	Remise a zero de la projection selon Y.
-//--
 {
 if( hprojy == NULL ) return;
@@ -1428,9 +1280,8 @@
 }
 
-//++
+/*!
+  Remise a zero des projections selon X et Y.
+*/
 void Histo2D::ZeroProj()
-//
-//	Remise a zero des projections selon X et Y.
-//--
 {
 ZeroProjX();
@@ -1438,24 +1289,11 @@
 }
 
-// Rappel des inline functions pour commentaires
-//++
-// inline Histo*  HProjX()
-//	Retourne le pointeur sur l'histo 1D de la projection selon X.
-//--
-//++
-// inline Histo*  HProjY()
-//	Retourne le pointeur sur l'histo 1D de la projection selon Y.
-//--
-
-///////////////////////////////////////////////////////////////////
-//++
+///////////////////////////////////////////////////////////////////
 // Titre	Methodes pour gerer les bandes
-//--
-
-//++
+
+/*!
+  Pour creer une bande en X entre ybmin et ybmax.
+*/
 int Histo2D::SetBandX(float ybmin,float ybmax)
-//
-//	Pour creer une bande en X entre ybmin et ybmax.
-//--
 {
 b_s.num = lbandx.size();
@@ -1468,9 +1306,8 @@
 }
 
-//++
+/*!
+  Pour creer une bande en Y entre xbmin et xbmax.
+*/
 int Histo2D::SetBandY(float xbmin,float xbmax)
-//
-//	Pour creer une bande en Y entre xbmin et xbmax.
-//--
 {
 b_s.num = lbandy.size();
@@ -1483,9 +1320,8 @@
 }
 
-//++
+/*!
+  Destruction des histogrammes des bandes selon X.
+*/
 void Histo2D::DelBandX()
-//
-//	Destruction des histogrammes des bandes selon X.
-//--
 {
 if( lbandx.size() <= 0 ) return;
@@ -1495,9 +1331,8 @@
 }
 
-//++
+/*!
+  Destruction des histogrammes des bandes selon Y.
+*/
 void Histo2D::DelBandY()
-//
-//	Destruction des histogrammes des bandes selon Y.
-//--
 {
 if( lbandy.size() <= 0 ) return;
@@ -1507,9 +1342,8 @@
 }
 
-//++
+/*!
+  Remise a zero des bandes selon X.
+*/
 void Histo2D::ZeroBandX()
-//
-//	Remise a zero des bandes selon X.
-//--
 {
 if( lbandx.size() <= 0 ) return;
@@ -1519,9 +1353,8 @@
 }
 
-//++
+/*!
+  Remise a zero des bandes selon Y.
+*/
 void Histo2D::ZeroBandY()
-//
-//	Remise a zero des bandes selon Y.
-//--
 {
 if( lbandy.size() <= 0 ) return;
@@ -1531,9 +1364,8 @@
 }
 
-//++
+/*!
+  Retourne un pointeur sur la bande numero `n' selon X.
+*/
 Histo* Histo2D::HBandX(int n) const
-//
-//	Retourne un pointeur sur la bande numero `n' selon X.
-//--
 {
 if( lbandx.size() <= 0 || n < 0 || n >= (int) lbandx.size() ) return NULL;
@@ -1543,9 +1375,8 @@
 }
 
-//++
+/*!
+  Retourne un pointeur sur la bande numero `n' selon Y.
+*/
 Histo* Histo2D::HBandY(int n) const
-//
-//	Retourne un pointeur sur la bande numero `n' selon Y.
-//--
 {
 if( lbandy.size() <= 0 || n < 0 || n >= (int) lbandy.size() ) return NULL;
@@ -1555,9 +1386,8 @@
 }
 
-//++
+/*!
+  Retourne les limites de la bande numero `n' selon X.
+*/
 void Histo2D::GetBandX(int n,float& ybmin,float& ybmax) const
-//
-//	Retourne les limites de la bande numero `n' selon X.
-//--
 {
 ybmin = 0.; ybmax = 0.;
@@ -1568,9 +1398,8 @@
 }
 
-//++
+/*!
+  Retourne les limites de la bande numero `n' selon Y.
+*/
 void Histo2D::GetBandY(int n,float& xbmin,float& xbmax) const
-//
-//	Retourne les limites de la bande numero `n' selon Y.
-//--
 {
 xbmin = 0.; xbmax = 0.;
@@ -1581,9 +1410,8 @@
 }
 
-//++
+/*!
+  Informations sur les bandes.
+*/
 void Histo2D::ShowBand(int lp)
-//
-//	Informations sur les bandes.
-//--
 {
   cout << ">>>> Nombre de bande X : " << lbandx.size() << endl;
@@ -1608,24 +1436,11 @@
 }
 
-// Rappel des inline functions pour commentaires
-//++
-// inline int     NBandX()
-//	Retourne le nombre de bandes selon X
-//--
-//++
-// inline int     NBandY()
-//	Retourne le nombre de bandes selon Y
-//--
-
-///////////////////////////////////////////////////////////////////
-//++
-// Titre	Methodes pour gerer les bandes equidistantes
-//--
-
-//++
+///////////////////////////////////////////////////////////////////
+// Titre  Methodes pour gerer les bandes equidistantes ou slices
+
+/*!
+  Pour creer `nsli' bandes equidistantes selon X.
+*/
 int Histo2D::SetSliX(int nsli)
-//
-//	Pour creer `nsli' bandes equidistantes selon X.
-//--
 {
 if( nsli <= 0 ) return -1;
@@ -1645,9 +1460,8 @@
 }
 
-//++
+/*!
+  Pour creer `nsli' bandes equidistantes selon Y.
+*/
 int Histo2D::SetSliY(int nsli)
-//
-//	Pour creer `nsli' bandes equidistantes selon Y.
-//--
 {
 if( nsli <= 0 ) return -1;
@@ -1667,9 +1481,8 @@
 }
 
-//++
+/*!
+  Destruction des bandes equidistantes selon X.
+*/
 void Histo2D::DelSliX()
-//
-//	Destruction des bandes equidistantes selon X.
-//--
 {
 if( lslix.size() <= 0 ) return;
@@ -1679,9 +1492,8 @@
 }
 
-//++
+/*!
+  Destruction des bandes equidistantes selon Y.
+*/
 void Histo2D::DelSliY()
-//
-//	Destruction des bandes equidistantes selon Y.
-//--
 {
 if( lsliy.size() <= 0 ) return;
@@ -1691,9 +1503,8 @@
 }
 
-//++
+/*!
+  Remise a zero des bandes equidistantes selon X.
+*/
 void Histo2D::ZeroSliX()
-//
-//	Remise a zero des bandes equidistantes selon X.
-//--
 {
 if( lslix.size() <= 0 ) return;
@@ -1703,9 +1514,8 @@
 }
 
-//++
+/*!
+  Remise a zero des bandes equidistantes selon Y.
+*/
 void Histo2D::ZeroSliY()
-//
-//	Remise a zero des bandes equidistantes selon Y.
-//--
 {
 if( lsliy.size() <= 0 ) return;
@@ -1715,10 +1525,9 @@
 }
 
-//++
+/*!
+  Retourne un pointeur sur la bande equidistante numero `n'
+  selon X.
+*/
 Histo* Histo2D::HSliX(int n) const
-//
-//	Retourne un pointeur sur la bande equidistante numero `n'
-//	selon X.
-//--
 {
 if( lslix.size() <= 0 || n < 0 || n >= (int) lslix.size() ) return NULL;
@@ -1728,10 +1537,9 @@
 }
 
-//++
+/*!
+  Retourne un pointeur sur la bande equidistante numero `n'
+  selon Y.
+*/
 Histo* Histo2D::HSliY(int n) const
-//
-//	Retourne un pointeur sur la bande equidistante numero `n'
-//	selon Y.
-//--
 {
 if( lsliy.size() <= 0 || n < 0 || n >= (int) lsliy.size() ) return NULL;
@@ -1741,9 +1549,8 @@
 }
 
-//++
+/*!
+  Informations sur les bandes equidistantes.
+*/
 void Histo2D::ShowSli(int lp)
-//
-//	Informations sur les bandes equidistantes.
-//--
 {
 list<bande_slice>::iterator i;
@@ -1764,15 +1571,4 @@
   }
 }
-
-// Rappel des inline functions pour commentaires
-//++
-// inline int     NSliX()
-//	Retourne le nombre de slices selon X
-//--
-//++
-// inline int     NSliY()
-//	Retourne le nombre de slices selon Y
-//--
-
 
 ///////////////////////////////////////////////////////////
Index: /trunk/SophyaLib/HiStats/histos2.h
===================================================================
--- /trunk/SophyaLib/HiStats/histos2.h	(revision 913)
+++ /trunk/SophyaLib/HiStats/histos2.h	(revision 914)
@@ -22,4 +22,24 @@
 class GeneralFit;
 
+
+/*!
+  Classe d'histogrammes 2D
+  \verbatim
+    Remarque sur les indices:
+     H(i,j)   -> i  = coord x (0<i<nx),     j  = coord y (0<j<ny)
+     v(ii,jj) -> ii = ligne (0<i<NRows()),  jj = colonne (0<i<NCol())
+     On fait une correspondance directe i<->ii et j<->jj
+     ce qui, en representation classique des histos2D et des matrices
+     entraine une inversion x<->y cad une symetrie / diagonale principale
+     H(0,...)  represente ^         mais v(0,...) represente
+                          |x.......               |xxxxxxxx|
+                          |x.......               |........|
+                          |x.......               |........|
+                          |x.......               |........|
+                          |x.......               |........|
+                          --------->
+                          colonne no 1            ligne no 1
+  \endverbatim
+*/
 class Histo2D : public AnyDataObj {
   friend class ObjFileIO<Histo2D>;
@@ -75,31 +95,52 @@
 
   // INLINES
+  //! Retourne l'abscisse minimum.
   inline float   XMin() const {return xmin;}
+  //! Retourne l'abscisse maximum.
   inline float   XMax() const {return xmax;}
+  //! Retourne l'ordonnee minimum.
   inline float   YMin() const {return ymin;}
+  //! Retourne l'ordonnee maximum.
   inline float   YMax() const {return ymax;}
+  //! Retourne le nombre de bins selon X.
   inline int_4   NBinX() const {return nx;}
+  //! Retourne le nombre de bins selon Y.
   inline int_4   NBinY() const {return ny;}
+  //! Retourne la largeur du bin selon X.
   inline float   WBinX() const {return wbinx;}
+  //! Retourne la largeur du bin selon Y.
   inline float   WBinY() const {return wbiny;}
+  //! Retourne le pointeur sur le tableaux des contenus.
   inline float*  Bins() const  {return data;}
+  //! Retourne le contenu du bin i,j.
   inline float   operator()(int i,int j) const {return data[j*nx+i];}
+  //! Remplit le contenu du bin i,j.
   inline float&  operator()(int i,int j)       {return data[j*nx+i];}
+  //! retourne "true" si il y a des erreurs stoquees
   inline bool    HasErrors() { if(err2) return true; else return false;}
+  //! Retourne l'erreur du bin i,j.
   inline float   Error(int i,int j)  const
                    {if(err2)
                       {if(err2[j*nx+i]>0.) return sqrt(err2[j*nx+i]); else return 0.;}
                     else return 0.;}
+  //! Remplit l'erreur au carre du bin i,j.
   inline double  Error2(int i,int j) const
                    {if(err2) return err2[j*nx+i]; else return 0.;}
+  //! Remplit l'erreur au carre du bin i,j.
   inline double& Error2(int i,int j) {return err2[j*nx+i];}
+  //! Retourne la somme ponderee.
   inline float   NData() const    {return (float) nHist;}
+  //! Retourne le nombre d'entrees.
   inline int_4   NEntries() const {return nEntries;}
+  //! Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j.
   inline void BinLowEdge(int i,int j,float& x,float& y)
                  {x = xmin + i*wbinx; y = ymin + j*wbiny;}
+  //! Retourne l'abscisse et l'ordonnee du centre du bin i,j.
   inline void BinCenter(int i,int j,float& x,float& y)
                  {x = xmin + (i+0.5)*wbinx; y = ymin + (j+0.5)*wbiny;}
+  //! Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j.
   inline void BinHighEdge(int i,int j,float& x,float& y)
                  {x = xmin + (i+1)*wbinx; y = ymin + (j+1)*wbiny;}
+  //! Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y.
   inline void FindBin(float x,float y,int& i,int& j)
     { i = (int) floorf((x - xmin)/wbinx); j = (int) floorf((y - ymin)/wbiny);}
@@ -139,10 +180,14 @@
   void           ZeroProjY();
   void           ZeroProj();
+  //! Retourne le pointeur sur l'histo 1D de la projection selon X.
   inline Histo*  HProjX() const {return hprojx;}
+  //! Retourne le pointeur sur l'histo 1D de la projection selon Y.
   inline Histo*  HProjY() const {return hprojy;}
   void           ShowProj();
 
   // BANDES
+  //! Retourne le nombre de bandes selon X
   inline int     NBandX() const {return lbandx.size();}
+  //! Retourne le nombre de bandes selon Y
   inline int     NBandY() const {return lbandy.size();}
   int            SetBandX(float ybmin,float ybmax);
@@ -159,5 +204,7 @@
 
   // SLICES
+  //! Retourne le nombre de slices selon X
   inline int     NSliX() const {return lslix.size();}
+  //! Retourne le nombre de slices selon Y
   inline int     NSliY() const {return lsliy.size();}
   int            SetSliX(int nsli);
@@ -174,8 +221,10 @@
 protected:
 #endif
+  //! structure de definition des bandes
   struct bande_slice {
-    int num;
-    float min, max;
-    Histo* H;
+    int num;   //!< nombre de bandes
+    float min; //!< limite minimum pour remplir la bande
+    float max; //!< limite maximum pour remplir la bande
+    Histo* H;  //!< pointer sur l Histo 1D de la bande
     STRUCTCOMP(bande_slice)
   };
@@ -186,29 +235,31 @@
   void Delete();
 
-  float*         data;
-  double*        err2;
-
-  float          over[3][3];
-  double         nHist;
-  int_4          nEntries;
-
-  int_4          nx,ny,nxy;
-  float          xmin;
-  float          xmax;
-  float          ymin;
-  float          ymax;
-  float          wbinx;
-  float          wbiny;
+  float*         data; //!< donnees
+  double*        err2; //!< erreurs carrees
+
+  float          over[3][3]; //!< overflow table
+  double         nHist;      //!< somme ponderee des entrees
+  int_4          nEntries;   //!< nombre d'entrees
+
+  int_4          nx;    //!< nombre de bins en X
+  int_4          ny;    //!< nombre de bins en Y
+  int_4          nxy;   //!< nombre de bins total
+  float          xmin;  //!< abscisse minimum
+  float          xmax;  //!< abscisse maximum
+  float          ymin;  //!< ordonnee minimum
+  float          ymax;  //!< ordonnee maximum
+  float          wbinx; //!< largeur du bin en X
+  float          wbiny; //!< largeur du bin en Y
 
   bande_slice    b_s;
 
-  Histo*         hprojx;
-  Histo*         hprojy;
-
-  list<bande_slice>  lbandx;
-  list<bande_slice>  lbandy;
+  Histo*         hprojx; //!< pointer sur Histo des proj X
+  Histo*         hprojy; //!< pointer sur Histo des proj Y
+
+  list<bande_slice>  lbandx; //!< liste des bandes selon X
+  list<bande_slice>  lbandy; //!< liste des bandes selon Y
   
-  list<bande_slice>  lslix;
-  list<bande_slice>  lsliy;
+  list<bande_slice>  lslix; //!< liste des slices selon X
+  list<bande_slice>  lsliy; //!< liste des slices selon Y
 
 };
Index: /trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- /trunk/SophyaLib/NTools/generaldata.cc	(revision 913)
+++ /trunk/SophyaLib/NTools/generaldata.cc	(revision 914)
@@ -19,32 +19,11 @@
 //================================================================
 
-//++
-// Class	GeneralFitData
-// Lib		Outils++ 
-// include	generaldata.h
-//
-//	Classe de stoquage de donnees a plusieurs variables avec erreur
-//	sur l'ordonnee et sur les abscisses (options).
-//|   {x0(i),Ex0(i), x1(i),Ex1(i), x2(i),Ex2(i) ... ; Y(i),EY(i)}
-//--
-
-// Pour memoire, structure du rangement (n=mNVar):
-// - Valeur des abscisses mXP (idem pour mErrXP):
-//   x0,x1,x2,...,xn   x0,x1,x2,...,xn  ....  x0,x1,x2,....,xn
-//   |  1er point  |   |  2sd point  |  ....  | point mNData |
-//   Donc abscisse J=[0,mNVar[ du point numero I=[0,mNData[: mXP[I*mNVar+J]
-// - Valeur de l'ordonnee mF (idem pour mErr et mOK):
-//          f                f                      f
-//   |  1er point  |  |  2sd point  |  .... | point mNData |
-//   Donc point numero I [0,mNData[ : mF[i]
-
-//////////////////////////////////////////////////////////////////////
-//++
+//////////////////////////////////////////////////////////////////////
+/*!
+  Constructeur. ``nVar'' represente la dimension de l'espace des abscisses,
+  ``ndatalloc'' le nombre maximum de points et ``errx'' si non nul
+  indique que l'on fournit des erreurs sur les ``nVar'' variables en abscisse.
+*/
 GeneralFitData::GeneralFitData(unsigned int nVar, unsigned int ndatalloc, uint_2 errx)
-//
-//	Constructeur. ``nVar'' represente la dimension de l'espace des abscisses,
-//	``ndatalloc'' le nombre maximum de points et ``errx'' si non nul
-//	indique que l'on fournit des erreurs sur les ``nVar'' variables en abscisse.
-//--
   : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
   , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
@@ -59,13 +38,12 @@
 }
 
-//++
+/*!
+  Constructeur par copie. 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::GeneralFitData(const GeneralFitData& data, bool clean)
-//
-//	Constructeur par copie. 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.
-//--
   : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
   , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
@@ -98,9 +76,8 @@
 }
 
-//++
+/*!
+  Constructeur par defaut.
+*/
 GeneralFitData::GeneralFitData()
-//
-//	Constructeur par defaut.
-//--
   : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
   , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
@@ -110,9 +87,8 @@
 }
 
-//++
+/*!
+  Destructeur
+*/
 GeneralFitData::~GeneralFitData()
-//
-//	Destructeur
-//--
 {
  Delete();
@@ -120,12 +96,11 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour redefinir la structure de donnees (ou la creer si on a utilise
+  le createur par defaut). Voir les explications des arguments
+  dans les commentaires du constructeur. Si ``errx''\<0 alors
+  la valeur prise est celle definie auparavent.
+*/
 void GeneralFitData::Alloc(unsigned int nVar, unsigned int ndatalloc, int_2 errx)
-//
-//	Pour redefinir la structure de donnees (ou la creer si on a utilise
-//	le createur par defaut). Voir les explications des arguments
-//	dans les commentaires du constructeur. Si ``errx''<0 alors
-//	la valeur prise est celle definie auparavent.
-//--
 {
 ASSERT( nVar>0 && ndatalloc>0 );
@@ -151,4 +126,7 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+   Gestion des des-allocations
+*/
 void GeneralFitData::Delete()
 {
@@ -163,11 +141,10 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Remise a zero de la structure pour nouveau remplissage (pas d'arg)
+  ou remise a la position ``ptr'' (si arg). Les donnees apres ``ptr''
+  sont sur-ecrites.
+*/
 void GeneralFitData::SetDataPtr(int ptr)
-//
-//	Remise a zero de la structure pour nouveau remplissage (pas d'arg)
-//	ou remise a la position ``ptr'' (si arg). Les donnees apres ``ptr''
-//	sont sur-ecrites.
-//--
 {
  ASSERT(ptr >= 0 && ptr < mNDataAlloc);
@@ -179,9 +156,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour tuer un point
+*/
 void GeneralFitData::KillData(int i)
-//
-//	Pour tuer un point
-//--
 {
  ASSERT(i >= 0 && i < mNData);
@@ -192,9 +168,8 @@
 }
 
-//++
+/*!
+  Pour tuer une serie de points
+*/
 void GeneralFitData::KillData(int i1,int i2)
-//
-//	Pour tuer une serie de points
-//--
 {
  ASSERT(i1 >= 0 && i1 < mNData);
@@ -206,9 +181,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour re-valider le point numero i ([0,NData]).
+*/
 void GeneralFitData::ValidData(int i)
-//
-//	Pour re-valider le point numero i ([0,NData]).
-//--
 {
  ASSERT(i >= 0 && i < mNData);
@@ -223,9 +197,8 @@
 }
 
-//++
+/*!
+  Pour re-valider les points numeros i1 a i2.
+*/
 void GeneralFitData::ValidData(int i1,int i2)
-//
-//	Pour re-valider les points numeros i1 a i2.
-//--
 {
  ASSERT(i1 >= 0 && i1 < mNData);
@@ -236,9 +209,8 @@
 }
 
-//++
+/*!
+  Pour re-valider tous les points.
+*/
 void GeneralFitData::ValidData()
-//
-//	Pour re-valider tous les points.
-//--
 {
  for(int i=0;i<mNData;i++) ValidData(i);
@@ -246,21 +218,17 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour redefinir un point a \f$ {x,[errx] ; f,err} \f$
+*/
 void GeneralFitData::RedefineData1(int i,double x,double f,double err,double errx)
-//
-//	Pour redefinir un point a
-//|     {x,[errx] ; f,err}
-//--
 {
  RedefineData(i,&x,f,err,&errx);
 }
 
-//++
+/*!
+  Pour redefinir un point a \f$ {x,[errx], y,[erry] ; f,err} \f$ 
+*/
 void GeneralFitData::RedefineData2(int i,double x,double y,double f
                                   ,double err,double errx,double erry)
-//
-//	Pour redefinir un point a
-//|     {x,[errx], y,[erry] ; f,err}
-//--
 {
  double xp[2] = {x,y};
@@ -269,10 +237,9 @@
 }
 
-//++
+/*!
+  Pour redefinir un point a
+  \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$ 
+*/
 void GeneralFitData::RedefineData(int i,double* xp,double f,double err,double* errxp)
-//
-//	Pour redefinir un point a
-//| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
-//--
 {
  ASSERT(i>=0 && i<mNData);
@@ -300,21 +267,17 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour ajouter un point \f$ {x,[errx] ; f,err} \f$
+*/
 void GeneralFitData::AddData1(double x, double f, double err, double errx)
-//
-//	Pour ajouter un point
-//|     {x,[errx] ; f,err}
-//--
 {
  AddData(&x,f,err,&errx);
 }
 
-//++
+/*!
+  Pour ajouter un point \f$ {x,[errx], y,[erry] ; f,err} \f$ 
+*/
 void GeneralFitData::AddData2(double x, double y, double f
                              , double err, double errx, double erry)
-//
-//	Pour ajouter un point
-//|     {x,[errx], y,[erry] ; f,err}
-//--
 {
  double xp[2] = {x,y};
@@ -323,10 +286,9 @@
 }
 
-//++
+/*!
+  Pour ajouter un point
+  \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$
+*/
 void GeneralFitData::AddData(double* xp, double f, double err,double* errxp)
-//
-//	Pour ajouter un point
-//| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
-//--
 {
  ASSERT(mNData < mNDataAlloc);
@@ -351,10 +313,9 @@
 }
 
-//++
+/*!
+  Pour ajouter un point
+ \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$ 
+*/
 void GeneralFitData::AddData(float* xp, float f, float err, float* errxp)
-//
-//	Pour ajouter un point
-//| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
-//--
 {
  {for(int i=0;i<mNVar;i++) BuffVar[i] = (double) xp[i];}
@@ -364,11 +325,10 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+  \f$ {x(i),[errx(i)] ; f(i),err(i)} \f$
+*/
 void GeneralFitData::SetData1(int nData
             , double* x, double* f, double *err, double *errx)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|     {x(i),[errx(i)] ; f(i),err(i)}
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -381,11 +341,10 @@
 }
 
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+  \f$ {x(i),[errx(i)] ; f(i),err(i)} \f$
+*/
 void GeneralFitData::SetData1(int nData
             , float* x, float* f, float* err, float *errx)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|     {x(i),[errx(i)] ; f(i),err(i)}
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -398,11 +357,10 @@
 }
 
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+  \f$ {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)} \f$
+*/
 void GeneralFitData::SetData2(int nData, double* x, double* y, double* f
                              ,double *err,double *errx,double *erry)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|     {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)}
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -416,11 +374,10 @@
 }
 
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+ \f$ {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)} \f$
+*/
 void GeneralFitData::SetData2(int nData, float* x, float* y, float* f
                              ,float *err,float *errx,float *erry)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|     {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)}
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -434,18 +391,20 @@
 }
 
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+  \f$ {X0(i),[EX0(i)], X1(i),[EX1(i)], X2(i),[EX2(i)], ... ; F(i),Err(i)} \f$
+
+  Attention: si la structure est n'est pas vide, les tableaux sont copies
+  apres les donnees pre-existantes (qui ne sont donc pas detruites). Pour
+  effacer les donnees pre-existantes utiliser SetDataPtr(0).
+  \verbatim
+      Ici **xp est un pointeur sur un tableau de pointeurs tq
+        xp[0] = &X0[0], xp[1] = &X1[0], xp[2] = &X2[0] ...
+      ou X0,X1,X2,... sont les tableaux X0[nData] X1[nData] X2[nData] ...
+      des variables (meme commentaire pour errxp).
+  \endverbatim
+*/
 void GeneralFitData::SetData(int nData,double** xp, double *f
                             , double *err, double** errxp)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|   {X0(i),[EX0(i)], X1(i),[EX1(i)], X2(i),[EX2(i)], ... ; F(i),Err(i)}
-//	Attention: si la structure est n'est pas vide, les tableaux sont copies
-//	apres les donnees pre-existantes (qui ne sont donc pas detruites). Pour
-//	effacer les donnees pre-existantes utiliser SetDataPtr(0).
-//|   Ici **xp est un pointeur sur un tableau de pointeurs tq
-//|     xp[0] = &X0[0], xp[1] = &X1[0], xp[2] = &X2[0] ...
-//|   ou X0,X1,X2,... sont les tableaux X0[nData] X1[nData] X2[nData] ...
-//|   des variables (meme commentaire pour errxp).
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -461,10 +420,9 @@
 }
 
-//++
+/*!
+  Voir commentaire ci-dessus.
+*/
 void GeneralFitData::SetData(int nData,float** xp, float *f
                             , float *err, float** errxp)
-//
-//	Voir commentaire ci-dessus.
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -482,9 +440,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Impression de l'etat de la structure de donnees
+*/
 void GeneralFitData::PrintStatus()
-//
-//	Impression de l'etat de la structure de donnees
-//--
 {
   cout<<"GeneralFitData:: "<<endl
@@ -495,9 +452,8 @@
 }
 
-//++
+/*!
+  Impression du point i
+*/
 void GeneralFitData::PrintData(int i)
-//
-//	Impression du point i
-//--
 {
  ASSERT(i>=0 && i<mNData);
@@ -512,9 +468,8 @@
 }
 
-//++
+/*!
+  Impression des points i1 a i2
+*/
 void GeneralFitData::PrintData(int i1,int i2)
-//
-//	Impression des points i1 a i2
-//--
 {
  if(i1<0) i1=0;
@@ -529,9 +484,8 @@
 }
 
-//++
+/*!
+  Impression de tous les points
+*/
 void GeneralFitData::PrintData()
-//
-//	Impression de tous les points
-//--
 {
  ASSERT(mNData>0);
@@ -540,9 +494,8 @@
 }
 
-//++
+/*!
+  Impression de l'etat de la structure de donnees avec bornes sur "s"
+*/
 void GeneralFitData::Show(ostream& os) const
-//
-//	Impression de l'etat de la structure de donnees avec bornes sur "s"
-//--
 {
 double min,max;
@@ -557,16 +510,17 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne les numeros des points de valeurs minimum et maximum
+  de la variable ``var'':
+  \verbatim
+    La variable "var" est de la forme : var = AB avec
+     B = 0 : variable d'ordonnee Y (valeur de A indifferente)
+     B = 1 : erreur variable d'ordonnee EY (valeur de A indifferente)
+     B = 2 : variable d'abscisse X numero A #[0,NVar[
+     B = 3 : erreur variable d'abscisse EX numero A #[0,NVar[
+    - Return NData checked si ok, -1 si probleme.
+  \endverbatim
+*/
 int GeneralFitData::GetMnMx(int var,int& imin,int& imax) const
-//
-//	Retourne les numeros des points de valeurs minimum et maximum
-//	de la variable ``var'':
-//| La variable "var" est de la forme : var = AB avec
-//|  B = 0 : variable d'ordonnee Y (valeur de A indifferente)
-//|  B = 1 : erreur variable d'ordonnee EY (valeur de A indifferente)
-//|  B = 2 : variable d'abscisse X numero A #[0,NVar[
-//|  B = 3 : erreur variable d'abscisse EX numero A #[0,NVar[
-//| - Return NData checked si ok, -1 si probleme.
-//--
 {
 imin = imax = -1;
@@ -592,10 +546,9 @@
 }
 
-//++
+/*!
+  Retourne le minimum et le maximum de la variable ``var''
+  (cf commentaires GetMnMx).
+*/
 int GeneralFitData::GetMnMx(int var,double& min,double& max) const
-//
-//	Retourne le minimum et le maximum de la variable ``var''
-//	(cf commentaires GetMnMx).
-//--
 {
 min = 1.; max = -1.;
@@ -622,13 +575,15 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+//
+  Retourne la moyenne et le sigma de la variable ``var''
+  (cf commentaires GetMnMx).
+  \verbatim
+    - Return : nombre de donnees utilisees, -1 si pb, -2 si sigma<0.
+    - Seuls les points valides de valeur entre min,max sont utilises.
+      Si min>=max pas de coupures sur les valeurs.
+  \endverbatim
+*/
 int GeneralFitData::GetMeanSigma(int var,double& mean,double& sigma,double min,double max)
-//
-//	Retourne la moyenne et le sigma de la variable ``var''
-//	(cf commentaires GetMnMx).
-//| - Return : nombre de donnees utilisees, -1 si pb, -2 si sigma<0.
-//| - Seuls les points valides de valeur entre min,max sont utilises.
-//|   Si min>=max pas de coupures sur les valeurs.
-//--
 {
 mean = sigma = 0.;
@@ -661,17 +616,18 @@
 }
 
-//++
+/*!
+  Retourne le mode de la variable ``var''
+  (cf commentaires GetMnMx).
+  \verbatim
+    - Return : nombre de donnees utilisees, -1 si pb.
+    - Seuls les points valides de valeur entre min,max sont utilises.
+      Si min>=max pas de coupures sur les valeurs.
+    - Le calcul du mode est approximee par la formule:
+        Mode = Median - coeff*(Mean-Median)   (def: coeff=0.8)
+    - Kendall and Stuart donne coeff=2., mais coeff peut etre regle.
+  \endverbatim
+*/
 int GeneralFitData::GetMoMeMed(int var,double& mode,double& mean,double& median,
                                double min,double max,double coeff)
-//
-//	Retourne le mode de la variable ``var''
-//	(cf commentaires GetMnMx).
-//| - Return : nombre de donnees utilisees, -1 si pb.
-//| - Seuls les points valides de valeur entre min,max sont utilises.
-//|   Si min>=max pas de coupures sur les valeurs.
-//| - Le calcul du mode est approximee par la formule:
-//|     Mode = Median - coeff*(Mean-Median)   (def: coeff=0.8)
-//| - Kendall and Stuart donne coeff=2., mais coeff peut etre regle.
-//--
 {
 mode = mean = median = 0.;
@@ -716,9 +672,8 @@
 }
 
-//++
+/*!
+  Cf description ci-dessus ``GetMoMeMed''.
+*/
 int GeneralFitData::GetMode(int var,double& mode,double min,double max,double coeff)
-//
-//	Cf description ci-dessus ``GetMoMeMed''.
-//--
 {
 double mean,median;
@@ -727,19 +682,20 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour fiter un polynome de degre ``degre''. On fite
+  Y=f(X) ou Y=Val et X=Absc(varx). Si ``ey'' est ``true''
+  le fit prend en compte les erreurs stoquees dans EVal,
+  sinon fit sans erreurs. Le resultat du fit est retourne
+  dans le polynome ``pol''.
+  \verbatim
+  Return:
+     -   Res = le residu du fit
+     -   -1 si degre<0
+     -   -2 si probleme sur numero de variable X
+     -   -4 si NDataGood<0
+     -   -5 si nombre de data trouves different de NDataGood
+  \endverbatim
+*/
 double GeneralFitData::PolFit(int varx,Poly& pol,int degre,bool ey)
-//
-//	Pour fiter un polynome de degre ``degre''. On fite
-//	Y=f(X) ou Y=Val et X=Absc(varx). Si ``ey'' est ``true''
-//	le fit prend en compte les erreurs stoquees dans EVal,
-//	sinon fit sans erreurs. Le resultat du fit est retourne
-//	dans le polynome ``pol''.
-//| Return:
-//|  -   Res = le residu du fit
-//|  -   -1 si degre<0
-//|  -   -2 si probleme sur numero de variable X
-//|  -   -4 si NDataGood<0
-//|  -   -5 si nombre de data trouves different de NDataGood
-//--
 {
 if(degre<0) return -1.;
@@ -769,25 +725,25 @@
 }
 
-//++
+/*!
+  Pour fiter un polynome de degre ``degre1''. On fite
+  Z=f(X,Y) ou Z=Val et X=Absc(varx) et Y=Absc(vary).
+  Si ``ey'' est ``true'' le fit prend en compte les erreurs
+  stoquees dans EVal, sinon fit sans erreurs. Si ``degre2''
+  negatif, le fit determine un polynome en X,Y de degre
+  total ``degre`''. Si ``degre2'' positif ou nul, le fit
+  demande un fit de ``degre1'' pour la variable X et de degre
+  ``degre2'' sur la variable Y. Le resultat du fit est retourne
+  dans le polynome ``pol''.
+  \verbatim
+    Return:
+     -   Res = le residu du fit
+     -   -1 si degre<0
+     -   -2 si probleme sur numero de variable X
+     -   -3 si probleme sur numero de variable Y
+     -   -4 si NDataGood<0
+     -   -5 si nombre de data trouves different de NDataGood
+  \endverbatim
+*/
 double GeneralFitData::PolFit(int varx,int vary,Poly2& pol,int degre1,int degre2,bool ez)
-//
-//
-//	Pour fiter un polynome de degre ``degre1''. On fite
-//	Z=f(X,Y) ou Z=Val et X=Absc(varx) et Y=Absc(vary).
-//	Si ``ey'' est ``true'' le fit prend en compte les erreurs
-//	stoquees dans EVal, sinon fit sans erreurs. Si ``degre2''
-//	negatif, le fit determine un polynome en X,Y de degre
-//	total ``degre`''. Si ``degre2'' positif ou nul, le fit
-//	demande un fit de ``degre1'' pour la variable X et de degre
-//	``degre2'' sur la variable Y. Le resultat du fit est retourne
-//	dans le polynome ``pol''.
-//| Return:
-//|  -   Res = le residu du fit
-//|  -   -1 si degre<0
-//|  -   -2 si probleme sur numero de variable X
-//|  -   -3 si probleme sur numero de variable Y
-//|  -   -4 si NDataGood<0
-//|  -   -5 si nombre de data trouves different de NDataGood
-//--
 {
 if(degre1<0) return -1.;
@@ -823,9 +779,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne une classe contenant les residus du fit ``gfit''.
+*/
 GeneralFitData GeneralFitData::FitResidus(GeneralFit& gfit)
-//
-//	Retourne une classe contenant les residus du fit ``gfit''.
-//--
 {
 if(gfit.GetNVar()!=mNVar)
@@ -834,9 +789,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant la function du fit ``gfit''.
+*/
 GeneralFitData GeneralFitData::FitFunction(GeneralFit& gfit)
-//
-//	Retourne une classe contenant la function du fit ``gfit''.
-//--
 {
 if(gfit.GetNVar()!=mNVar)
@@ -846,14 +800,16 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+//
+  Retourne la donnee `n' dans le vecteur de double `ret'.
+  \verbatim
+    Par defaut, ret=NULL et le buffer interne de la classe est retourne
+    - Les donnees sont rangees dans l'ordre:
+       x0,x1,x2,... ; ex0,ex1,ex2,...  ; y ; ey ; ok(0/1)
+       |<- NVar ->| + |<-   NVar   ->| + 1 +  1 +  1
+      Le vecteur ret a la taille 2*NVar+2+1
+  \endverbatim
+*/
 r_8* GeneralFitData::GetVec(int n, r_8* ret)   const
-//
-//	Retourne la donnee `n' dans le vecteur de double `ret'.
-//| Par defaut, ret=NULL et le buffer interne de la classe est retourne
-//| - Les donnees sont rangees dans l'ordre:
-//|    x0,x1,x2,... ; ex0,ex1,ex2,...  ; y ; ey ; ok(0/1)
-//|    |<- NVar ->| + |<-   NVar   ->| + 1 +  1 +  1
-//|   Le vecteur ret a la taille 2*NVar+2+1
-//--
 {
 int i;
@@ -870,10 +826,9 @@
 }
 
-//++
+/*!
+  Retourne la donnee `n' dans le vecteur de float `ret'
+  (meme commentaires que pour GetVec).
+*/
 r_4* GeneralFitData::GetVecR4(int n, r_4* ret)   const
-//
-//	Retourne la donnee `n' dans le vecteur de float `ret'
-//	(meme commentaires que pour GetVec).
-//--
 {
 if (ret == NULL) ret = BuffVarR4;
@@ -886,87 +841,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
-// int inline int GetSpaceFree() const
-//	Retourne la place restante dans la structure (nombre de
-//	donnees que l'on peut encore stoquer).
-//--
-//++
-// inline int  NVar()       const
-//	Retourne le nombre de variables Xi
-//--
-//++
-// inline int  NData()
-//	Retourne le nombre de donnees
-//--
-//++
-// inline int  NDataGood()  const
-//	Retourne le nombre de bonnes donnees (utilisees pour le fit)
-//--
-//++
-// inline int  NDataAlloc() const
-//	Retourne la place maximale allouee pour les donnees
-//--
-//++
-// inline unsigned short int IsValid(int i) const
-//	Retourne 1 si point valide, sinon 0
-//--
-//++
-// inline bool HasXErrors()
-//	Retourne ``true'' si il y a des erreurs sur les variables
-//	d'abscisse, ``false'' sinon.
-//--
-//++
-// inline double X1(int i) const
-//	Retourne l'abscisse pour 1 dimension (y=f(x)) donnee I
-//--
-//++
-// inline double X(int i) const
-//	Retourne la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Y(int i) const
-//	Retourne la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Z(int i) const
-//	Retourne la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Absc(int j,int i) const
-//	Retourne la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
-//--
-//++
-// inline double Val(int i) const
-//	Retourne la valeur de la Ieme donnee
-//--
-//++
-// inline double EX1(int i) const
-//	Retourne l'erreur (dx) sur l'abscisse pour 1 dimension (y=f(x)) donnee I
-//--
-//++
-// inline double EX(int i) const
-//	Retourne l'erreur (dx) sur la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EY(int i) const
-//	Retourne l'erreur (dy) sur la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EZ(int i) const
-//	Retourne l'erreur (dz) sur la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EAbsc(int j,int i) const
-//	Retourne l'erreur (dxj) sur la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
-//--
-//++
-// inline double EVal(int i) const {return mErr[i];}
-//	Retourne l'erreur de la Ieme donnee
-//--
-
-
-//////////////////////////////////////////////////////////////////////
 // ------- Implementation de  l interface NTuple  ---------
 
+/*!
+  Retourne le nombre de ligne = NData() (pour interface NTuple)
+*/
 uint_4 GeneralFitData::NbLines() const
 {
@@ -974,19 +851,22 @@
 }
 
-//++
+/*!
+  Retourne le nombre de colonnes du ntuple equivalent:
+  \verbatim
+    Exemple: on a une fonction sur un espace a 4 dimensions:
+    "x0,x1,x2,x3    , ex0,ex1,ex2,ex3    , y,   ey ,    ok"
+      0  1  2  3        4   5   6   7      8     9      10
+      |        |        |           |      |     |       |        
+      0       nv-1     nv         2*nv-1  2*nv  2*nv+1  2*nv+2
+    soit 2*nvar+3 variables/colonnes.
+  \endverbatim
+  (pour interface NTuple)
+*/
 uint_4 GeneralFitData::NbColumns() const
-//
-//	Retourne le nombre de colonnes du ntuple equivalent:
-//| Exemple: on a une fonction sur un espace a 4 dimensions:
-//| "x0,x1,x2,x3    , ex0,ex1,ex2,ex3    , y,   ey ,    ok"
-//|   0  1  2  3        4   5   6   7      8     9      10
-//|   |        |        |           |      |     |       |        
-//|   0       nv-1     nv         2*nv-1  2*nv  2*nv+1  2*nv+2
-//| soit 2*nvar+3 variables/colonnes.
-//--
 {
 return(2*NVar()+3);
 }
 
+//! Pour interface NTuple
 r_8 * GeneralFitData::GetLineD(int n) const
 {
@@ -994,4 +874,5 @@
 }
 
+//! Pour interface NTuple
 r_8 GeneralFitData::GetCell(int n, int k) const
 {
@@ -1001,4 +882,5 @@
 }
 
+//! Pour interface NTuple
 r_8 GeneralFitData::GetCell(int n, string const & nom) const
 {
@@ -1007,9 +889,8 @@
 }
 
-//++
+/*!
+  Retourne le minimum et le maximum de la variable `k' (pour interface NTuple).
+*/
 void GeneralFitData::GetMinMax(int k, double& min, double& max)  const
-//
-//	Retourne le minimum et le maximum de la variable `k'.
-//--
 {
 int var;
@@ -1024,4 +905,5 @@
 }
 
+//! Pour interface NTuple
 void GeneralFitData::GetMinMax(string const & nom, double& min, double& max)   const
 {
@@ -1030,4 +912,5 @@
 }
 
+//! Pour interface NTuple
 int GeneralFitData::ColumnIndex(string const & nom)  const
 {
@@ -1043,4 +926,5 @@
 }
 
+//! Pour interface NTuple
 string GeneralFitData::ColumnName(int k) const
 {
@@ -1056,11 +940,10 @@
 }
 
-//++
+/*!
+  Retourne une chaine de caracteres avec la declaration des noms de 
+  variables. si "nomx!=NULL" , des instructions d'affectation
+  a partir d'un tableau "nomx[i]" sont ajoutees (pour interface NTuple).
+*/
 string GeneralFitData::VarList_C(const char* nomx)  const
-//
-//	Retourne une chaine de caracteres avec la declaration des noms de 
-//	variables. si "nomx!=NULL" , des instructions d'affectation
-//	a partir d'un tableau "nomx[i]" sont ajoutees. 
-//--
 {
 char buff[256];
Index: /trunk/SophyaLib/NTools/generaldata.h
===================================================================
--- /trunk/SophyaLib/NTools/generaldata.h	(revision 913)
+++ /trunk/SophyaLib/NTools/generaldata.h	(revision 914)
@@ -19,9 +19,31 @@
 //================================================================
 
+/*!
+  Classe de stoquage de donnees a plusieurs variables avec erreur
+  sur l'ordonnee et sur les abscisses (options) :
+
+  \f$ {x0(i),Ex0(i), x1(i),Ex1(i), x2(i),Ex2(i) ... ; Y(i),EY(i)} \f$
+  \verbatim
+   Pour memoire, structure du rangement (n=mNVar):
+   - Valeur des abscisses mXP (idem pour mErrXP):
+     x0,x1,x2,...,xn   x0,x1,x2,...,xn  ....  x0,x1,x2,....,xn
+     |  1er point  |   |  2sd point  |  ....  | point mNData |
+     Donc abscisse J=[0,mNVar[ du point numero I=[0,mNData[: mXP[I*mNVar+J]
+   - Valeur de l'ordonnee mF (idem pour mErr et mOK):
+            f                f                      f
+     |  1er point  |  |  2sd point  |  .... | point mNData |
+     Donc point numero I [0,mNData[ : mF[i]
+  \endverbatim
+*/
+
 class GeneralFitData : public AnyDataObj , public NTupleInterface {
   friend class GeneralFit;
   friend class ObjFileIO<GeneralFitData>;
 public:
-  enum {Def_ErrF = 1, Def_ErrX = 0};
+  //! Valeurs par defaut pour l'utilisation des erreurs
+  enum {
+    Def_ErrF = 1, //!< erreurs sur F par defaut
+    Def_ErrX = 0  //!< pas d'erreurs sur les variables X,Y,... par defaut
+    };
 
   GeneralFitData(unsigned int nVar, unsigned int nDataAlloc, uint_2 errx=0);
@@ -67,40 +89,59 @@
   inline void Show() const {Show(cout);}
 
+  //! Retourne la place restante dans la structure (nombre de donnees que l'on peut encore stoquer).
   inline int GetSpaceFree() const { return mNDataAlloc - mNData; }
+  //! Retourne le nombre de variables Xi
   inline int NVar()       const {return mNVar;}
+  //! Retourne le nombre de donnees
   inline int NData()      const {return mNData;}
+  //! Retourne le nombre de bonnes donnees (utilisees pour le fit)
   inline int NDataGood()  const {return mNDataGood;}
+  //! Retourne la place maximale allouee pour les donnees
   inline int NDataAlloc() const {return mNDataAlloc;}
 
+  //! Retourne 1 si point valide, sinon 0
   inline unsigned short int IsValid(int i) const
                 {if(i>=0 && i<mNData) return mOK[i]; else return 0;}
+  //! Retourne ``true'' si il y a des erreurs sur les variables d'abscisse, ``false'' sinon.
   inline bool HasXErrors() {if(mErrXP) return true; else return false;}
 
+  //! Retourne l'abscisse pour 1 dimension (y=f(x)) donnee I
   inline double X1(int i) const
                 {if(i>=0 && i<mNData) return mXP[i]; else return 0.;}
+  //! Retourne la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
   inline double X(int i) const
                 {if(i>=0 && i<mNData) return mXP[i*mNVar]; else return 0.;}
+  //! Retourne la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
   inline double Y(int i) const
                 {if(i>=0 && i<mNData && 1<mNVar) return mXP[i*mNVar+1]; else return 0.;}
+  //! etourne la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
   inline double Z(int i) const
                 {if(i>=0 && i<mNData && 2<mNVar) return mXP[i*mNVar+2]; else return 0.;}
+  //! Retourne la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
   inline double Absc(int j,int i) const
                 {if(i>=0 && i<mNData && j<mNVar)return mXP[i*mNVar+j]; else return 0.;}
+  //! Retourne la valeur de la Ieme donnee
   inline double Val(int i) const
                 {if(i>=0 && i<mNData) return mF[i]; else return 0.;}
 
+  //! Retourne l'erreur (dx) sur l'abscisse pour 1 dimension (y=f(x)) donnee I
   inline double EX1(int i) const
                 {if(mErrXP && i>=0 && i<mNData) return mErrXP[i]; else return 0.;}
+  //! Retourne l'erreur (dx) sur la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
   inline double EX(int i) const
                 {if(mErrXP && i>=0 && i<mNData) return mErrXP[i*mNVar]; else return 0.;}
+  //! Retourne l'erreur (dy) sur la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
   inline double EY(int i) const
                 {if(mErrXP && i>=0 && i<mNData && 1<mNVar) return mErrXP[i*mNVar+1];
                  else return 0.;}
+  //! Retourne l'erreur (dz) sur la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
   inline double EZ(int i) const
                 {if(mErrXP && i>=0 && i<mNData && 2<mNVar) return mErrXP[i*mNVar+2];
                  else return 0.;}
+  //! Retourne l'erreur (dxj) sur la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
   inline double EAbsc(int j,int i) const
                 {if(mErrXP && i>=0 && i<mNData && j<mNVar) return mErrXP[i*mNVar+j];
                  else return 0.;}
+  //! Retourne l'erreur de la Ieme donnee
   inline double EVal(int i) const
                 {if(i>=0 && i<mNData) return mErr[i]; else return 0.;}
@@ -139,9 +180,9 @@
   int_4   mNDataGood;
   uint_2  mOk_EXP;
-  r_8* mXP;             // x0 y0 z0, x1 y1 z1, ..., xn yn zn 
-  r_8* mErrXP;          // Ex0 Ey0 Ez0, Ex1 Ey1 Ez1, ..., Exn Eyn Ezn 
-  r_8* mF;              // F0, F1, ...., Fn
-  r_8* mErr;            // EF0, EF1, ...., EFn
-  uint_2* mOK; // 1 si pt valid, 0 sinon
+  r_8* mXP;             //!< x0 y0 z0, x1 y1 z1, ..., xn yn zn 
+  r_8* mErrXP;          //!< Ex0 Ey0 Ez0, Ex1 Ey1 Ez1, ..., Exn Eyn Ezn 
+  r_8* mF;              //!< F0, F1, ...., Fn
+  r_8* mErr;            //!< EF0, EF1, ...., EFn
+  uint_2* mOK;          //!< 1 si pt valid, 0 sinon
   r_8* BuffVar;
   r_4* BuffVarR4;
Index: /trunk/SophyaLib/NTools/generalfit.cc
===================================================================
--- /trunk/SophyaLib/NTools/generalfit.cc	(revision 913)
+++ /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.
-//--
Index: /trunk/SophyaLib/NTools/generalfit.h
===================================================================
--- /trunk/SophyaLib/NTools/generalfit.h	(revision 913)
+++ /trunk/SophyaLib/NTools/generalfit.h	(revision 914)
@@ -13,4 +13,9 @@
 //================================================================
 
+
+/*!
+  Classe de fonctions parametrees a plusieurs variables:
+  \f$ F[x1,x2,x3,...:a1,a2,a3,...] \f$
+*/
 class GeneralFunction {
 public:
@@ -18,4 +23,5 @@
   virtual ~GeneralFunction();
 
+  //! Valeur de la fonction a definir par l'utilisateur (fct virtuelle pure)
   virtual double Value(double const xp[], double const* parm)=0;
   virtual double Val_Der(double const xp[], double const* parm
@@ -25,10 +31,12 @@
   void SetDeltaParm(double const* dparam);
 
+  //! Retourne le nombre de variables Xi
   inline int     NVar() const {return mNVar;}
+  //! Retourne le nombre de parametres Ai
   inline int     NPar() const {return mNPar;}
 
 protected:
-  const int mNVar;  // nombre de variables f(x,y,z,...)
-  const int mNPar;  // nombre de parametres
+  const int mNVar;  //!< nombre de variables f(x,y,z,...)
+  const int mNPar;  //!< nombre de parametres
 
   double *deltaParm;
@@ -40,4 +48,12 @@
 //================================================================
 
+/*!
+  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).
+*/
 class GeneralFunc : public GeneralFunction {
 public:
@@ -62,4 +78,8 @@
 class GeneralFitData;
 
+/*!
+  Classe de Xi2 a plusieurs parametres :
+  \f$ Xi2[a1,a2,a3,...] \f$
+*/
 class GeneralXi2 {
 public:
@@ -67,4 +87,10 @@
   virtual ~GeneralXi2();
 
+  /*!
+  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').
+  */
   virtual double Value(GeneralFitData& data, double* parm, int& ndataused)=0;
   virtual double Derivee(GeneralFitData& data, int i, double* parm);
@@ -74,8 +100,9 @@
   void SetDeltaParm(double const* dparam);
 
+  //! Retourne le nombre de parametres Ai.
   inline int     NPar() const {return mNPar;}
 
 protected:
-  const int mNPar;  // nombre de parametres
+  const int mNPar;  //!< nombre de parametres
 
   double *deltaParm;
@@ -86,4 +113,5 @@
 //================================================================
 
+//! Classe de fit d'une GeneralFunction sur une GeneralFitData
 class GeneralFit {
 public:
@@ -129,19 +157,32 @@
   double          GetMax(int n);
   double          GetMin(int n);
+  //! Retourne le Chi2
   inline double   GetChi2()    const {return Chi2;};
+  //! Retourne le Chi2 reduit
   inline double   GetChi2Red() const {
                         if(mNddl<=0) return (double) mNddl;
                         return Chi2/(double) mNddl;
                                      };
+  //! Retourne la precision de convergence pour le parametre i.
   inline double   GetEps(int i) const {return Eps(i);};
+  //! Retourne le nombre de degres de liberte
   inline int      GetNddl()    const {return mNddl;};
+  //! Retourne le nombre d'iterations
   inline int      GetNStep()   const {return nStep;};
+  //! Retourne le nombre de variables
   inline int      GetNVar()    const {return mNVar;};
+  //! Retourne le nombre de parametres
   inline int      GetNPar()    const {return mNPar;};
+  //! Retourne le nombre de parametres libres
   inline int      GetNFree()   const {return mNParFree;};
+  //! Retourne le nombre de parametres bornes
   inline int      GetNBound()  const {return mNParBound;};
+  //! Retourne le nstop de convergence
   inline int      GetNStop()   const {return nStop;};
+  //! Retourne le nstop de convergence lente.
   inline int      GetNStopLent()   const {return nStopLent;};
+  //! Retourne le pointeur sur la GeneralFunction utilisee.
   inline GeneralFunction*  GetFunction() const {return mFunction;};
+  //! Retourne le pointeur sur la GeneralFitData utilisee.
   inline GeneralFitData*   GetGData() const {return mData;};
 
@@ -158,9 +199,9 @@
 
 protected:
-  int             mNtry;       // numero d'appel de la routine de fit.
-  int             mNVar;       // nombre de variables f(x,y,z,...)
-  int             mNPar;       // nombre de parametres
-  int             mNParFree;   // nombre de parametres libres
-  int             mNParBound;  // nombre de parametres bornes
+  int             mNtry;       //!< numero d'appel de la routine de fit.
+  int             mNVar;       //!< nombre de variables f(x,y,z,...)
+  int             mNPar;       //!< nombre de parametres
+  int             mNParFree;   //!< nombre de parametres libres
+  int             mNParBound;  //!< nombre de parametres bornes
   GeneralFunction*  mFunction;
   GeneralXi2*       mFuncXi2;
Index: /trunk/SophyaLib/TArray/tmatrix.h
===================================================================
--- /trunk/SophyaLib/TArray/tmatrix.h	(revision 913)
+++ /trunk/SophyaLib/TArray/tmatrix.h	(revision 914)
@@ -23,5 +23,5 @@
   TMatrix(const TMatrix<T>& a, bool share);
   TMatrix(const TArray<T>& a); 
-  TMatrix(const TArray<T>& a,  bool share, short mm=CMemoryMapping);
+  TMatrix(const TArray<T>& a,  bool share, short mm=AutoMemoryMapping);
   virtual ~TMatrix();
 
Index: /trunk/SophyaLib/TArray/triangmtx.h
===================================================================
--- /trunk/SophyaLib/TArray/triangmtx.h	(revision 913)
+++ /trunk/SophyaLib/TArray/triangmtx.h	(revision 914)
@@ -1,4 +1,3 @@
 // This may look like C code, but it is really -*- C++ -*-
-/*! Class for inferior triangular matrix (base class for the class Alm) */
 
 #ifndef TRIANGMTX_H_SEEN
@@ -10,15 +9,17 @@
 namespace SOPHYA {
 
+//! Class for inferior triangular matrix (base class for the class Alm)
 template <class T>
-class TriangularMatrix 
-  {
-    
-  public :
+class TriangularMatrix {
+public :
 
+//! Default constructor
 TriangularMatrix()   {};
-  /* instanciate a triangular matrix from the number of rows */
+//! instanciate a triangular matrix from the number of rows
 TriangularMatrix(int rowSize)  : long_diag_((uint_4)rowSize) {elem_.ReSize((uint_4) (rowSize*(rowSize+1)/2) ); };
+//! Copy constructor (possibility of sharing datas)
 TriangularMatrix(const TriangularMatrix<T>& a,  bool share=false)  : elem_(a.elem_, share),  long_diag_(a.long_diag_) {;}
-/*! resize the matrix with a new number of rows */
+
+//! resize the matrix with a new number of rows
 inline void ReSizeRow(int rowSize) 
   {
@@ -28,4 +29,5 @@
  inline void SetTemp(bool temp=false) const {elem_.SetTemp(temp);}
 
+//! Equal operator
 inline TriangularMatrix<T>& operator = (const TriangularMatrix<T>& a)
 {
@@ -34,15 +36,21 @@
   return *this;
 }
+
+//! () operator : access to elements row \b l and column \b m
 inline T& operator()(int l, int m) 
   {
       return  elem_(adr_ij(l,m));
   }
+//! () operator : access to elements row \b l and column \b m
 inline T const& operator()(int l, int m) const 
   {
       return *(elem_.Begin()+ adr_ij(l,m));
   }
- inline  int_4  rowNumber() const {return (int_4)long_diag_;}
-  private: 
- /*! compute the address of an element in the single array representing the matrix */
+
+//! Return number of rows
+inline  int_4  rowNumber() const {return (int_4)long_diag_;}
+
+private: 
+//! compute the address of an element in the single array representing the matrix
 inline uint_4 adr_ij(int i,int j) const 
 {
@@ -56,6 +64,6 @@
 }
 
- uint_4 long_diag_;
- NDataBlock<T> elem_;
+uint_4 long_diag_;    //!< size of the square matrix
+NDataBlock<T> elem_;  //!< Data block
 
   };
Index: /trunk/SophyaLib/TArray/tvector.cc
===================================================================
--- /trunk/SophyaLib/TArray/tvector.cc	(revision 913)
+++ /trunk/SophyaLib/TArray/tvector.cc	(revision 914)
@@ -1,3 +1,3 @@
-// $Id: tvector.cc,v 1.4 2000-04-12 17:42:30 ansari Exp $
+// $Id: tvector.cc,v 1.5 2000-04-13 16:04:49 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
@@ -70,5 +70,5 @@
  */
 template <class T>
-TVector<T>::TVector(const TArray<T>& a, bool share, short mm, short lcv )
+TVector<T>::TVector(const TArray<T>& a, bool share, short lcv, short mm)
 : TMatrix<T>(a, share, mm)
 {
Index: /trunk/SophyaLib/TArray/tvector.h
===================================================================
--- /trunk/SophyaLib/TArray/tvector.h	(revision 913)
+++ /trunk/SophyaLib/TArray/tvector.h	(revision 914)
@@ -17,9 +17,9 @@
   // Creation / destruction 
   TVector();
-  TVector(uint_4 n, short lcv=ColumnVector, short mm=AutoMemoryMapping);
+  TVector(uint_4 n, short lcv=AutoVectorType, short mm=AutoMemoryMapping);
   TVector(const TVector<T>& v);
   TVector(const TVector<T>& v, bool share);
   TVector(const TArray<T>& a);
-  TVector(const TArray<T>& a,  bool share, short mm=CMemoryMapping, short lcv=ColumnVector);
+  TVector(const TArray<T>& a,  bool share, short lcv=AutoVectorType, short mm=AutoMemoryMapping);
 
   virtual ~TVector();
@@ -28,5 +28,4 @@
   inline  TVector<T>& operator = (const TVector<T>& a)
                        { Set(a);  return(*this); }
-
 
   // Gestion taille/Remplissage
@@ -50,5 +49,5 @@
   // Operateur d'affectation
   //! Fill the vector with Sequence \b seq
-  inline  TMatrix<T>&  operator = (Sequence seq) { SetSeq(seq); return(*this); }
+  inline  TVector<T>&  operator = (Sequence seq) { SetSeq(seq); return(*this); }
 
   // Operations diverses  avec une constante
