Index: trunk/SophyaLib/NTools/fct1dfit.cc
===================================================================
--- trunk/SophyaLib/NTools/fct1dfit.cc	(revision 919)
+++ trunk/SophyaLib/NTools/fct1dfit.cc	(revision 926)
@@ -18,38 +18,22 @@
 
 /////////////////////////////////////////////////////////////////
-//++ 
-// Module	Classes de fonctions 1D
-// Lib	Outils++ 
-// include	fct1dfit.h
-//--
-/////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////////////////////////////
-//++
-// Titre	Gauss1DPol
-// \index{Gauss1DPol}
-//
-//|  Gaussienne+polynome:
-//|  Si polcenter=true: xc=(x-par[1]), sinon xc=x
-//|  f(x) = par[0]*exp[-0.5*( (x-par[1]) / par[2] )**2 ]
-//|        +par[3] + par[4]*xc + .... + par[3+NDegPol]*xc**NDegPol
-//|  NDegPol = degre du polynome, si <0 pas de polynome
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::Gauss1DPol
+  \ingroup NTools
+  \anchor Gauss1DPol
+  \verbatim
+     Gaussienne+polynome:
+     Si polcenter=true: xc=(x-par[1]), sinon xc=x
+     f(x) = par[0]*exp[-0.5*( (x-par[1]) / par[2] )**2 ]
+           +par[3] + par[4]*xc + .... + par[3+NDegPol]*xc**NDegPol
+     NDegPol = degre du polynome, si <0 pas de polynome
+  \endverbatim
+*/
 Gauss1DPol::Gauss1DPol(unsigned int ndegpol,bool polcenter)
-//
-//	Createur.
-//--
 : GeneralFunction(1,ndegpol+4), NDegPol(ndegpol), PolCenter(polcenter)
 {
 }
 
-//++
 Gauss1DPol::Gauss1DPol(bool polcenter)
-//
-//	Createur.
-//--
 : GeneralFunction(1,3), NDegPol(-1), PolCenter(polcenter)
 {
@@ -107,30 +91,22 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	GaussN1DPol
-// \index{GaussN1DPol}
-//
-//| Gaussienne_Normalisee+polynome (par[0]=Volume:
-//|  Si polcenter=true: xc=(x-par[1]), sinon xc=x
-//|  f(x) = par[0]/(sqrt(2*Pi)*par[2])*exp[-0.5*((x-par[1])/par[2])**2 ]
-//|        +par[3] + par[4]*xc + .... + par[3+NDegPol]*xc**NDegPol
-//|  NDegPol = degre du polynome, si <0 pas de polynome
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::GaussN1DPol
+  \ingroup NTools
+  \anchor GaussN1DPol
+  \verbatim
+    Gaussienne_Normalisee+polynome (par[0]=Volume:
+     Si polcenter=true: xc=(x-par[1]), sinon xc=x
+     f(x) = par[0]/(sqrt(2*Pi)*par[2])*exp[-0.5*((x-par[1])/par[2])**2 ]
+           +par[3] + par[4]*xc + .... + par[3+NDegPol]*xc**NDegPol
+     NDegPol = degre du polynome, si <0 pas de polynome
+  \endverbatim
+*/
 GaussN1DPol::GaussN1DPol(unsigned int ndegpol,bool polcenter)
-//
-//	Createur.
-//--
 : GeneralFunction(1,ndegpol+4), NDegPol(ndegpol), PolCenter(polcenter)
 {
 }
 
-//++
 GaussN1DPol::GaussN1DPol(bool polcenter)
-//
-//	Createur.
-//--
 : GeneralFunction(1,3), NDegPol(-1), PolCenter(polcenter)
 {
@@ -189,30 +165,22 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	Exp1DPol
-// \index{Exp1DPol}
-//
-//|  Exponentielle+polynome:
-//|  xx = x - X_Center
-//|  f(x) = exp[par[0]+par[1]*xx]
-//|        +par[2] + par[3]*xx + .... + par[2+NDegPol]*xx**NDegPol
-//|  NDegPol = degre du polynome, si <0 pas de polynome
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::Exp1DPol
+  \ingroup NTools
+  \anchor Exp1DPol
+  \verbatim
+     Exponentielle+polynome:
+     xx = x - X_Center
+     f(x) = exp[par[0]+par[1]*xx]
+           +par[2] + par[3]*xx + .... + par[2+NDegPol]*xx**NDegPol
+     NDegPol = degre du polynome, si <0 pas de polynome
+  \endverbatim
+*/
 Exp1DPol::Exp1DPol(unsigned int ndegpol,double x0)
-//
-//	Createur.
-//--
 : GeneralFunction(1,ndegpol+3), NDegPol(ndegpol), X_Center(x0)
 {
 }
 
-//++
 Exp1DPol::Exp1DPol(double x0)
-//
-//	Createur.
-//--
 : GeneralFunction(1,2), NDegPol(-1), X_Center(x0)
 {
@@ -259,20 +227,16 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	Polyn1D
-// \index{Polyn1D}
-//
-//| polynome 1D:
-//|  xx = x - X_Center
-//|  f(x) = par[0] + par[1]*xx + .... + par[NDegPol+1]*xx**NDegPol
-//|  NDegPol = degre du polynome
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::Polyn1D
+  \ingroup NTools
+  \anchor Polyn1D
+  \verbatim
+    polynome 1D:
+     xx = x - X_Center
+     f(x) = par[0] + par[1]*xx + .... + par[NDegPol+1]*xx**NDegPol
+     NDegPol = degre du polynome
+  \endverbatim
+*/
 Polyn1D::Polyn1D(unsigned int ndegpol,double x0)
-//
-//	Createur.
-//--
 : GeneralFunction(1,ndegpol+1), NDegPol(ndegpol), X_Center(x0)
 {
@@ -309,39 +273,33 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	HarmonieNu
-// \index{HarmonieNu}
-//
-//| Analyse harmonique:
-//|  f(t) = par(1) + Sum[par(2k)  *cos(2*pi*k*par(0)*(t-t0)]
-//|                + Sum[par(2k+1)*sin(2*pi*k*par(0)*(t-t0)]
-//|  la somme Sum porte sur l'indice k qui varie de [1,NHarm()+1]
-//|  avec la convention   k=1  pour le fondamental
-//|                       k>1  pour le (k-1)ieme harmonique
-//--
-//++
-//|  par(0) = inverse de la periode (frequence)
-//|  par(1) = terme constant
-//|  par(2), par(3) = termes devant le cosinus et le sinus
-//|                   du fondamental
-//|  par(2(m+1)), par(2(m+1)+1) = termes devant le cosinus
-//|                   et le sinus de l'harmonique m (m>=1).
-//|  NHarm() = nombre d'harmoniques a fitter.
-//|  T0() = centrage des temps, ce n'est pas un parametre du fit.
-//	`Conseil:' Avant de faire un fit avec les `NHarm()'
-//	harmoniques, il est preferable de faire un pre-fit
-//	ou seuls les parametres 1,2 et 3 sont libres et d'injecter
-//	le resultat du fit sur ces 3 parametres comme valeurs
-//	de depart pour le fit global avec les `NHarm()' harmoniques.
-//	De toute facon, le fit ne marchera que si la periode
-//	est initialisee de facon tres precise.
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::HarmonieNu
+  \ingroup NTools
+  \anchor HarmonieNu
+  \verbatim
+    Analyse harmonique:
+     f(t) = par(1) + Sum[par(2k)  *cos(2*pi*k*par(0)*(t-t0)]
+                   + Sum[par(2k+1)*sin(2*pi*k*par(0)*(t-t0)]
+     la somme Sum porte sur l'indice k qui varie de [1,NHarm()+1]
+     avec la convention   k=1  pour le fondamental
+                          k>1  pour le (k-1)ieme harmonique
+     par(0) = inverse de la periode (frequence)
+     par(1) = terme constant
+     par(2), par(3) = termes devant le cosinus et le sinus
+                      du fondamental
+     par(2(m+1)), par(2(m+1)+1) = termes devant le cosinus
+                      et le sinus de l'harmonique m (m>=1).
+     NHarm() = nombre d'harmoniques a fitter.
+     T0() = centrage des temps, ce n'est pas un parametre du fit.
+   	`Conseil:' Avant de faire un fit avec les `NHarm()'
+   	harmoniques, il est preferable de faire un pre-fit
+   	ou seuls les parametres 1,2 et 3 sont libres et d'injecter
+   	le resultat du fit sur ces 3 parametres comme valeurs
+   	de depart pour le fit global avec les `NHarm()' harmoniques.
+   	De toute facon, le fit ne marchera que si la periode
+   	est initialisee de facon tres precise.
+  \endverbatim
+*/
 HarmonieNu::HarmonieNu(unsigned int nharm,double t0)
-//
-//	Createur.
-//--
 : GeneralFunction(1,4+2*nharm), NHarm(nharm), T0(t0)
 {
@@ -384,32 +342,26 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	HarmonieT
-// \index{HarmonieT}
-//
-//| Analyse harmonique:
-//|  f(t) = par(1) + Sum[par(2k)  *cos(2*pi*k*(t-t0)/par(0)]
-//|                + Sum[par(2k+1)*sin(2*pi*k*(t-t0)/par(0)]
-//|  la somme Sum porte sur l'indice k qui varie de [1,NHarm()+1]
-//|  avec la convention   k=1  pour le fondamental
-//|                       k>1  pour le (k-1)ieme harmonique
-//--
-//++
-//|  par(0) = periode
-//|  par(1) = terme constant
-//|  par(2), par(3) = termes devant le cosinus et le sinus
-//|                   du fondamental
-//|  par(2(m+1)), par(2(m+1)+1) = termes devant le cosinus
-//|                   et le sinus de l'harmonique m (m>=1).
-//|  NHarm() = nombre d'harmoniques a fitter.
-//|  T0() = centrage des temps, ce n'est pas un parametre du fit.
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::HarmonieT
+  \ingroup NTools
+  \anchor HarmonieT
+  \verbatim
+    Analyse harmonique:
+     f(t) = par(1) + Sum[par(2k)  *cos(2*pi*k*(t-t0)/par(0)]
+                   + Sum[par(2k+1)*sin(2*pi*k*(t-t0)/par(0)]
+     la somme Sum porte sur l'indice k qui varie de [1,NHarm()+1]
+     avec la convention   k=1  pour le fondamental
+                          k>1  pour le (k-1)ieme harmonique
+     par(0) = periode
+     par(1) = terme constant
+     par(2), par(3) = termes devant le cosinus et le sinus
+                      du fondamental
+     par(2(m+1)), par(2(m+1)+1) = termes devant le cosinus
+                      et le sinus de l'harmonique m (m>=1).
+     NHarm() = nombre d'harmoniques a fitter.
+     T0() = centrage des temps, ce n'est pas un parametre du fit.
+  \endverbatim
+*/
 HarmonieT::HarmonieT(unsigned int nharm,double t0)
-//
-//	Createur.
-//--
 : GeneralFunction(1,4+2*nharm), NHarm(nharm), T0(t0)
 {
@@ -455,41 +407,29 @@
 
 /////////////////////////////////////////////////////////////////
-//++ 
-// Module	Classes de fonctions 2D
-// Lib	Outils++ 
-// include	fct1dfit.h
-//--
-/////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////////////////////////////
-//++
-// Titre	Polyn2D
-// \index{Polyn2D}
-//
-//| polynome 2D de degre total degre:
-//|  NDegPol = degre du polynome (note N dans la suite)
-//|  x = x - X_Center,  y = y - Y_Center
-//|  f(x,y) = p[0] +sum(k=1,n){ sum(i=0,k){ p[ki]*x^i*y^(k-i) }}
-//|  Il y a k+1 termes de degre k  (ex: x^i*y^(k-i))
-//|  terme de degre k avec x^i: p[ki] avec  ki = k*(k+1)/2 + i
-//| C'est a dire:
-//| deg0:   p0
-//| deg1: + p1*y + p2*x
-//| deg2: + p3*y^2 + p4*x*y + p5*x^2
-//| deg3: + p6*y^3 + p7*x*y^2 + p8*x^2*y + p9*x^3
-//| deg4: + p10*y^4 + p11*x*y^3 + p12*x^2*y^2 + p13*x^3*y + p14*x^4
-//| deg5: + p15*y^5 + ...                       ... + ... + p20*x^5
-//| ...
-//| degk: + p[k*(k+1)/2]*y^k + ...           ... + p[k*(k+3)/2]*x^k
-//| ...
-//| degn: + p[n*(n+1)/2]*y^n + ...           ... + p[n*(n+3)/2]*x^n
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::Polyn2D
+  \ingroup NTools
+  \anchor Polyn2D
+  \verbatim
+    polynome 2D de degre total degre:
+     NDegPol = degre du polynome (note N dans la suite)
+     x = x - X_Center,  y = y - Y_Center
+     f(x,y) = p[0] +sum(k=1,n){ sum(i=0,k){ p[ki]*x^i*y^(k-i) }}
+     Il y a k+1 termes de degre k  (ex: x^i*y^(k-i))
+     terme de degre k avec x^i: p[ki] avec  ki = k*(k+1)/2 + i
+    C'est a dire:
+    deg0:   p0
+    deg1: + p1*y + p2*x
+    deg2: + p3*y^2 + p4*x*y + p5*x^2
+    deg3: + p6*y^3 + p7*x*y^2 + p8*x^2*y + p9*x^3
+    deg4: + p10*y^4 + p11*x*y^3 + p12*x^2*y^2 + p13*x^3*y + p14*x^4
+    deg5: + p15*y^5 + ...                       ... + ... + p20*x^5
+    ...
+    degk: + p[k*(k+1)/2]*y^k + ...           ... + p[k*(k+3)/2]*x^k
+    ...
+    degn: + p[n*(n+1)/2]*y^n + ...           ... + p[n*(n+3)/2]*x^n
+  \endverbatim
+*/
 Polyn2D::Polyn2D(unsigned int ndegpol,double x0,double y0)
-//
-//	Createur.
-//--
 : GeneralFunction(2,ndegpol*(ndegpol+3)/2+1), NDegPol(ndegpol), X_Center(x0), Y_Center(y0)
 {
Index: trunk/SophyaLib/NTools/fct1dfit.h
===================================================================
--- trunk/SophyaLib/NTools/fct1dfit.h	(revision 919)
+++ trunk/SophyaLib/NTools/fct1dfit.h	(revision 926)
@@ -11,4 +11,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! Gaussienne + polynome
 class Gauss1DPol : public GeneralFunction {
 public:
@@ -28,4 +29,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! Gaussienne_Normalisee+polynome
 class GaussN1DPol : public GeneralFunction {
 public:
@@ -45,4 +47,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! Exponentielle + polynome
 class Exp1DPol : public GeneralFunction {
 public:
@@ -63,4 +66,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! polynome 1D
 class Polyn1D : public GeneralFunction {
 public:
@@ -80,4 +84,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! Analyse harmonique
 class HarmonieNu : public GeneralFunction {
 public:
@@ -98,4 +103,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! Analyse harmonique
 class HarmonieT : public GeneralFunction {
 public:
@@ -120,4 +126,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! polynome 2D
 class Polyn2D : public GeneralFunction {
 public:
Index: trunk/SophyaLib/NTools/fct2dfit.cc
===================================================================
--- trunk/SophyaLib/NTools/fct2dfit.cc	(revision 919)
+++ trunk/SophyaLib/NTools/fct2dfit.cc	(revision 926)
@@ -22,34 +22,28 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Class	GeneralPSF2D
-// Lib	Outils++ 
-// include	fct2dfit.h
-//
-//	Classe de definition d'une PSF 2D a nPar parametres
-//	Pour definir une PSF, il faut creer une classe qui herite
-//	de ``GeneralPSF2D'' (cf par exemple GauRho2D...).
-//	La disposition des parametres definissant la PSF est indifferente,
-//	toutefois il est conseille de suivre l'ordre:
-//--
-//++
-//  - PSF 2D a NPar parametres:
-//  p[0] = Volume (ou hauteur)
-//  p[1] = centre X0, p[2] = centre Y0
-//  p[3] = SigmaX   , p[4] = SigmaY,    p[5] = Rho
-//  p[6],p[7],... = autres parametres (eventuels) definissant la PSF.
-//                  (ex: pour la Moffat p[6] = exposant Beta et NPar=8).
-//  p[NPar-1] = Fond
-//--
-//++
-//	L'emploi de certaines classes comme par exemple ``GenMultiPSF2D''
-//	necessite de suivre rigoureusement l'ordre indique ci-dessus
-//	pour les parametres.
-//--
-
-//++
+/*!
+  \class SOPHYA::GeneralPSF2D
+  \ingroup NTools
+  \anchor GeneralPSF2D
+   Classe de definition d'une PSF 2D a nPar parametres
+   Pour definir une PSF, il faut creer une classe qui herite
+   de ``GeneralPSF2D'' (cf par exemple GauRho2D...).
+   La disposition des parametres definissant la PSF est indifferente,
+   toutefois il est conseille de suivre l'ordre:
+  \verbatim
+   - PSF 2D a NPar parametres:
+   p[0] = Volume (ou hauteur)
+   p[1] = centre X0, p[2] = centre Y0
+   p[3] = SigmaX   , p[4] = SigmaY,    p[5] = Rho
+   p[6],p[7],... = autres parametres (eventuels) definissant la PSF.
+                   (ex: pour la Moffat p[6] = exposant Beta et NPar=8).
+   p[NPar-1] = Fond
+  \endverbatim
+   L'emploi de certaines classes comme par exemple ``GenMultiPSF2D''
+   necessite de suivre rigoureusement l'ordre indique ci-dessus
+   pour les parametres.
+*/
+
 GeneralPSF2D::GeneralPSF2D(unsigned int nPar)
-//
-//--
 : GeneralFunction(2,nPar), VolEps(1.e-4)
 {
@@ -61,13 +55,14 @@
 }
 
-//++
+/*!
+  \verbatim
+    ValueH = hauteur*forme(x,y)+fond tq forme(0,0)=1.
+        alors que Value = volume*forme(x,y)+fond tq volume(forme)=1.
+    Dans notre convention le dernier parametre est le fond,
+    le premier le volume et les 2 suivants le centrage x0,y0
+    ---> Ici parm[0] = hauteur
+  \endverbatim
+ */
 double GeneralPSF2D::ValueH(double const xp[], double const* parm)
-//
-//| ValueH = hauteur*forme(x,y)+fond tq forme(0,0)=1.
-//|     alors que Value = volume*forme(x,y)+fond tq volume(forme)=1.
-//| Dans notre convention le dernier parametre est le fond,
-//| le premier le volume et les 2 suivants le centrage x0,y0
-//| ---> Ici parm[0] = hauteur
-//--
 {
 double x0[2];
@@ -82,15 +77,16 @@
 }
 
-//++
+/*!
+  \verbatim
+    Cette fonction calcule le volume d'une PSF de hauteur=1
+    avec une precision de "VolEps"
+    dans le but de connaitre le coefficient permettant
+    de convertir le volume d'une PSF en son amplitude
+    ou vice-versa: " volume = VolPSF * hauteur "
+     L'integration se fait 1/4 de pixel par 1/4 de pixel
+     ATTENTION: Il s'agit de PSF donc x,y,x0,y0,Sigma.. sont en pixels
+  \endverbatim
+ */
 double GeneralPSF2D::VolPSF(double const* parm)
-//
-//| Cette fonction calcule le volume d'une PSF de hauteur=1
-//| avec une precision de "VolEps"
-//| dans le but de connaitre le coefficient permettant
-//| de convertir le volume d'une PSF en son amplitude
-//| ou vice-versa: " volume = VolPSF * hauteur "
-//|  L'integration se fait 1/4 de pixel par 1/4 de pixel
-//|  ATTENTION: Il s'agit de PSF donc x,y,x0,y0,Sigma.. sont en pixels
-//--
 {
  double x[2],step;
@@ -135,9 +131,6 @@
 }
 
-//++
+//! Definition des defauts des parametres
 void GeneralPSF2D::DefaultParam(double *parm)
-//
-//	Definition des defauts des parametres
-//--
 {
   for (int i=0; i<mNPar; i++) parm[i] = 0.;
@@ -145,9 +138,6 @@
 }
 
-//++
+//! Definition de la precision sur le calcul du volume
 void GeneralPSF2D::SetVolEps(double const prec)
-//
-//	Definition de la precision sur le calcul du volume
-//--
 {
   VolEps = prec;
@@ -159,52 +149,48 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Class	GenMultiPSF2D
-// Lib	Outils++ 
-// include	fct2dfit.h
-//
-//	Classe de definition d'un ensemble de PSF2D
-//	pour fiter simultanement plusieurs etoiles et un fond constant.
-//	Les parametres de forme de la PSF (Sx, Sy, Rho etc... et Fond)
-//	sont les memes pour toutes les etoiles, seuls le centre
-//	(X0,Y0) et le volume (ou la hauteur) V varient pour chaque etoile.
-//	La disposition des parametres definissant la PSF generique
-//	est obligatoirement la suivante:
-//--
-//++
-//|  - PSF 2D a NPar parametres:
-//|  p[0] = Volume (ou hauteur)
-//|  p[1] = centre X0, p[2] = centre Y0
-//|  p[3] = SigmaX   , p[4] = SigmaY,    p[5] = Rho
-//|  p[6],p[7],... = autres parametres (eventuels) definissant la PSF.
-//|                  (ex: pour la Moffat p[6] = exposant Beta et NPar=8).
-//|  p[NPar-1] = Fond
-//|
-//--
-//++
-//|  - La Multi-PSF a ses parametres arranges dans l'ordre suivant:
-//|    Soit NStar le nombre d'etoiles a fiter simultanement
-//|         NP = le nombre de parametres de la PSF 2D generique
-//|    On a NF = NP-7 parametres de forme supplementaires
-//|         (ex: nf=0 pour GauRho2D, nf=1 pour MofRho2D)
-//|  p[0],p[1],p[2] = V0,X0,Y0 pour la premiere etoile
-//|  p[3],p[4],p[5] = V1,X1,Y1 pour la deuxieme etoile
-//|  ...
-//|  p[3*i],p[3*i+1],p[3*i+2] = Vi,Xi,Yi pour la (i+1) ieme etoile
-//|  ...
-//|  p[m*i],p[m*i+1],p[m*i+2] = Vm,Xm,Ym   ;   m = NStar-1
-//|                       pour la NStar ieme et derniere etoile
-//|  p[3*NStar],p[3*NStar+1],p[3*NStar+2] = SigmaX, SigmaY et Rho
-//|  p[3*NStar+3],...,p[3*NStar+2+NF] = parametres de forme
-//|                        supplementaires pour definir la PSF 2D
-//|  p[3*NStar+2+NF+1] = Fond
-//--
-
-//++
+/*!
+  \class SOPHYA::GenMultiPSF2D
+  \ingroup NTools
+  \anchor GenMultiPSF2D
+   Classe de definition d'un ensemble de PSF2D
+   pour fiter simultanement plusieurs etoiles et un fond constant.
+   Les parametres de forme de la PSF (Sx, Sy, Rho etc... et Fond)
+   sont les memes pour toutes les etoiles, seuls le centre
+   (X0,Y0) et le volume (ou la hauteur) V varient pour chaque etoile.
+   La disposition des parametres definissant la PSF generique
+   est obligatoirement la suivante:
+  \verbatim
+     - PSF 2D a NPar parametres:
+     p[0] = Volume (ou hauteur)
+     p[1] = centre X0, p[2] = centre Y0
+     p[3] = SigmaX   , p[4] = SigmaY,    p[5] = Rho
+     p[6],p[7],... = autres parametres (eventuels) definissant la PSF.
+                     (ex: pour la Moffat p[6] = exposant Beta et NPar=8).
+     p[NPar-1] = Fond
+   
+     - La Multi-PSF a ses parametres arranges dans l'ordre suivant:
+       Soit NStar le nombre d'etoiles a fiter simultanement
+            NP = le nombre de parametres de la PSF 2D generique
+       On a NF = NP-7 parametres de forme supplementaires
+            (ex: nf=0 pour GauRho2D, nf=1 pour MofRho2D)
+     p[0],p[1],p[2] = V0,X0,Y0 pour la premiere etoile
+     p[3],p[4],p[5] = V1,X1,Y1 pour la deuxieme etoile
+     ...
+     p[3*i],p[3*i+1],p[3*i+2] = Vi,Xi,Yi pour la (i+1) ieme etoile
+     ...
+     p[m*i],p[m*i+1],p[m*i+2] = Vm,Xm,Ym   ;   m = NStar-1
+                          pour la NStar ieme et derniere etoile
+     p[3*NStar],p[3*NStar+1],p[3*NStar+2] = SigmaX, SigmaY et Rho
+     p[3*NStar+3],...,p[3*NStar+2+NF] = parametres de forme
+                           supplementaires pour definir la PSF 2D
+     p[3*NStar+2+NF+1] = Fond
+  \endverbatim
+*/
+
+/*!
+  Createur. ``psf2d'' est le nom de la PSF generique a utiliser,
+  et ``nstar'' est le nombre d'etoiles a fiter simultanement.
+  */
 GenMultiPSF2D::GenMultiPSF2D(GeneralPSF2D* psf2d,unsigned int nstar)
-//
-//	Createur. ``psf2d'' est le nom de la PSF generique a utiliser,
-//	et ``nstar'' est le nombre d'etoiles a fiter simultanement.
-//--
   : GeneralPSF2D((psf2d!=NULL) ? 3*nstar+4+psf2d->NPar()-7: 0)
   , mPsf2D(psf2d), mNStar(nstar)
@@ -299,40 +285,28 @@
 
 /////////////////////////////////////////////////////////////////
-//++ 
-// Module	Classes de PSF 2D
-// Lib	Outils++ 
-// include	fct2dfit.h
-//--
-/////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////////////////////////////
-//++
-// Titre	GauRho2D
-// \index{GauRho2D}
-//
-//| gaussienne+fond 2D
-//| Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=fond
-//|   sigx,sigy,rho = sigma et rho de la gaussienne
-//|   x0,y0 = centre de la gaussienne
-//|  PSF(x,y) = N * exp[ - 1/2 (X**2 + Y**2 -2*rho*X*Y) ]
-//|           avec X = (x-x0)/sigx et Y = (y-y0)/sigy
-//|                N = sqrt(1-rho**2)/(2*Pi*sigx*sigy)
-//|  le volume de cette gaussienne est V=1.
-//|  F(x,y) = Par[0]*PSF(x,y)+Par[6] (volume=Par[0],fond=Par[6])
-//--
-//++
-//| -*- Remarque: De la facon dont est ecrite la PSF gaussienne
-//| sigx,sigy representent les sigmas des gaussiennes 1D
-//| qui sont les coupes de la gaussienne 2D pour y=0 et x=0.
-//| Les moments centres d'ordre 2 sont
-//|   sx = sigx/sqrt(1-ro^2) et sy = sigy/sqrt(1-ro^2)
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::GauRho2D
+  \ingroup NTools
+  \anchor GauRho2D
+  \verbatim
+    gaussienne+fond 2D
+    Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=fond
+      sigx,sigy,rho = sigma et rho de la gaussienne
+      x0,y0 = centre de la gaussienne
+     PSF(x,y) = N * exp[ - 1/2 (X**2 + Y**2 -2*rho*X*Y) ]
+              avec X = (x-x0)/sigx et Y = (y-y0)/sigy
+                   N = sqrt(1-rho**2)/(2*Pi*sigx*sigy)
+     le volume de cette gaussienne est V=1.
+     F(x,y) = Par[0]*PSF(x,y)+Par[6] (volume=Par[0],fond=Par[6])
+    -*- Remarque: De la facon dont est ecrite la PSF gaussienne
+    sigx,sigy representent les sigmas des gaussiennes 1D
+    qui sont les coupes de la gaussienne 2D pour y=0 et x=0.
+    Les moments centres d'ordre 2 sont
+      sx = sigx/sqrt(1-ro^2) et sy = sigy/sqrt(1-ro^2)
+  \endverbatim
+*/
+/////////////////////////////////////////////////////////////////
+
 GauRho2D::GauRho2D()
-//
-//	Createur
-//--
 : GeneralPSF2D(7)
 {
@@ -409,18 +383,17 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	GauRhInt2D
-// \index{GauRhInt2D}
-//
-//| Cette fonction calcule une approximation a l'integrale d'une
-//| gaussienne 2D sur un carre de longueur unite (x,y-05 -> x,y+0.5)
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::GauRhInt2D
+  \ingroup NTools
+  \anchor GauRhInt2D
+  \verbatim
+    Cette fonction calcule une approximation a l'integrale d'une
+    gaussienne 2D sur un carre de longueur unite (x,y-05 -> x,y+0.5)
+  \endverbatim
+  \sa GauRho2D
+*/
+/////////////////////////////////////////////////////////////////
+
 GauRhInt2D::GauRhInt2D()
-//
-//	Createur
-//--
 : GeneralPSF2D(7)
 {
@@ -519,29 +492,27 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	GdlRho2D
-// \index{GdlRho2D}
-//
-//| Cette fonction calcule une gaussienne 2D de volume 1 approchee
-//|  par son developpement limite au 3ieme ordre (see dophot)
-//|  Meme commentaire que GauRho2D, cf plus haut sauf que:
-//|  Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=fond
-//|    z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
-//|    PSF(x,y) = N / [ 1 + z**2 + B4/2 *z**4 + B6/6 *z**6 ]
-//|               N = KB4B6
-//|    le coefficient KB4B6 etant trop dur a calculer analytiquement
-//|    Il doit etre calcule numeriquement et entre dans ce programme
-//|  ATTENTION: dans cette routine B4 et B6 sont imposes et pas fites!
-//|  - DL de la gaussienne:  B4=1., B6=1., KB4B6=0.13688679
-//|  le volume de cette gaussienne est V=1.
-//|  F(x,y) = Par[0]*PSF(x,y)+Par[6] (volume=Par[0],fond=Par[6])
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::GdlRho2D
+  \ingroup NTools
+  \anchor GdlRho2D
+  \verbatim
+    Cette fonction calcule une gaussienne 2D de volume 1 approchee
+     par son developpement limite au 3ieme ordre (see dophot)
+     Meme commentaire que GauRho2D, cf plus haut sauf que:
+     Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=fond
+       z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
+       PSF(x,y) = N / [ 1 + z**2 + B4/2 *z**4 + B6/6 *z**6 ]
+                  N = KB4B6
+       le coefficient KB4B6 etant trop dur a calculer analytiquement
+       Il doit etre calcule numeriquement et entre dans ce programme
+     ATTENTION: dans cette routine B4 et B6 sont imposes et pas fites!
+     - DL de la gaussienne:  B4=1., B6=1., KB4B6=0.13688679
+     le volume de cette gaussienne est V=1.
+     F(x,y) = Par[0]*PSF(x,y)+Par[6] (volume=Par[0],fond=Par[6])
+  \endverbatim
+*/
+/////////////////////////////////////////////////////////////////
+
 GdlRho2D::GdlRho2D()
-//
-//	Createur
-//--
 : GeneralPSF2D(7)
 {
@@ -617,17 +588,14 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	GdlRhInt2D
-// \index{GdlRhInt2D}
-//
-//	fonction integree de  GdlRho2d
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::GdlRhInt2D
+  \ingroup NTools
+  \anchor GdlRhInt2D
+  Fonction integree de GdlRho2d
+  \sa GdlRho2D
+*/
+/////////////////////////////////////////////////////////////////
+
 GdlRhInt2D::GdlRhInt2D()
-//
-//	Createur
-//--
 : GeneralPSF2D(7)
 {
@@ -732,36 +700,34 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	Gdl1Rho2D
-// \index{Gdl1Rho2D}
-//
-//| Cette fonction calcule une gaussienne 2D approchee
-//| par son developpement limite au 2sd ordre (see dophot)
-//| Meme commentaire que GauRho2D, cf plus haut sauf que:
-//|   z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
-//|   PSF(x,y) = N / [ 1 + z**2 + B4/2 *z**4 ]
-//|   Le coefficient B4 est fitte (6ieme parametres)
-//| ATTENTION: les normalisations N dependent de B4
-//|  1-/ B4 est suppose etre toujours positif pour que la PSF tendent
-//|      vers 0+ quand z2 tend vers l'infini
-//|  2-/ Il y a 3 cas de calcul de K(B4) = int(PSF(x,y)) de 0 a l'infini
-//|             0<B4<1/2, 1/2<B4, et B4=1/2
-//|      mais pour des raisons d'analyse
-//|      numerique j'ai pris 3 intervalles:
-//|             0.<B4<0.499, 0.501<B4, 0.499<=B4<=0.501
-//|      dans le 3ieme intervalle, comme K est continue est derivable
-//|      en B4=1/2, j'ai represente K par la droite tangeante
-//|      ce qui, apres verification dans paw est une tres bonne approx.
-//|      (je tiens les calculs a disposition.. me demander)
-//|  Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=B4 [7]=fond
-//|  F(x,y) = Par[0]*PSF(x,y)+Par[7]
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::Gdl1Rho2D
+  \ingroup NTools
+  \anchor Gdl1Rho2D
+  \verbatim
+    Cette fonction calcule une gaussienne 2D approchee
+    par son developpement limite au 2sd ordre (see dophot)
+    Meme commentaire que GauRho2D, cf plus haut sauf que:
+      z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
+      PSF(x,y) = N / [ 1 + z**2 + B4/2 *z**4 ]
+      Le coefficient B4 est fitte (6ieme parametres)
+    ATTENTION: les normalisations N dependent de B4
+     1-/ B4 est suppose etre toujours positif pour que la PSF tendent
+         vers 0+ quand z2 tend vers l'infini
+     2-/ Il y a 3 cas de calcul de K(B4) = int(PSF(x,y)) de 0 a l'infini
+                0<B4<1/2, 1/2<B4, et B4=1/2
+         mais pour des raisons d'analyse
+         numerique j'ai pris 3 intervalles:
+                0.<B4<0.499, 0.501<B4, 0.499<=B4<=0.501
+         dans le 3ieme intervalle, comme K est continue est derivable
+         en B4=1/2, j'ai represente K par la droite tangeante
+         ce qui, apres verification dans paw est une tres bonne approx.
+         (je tiens les calculs a disposition.. me demander)
+     Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=B4 [7]=fond
+     F(x,y) = Par[0]*PSF(x,y)+Par[7]
+  \endverbatim
+*/
+/////////////////////////////////////////////////////////////////
+
 Gdl1Rho2D::Gdl1Rho2D()
-//
-//	Createur
-//--
 : GeneralPSF2D(8)
 {
@@ -894,17 +860,14 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	Gdl1RhInt2D
-// \index{Gdl1RhInt2D}
-//
-//	fonction integree de Gdl1Rho2D
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::Gdl1RhInt2D
+  \ingroup NTools
+  \anchor Gdl1RhInt2D
+  Fonction integree de Gdl1Rho2D
+  \sa Gdl1Rho2D
+*/
+/////////////////////////////////////////////////////////////////
+
 Gdl1RhInt2D::Gdl1RhInt2D()
-//
-//	Createur
-//--
 : GeneralPSF2D(8)
 {
@@ -1058,28 +1021,25 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	Gdl2Rho2D
-// \index{Gdl2Rho2D}
-//
-//| Cette fonction calcule une gaussienne 2D de hauteur 1 approchee
-//| par son developpement limite ordre 3 (see dophot)
-//| Meme commentaire que GauRho2D, cf plus haut sauf que:
-//|   z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
-//|   Z**2 = B2*z2
-//|   PSF(x,y) = h / [ 1 + Z**2 + B4**2/2 *Z**4 + B6**2/6 *Z**6 ]
-//|   B2,B4,B6 peuvent etre fittes
-//| - DL de la gaussienne:  B2=B4=B6=1.
-//|  Par [0]=hauteur [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho
-//|      [6]=B4 [7]=B6 [8]=B2 [9]= fond
-//|  F(x,y) = Par[0]*PSF(x,y)+Par[9]
-//--
-/////////////////////////////////////////////////////////////////
-
-
-//++
+/*!
+  \class SOPHYA::Gdl2Rho2D
+  \ingroup NTools
+  \anchor Gdl2Rho2D
+  \verbatim
+    Cette fonction calcule une gaussienne 2D de hauteur 1 approchee
+    par son developpement limite ordre 3 (see dophot)
+    Meme commentaire que GauRho2D, cf plus haut sauf que:
+      z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
+      Z**2 = B2*z2
+      PSF(x,y) = h / [ 1 + Z**2 + B4**2/2 *Z**4 + B6**2/6 *Z**6 ]
+      B2,B4,B6 peuvent etre fittes
+    - DL de la gaussienne:  B2=B4=B6=1.
+     Par [0]=hauteur [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho
+         [6]=B4 [7]=B6 [8]=B2 [9]= fond
+     F(x,y) = Par[0]*PSF(x,y)+Par[9]
+  \endverbatim
+*/
+/////////////////////////////////////////////////////////////////
+
 Gdl2Rho2D::Gdl2Rho2D()
-//
-//	Createur
-//--
 : GeneralPSF2D(10)
 {
@@ -1163,17 +1123,14 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	Gdl2RhInt2D
-// \index{Gdl2RhInt2D}
-//
-//	fonction integree de Gdl2Rho2d
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::Gdl2RhInt2D
+  \ingroup NTools
+  \anchor Gdl2RhInt2D
+  Fonction integree de Gdl2Rho2d
+  \sa Gdl2Rho2D
+*/
+/////////////////////////////////////////////////////////////////
+
 Gdl2RhInt2D::Gdl2RhInt2D()
-//
-//	Createur
-//--
 : GeneralPSF2D(10)
 {
@@ -1282,25 +1239,23 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	MofRho2D
-// \index{MofRho2D}
-//
-//| Cette fonction calcule une Moffat 2D
-//|   Par [0]=hauteur [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho
-//|       [6]=Gm [7]= fond
-//|  PSF(x,y)  = valeur de la Moffat normalisee a un volume = 1
-//|  PSF(x,y) = N / [ 1. +  0.5*(X**2 + Y**2 -2*rho*X*Y) ]**Gm
-//|           avec X = (x-x0)/sigx et Y = (y-y0)/sigy et Gm>1
-//|                N = (1-Gm)*sqrt(1-rho**2)/(2*Pi*sigx*sigy)
-//|  le volume de cette Moffat est V=1.
-//|  F(x,y) = Par[0]*PSF(x,y)+Par[7]
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::MofRho2D
+  \ingroup NTools
+  \anchor MofRho2D
+  \verbatim
+    Cette fonction calcule une Moffat 2D
+      Par [0]=hauteur [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho
+          [6]=Gm [7]= fond
+     PSF(x,y)  = valeur de la Moffat normalisee a un volume = 1
+     PSF(x,y) = N / [ 1. +  0.5*(X**2 + Y**2 -2*rho*X*Y) ]**Gm
+              avec X = (x-x0)/sigx et Y = (y-y0)/sigy et Gm>1
+                   N = (1-Gm)*sqrt(1-rho**2)/(2*Pi*sigx*sigy)
+     le volume de cette Moffat est V=1.
+     F(x,y) = Par[0]*PSF(x,y)+Par[7]
+  \endverbatim
+*/
+/////////////////////////////////////////////////////////////////
+
 MofRho2D::MofRho2D()
-//
-//	Createur 
-//--
 : GeneralPSF2D(8)
 {
@@ -1381,17 +1336,14 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	MofRhInt2D
-// \index{MofRhInt2D}
-//
-//	fonction integree de MofRho2d
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
+/*!
+  \class SOPHYA::MofRhInt2D
+  \ingroup NTools
+  \anchor MofRhInt2D
+  Fonction integree de MofRho2d
+  \sa MofRho2D
+*/
+/////////////////////////////////////////////////////////////////
+
 MofRhInt2D::MofRhInt2D()
-//
-//	Createur 
-//--
 : GeneralPSF2D(8)
 {
@@ -1512,16 +1464,12 @@
 
 /////////////////////////////////////////////////////////////////
-//++
-// Titre	X2-GauRho2D
-// \index{X2-GauRho2D}
-//
-//	Chi2 pour une Gaussienne+fond 2D (voir detail dans GauRho2D).
-//--
-/////////////////////////////////////////////////////////////////
-
-//++
-// X2-GauRho2D::X2-GauRho2D()
-//	Createur 
-//--
+/*!
+  \class SOPHYA::X2_GauRho2D
+  \ingroup NTools
+  \anchor X2_GauRho2D
+   Chi2 pour une Gaussienne+fond 2D (voir detail dans GauRho2D).
+*/
+/////////////////////////////////////////////////////////////////
+
 X2_GauRho2D::X2_GauRho2D()
 : GeneralXi2(7)
Index: trunk/SophyaLib/NTools/fct2dfit.h
===================================================================
--- trunk/SophyaLib/NTools/fct2dfit.h	(revision 919)
+++ trunk/SophyaLib/NTools/fct2dfit.h	(revision 926)
@@ -10,4 +10,5 @@
 //================================================================
 
+//! Classe de definition d'une PSF 2D a nPar parametres
 class GeneralPSF2D : public GeneralFunction {
 public:
@@ -28,4 +29,5 @@
 //================================================================
 
+//! Classe de definition d'un ensemble de PSF2D
 class GenMultiPSF2D : public GeneralPSF2D {
 public:
@@ -51,4 +53,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! gaussienne + fond 2D
 class GauRho2D : public GeneralPSF2D {
 public:
@@ -64,4 +67,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! gaussienne integree + fond 2D
 class GauRhInt2D : public GeneralPSF2D {
 public:
@@ -77,4 +81,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! gaussienne 2D de volume 1 approchee par dl au 3ieme ordre
 class GdlRho2D : public GeneralPSF2D {
 public:
@@ -90,4 +95,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! gaussienne integree 2D de volume 1 approchee par dl au 3ieme ordre
 class GdlRhInt2D : public GeneralPSF2D {
 public:
@@ -103,4 +109,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! gaussienne 2D de volume 1 approchee par dl au 2sd ordre
 class Gdl1Rho2D : public GeneralPSF2D {
 public:
@@ -116,4 +123,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! gaussienne ontegree 2D de volume 1 approchee par dl au 2sd ordre
 class Gdl1RhInt2D : public GeneralPSF2D {
 public:
@@ -129,4 +137,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! gaussienne 2D de hauteur 1 approchee dl 3ieme
 class Gdl2Rho2D : public GeneralPSF2D {
 public:
@@ -141,4 +150,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! gaussienne integree 2D de hauteur 1 approchee dl 3ieme
 class Gdl2RhInt2D : public GeneralPSF2D {
 public:
@@ -153,4 +163,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! Moffat 2D
 class MofRho2D : public GeneralPSF2D {
 public:
@@ -166,4 +177,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! Moffat integree 2D
 class MofRhInt2D : public GeneralPSF2D {
 public:
@@ -183,4 +195,5 @@
 
 //////////////////////////////////////////////////////////////////
+//! Chi2 pour une Gaussienne+fond 2D
 class X2_GauRho2D : public GeneralXi2 {
 public:
Index: trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- trunk/SophyaLib/NTools/generaldata.cc	(revision 919)
+++ trunk/SophyaLib/NTools/generaldata.cc	(revision 926)
@@ -18,4 +18,24 @@
 // GeneralFitData
 //================================================================
+
+/*!
+  \class SOPHYA::GeneralFitData
+  \ingroup NTools
+  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
+*/
 
 //////////////////////////////////////////////////////////////////////
Index: trunk/SophyaLib/NTools/generaldata.h
===================================================================
--- trunk/SophyaLib/NTools/generaldata.h	(revision 919)
+++ trunk/SophyaLib/NTools/generaldata.h	(revision 926)
@@ -19,22 +19,5 @@
 //================================================================
 
-/*!
-  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
-*/
-
+//! Classe de stoquage de donnees a plusieurs variables avec erreur
 class GeneralFitData : public AnyDataObj , public NTupleInterface {
   friend class GeneralFit;
Index: trunk/SophyaLib/NTools/generalfit.cc
===================================================================
--- trunk/SophyaLib/NTools/generalfit.cc	(revision 919)
+++ trunk/SophyaLib/NTools/generalfit.cc	(revision 926)
@@ -20,4 +20,11 @@
 // GeneralFunction
 //================================================================
+
+/*!
+  \class SOPHYA::GeneralFunction
+  \ingroup NTools
+   Classe de fonctions parametrees a plusieurs variables:
+  \f$ F[x1,x2,x3,...:a1,a2,a3,...] \f$
+*/
 
 //////////////////////////////////////////////////////////////////////
@@ -85,4 +92,15 @@
 // GeneralFunc
 //================================================================
+
+/*!
+  \class SOPHYA::GeneralFunc
+  \ingroup NTools
+  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).
+*/
 
 /////////////////////////////////////////////////////////////////
@@ -161,4 +179,11 @@
 //================================================================
 
+/*!
+  \class SOPHYA::GeneralXi2
+  \ingroup NTools
+  Classe de Xi2 a plusieurs parametres :
+  \f$ Xi2[a1,a2,a3,...] \f$
+*/
+
 //////////////////////////////////////////////////////////////////////
 /*!
@@ -263,4 +288,11 @@
 //                                Christophe 8/11/93 La Silla
 //                                re-codage C++ 16/01/96 Saclay
+
+/*!
+  \class SOPHYA::GeneralFit
+  \ingroup NTools
+  Classe de fit d'une GeneralFunction sur une GeneralFitData
+  */
+
 //////////////////////////////////////////////////////////////////////
 /*!
Index: trunk/SophyaLib/NTools/generalfit.h
===================================================================
--- trunk/SophyaLib/NTools/generalfit.h	(revision 919)
+++ trunk/SophyaLib/NTools/generalfit.h	(revision 926)
@@ -13,9 +13,5 @@
 //================================================================
 
-
-/*!
-  Classe de fonctions parametrees a plusieurs variables:
-  \f$ F[x1,x2,x3,...:a1,a2,a3,...] \f$
-*/
+//! Classe de fonctions parametrees a plusieurs variables
 class GeneralFunction {
 public:
@@ -25,4 +21,5 @@
   //! Valeur de la fonction a definir par l'utilisateur (fct virtuelle pure)
   virtual double Value(double const xp[], double const* parm)=0;
+  //! Valeur de la fonction derivee selon les parametres pouvant etre redefinie
   virtual double Val_Der(double const xp[], double const* parm
                         , double* DgDpar);
@@ -48,12 +45,5 @@
 //================================================================
 
-/*!
-  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).
-*/
+//! Classe de fonctions parametrees a plusieurs variables type C
 class GeneralFunc : public GeneralFunction {
 public:
@@ -78,8 +68,5 @@
 class GeneralFitData;
 
-/*!
-  Classe de Xi2 a plusieurs parametres :
-  \f$ Xi2[a1,a2,a3,...] \f$
-*/
+//! Classe de Xi2 a plusieurs parametres
 class GeneralXi2 {
 public:
Index: trunk/SophyaLib/NTools/ntoolsinit.cc
===================================================================
--- trunk/SophyaLib/NTools/ntoolsinit.cc	(revision 919)
+++ trunk/SophyaLib/NTools/ntoolsinit.cc	(revision 926)
@@ -12,6 +12,16 @@
 #include "datime.h"
 
+/*!
+   \defgroup NTools NTools module
+   This module contains various tools for Sophya.
+*/
+
 int NToolsInitiator::FgInit = 0;
 
+/*!
+  \class SOPHYA::NToolsInitiator
+  \ingroup NTools
+  Tools initiator
+*/
 NToolsInitiator::NToolsInitiator()
   : TArrayInitiator()
Index: trunk/SophyaLib/NTools/ntoolsinit.h
===================================================================
--- trunk/SophyaLib/NTools/ntoolsinit.h	(revision 919)
+++ trunk/SophyaLib/NTools/ntoolsinit.h	(revision 926)
@@ -11,4 +11,5 @@
 namespace SOPHYA {
 
+//! Tools initiator
 class NToolsInitiator : public TArrayInitiator {
 private:
