Index: trunk/SophyaLib/NTools/FSAppIrrSmpl.h
===================================================================
--- trunk/SophyaLib/NTools/FSAppIrrSmpl.h	(revision 2765)
+++ trunk/SophyaLib/NTools/FSAppIrrSmpl.h	(revision 2808)
@@ -25,31 +25,42 @@
 
 ////////////////////////////////////////////////////////////////////
-// Un signal donne , suppose a bande de frequences limitee, de longueur 
-// finie est periodise. Ce signal periodise est suppose developpe 
-// en serie de Fourier finie: l'approximation consiste a rechercher 
-// les coefficients de cette serie de Fourier. Cela est fait en utilisant 
-// le fait que la matrice du systeme a ecrire est Toeplitz. On utilise
-// une classe ToeplitzMatrix, qui utilise les FFT pour la resolution
-// L'utilisation standard comporte les etapes suivantes : 
-//
-//   constructeur --> definit l'echantillonnage et l'amplitude
-//                    des abscisses (pour periodisation)
-//
-//   methode approximateSignal(nbFreq, signal) : definit la bande
-//                    de frequences et les valeurs du signal
-//
-//   recuperation de valeurs approximees ou interpolees : 
-//   methodes:  . restaureSignal() (signal "debruite" aux valeurs 
-//                                              d'echantionnage) 
-//              . restaureRegularlySampledSignal() (signal recalcule
-//                          sur un echantillonnage regulier quelconque)
-//              . computeSignalOnASampling()  (signal recalcule
-//                          sur un echantillonnage irregulier quelconque)
-//
-//  on peut aussi recuperer les valeurs des coefficients du developpement
-//  en serie de Fourier (methodes complexFourierCoef() et coeffCosSin()
+/*! 
+  \ingroup NTools
+  \class SOPHYA::FSApproximationIrregularSampling
+  \brief Signal interpolation/approximation using Fourier series with irregularly 
+  sampled data
+
+  \verbatim
+  Un signal donne , suppose a bande de frequences limitee, de longueur 
+  finie est periodise. Ce signal periodise est suppose developpe 
+  en serie de Fourier finie: l'approximation consiste a rechercher 
+  les coefficients de cette serie de Fourier. Cela est fait en utilisant 
+  le fait que la matrice du systeme a ecrire est Toeplitz. On utilise
+  une classe ToeplitzMatrix, qui utilise les FFT pour la resolution
+  L'utilisation standard comporte les etapes suivantes : 
+  
+  constructeur --> definit l'echantillonnage et l'amplitude
+  des abscisses (pour periodisation)
+  
+  methode approximateSignal(nbFreq, signal) : definit la bande
+  de frequences et les valeurs du signal
+  
+  recuperation de valeurs approximees ou interpolees : 
+  methodes:  . restaureSignal() (signal "debruite" aux valeurs 
+  d'echantionnage) 
+  . restaureRegularlySampledSignal() (signal recalcule
+  sur un echantillonnage regulier quelconque)
+  . computeSignalOnASampling()  (signal recalcule
+  sur un echantillonnage irregulier quelconque)
+  
+  on peut aussi recuperer les valeurs des coefficients du developpement
+  en serie de Fourier (methodes complexFourierCoef() et coeffCosSin()
+
+  \endverbatim 
+  \sa SOPHYA::ToeplitzMatrix
+*/
 /////////////////////////////////////////////////////////////////////
 
-
+namespace SOPHYA {
 class FSApproximationIrregularSampling
 {
@@ -163,4 +174,5 @@
 };
 
+} // namespace SOPHYA
 
 #endif
Index: trunk/SophyaLib/NTools/cspline.cc
===================================================================
--- trunk/SophyaLib/NTools/cspline.cc	(revision 2765)
+++ trunk/SophyaLib/NTools/cspline.cc	(revision 2808)
@@ -14,29 +14,22 @@
 #include "cspline.h"
 
-//++
-// Class	CSpline
-// Lib	Outils++ 
-// include	cspline.h
-//
-//	Classe de spline 1D
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-//////////////////////////////////////////////////////////////////////////////
-//++
+/*!
+  \class SOPHYA::CSpline
+  \ingroup NTools
+  Spline 3 smoother (interpolator) for 1-D data points (y = f(x)) 
+  \sa CSpline2
+*/
+
+/*!
+  Createur pour spline 3 sur "x[0->n],y[0->n]" avec "yp1,ypn" derivees
+  au premier et dernier points et "natural" indiquant les types de
+  contraintes sur les derivees 2sd au premier et dernier point.
+  "order" doit etre mis a "true" si le tableau de "x[]" n'est pas ordonne
+  dans l'ordre des "x" croissants ("x[i]<x[i+1]"): cette option
+  realloue la place pour les tableaux "x,y" autrement seule une
+  connection aux tableaux "x,y" externes est realisee.
+*/
 CSpline::CSpline(int n,double* x,double* y,double yp1,double ypn
                 ,int natural,bool order)
-//
-//	Createur pour spline 3 sur "x[0->n],y[0->n]" avec "yp1,ypn" derivees
-//	au premier et dernier points et "natural" indiquant les types de
-//	contraintes sur les derivees 2sd au premier et dernier point.
-//	"order" doit etre mis a "true" si le tableau de "x[]" n'est pas ordonne
-//	dans l'ordre des "x" croissants ("x[i]<x[i+1]"): cette option
-//	realloue la place pour les tableaux "x,y" autrement seule une
-//	connection aux tableaux "x,y" externes est realisee.
-//--
   : Nel(0), corrupt_Y2(true), XY_Created(false), Natural(natural)
   , YP1(yp1), YPn(ypn), X(NULL), Y(NULL), Y2(NULL), tmp(NULL)
@@ -47,10 +40,6 @@
 }
 
-//////////////////////////////////////////////////////////////////////////////
-//++
+//!	Createur par defaut.
 CSpline::CSpline(double yp1,double ypn,int natural)
-//
-//	Createur par defaut.
-//--
   : Nel(0), corrupt_Y2(true), XY_Created(false), Natural(natural)
   , YP1(yp1), YPn(ypn), X(NULL), Y(NULL), Y2(NULL), tmp(NULL)
@@ -59,27 +48,21 @@
 
 //////////////////////////////////////////////////////////////////////////////
+//! destructeur
 CSpline::~CSpline()
-// destructeur
 {
 DelTab();
 }
 
-//++
-// Titre	Methodes
-//--
-
-//////////////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour changer les tableaux sans recreer la classe,
+  memes arguments que dans le createur.
+  Pour connecter les tableaux "x[n],y[n]" aux pointeurs internes "X,Y"
+  Si "order=true", on considere que x n'est pas range par ordre
+  des "x" croissants. La methode alloue de la place pour des tableaux
+  internes "X,Y" qu'elle re-ordonne par "x" croissant.
+  "force=true" impose la reallocation des divers buffers, sinon
+  la reallocation n'a lieu que si le nombre de points augmente.
+*/
 void CSpline::SetNewTab(int n,double* x,double* y,bool order,bool force)
-//
-//	Pour changer les tableaux sans recreer la classe,
-//	memes arguments que dans le createur.
-//	Pour connecter les tableaux "x[n],y[n]" aux pointeurs internes "X,Y"
-//	Si "order=true", on considere que x n'est pas range par ordre
-//	des "x" croissants. La methode alloue de la place pour des tableaux
-//	internes "X,Y" qu'elle re-ordonne par "x" croissant.
-//	"force=true" impose la reallocation des divers buffers, sinon
-//	la reallocation n'a lieu que si le nombre de points augmente.
-//--
 {
 ASSERT( n>3 );
@@ -132,6 +115,6 @@
 
 //////////////////////////////////////////////////////////////////////////////
+//! destruction des divers tableaux en tenant compte des allocations/connections
 void CSpline::DelTab()
-// destruction des divers tableaux en tenant compte des allocations/connections
 {
 if( X   != NULL && XY_Created ) delete [] X;    X   = NULL;
@@ -142,10 +125,9 @@
 
 //////////////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour changer les valeurs des derivees 1ere au 1er et dernier points
+  Valeurs imposees des derivees 1ere au points "X[0]" et "X[Nel-1]".
+*/
 void CSpline::SetBound1er(double yp1,double ypn)
-//
-//	Pour changer les valeurs des derivees 1ere au 1er et dernier points
-//	Valeurs imposees des derivees 1ere au points "X[0]" et "X[Nel-1]".
-//--
 {
 if( yp1 == YP1 && ypn == YPn ) return;
@@ -157,11 +139,6 @@
 }
 
-//////////////////////////////////////////////////////////////////////////////
-//++
+//! Pour calculer les tableaux de coeff permettant le calcul des interpolations spline.
 void CSpline::ComputeCSpline()
-//
-//	Pour calculer les tableaux de coeff permettant le calcul
-//	des interpolations spline.
-//--
 {
 // on ne fait rien si les tableaux ne sont pas connectes
@@ -206,10 +183,6 @@
 }
 
-//////////////////////////////////////////////////////////////////////////////
-//++
+//!	Interpolation spline en \b x
 double CSpline::CSplineInt(double x)
-//
-//	Interpolation spline en "x"
-//--
 {
 int klo,khi,k;
@@ -243,46 +216,28 @@
 }
 
-///////////////////////////////////////////////////////////////
-///////// rappel des inlines pour commentaires ////////////////
-///////////////////////////////////////////////////////////////
-
-//++
-// inline void SetNaturalCSpline(int type = NaturalAll)
-//	Pour changer le type de contraintes sur les derivees 2sd
-//--
-//++
-// inline void Free_Tmp()
-//	Pour liberer la place tampon qui ne sert que
-//	dans ComputeCSpline() et pas dans CSplineInt
-//--
-
-//////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-//++
-// Class	CSpline2
-// Lib	Outils++ 
-// include	cspline.h
-//
-//	Classe de spline 2D
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-//////////////////////////////////////////////////////////////////////////////
-//++
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+/*!
+  \class SOPHYA::CSpline2
+  \ingroup NTools
+  Spline smoother (interpolator) for 2-D data points (y = f(x1,x2)) 
+  \sa CSpline
+*/
+
+/*!
+  Contructeur - Meme commentaire que pour CSpline avec:
+  \verbatim
+  x1[n1]: liste des coordonnees selon l axe 1
+  x2[n2]: liste des coordonnees selon l axe 2
+  y[n1*n2]: liste des valeurs avec le rangement suivant
+  x1[0]......x1[n1-1]  x1[0]......x1[n1-1]  ... x1[0]......x1[n1-1]
+  |    0<=i<n1      |  |    0<=i<n1      |  ... |    0<=i<n1      |
+  |      j=0 X2[0]            j=1 X2[1]              j=n2-1 X2[n2-1]
+  \endverbatim
+*/
 CSpline2::CSpline2(int n1,double* x1,int n2,double* x2,double* y
                   ,int natural,bool order)
-//
-//	Meme commentaire que pour CSpline avec:
-//| x1[n1]: liste des coordonnees selon l axe 1
-//| x2[n2]: liste des coordonnees selon l axe 2
-//| y[n1*n2]: liste des valeurs avec le rangement suivant
-//| x1[0]......x1[n1-1]  x1[0]......x1[n1-1]  ... x1[0]......x1[n1-1]
-//| |    0<=i<n1      |  |    0<=i<n1      |  ... |    0<=i<n1      |
-//|      j=0 X2[0]            j=1 X2[1]              j=n2-1 X2[n2-1]
-//--
   : Nel1(0), Nel2(0), corrupt_Y2(true), XY_Created(false), Natural(natural)
   , X1(NULL), X2(NULL), Y(NULL), Y2(NULL)
@@ -294,10 +249,6 @@
 }
 
-//////////////////////////////////////////////////////////////////////////////
-//++
+//!	Createur par defaut.
 CSpline2::CSpline2(int natural)
-//
-//	Createur par defaut.
-//--
   : Nel1(0), Nel2(0), corrupt_Y2(true), XY_Created(false), Natural(natural)
   , X1(NULL), X2(NULL), Y(NULL), Y2(NULL)
@@ -312,15 +263,8 @@
 }
 
-//++
-// Titre	Methodes
-//--
-
-//////////////////////////////////////////////////////////////////////////////
-//++
+//////////////////////////////////////////////////////////////////////////////
+//!	Voir commentaire meme methode de CSpline
 void CSpline2::SetNewTab(int n1,double* x1,int n2,double* x2,double* y
                         ,bool order,bool force)
-//
-//	Voir commentaire meme methode de CSpline
-//--
 {
 ASSERT( n1>3 && n2>3 );
@@ -430,9 +374,6 @@
 
 //////////////////////////////////////////////////////////////////////////////
-//++
+//!	Voir commentaire meme methode de CSpline
 void CSpline2::ComputeCSpline()
-//
-//	Voir commentaire meme methode de CSpline
-//--
 {
 // on ne fait rien si X1 ou X2 ou Y non connectes
@@ -454,9 +395,6 @@
 
 //////////////////////////////////////////////////////////////////////////////
-//++
+//! Calcule la valeur interpole (spline) pour le point \b (x1,x2)
 double CSpline2::CSplineInt(double x1,double x2)
-//
-//	Voir commentaire meme methode de CSpline
-//--
 {
 // calcul de la valeur Y pour x=x1 et remplissage du tampon tmp
@@ -471,10 +409,2 @@
 }
 
-///////////////////////////////////////////////////////////////
-///////// rappel des inlines pour commenatires ////////////////
-///////////////////////////////////////////////////////////////
-
-//++
-// inline void SetNaturalCSpline(int type = NaturalAll)
-//	Voir commentaire meme methode de CSpline
-//--
Index: trunk/SophyaLib/NTools/cspline.h
===================================================================
--- trunk/SophyaLib/NTools/cspline.h	(revision 2765)
+++ trunk/SophyaLib/NTools/cspline.h	(revision 2808)
@@ -31,7 +31,9 @@
   void SetBound1er(double yp1 = 0.,double yp2 = 0.);
 
+//!  Pour changer le type de contraintes sur les derivees 2sd
   inline void SetNaturalCSpline(int type = NaturalAll)
                  { Natural = type;}
 
+//!  Pour liberer la place tampon qui ne sert que dans ComputeCSpline() et pas dans CSplineInt
   inline void Free_Tmp()
                 { if(tmp != NULL) delete [] tmp; tmp=NULL;}
@@ -88,4 +90,5 @@
                 ,bool order=true,bool force=false);
 
+//!  Pour changer le type de contraintes sur les derivees 2sd
   inline void SetNaturalCSpline(int type = CSpline::NaturalAll)
                  { Natural = type;}
Index: trunk/SophyaLib/NTools/dates.cc
===================================================================
--- trunk/SophyaLib/NTools/dates.cc	(revision 2765)
+++ trunk/SophyaLib/NTools/dates.cc	(revision 2808)
@@ -11,30 +11,31 @@
 #include "dates.h"
 
-//++
-// Class	TimeZone
-// Lib		Outils++ 
-// include	dates.h
-//
-//	Classe de fuseau horaire. Permet les conversion
-//	GMT <-> temps local, en gérant les changements
-//	d'heure hiver-été.
-//	Deux fuseaux horaires sont prédéfinis, "France"
-//	et "Chili".
-//--
+/*! 
+  \class TimeZone
+  \ingroup NTools
+  Management of time zones - This class is used with class Date.
+  \warning Unless necessary, DO NOT USE this class. 
+  \sa SOPHYA::TimeStamp
+
+  \verbatim
+  
+  Classe de fuseau horaire. Permet les conversion
+  GMT <-> temps local, en gérant les changements
+  d'heure hiver-été.
+  Deux fuseaux horaires sont prédéfinis, "France"
+  et "Chili".
+  \endverbatim
+*/
 
 TimeZone* gTimeZone = NULL;
 
-//++
-// Titre	Constructeurs
-//--
-
-//++
+
+/*!	
+  Constructeur par défaut. Il lit la variable
+  d'environnement ACQ_TZ pour choisir le fuseau
+  horaire. Si la variable n'est pas définie, nous
+  sommes en France...
+*/  
 TimeZone::TimeZone()
-//
-//	Constructeur par défaut. Il lit la variable
-//	d'environnement ACQ_TZ pour choisir le fuseau
-//	horaire. Si la variable n'est pas définie, nous
-//	sommes en France...
-//--
 {
   char* p = getenv("ACQ_TZ");
@@ -47,22 +48,18 @@
 }
 
-//++
+//!	Constructeur à partir du nom d'un fuseau horaire.
 TimeZone::TimeZone(const char* nom)
-//
-//	Constructeur à partir du nom d'un fuseau horaire.
-//--
 {
   SetZone(nom);
 }
 
-//++
+/*!	
+  Choisit un fuseau horaire. Contient la définition
+  du fuseau "France" (GMT+1, DST : dernier dimanche
+  de mars - dernier dimanche de septembre, c'est-à-dire
+  pré-gouvernement Juppé), et Chili (GMT-4, DST :
+  deuxième dimanche d'octobre - deuxième dimanche de mars).
+*/
 void TimeZone::SetZone(const char* nom)
-//	
-//	Choisit un fuseau horaire. Contient la définition
-//	du fuseau "France" (GMT+1, DST : dernier dimanche
-//	de mars - dernier dimanche de septembre, c'est-à-dire
-//	pré-gouvernement Juppé), et Chili (GMT-4, DST :
-//	deuxième dimanche d'octobre - deuxième dimanche de mars).
-//--
 {
   if (!strcmp(nom,"France")) {
@@ -96,9 +93,6 @@
 }
 
-//++
+//!	Teste si une date est en heure d'été (DST).
 int TimeZone::IsDst(const Date& date)
-//
-//	Teste si une date est en heure d'été (DST).
-//--
 {
   Date dt = date;
@@ -139,48 +133,50 @@
 }
 
-//++
+/*!
+  Retourne la difference TL-GMT pour une date donnée,
+  en tenant compte de l'heure d'été éventuelle.
+*/
 int TimeZone::GetOffset(const Date& date)
-//
-//	Retourne la difference TL-GMT pour une date donnée,
-//	en tenant compte de l'heure d'été éventuelle.
-//--
 {
   return IsDst(date) ? gmtOffset+dstOffset : gmtOffset;
 }
 
-//++
-// Class	Date
-// Lib		Outils++ 
-// include	dates.h
-//
-//	Une classe date comme une autre, avec gestion
-//	temps local / GMT / changement d'heure, et un 
-//	jour temps sidéral.
-//
-//	Une partie de la date (heure, jour...) peut être
-//	indéterminée. Les comparaisons sont alors faites
-//	de façon astucieuse...
-//
-//	La date peut être déterminée de minuit à minuit
-//	ou de midi à midi (nuit d'observation). Logique
-//	complexe et peut-être foireuse pour passer de
-//	l'un à l'autre, mais pas encore d'ennuis pour le
-//	moment... Une date-nuit doit avoir une heure
-//	indéterminée.
-//
-//	Il faut que Date::gTimeZone soit initialisé pour
-//	éviter des gros pépins, mais PeidaInit() le fait.
-//
-//	An 2000 : Lorsqu'on gère des dates sous forme de chaine :
-//	* En sortie, 2 caractères pour l'année entre 1950 et 1999
-//	  et 4 caractères sinon
-//	* En entrée, si AA<100 on ajoute 1900.
-//--
-
-//++
+
+
+/*! 
+  \class Date
+  \ingroup NTools
+  Date manipulation classe
+  \warning Unless necessary, DO NOT USE this class.
+  Use  SOPHYA::TimeStamp instead.
+
+  \verbatim
+  
+  Une classe date comme une autre, avec gestion
+  temps local / GMT / changement d'heure, et un 
+  jour temps sidéral.
+  
+  Une partie de la date (heure, jour...) peut être
+  indéterminée. Les comparaisons sont alors faites
+  de façon astucieuse...
+  
+  La date peut être déterminée de minuit à minuit
+  ou de midi à midi (nuit d'observation). Logique
+  complexe et peut-être foireuse pour passer de
+  l'un à l'autre, mais pas encore d'ennuis pour le
+  moment... Une date-nuit doit avoir une heure
+  indéterminée.
+  
+  Il faut que Date::gTimeZone soit initialisé pour
+  éviter des gros pépins, mais PeidaInit() le fait.
+  
+  An 2000 : Lorsqu'on gère des dates sous forme de chaine :
+  * En sortie, 2 caractères pour l'année entre 1950 et 1999
+  et 4 caractères sinon
+  * En entrée, si AA<100 on ajoute 1900.
+
+*/
+//!	Retourne le nombre de jours dans le mois
 short Date::MonthDays(short mois, short annee)
-//
-//	Retourne le nombre de jours dans le mois
-//--
 {
   if (mois<1 || mois>12) throw ParmError(PExcLongMessage(""));
@@ -206,49 +202,43 @@
 }
     
-//++
+//!  Retourne le nombre de jours dans l'année
 short Date::YearDays(short annee)
-//
-//	Retourne le nombre de jours dans l'année
-//--
 {
   return (((annee%4 == 0) && (annee%100 != 0)) || (annee%400 == 0)) ? 366 : 365;
 }
 
-//++
 bool Date::UndetDate() const
-//
-//	Retourne true si une partie de la date (jour
-//	ou mois ou année) est indéterminée.
-//--
+/*!
+  Retourne true si une partie de la date (jour 
+  ou mois ou année) est indéterminée.
+*/
 {
   return ((AA == -1) || (MM == -1) || (JJ == -1));
 }
 
-//++
+/*!
+  Retourne true si toute la date (jour
+  et mois et année) est indéterminée.
+*/
 bool Date::AllUndetDate() const
-//
-//	Retourne true si toute la date (jour
-//	et mois et année) est indéterminée.
-//--
 {
   return ((AA == -1) && (MM == -1) && (JJ == -1));
 }
 
-//++
 bool Date::UndetTime() const
-//
-//	Retourne true si une partie de l'heure (heure
-//	ou minutes ou secondes) est indéterminée.
-//--
+/*!	
+  Retourne true si une partie de l'heure (heure
+  ou minutes ou secondes) est indéterminée.
+*/
 {
   return ((hh == -1) || (mm == -1) || (ss == -1));
 }
 
-//++
+
+/*!
+  Retourne true si toute l'heure (heure
+  et minutes et secondes) est indéterminée.
+*/
 bool Date::AllUndetTime() const
-//
-//	Retourne true si toute l'heure (heure
-//	et minutes et secondes) est indéterminée.
-//--
 {
   return ((hh == -1) && (mm == -1) && (ss == -1));
@@ -257,10 +247,7 @@
 //Date::operator double() const
 
-//++
+//!	Jours écoulés depuis le 0 janvier 1901 0h TU
 double
 Date::GetDays() const
-//
-//	Jours écoulés depuis le 0 janvier 1901 0h TU
-//--
 {
    if (UndetTime() && !AllUndetTime()) throw ParmError(PExcLongMessage(""));
@@ -281,9 +268,6 @@
 }
 
-//++
+//!	Initialisation a partir jours écoulés depuis le 0 janvier 1901 0h TU
 void Date::Set(double t)
-//
-//	Jours écoulés depuis le 0 janvier 1901 0h TU
-//--
 {
    t += 1/8640000.0;
@@ -323,9 +307,7 @@
    nuit = 0;
 }
-//++
+
+//!	Constructeur. Prend l'heure courante...
 Date::Date()
-//
-//	Constructeur. Prend l'heure courante...
-//--
 : timeZone(gTimeZone)
 {
@@ -342,20 +324,12 @@
 }
 
-//++
+//!	Constructeur simple.
 Date::Date(int J, int M, int A, int h, int m, double s)
-//
-//	Constructeur simple.
-//--
 : JJ(J), MM(M), AA(A), hh(h), mm(m), ss(s), timeZone(gTimeZone), nuit(0)
 {
 }
 
-//++
+//!	Constructeur à partir des jours écoulés depuis le 0 janvier 1901 0h TU
 Date::Date(double t)
-//
-//	Constructeur à partir des 
-//	jours écoulés depuis le 0 janvier 1901 0h TU
-//
-//--
 : timeZone(gTimeZone)
 {
@@ -363,22 +337,16 @@
 }
 
-//++
+//!	On change de fuseau horaire.
 void Date::SetTimeZone(TimeZone* tz)
-// 
-//	On change de fuseau horaire.
-//--
 {
   timeZone = tz;
 }
 
-//++
+/*!
+  Constructeur à partir de la date sous la forme
+  'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
+  (par défaut) ou Date::kLocalTime.
+*/
 Date::Date(const char* date, const char* heure, int tOpt)
-//
-//	Constructeur à partir de la date sous la forme
-//	'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
-//	(par défaut) ou Date::kLocalTime.
-//
-//	Tout ou partie de la date peut être indéterminée ('??').
-//--
 : timeZone(gTimeZone)
 {
@@ -386,13 +354,12 @@
 }
 
-//++
+/*!
+  Constructeur à partir de la date sous la forme
+  'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
+  (par défaut) ou Date::kLocalTime.
+  
+  Tout ou partie de la date peut être indéterminée ('??').
+*/
 Date::Date(string const& date, string const& heure, int tOpt)
-//
-//	Constructeur à partir de la date sous la forme
-//	'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
-//	(par défaut) ou Date::kLocalTime.
-//
-//	Tout ou partie de la date peut être indéterminée ('??').
-//--
 : timeZone(gTimeZone)
 {
@@ -400,26 +367,24 @@
 }
 
-//++
+/*!
+  Positionne la date sous la forme
+  'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
+  (par défaut) ou Date::kLocalTime.
+  
+  Tout ou partie de la date peut être indéterminée ('??').
+*/
 void Date::Set(string const& date, string const& heure, int tOpt)
-//
-//	Positionne la date sous la forme
-//	'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
-//	(par défaut) ou Date::kLocalTime.
-//
-//	Tout ou partie de la date peut être indéterminée ('??').
-//--
 {
   Set(date.c_str(), heure == "" ? (char*)NULL : heure.c_str(), tOpt);
 }
 
-//++
+/*!
+  Positionne la date sous la forme
+  'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
+  (par défaut) ou Date::kLocalTime.
+  
+  Tout ou partie de la date peut être indéterminée ('??').
+*/
 void Date::Set(const char* date, const char* heure, int tOpt)
-//
-//	Positionne la date sous la forme
-//	'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
-//	(par défaut) ou Date::kLocalTime.
-//
-//	Tout ou partie de la date peut être indéterminée ('??').
-//--
 {
   nuit = 0;
@@ -538,10 +503,9 @@
 }
 
-//++
+/*!
+  Récupère la date sous la forme d'une chaîne 'DD/MM/YYYY'
+  en tOpt = Date::kGMTTime ou Date::kLocalTime.
+*/
 void Date::GetDateStr(char* s, int tOpt) const
-//
-//	Récupère la date sous la forme d'une chaîne 'DD/MM/YYYY'
-//	en tOpt = Date::kGMTTime ou Date::kLocalTime.
-//--
 {
   Date dt(*this);
@@ -566,9 +530,6 @@
 }
 
-//++
+//!	Code EROS de la date.
 void Date::GetDateCode(char* s, int tOpt) const
-//
-//	Code EROS de la date.
-//--
 {
   Date dt(*this);
@@ -603,9 +564,6 @@
 }
 
-//++
+//!	Récupère l'heure sous la forme 'HH:MM:SS'
 void Date::GetTimeStr(char* s, int tOpt) const
-//
-//	Récupère l'heure sous la forme 'HH:MM:SS'
-//--
 {
   Date dt(*this);
@@ -624,19 +582,15 @@
 }
 
-//++
+//!	Récupèrera un jour le temps sidéral.
 void Date::GetSidTStr(char* s) const
-//
-//	Récupèrera un jour le temps sidéral.
-//--
 {
   strcpy(s,"TOBEDONE!!");
 }
 
-//++
 string Date::DateStr(int tOpt) const
-//
-//	Récupère la date sous la forme d'une chaîne 'DD/MM/YYYY'
-//	en tOpt = Date::kGMTTime ou Date::kLocalTime.
-//--
+/*!
+  Récupère la date sous la forme d'une chaîne 'DD/MM/YYYY'
+  en tOpt = Date::kGMTTime ou Date::kLocalTime.
+*/
 {
    char s[20];
@@ -645,9 +599,6 @@
 }
 
-//++
+//!	Code EROS de la date.
 string Date::DateCode(int tOpt) const
-//
-//	Code EROS de la date.
-//--
 {
    char s[20];
@@ -656,9 +607,6 @@
 }
 
-//++
+//!	Récupère l'heure sous la forme 'HH:MM:SS'
 string Date::TimeStr(int tOpt) const
-//
-//	Récupère l'heure sous la forme 'HH:MM:SS'
-//--
 {
    char s[20];
@@ -667,9 +615,6 @@
 }
 
-//++
+//!	Récupèrera un jour le temps sidéral.
 string Date::SidTStr() const
-//
-//	Récupèrera un jour le temps sidéral.
-//--
 {
    char s[20];
@@ -678,10 +623,6 @@
 }
 
-//++
+//!   Retourne le jour dans la semaine, 0-6 avec 0 = Date::jour_Lundi.
 int Date::DayOfWeek(int tOpt) const
-//
-//	Retourne le jour dans la semaine, 0-6
-//	avec 0 = Date::jour_Lundi.
-//--
 {
   double t = GetDays();
@@ -696,10 +637,9 @@
 }
 
-//++
+/*!
+  Retourne la date correspondant au ieme joursem dans le mois 
+  correspondant (exemple, 2e dimanche de mars 1960).
+*/
 short Date::NthMonthDay(short i, short joursem, short mois, short annee)
-//
-//	Retourne la date correspondant au ieme joursem dans le mois 
-//	correspondant (exemple, 2e dimanche de mars 1960).
-//--
 {
    if (i>0) {
@@ -717,9 +657,6 @@
 }
 
-//++
+//! Ajout un nombre \b dt en jours
 Date& Date::operator += (double dt)     
-//
-//	dt en jours
-//--
 {
   int u = UndetTime();
@@ -729,9 +666,6 @@
 }
 
-//++
+//!  retranche un intervalle de temps \b dt en jours
 Date& Date::operator -= (double dt)    
-//
-//	dt en jours
-//--
 {
   int u = UndetTime();
@@ -741,8 +675,5 @@
 }
 
-//++
 Date operator + (Date const& d, double dt)
-//
-//--
 {
   Date a(d);
@@ -751,8 +682,5 @@
 }
 
-//++
 Date operator - (Date const& d, double dt)
-//
-//--
 {
   Date a(d);
@@ -761,9 +689,6 @@
 }
 
-//++
+//!	Résultat en jours
 double operator - (Date const& a, Date const& b)
-//
-//	Résultat en jours
-//--
 {
   if (a.UndetTime() != b.UndetTime()) throw ParmError(PExcLongMessage(""));
@@ -772,9 +697,6 @@
 }
 
-//++
+//!	On n'a pas égalite dès que des éléments déterminés sont différents
 bool operator == (Date const& a, Date const& b)
-//
-//	On n'a pas égalite dès que des éléments déterminés sont différents
-//--
 {
   if (a.nuit && a.UndetTime() && !b.nuit && !b.UndetTime() && b.hh<12)
@@ -792,17 +714,11 @@
 }
 
-//++
 bool operator != (Date const& a, Date const& b)
-//
-//--
 {
   return !(a == b);
 }
 
-//++
+//!	Inégalité large. Pas de subtilités
 bool operator <= (Date const& a, Date const& b)
-//
-//	Inégalité large. Pas de subtilités
-//--
 {
   if (a.nuit && a.UndetTime() && !b.nuit && !b.UndetTime() && b.hh<12)
@@ -838,35 +754,25 @@
 }
 
-//++
+/*!
+  Inégalité stricte, codée à partir de la large pour résoudre
+  sans cas particuliers les subtilités 
+  01/02/95 < ??/03/95 mais pas 01/02/95 < ??/02/95
+*/
 bool operator < (Date const& a, Date const& b)
-//
-//	Inégalité stricte, codée à partir de la large pour résoudre
-//	sans cas particuliers les subtilités 
-//	01/02/95 < ??/03/95 mais pas 01/02/95 < ??/02/95
-//--
 {
   return (a <= b) && !(a == b);
 }
 
-//++
 bool operator >= (Date const& a, Date const& b)
-//
-//--
 {
   return (b <= a);
 }
 
-//++
 bool operator > (Date const& a, Date const& b)
-//
-//--
 {
   return (b < a);
 }
 
-//++
 ostream& operator << (ostream& s, Date const& d)
-//
-//--
 {
   char x[20];
@@ -877,2 +783,3 @@
   return s;
 }
+
Index: trunk/SophyaLib/NTools/dates.h
===================================================================
--- trunk/SophyaLib/NTools/dates.h	(revision 2765)
+++ trunk/SophyaLib/NTools/dates.h	(revision 2808)
@@ -14,15 +14,13 @@
 
 class TimeZone;
-// <summary> Dates, conversions, operations </summary>
+//! Dates, conversions, operations 
 // Classe generale de date et heure, operation, TU/TL ...
 class Date  {
 public:
-  // Enumerations jours et mois
-  // <group>
+  //! Enumerations jours et mois
   enum Jour {jour_Lundi=0, jour_Mardi, jour_Mercredi, jour_Jeudi, jour_Vendredi, jour_Samedi, jour_Dimanche};
   enum Mois {mois_Janvier=1, mois_Fevrier, mois_Mars, mois_Avril, mois_Mai, mois_Juin, mois_Juillet,
              mois_Aout, mois_Septembre, mois_Octobre, mois_Novembre, mois_Decembre};
   enum {kGMTTime=0, kLocalTime=1};
-  // </group>  
 
   // Constructeur : maintenant 
Index: trunk/SophyaLib/NTools/datime.c
===================================================================
--- trunk/SophyaLib/NTools/datime.c	(revision 2765)
+++ trunk/SophyaLib/NTools/datime.c	(revision 2808)
@@ -16,30 +16,22 @@
 
 /*       Fonctions de calcule de date et temps (Heure)       */
-/* 
-++ 
-  Module 	Dates (C)
-  Lib	LibsUtil
-  include	datime.h
-
-	Ce groupe de fonctions permettent de manipuler des dates et heures.
-	En particulier, il est possible de calculer l'ecart (en nombre de jours
-	ou de secondes separant deux dates, ou le temps sideral correspondant 
-	a une date et heure legale. Deux structures simples sont definies
-	afin de faciliter le passage des arguments entre differentes fonctions:
-	- *JMA* : Jour, Mois, Annee
- 	- *HMS* : Heure, Minutes, Secondes
-
---
-*/
-/*
-++
-  Links	Voir aussi:
- Temps Sideral, Universel (C)
---
-*/
-/*
-++
-Titre	Quelques Macros 
---
+/*! 
+  \ingroup NTools
+  \file datime.c
+  \brief Set of C functions and macros to manipulate date and time  + Sidereal time
+  and simple astronomical functions.
+
+  \warning  If possible, use class SOPHYA::TimeStamp in module BaseTools
+  for date/time computation.
+
+  Ce groupe de fonctions permettent de manipuler des dates et heures.
+  En particulier, il est possible de calculer l'ecart (en nombre de jours
+  ou de secondes separant deux dates, ou le temps sideral correspondant 
+  a une date et heure legale. Deux structures simples sont definies
+  afin de faciliter le passage des arguments entre differentes fonctions:
+  - JMA : Jour, Mois, Annee
+  - HMS : Heure, Minutes, Secondes
+
+  \sa SOPHYA::TimeStamp
 */
 
@@ -68,5 +60,9 @@
 --
 */
-
+/*!
+  \ingroup NTools
+   Decodage d'une chaine de caracteres "strg" sous forme de "hh:mm:ss 10:43:60.5"
+   en structure HMS "hms" avec gestion des signes (decodage correcte de -44:30:05.23)
+*/
 void StrtoHMS(char *s,HMS* h)
 /* On ne peut pas ecrire 1:-05:-45 pas gere et debile! (mn et sec >=0.)  cmv 12/8/97 */
@@ -101,5 +97,9 @@
 }
 
-
+/*!
+  \ingroup NTools
+  Ecrit le contenu de la structure HMS "hms" sous forme de "hh:mm:ss" dans la chaine
+  de caracteres "strg" avec gestion des signes
+*/
 void HMStoStr(HMS h,char *s)
 /* L'ecriture est forcee a h:mn:sec avec mn et sec >=0  cmv 12/8/97 */
@@ -117,4 +117,8 @@
 
 /* Nouvelle-Fonction */
+/*!
+  \ingroup NTools
+  \brief Retourne le nombre de jours dans le mois m, annee a
+*/
 int NbJourMois(int a, int m)
 /* Retourne le nombre de jours dans le mois m, annee a */
@@ -130,9 +134,11 @@
 }
 
+/*!
+  \ingroup NTools
+  Calcule le Nombre de jours ecoules depuis 0 Jan 1901. 
+  Si annee < 100  On considere annee = annee+1900  (1900-1999) 
+*/
 /* Nouvelle-Fonction */
 long JMAtoJ(JMA jma)
-/*           Calcule le Nb. de jours ecoules depuis 0 Jan 1901         */
-/*   Si annee < 100  On considere annee = annee+1900  (1900-1999)      */
-
 {
 long rc,nban;
@@ -162,7 +168,10 @@
 }
 
+/*!
+  \ingroup NTools
+  \brief retourne la date correspondant a \b j jours ecoules depuis le 0/1/1901
+*/
 /* Nouvelle-Fonction */
 JMA JtoJMA(long j)
-/* retourne la date correspondant a j jours ecoules depuis le 0/1/1901 */
 {
 long i;
@@ -215,9 +224,10 @@
 }
 
+/*!
+  \ingroup NTools
+  \brief Cette fonction calcule le numero de jour de la semaine (Lundi=1 .. Dimanche=7) 
+*/
 /* Nouvelle-Fonction */
 int NumJour(JMA jma)
-/*        Cette fonction calcule le numero de jour de la semaine    */
-/*        (Lundi=1 .. Dimanche=7)                                   */
-
 {
 int l;
@@ -289,9 +299,12 @@
 }
 
+/*!
+  \ingroup NTools
+  Pour "nj=dd*10+jj", calcule la date correspondant au jour
+  "jj" (1 .. 7 - Lundi .. Dimanche) du mois "mm" , annee "aa"
+  se trouvant apres (ou egal a) la date "dd/mm/aa" .
+  Si annee "aa" <= 99   ->  annee de 1901 - 1999
+*/
 JMA JApmmaatoJMA(int nj, int mm, int aa)
-/*    Pour "nj=dd*10+jj", calcule la date correspondant au jour
-      "jj" (1 .. 7 - Lundi .. Dimanche) du mois "mm" , annee "aa"
-      se trouvant apres (ou egal a) la date "dd/mm/aa" .
-      Si annee "aa" <= 99   ->  annee de 1901 - 1999       */
 {
 int i, dd, jj;
@@ -311,4 +324,9 @@
 }
 
+/*!
+  \ingroup NTools
+  Cette fonction calcule le nombre d'heures en decimales pour \b hms. 
+  Heures/Minutes/Secondes peuvent etre +/- avec toutes les combinaisons possibles
+*/
 /* Nouvelle-Fonction */
 double HMStoH(HMS hms)
@@ -321,5 +339,8 @@
 
 
-
+/*!
+  \ingroup NTools
+  \brief Conversion en secondes de la structure HMS  "hms"
+*/
 /* Nouvelle-Fonction */
 double HMStoSec(HMS hms)
@@ -330,4 +351,9 @@
 }
 
+/*!
+  \ingroup NTools
+  Calcule le nombre de secondes correspondant a "date,heure" 
+  a partir de l'origine 1er Janv 1990  0H00 ( Date entre 1930 - 2050 )
+*/
 /* Nouvelle-Fonction */
 long DatetoSec(char const* date, char const* heure)
@@ -348,4 +374,10 @@
 }
 
+/*!
+  \ingroup NTools
+  Calcule le nombre de secondes correspondant a "date,heure" 
+  a partir de l'origine 1er Janv 1990  0H00 ( Date entre 1930 - 2050 )
+  en tenant compte des decalages des heures legales.
+*/
 /* Nouvelle-Fonction */
 long DatetoSecOff(char const* date, char const* heure)
@@ -368,4 +400,8 @@
 }
 
+/*!
+  \ingroup NTools
+  \brief Conversion heures en decimales en structure HMS
+*/
 /* Nouvelle-Fonction */
 HMS HtoHMS(double h)
@@ -386,8 +422,12 @@
 }
 
+/*!
+  \ingroup NTools
+  Conversion degres decimaux en structure HMS (deg,min,sec)
+  Degres decimaux en D , M , Sec  Il y a un modulo 360.
+  la sortie est telle que -180 < deg <= 180.
+*/
 /* Nouvelle-Fonction */
 HMS DtoDMS(double h)
-/* Degres decimaux en D , M , Sec  Il y a un modulo 360  */
-/* la sortie est telle que -180 < deg <= 180. */
 {
 HMS hms;
@@ -408,4 +448,9 @@
 }
 
+/*!
+  \ingroup NTools
+  Conversion degres/heures decimaux en structure HMS (deg/heure,min,sec)
+  SANS modulo 360/24
+*/
 /* Nouvelle-Fonction */
 HMS DoubletoHMS(double h)
@@ -875,5 +920,8 @@
 }
 
-
+/*!
+  \ingroup NTools
+  \brief Cette fonction  donne le temps sideral moyen a greenwich a 0h UT 
+*/
 /* Nouvelle-Fonction  */
 HMS GMST_at_0h_UT (JMA date)
@@ -925,5 +973,20 @@
 --
 */
-
+/*!
+  \ingroup NTools
+  Cette fonction calcule le temps sideral GMT a partir du temps
+  universel et de la date GMT.
+  \verbatim
+  Temps sideral
+  Jour Sideral = 86400 Sec. Sid.  ( = 24 H Sid. )    
+  Annee Solaire = 365 J 5H 48' 46"  =~  365.2422 J                       
+  Annee Solaire = 365.2422 Jours Solaire Moyen = 366.2422 Jours Sideraux 
+  Jour Sol. Moyem = 24 H Sol. = 24 H Sid. * (366.2422 / 365.2422)        
+  Jour Solaire Moyen = 86636.555359 Sec. Sid. = 24 H 3' 56.555359"       
+  Heure Solaire Moyen = 3609.85647 Sec. Sid.                             
+  Sec. Sol. = 1.0027379 Sec. Sid.                                        
+  Le 1er Janvier 1989 0H TU Il etait 6H 42' 30" GMT_Sideral 
+  \endverbatim
+*/
 /* Nouvelle-Fonction  */
 HMS TUtoTSid(JMA date, HMS TU)
@@ -964,4 +1027,10 @@
 }
 
+/*!
+  \ingroup NTools
+  Cette fonction calcule les temps universels a partir du temps
+  sideral GMT et de la date GMT. Selon la valeur du TS, il peut y avoir
+  une ou deux possibilites pour le TU (return code).
+*/
 /* Nouvelle-Fonction  */
 int TSidtoTU(JMA date, HMS TS, HMS *TU1, HMS *TU2)
@@ -1027,17 +1096,16 @@
 }
 
-/*
-++
-void TSidSetupLaSilla()
-	Fonction d'initialisation de conversion  de temps sideral et legal 
-	pour la ESO-Silla "SetTSolMOff() , SetTLegOff()".
-|       Longitude = 70 deg 43.8 min ouest
-|       Latitude  = 29 deg 15.4 min Sud    
-|       T Sol. Moyen - TU = -4.715333 Heures
-|       TLegal-TU : -4 Heures de Mars a Octobre, -3 Heures sinon
-|       Changement le 1er dimanche >= 8/03  8/10 a midi (12:00:00)
---
-*/
-
+/*!
+  \ingroup NTools
+  Fonction d'initialisation de conversion  de temps sideral et legal 
+  pour la ESO-Silla "SetTSolMOff() , SetTLegOff()".
+  \verbatim
+  Longitude = 70 deg 43.8 min ouest
+  Latitude  = 29 deg 15.4 min Sud    
+  T Sol. Moyen - TU = -4.715333 Heures
+  TLegal-TU : -4 Heures de Mars a Octobre, -3 Heures sinon
+  Changement le 1er dimanche >= 8/03  8/10 a midi (12:00:00)
+  \endverbatim
+*/
 /* Fonction d'initialisation de calcul de temps sideral pour la Silla */
 void TSidSetupLaSilla()
@@ -1053,12 +1121,10 @@
 
 
-/*
-++
-double ToJulianDay(JMA dateTU, HMS hmsTU);
-	Calcul du jour Julien pour une date TU.
-	Uniquement valable a partir du 15/10/1582 00:00:00.
---
-*/
-
+/*!
+  \ingroup NTools
+  Calcul du jour Julien pour une date TU.
+  Uniquement valable a partir du 15/10/1582 00:00:00.
+  
+*/
 double ToJulianDay(JMA dateTU, HMS hmsTU)
 /* Cf Fundamental astronomie, Springer Verlag 2sd ed.  cmv 4/12/98 */
@@ -1074,12 +1140,9 @@
 }
 
-/*
-++
-int FromJulianDay(double JD,JMA* dateTU, HMS* hmsTU);
-	Calcul de la date date et l'heure TU a partir d'un jour Julien.
-	Retourne 0 si succes.
---
-*/
-
+/*!
+  \ingroup NTools
+  Calcul de la date date et l'heure TU a partir d'un jour Julien.
+  Retourne 0 si succes.
+*/
 int FromJulianDay(double JD,JMA* dateTU, HMS* hmsTU)
 /* Cf Fundamental astronomie, Springer Verlag 2sd ed.  cmv 4/12/98 */
@@ -1115,12 +1178,9 @@
 
 
-/*
-++
-double StrgtoDegDec(char *strg)
-	Cette fonction renvoie la valeur decimale en heures
-	d'un angle specifie sous forme de [-][+]dd:mm:ss.
---
-*/
-
+/*!
+  \ingroup NTools
+  Cette fonction renvoie la valeur decimale en heures
+  d'un angle specifie sous forme de [-][+]dd:mm:ss.
+*/
 double StrgtoDegDec(char *strg)
 /*         cmv 4/12/98 */
@@ -1143,10 +1203,8 @@
 }
 
-/*
-++
-char * DegDectoStrg(double deg, char *strg)
-	Cette fonction ecrit une valeur en degre decimal sous 
-	forme de [-]dd:mm:ss.
---
+/*!
+  \ingroup NTools
+  Cette fonction ecrit une valeur en degre decimal sous 
+  forme de [-]dd:mm:ss.
 */
 
@@ -1172,10 +1230,9 @@
 }
 
-/*
-++
-double EccEarth(JMA dateTU)
-	Valeur de l'eccentricite de l'orbite terrestre
-	a la date TU ``dateTU''.
---
+/*!
+  \ingroup NTools
+  Valeur de l'eccentricite de l'orbite terrestre
+  a la date TU ``dateTU''.
+  Cf Fundamental astronomie, Springer Verlag 2sd ed p477 table E10
 */
 double EccEarth(JMA dateTU)
@@ -1191,10 +1248,8 @@
 }
 
-/*
-++
-double ObliqEarth(JMA dateTU)
-	Valeur de l'obliquite de l'orbite terrestre
-	a la date TU ``dateTU'' (en degres decimaux).
---
+/*!
+  \ingroup NTools
+  Valeur de l'obliquite de l'orbite terrestre
+  a la date TU ``dateTU'' (en degres decimaux).
 */
 double ObliqEarth(JMA dateTU)
@@ -1209,10 +1264,8 @@
 }
 
-/*
-++
-double LongEcPerihelie(JMA dateTU)
-	Retourne la Longitude Ecliptique du perihelie de
-	l'orbite terrestre a la date TU ``dateTU'' (en degres decimaux).
---
+/*! 
+  \ingroup NTools
+  Retourne la Longitude Ecliptique du perihelie de
+  l'orbite terrestre a la date TU ``dateTU'' (en degres decimaux).
 */
 double LongEcPerihelie(JMA dateTU)
@@ -1229,12 +1282,10 @@
 }
 
-/*
-++
-void EquatToEclip(double a,double d,double* l,double *b,JMA dateTU);
-	Renvoie les coordonnees ecliptiques ``l,b'' a partir de
-	coordonnees equatoriales ``a,d'' a la date TU ``dateTU''.
-	La date permet de corriger la variation annuelle
-	de l'obliquite terrestre.
---
+/*!
+  \ingroup NTools
+  Renvoie les coordonnees ecliptiques \b (l,b) a partir de
+  coordonnees equatoriales \b (a,d) a la date TU \b dateTU.
+  La date permet de corriger la variation annuelle
+  de l'obliquite terrestre.
 */
 void EquatToEclip(double a,double d,double* l,double *b,JMA dateTU)
Index: trunk/SophyaLib/NTools/datime.h
===================================================================
--- trunk/SophyaLib/NTools/datime.h	(revision 2765)
+++ trunk/SophyaLib/NTools/datime.h	(revision 2808)
@@ -10,4 +10,14 @@
 
 
+/*! 
+  \ingroup NTools
+  \file datime.h
+  Set of C functions and macros to manipulate date and time + Sidereal time.
+  \sa datime.c
+  \warning : If possible, use class SOPHYA::TimeStamp
+*/
+/*! 
+  \ingroup NTools
+  \brief Structure JMA pour representer une date (Jour, Mois Annee) */
 typedef struct 
   {
@@ -17,5 +27,8 @@
   }  JMA ;
 
-
+/*! 
+  \ingroup NTools
+  \brief Structure HMS pour representer une heure (Heure, Minute Seconde) 
+*/
 typedef struct 
   {
@@ -25,4 +38,5 @@
   } HMS ;
 
+/* \cond
 /*   ----------    2) Donnees constantes  ---------- */
 #ifdef  DATIMEPRIVEE
@@ -43,11 +57,13 @@
 #endif
 
+/* \endcond */
 /*    ------ 3) Macro de manipulation de date et heure  -------  */
-
 #define  NomJour(d)      (NomJo[NumJour(d)-1])
 #define  NomMois(d)      (NomMo[d.Mois-1])
 
-/*   Chaine de forme  hh:mm:sec  <->  structure HMS   */
+/*        Chaine de forme  hh:mm:sec  <->  structure HMS   */
+/*! \brief  Decodage de Chaine de forme  hh:mm:sec   ->  structure HMS   */
 #define  StrgtoHMS(s,h)  ( sscanf(s,"%d:%d:%lf", &(h.Heures),&(h.Minutes),&(h.Secondes)) )
+/*! \brief  structure HMS -> Chaine de forme  hh:mm:sec  */
 #define  HMStoStrg(h,s)  ( sprintf(s,"%02d:%02d:%02.0f", h.Heures,h.Minutes,h.Secondes) )
 
@@ -55,8 +71,10 @@
 /* EA 140998, machin infame pour que ca marche pour 1998/09/14... Pourquoi avoir fait */
 /* des macros ??????????????????????????????????????????????????????????????????????? */
+/*!  \brief Chaine de caracteres sous forme de dd/mm/aaaa -> structure JMA jma. */
 #define  StrgtoJMA(strg,j)  ( sscanf(strg,"%d/%d/%d", &(j.Jour),&(j.Mois),&(j.Annee)),\
     (j.Jour>1900 ? sscanf(strg,"%d/%d/%d", &(j.Annee),&(j.Mois),&(j.Jour)) : 1) ) 
-
+/*! \brief structure JMA -> Chaine de forme jj/mm/aa       */
 #define  JMAtoStrg(j,strg)  ( sprintf(strg,"%02d/%02d/%4d", j.Jour,j.Mois,j.Annee) )
+/*! \brief structure JMA -> Chaine de forme jj/mm/aa       */
 #define  JMAtoStrgLong(j,strg)   ( sprintf(strg,"%s , %d %s %d", NomJo[NumJour(j)-1], j.Jour, NomMo[j.Mois-1], j.Annee) )
 
Index: trunk/SophyaLib/NTools/difeq.cc
===================================================================
--- trunk/SophyaLib/NTools/difeq.cc	(revision 2765)
+++ trunk/SophyaLib/NTools/difeq.cc	(revision 2808)
@@ -3,50 +3,38 @@
 #include "ctimer.h"
 
-//++
-// Class	DiffEqSolver
-// Lib  	Outils++ 
-// include	difeq.h
-//
-//	Classe abstraite de résolveur d'équation différentielles.
-//	Beaucoup de méthodes renvoient l'objet afin de pouvoir
-//	utiliser une notation chaînée du type
-//|	s.Step(...).Start(...).Solve(...)
-//--
-//++ 
-// Links	Implementations
-// RK4DiffEq
-// RK4CDiffEq
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::DiffEqSolver
+  \brief Classe abstraite de résolveur d'équation différentielles.
+
+  Beaucoup de méthodes renvoient l'objet afin de pouvoir
+  utiliser une notation chaînée du type:
+
+  s.Step(...).Start(...).Solve(...)
+
+  \warning statut EXPERIMENTAL , NON TESTE
+
+  \sa SOPHYA::DiffEqFunction
+  \sa SOPHYA::RK4DiffEq  SOPHYA::RK4CDiffEq 
+*/
+
+//!	Constructeur vide. 
 DiffEqSolver::DiffEqSolver()
-//
-//	Constructeur vide. 
-//--
 : mFunc(NULL), mOwnFunc(false),
   mYStart(1), mXStart(0), mStep(0.01)
 {}
 
-//++
+//!  Constructeur général. L'équation est donnée sous forme de DiffEqFunction
 DiffEqSolver::DiffEqSolver(DiffEqFunction* f)
-//
-//	Constructeur général. L'équation est donnée sous forme
-//	de DiffEqFunction
-//--
 : mFunc(f), mOwnFunc(false),
   mYStart(mFunc->NFuncReal()), mXStart(0), mStep(0.01)
 {}
 
-//++
+/*!
+  Constructeur pour le cas particulier d'une équation du premier
+  ordre. Voir DiffEqFcn1. La fonction f correspond à l'équation
+  y' = f(y).
+*/
 DiffEqSolver::DiffEqSolver(DIFEQFCN1 f)
-//
-//	Constructeur pour le cas particulier d'une équation du premier
-//	ordre. Voir DiffEqFcn1. La fonction f correspond à l'équation
-//	y' = f(y).
-//--
 : mFunc(new DiffEqFcn1(f)), mOwnFunc(true),
   mYStart(mFunc->NFuncReal()), mXStart(0), mStep(0.01)
@@ -58,16 +46,12 @@
 }
 
-//++
-// Titre	Méthodes
-//--
-
-//++
+
+/*!
+  Permet de spécifier l'équation différentielle, sous la forme
+  d'une DiffEqFunction. Retourne l'objet DiffEqSolver : notation
+  chaînée possible
+*/
 DiffEqSolver&
 DiffEqSolver::Func(DiffEqFunction* f)
-//
-//	Permet de spécifier l'équation différentielle, sous la forme
-//	d'une DiffEqFunction. Retourne l'objet DiffEqSolver : notation
-//	chaînée possible
-//--
 {
   if (mFunc && mOwnFunc) delete mFunc;
@@ -77,12 +61,11 @@
 }
 
-//++
+/*!
+  Permet de spécifier l'équation différentielle, sous la forme
+  d'une fonction f telle que y' = f(y). Retourne l'objet DiffEqSolver : 
+  notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::Func(DIFEQFCN1 f)
-//
-//	Permet de spécifier l'équation différentielle, sous la forme
-//	d'une fonction f telle que y' = f(y). Retourne l'objet DiffEqSolver : 
-//	notation chaînée possible.
-//--
 {
   if (mFunc && mOwnFunc) delete mFunc;
@@ -92,12 +75,11 @@
 }
 
-//++
+/*!
+  Spécifie le pas d'intégration de l'équation différentielle (pour
+  les méthodes où ce pas a un sens). La valeur par défaut est 0.01.
+  Retourne l'objet DiffEqSolver : notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::Step(double step)
-//
-//	Spécifie le pas d'intégration de l'équation différentielle (pour
-//	les méthodes où ce pas a un sens). La valeur par défaut est 0.01.
-//	Retourne l'objet DiffEqSolver : notation chaînée possible.
-//--
 {
   mStep = step;
@@ -105,16 +87,16 @@
 }
 
-//++
+
+/*!
+  Spécifie le point de départ de l'intégration de l'équadif.
+  Le vecteur \b y contient les valeurs intiales. Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément du vecteur. \b t est la valeur initiale 
+  du temps.
+  La dimension de y doit correspondre au nombre apparent de fonctions.
+  Retourne l'objet DiffEqSolver : notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::StartV(Vector const& yi, double t)
-//
-//	Spécifie le point de départ de l'intégration de l'équadif.
-//	Le vecteur y contient les valeurs intiales. Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément du vecteur. t est la valeur initiale 
-//	du temps.
-//	La dimension de y doit correspondre au nombre apparent de fonctions.
-//	Retourne l'objet DiffEqSolver : notation chaînée possible.
-//--
 {
   ASSERT(mFunc != NULL);
@@ -127,12 +109,11 @@
 }
 
-//++
+/*!  
+  Spécifie le point de départ de l'intégration de l'équadif,
+  pour une équation y' = f(y). On donne le temps et la valeur de y.
+  Retourne l'objet DiffEqSolver : notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::Start1(double y, double t)
-//
-//	Spécifie le point de départ de l'intégration de l'équadif,
-//	pour une équation y' = f(y). On donne le temps et la valeur de y.
-//	Retourne l'objet DiffEqSolver : notation chaînée possible.
-//--
 {
   ASSERT(mFunc != NULL);
@@ -146,17 +127,17 @@
 }
 
-//++
+
+/*!
+  Spécifie le point de départ de l'intégration de l'équadif.
+  Le tableau \b yi contient les valeurs intiales. Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément du tableau. t est la valeur initiale 
+  du temps.
+  Le nombre d'éléments de yi doit correspondre au nombre apparent
+  de fonctions.
+  Retourne l'objet DiffEqSolver : notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::Start(double const* yi, double t)
-//
-//	Spécifie le point de départ de l'intégration de l'équadif.
-//	Le tableau yi contient les valeurs intiales. Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément du tableau. t est la valeur initiale 
-//	du temps.
-//	Le nombre d'éléments de yi doit correspondre au nombre apparent
-//	de fonctions.
-//	Retourne l'objet DiffEqSolver : notation chaînée possible.
-//--
 {
   mYStart.Realloc(mFunc->NFunc());
@@ -169,35 +150,36 @@
 }
 
-//++
-// virtual void DiffEqSolver::SolveArr(Matrix&  y, double* t, double tf, int n)=0
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps. N valeurs intermédiaires sont retournées dans 
-//	les tableaux y et t :
-//	t[i] est le temps au pas i, pour 0<=i<n
-//	y[i] sont les valeurs des fonctions au pas i.
-//	Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément de y[i].
-//	t[n-1] vaut tf.
-//	Le nombre d'éléments de y[i] doit correspondre au nombre apparent
-//	de fonctions.
-//	Cette fonction doit être redéfinie pour chaque méthode de résolution
-//	d'équations. Elle est appelée par toutes les autres fonctions de
-//	résolution (autres SolveArr, et Solve).
-//--
-
-
-//++
+/*!
+  \fn virtual void DiffEqSolver::SolveArr(Matrix&  y, double* t, double tf, int n)
+
+  Lance la résolution de l'équadif, jusqu'à la valeur
+  tf du temps. N valeurs intermédiaires sont retournées dans 
+  les tableaux y et t :
+  - t[i] est le temps au pas i, pour 0<=i<n
+  - y[i] sont les valeurs des fonctions au pas i.
+
+  Voir la description	
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément de y[i].
+  t[n-1] vaut tf.
+  Le nombre d'éléments de y[i] doit correspondre au nombre apparent
+  de fonctions.
+  Cette fonction doit être redéfinie pour chaque méthode de résolution
+  d'équations. Elle est appelée par toutes les autres fonctions de
+  résolution (autres SolveArr, et Solve).
+*/
+
+
+/*!
+  Lance la résolution de l'équadif, jusqu'à la valeur
+  tf du temps. Les valeurs finales sont retournées dans yf.
+  Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément de yf.
+  Le nombre d'éléments de yf doit correspondre au nombre apparent
+  de fonctions.
+*/
 void
 DiffEqSolver::SolveV(Vector& yf, double tf)
-//
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps. Les valeurs finales sont retournées dans yf.
-//	Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément de yf.
-//	Le nombre d'éléments de yf doit correspondre au nombre apparent
-//	de fonctions.
-//--
 {
   double t;
@@ -209,12 +191,12 @@
 }
 
-//++
+
+/*!
+  Lance la résolution de l'équadif, jusqu'à la valeur
+  tf du temps, pour une équation du premier ordre y' = f(y).
+  La valeur finale de y est retournée dans yf.
+*/
 void
 DiffEqSolver::Solve1(double& yf, double tf)
-//
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps, pour une équation du premier ordre y' = f(y).
-//	La valeur finale de y est retournée dans yf.
-//--
 {
   ASSERT(mFunc->NFunc() == 1);
@@ -225,16 +207,16 @@
 }
 
-//++
+
+/*!
+  Lance la résolution de l'équadif, jusqu'à la valeur	
+  tf du temps. Les valeurs finales sont retournées dans yf.
+  Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément de yf.
+  Le nombre d'éléments de yf doit correspondre au nombre apparent
+  de fonctions.
+*/
 void
 DiffEqSolver::Solve(double* yf, double tf)
-//
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps. Les valeurs finales sont retournées dans yf.
-//	Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément de yf.
-//	Le nombre d'éléments de yf doit correspondre au nombre apparent
-//	de fonctions.
-//--
 {
   double t;
@@ -245,15 +227,14 @@
 }
 
-//++
+/*!
+  Lance la résolution de l'équadif (du premier ordre), jusqu'à la valeur
+  tf du temps. N valeurs intermediaires sont retournées dans 
+  les tableaux y et t :
+  t[i] est le temps au pas i, pour 0<=i<n
+  y[i] est la valeur de la fonction au pas i.
+  t[n-1] vaut tf.
+*/
 void
 DiffEqSolver::SolveArr1(double*  y, double* t, double tf, int n)
-//
-//	Lance la résolution de l'équadif (du premier ordre), jusqu'à la valeur
-//	tf du temps. N valeurs intermediaires sont retournées dans 
-//	les tableaux y et t :
-//	t[i] est le temps au pas i, pour 0<=i<n
-//	y[i] est la valeur de la fonction au pas i.
-//	t[n-1] vaut tf.
-//--
 
 {
@@ -265,20 +246,19 @@
 }
 
-//++
+/*!
+  Lance la résolution de l'équadif, jusqu'à la valeur
+  tf du temps. N valeurs intermédiaires sont retournées dans 
+  les tableaux y et t :
+  t[i] est le temps au pas i, pour 0<=i<n
+  y[i] sont les valeurs des fonctions au pas i.
+  Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément de y[i].
+  t[n-1] vaut tf.
+  Le nombre d'éléments de y[i] doit correspondre au nombre apparent
+  de fonctions.
+*/
 void
 DiffEqSolver::SolveArr2(double** y, double* t, double tf, int n)
-//
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps. N valeurs intermédiaires sont retournées dans 
-//	les tableaux y et t :
-//	t[i] est le temps au pas i, pour 0<=i<n
-//	y[i] sont les valeurs des fonctions au pas i.
-//	Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément de y[i].
-//	t[n-1] vaut tf.
-//	Le nombre d'éléments de y[i] doit correspondre au nombre apparent
-//	de fonctions.
-//--
 {
    Matrix m(n, mFunc->NFuncReal());
@@ -290,53 +270,44 @@
 
 
-//++
-// Class	DiffEqFunction
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Classe de fonctions pour la résolution d'équations différentielles.
-//	On résoud de facon générale un système de n équations différentielles
-//	du premier ordre, donnant les dérivées fpi de n fonctions fi. 
-//	Cette méthode permet de résoudre toutes les sortes d'équations :
-//	pour une équation du second ordre on crée une fonction intermédiaire
-//	qui est la dérivée de la fonction cherchée.
-//--
-
-//++
-// DiffEqFunction::DiffEqFunction(int n)
-//	Constructeur. N est le nombre de fonctions dans le
-//	système.
-//--
-
-//++
-// DiffEqFunction::DiffEqFunction(int n, int napp)
-//	Constructeur. N est le nombre réel de fonctions dans le
-//	système, et napp le nombre apparent (pour l'utilisateur).
-//	En effet, dans certains cas, on peut avoir besoin de fonctions
-//	supplémentaires masquées à l'utilisateur, par exemple la fonction
-//	constante valant 1, si l'équadif fait intervenir le temps (t).
-//--
-
-//++
-//  virtual void ComputeV(Vector& fpi, Vector const& fi)
-//	Calcule les valeurs des dérivées fpi à partir des valeurs 
-//	des fonctions fi. A redéfinir.
-//--
-
-//++
-//  virtual void Compute(double& fp, double f)
-//	Dans le cas où il y a une seule fonction, calcule la dérivée
-//      fp à partir de la valeur de la fonction f. A redéfinir.
-//--
-
-//++
-// int NFunc()
-// 	Nombre apparent de fonctions dans le système
-//--
-  
-//++
-// int NFuncReal() {return mNFunc;}
-// 	Nombre réel de fonctions dans le système
-//--
+/*!
+  \ingroup NTools 
+  \class SOPHYA::DiffEqFunction
+  
+  \brief Classe de fonctions pour la résolution d'équations différentielles.
+  
+  On résoud de facon générale un système de n équations différentielles
+  du premier ordre, donnant les dérivées fpi de n fonctions fi. 
+  Cette méthode permet de résoudre toutes les sortes d'équations :
+  pour une équation du second ordre on crée une fonction intermédiaire
+  qui est la dérivée de la fonction cherchée.
+
+  \warning statut EXPERIMENTAL , NON TESTE
+
+  \sa SOPHYA::DiffEqSolver
+*/
+
+
+
+/*!
+  \fn DiffEqFunction::DiffEqFunction(int n, int napp)
+  Constructeur. N est le nombre réel de fonctions dans le
+  système, et napp le nombre apparent (pour l'utilisateur).
+  En effet, dans certains cas, on peut avoir besoin de fonctions
+  supplémentaires masquées à l'utilisateur, par exemple la fonction
+  constante valant 1, si l'équadif fait intervenir le temps (t).
+*/
+
+/*!
+  \fn virtual void ComputeV(Vector& fpi, Vector const& fi)
+  Calcule les valeurs des dérivées fpi à partir des valeurs 
+  des fonctions fi. A redéfinir.
+*/
+
+/*!
+  \fn virtual void Compute(double& fp, double f)
+  Dans le cas où il y a une seule fonction, calcule la dérivée
+  fp à partir de la valeur de la fonction f. A redéfinir.
+*/
+
 
 //++
@@ -348,28 +319,26 @@
 
 
-//++
-// Class	DiffEqFcn1
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles de la forme y' = f(y).
-//	On fournit une fonction de type
-//|	typedef double(*DIFEQFCN1)(double);
-//	qui retourne y' en fonction de y.
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
-
-//++
+/*! 
+  \ingroup NTools
+  \class SOPHYA::DiffEqFcn1
+  
+  \brief Objet-fonction générique pour la résolution d'équations
+  différentielles de la forme y' = f(y).
+  
+  On fournit une fonction de type <br>
+  <tt> typedef double(*DIFEQFCN1)(double); </tt> <br>
+  qui retourne y' en fonction de y.
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+
+//!	Constructeur. On fournit la fonction f tq y'=f(y)
 DiffEqFcn1::DiffEqFcn1(DIFEQFCN1 fcn)
-//
-//	Constructeur. On fournit la fonction f tq y'=f(y)
-//--
 : DiffEqFunction(1), mFcn(fcn)
 {}
 
+
+//! Implementation de Compute qui va utiliser la fonction fournie au constructeur.
 void
 DiffEqFcn1::Compute(double& fp, double f)
@@ -378,28 +347,25 @@
 }
 
-//++
-// Class	DiffEqFcnT1
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles de la forme y' = f(y,t).
-//	On fournit une fonction de type
-//|	typedef double(*DIFEQFCNT1)(double, double);
-//	qui retourne y' en fonction de y et t.
-//	Note : le système résolu est alors en fait
-//|	y'[0] = fcn(y[0], y[1])
-//|	y'[1] = 1
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class   SOPHYA::DiffEqFcnT1
+
+  Objet-fonction générique pour la résolution d'équations
+  différentielles de la forme y' = f(y,t).
+  On fournit une fonction de type
+  <tt>	typedef \tt double(*DIFEQFCNT1)(double, double); </tt>
+  qui retourne y' en fonction de y et t.
+
+  \verbatim
+  Note : le système résolu est alors en fait
+  y'[0] = fcn(y[0], y[1])
+  y'[1] = 1
+  \endverbatim
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+//! Constructeur. On fournit la fonction f tq y' = f(y,t)
 DiffEqFcnT1::DiffEqFcnT1(DIFEQFCNT1 fcn)
-//
-//	Constructeur. On fournit la fonction f tq y' = f(y,t)
-//--
 : DiffEqFunction(2, 1), mFcn(fcn)
 {}
@@ -419,28 +385,24 @@
 }
 
-//++
-// Class	DiffEqFcn2
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles de la forme y'' = f(y',y).
-//	On fournit une fonction de type
-//|	typedef double(*DIFEQFCN2)(double, double);
-//	qui retourne y'' en fonction de y' et y.
-//	Note : le système résolu est en fait
-//|	y'[0] = y[1]
-//|	y'[1] = f(y[1], y[0])
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class   SOPHYA::DiffEqFcn2
+  
+  Objet-fonction générique pour la résolution d'équations
+  différentielles de la forme y'' = f(y',y).
+  On fournit une fonction de type
+  <tt>	typedef double(*DIFEQFCN2)(double, double); </tt>
+  qui retourne y'' en fonction de y' et y.
+  \verbatim
+  Note : le système résolu est en fait
+  y'[0] = y[1]
+  y'[1] = f(y[1], y[0])
+  \endverbatim
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+//!   Constructeur. On fournit la fonction f tq y''=f(y',y)
 DiffEqFcn2::DiffEqFcn2(DIFEQFCN2 fcn)
-//
-//	Constructeur. On fournit la fonction f tq y''=f(y',y)
-//--
 : DiffEqFunction(2), mFcn(fcn)
 {}
@@ -453,29 +415,25 @@
 }
 
-//++
-// Class	DiffEqFcnT2
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles de la forme y'' = f(y',y,t).
-//	On fournit une fonction de type
-//|	typedef double(*DIFEQFCNT2)(double, double, double);
-//	qui retourne y'' en fonction de y', y et t.
-//	Note : le système résolu est alors en fait
-//|	y'[0] = y[1]
-//|	y'[1] = f(y[1], y[0], y[2])
-//|	y'[2] = 1
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::DiffEqFcnT2
+  
+  Objet-fonction générique pour la résolution d'équations
+  différentielles de la forme y'' = f(y',y,t).
+  On fournit une fonction de type <br>
+  <tt> typedef double(*DIFEQFCNT2)(double, double, double); </tt> <br>
+  qui retourne y'' en fonction de y', y et t.
+  \verbatim
+  Note : le système résolu est alors en fait
+  y'[0] = y[1]
+  y'[1] = f(y[1], y[0], y[2])
+  y'[2] = 1
+  \endverbatim
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+//!	Constructeur. On fournit la fonction f tq y'' = f(y',y,t)
 DiffEqFcnT2::DiffEqFcnT2(DIFEQFCNT2 fcn)
-//
-//	Constructeur. On fournit la fonction f tq y'' = f(y',y,t)
-//--
 : DiffEqFunction(3,2), mFcn(fcn)
 {}
@@ -497,28 +455,27 @@
 
 
-//++
-// Class	DiffEqFcnV
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles 3D de la forme y'' = f(y',y), ou y est
-//	un vecteur de dimension 3.
-//	On fournit une fonction de type
-//|	typedef void(*DIFEQFCNV)(Vector& y2, Vector const& y1, 
-//|	                         Vector const& y);
-//	qui retourne y'' en fonction de y' et y.
-//	Note : le système résolu est alors en fait
-//|	v(0-2) = y, v(3-5) = y'
-//|
-//|	v'[0] = v[3]
-//|	v'[1] = v[4]
-//|	v'[2] = v[5]
-//|	v'[3-5] = f(v[3-5], v[0-2])
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
+/*!
+  \ingroup NTools
+  \class  SOPHYA::DiffEqFcnV
+  
+  Objet-fonction générique pour la résolution d'équations
+  différentielles 3D de la forme y'' = f(y',y), ou y est
+  un vecteur de dimension 3.
+  On fournit une fonction de type <br>
+  <tt> typedef void(*DIFEQFCNV)(Vector& y2, Vector const& y1, <br>
+  Vector const& y); </tt> <br>
+  qui retourne y'' en fonction de y' et y.
+  \verbatim
+  Note : le système résolu est alors en fait
+  v(0-2) = y, v(3-5) = y'
+
+  v'[0] = v[3]
+  v'[1] = v[4]
+  v'[2] = v[5]
+  v'[3-5] = f(v[3-5], v[0-2])
+  \endverbatim
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
 
 DiffEqFcnV::DiffEqFcnV(DIFEQFCNV fcn)
@@ -543,21 +500,14 @@
 
 
-//++
-// Class	RK4DiffEq
-// Lib  	Outils++ 
-// include	difeq.h
-//
-//	Classe de résolution d'équadif par la méthode de
-//	Runge-Kutta d'ordre 4.
-//	Voir DiffEqSolver pour les méthodes.
-//--
-//++
-// Links	Parents
-// DiffEqSolver
-//--
-
-//++
-// Titre	Constructeurs
-//--
+/*!
+  \ingroup NTools
+  \class SOPHYA::RK4DiffEq
+  
+  Classe de résolution d'équadif par la méthode de
+  Runge-Kutta d'ordre 4.
+  Voir DiffEqSolver pour les méthodes.
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
 
 RK4DiffEq::RK4DiffEq()
@@ -565,18 +515,13 @@
 {}
 
-//++
+//!	Constructeur général
 RK4DiffEq::RK4DiffEq(DiffEqFunction* f)
-//
-//	Constructeur général
-//--
 : DiffEqSolver(f), k1(f->NFuncReal()), 
   k2(f->NFuncReal()), k3(f->NFuncReal()), k4(f->NFuncReal())
 {}
 
-//++
+
+//!	Constructeur pour y' = f(y)
 RK4DiffEq::RK4DiffEq(DIFEQFCN1 f)
-//
-//	Constructeur pour y' = f(y)
-//--
 : DiffEqSolver(f), k1(1), k2(1), k3(1), k4(1)
 {}
Index: trunk/SophyaLib/NTools/difeq.h
===================================================================
--- trunk/SophyaLib/NTools/difeq.h	(revision 2765)
+++ trunk/SophyaLib/NTools/difeq.h	(revision 2808)
@@ -21,11 +21,11 @@
 class DiffEqFunction  {
 public:
-  // Constructeur. n = nombre de fonctions dans le systeme
+  //! Constructeur. n = nombre de fonctions dans le systeme
   DiffEqFunction(int n)          : mNFunc(n), mNFuncApp(n) {}
   
-  // Constructeur. n = nombre reel de fonctions dans le systeme,
-  // m = nombre apparent (il y a dans certaines cas des fonctions a 
-  // usage interne,  par exemple la fonction constante valant 1...)
-  
+   
+  //  Constructeur. n = nombre reel de fonctions dans le systeme,
+  //  m = nombre apparent (il y a dans certaines cas des fonctions a 
+  //  usage interne,  par exemple la fonction constante valant 1....
   DiffEqFunction(int n, int m)   : mNFunc(n), mNFuncApp(m) {}
   
@@ -42,12 +42,11 @@
        { ASSERT(mNFunc == 1); }
   
-  // Nombre apparent de fonctions dans le systeme
+  //! Nombre apparent de fonctions dans le systeme
   int NFunc()     {return mNFuncApp;}
   
-  // Nombre reel de fonctions dans le systeme
+  //! Nombre reel de fonctions dans le systeme
   int NFuncReal() {return mNFunc;}
   
-  // Pour ajuster vecteur de depart quand il y a des fonctions a usage
-  // interne...
+  //! Pour ajuster vecteur de depart quand il y a des fonctions a usage v  interne...
   virtual void AdjustStart(Vector& /*start*/, double /*tstart*/) 
     {}   
@@ -68,10 +67,10 @@
 class DiffEqFcn1 : public DiffEqFunction {
 public:
-  // Constructeur, on fournit une fonction double->double
+  // Constructeur, on fournit une fonction double->double 
   // qui donne y' en fonction de y.
   DiffEqFcn1(DIFEQFCN1);
 
-  // Implementation de Compute qui va utiliser la fonction fournie
-  // au constructeur.
+  // Implementation de Compute qui va utiliser la fonction 
+  // fournie au constructeur.
   virtual void Compute(double& fp, double f);
 protected:
Index: trunk/SophyaLib/NTools/dynccd.cc
===================================================================
--- trunk/SophyaLib/NTools/dynccd.cc	(revision 2765)
+++ trunk/SophyaLib/NTools/dynccd.cc	(revision 2808)
@@ -11,50 +11,29 @@
 #include "dynccd.h"
 
-//++
-// Class	DynCCD
-// Lib		Images++ 
-// include	dynccd.h
-// 
-//	Cette classe permet la specification des parametres 
-//	definissant la dynamique du CCD, et doit etre utilise
-//      pour le calcul des images de bruit.
-//	- TypNoise = 1 :
-//	Bruit = Sqrt( (RONoise/Gain)**2 + ValPix/Gain )      
-//	- TypNoise = 2 :                                     
-//	Bruit = Sqrt( RefSFond**2 + (ValPix-RefFond)/Gain )  
-//	- TypNoise = 0 
-//	Bruit = 1  (Constant pour tous les pixels) 
-//	- TypNoise = 3         
-//	Bruit = Sqrt(Abs(ValPix)) 
-//
-//	Les pixels hors dynamique sont marques (Bruit = 0)
-//	( < MinADU ou > MaxADU) pour toutes valeurs de TypNoise.
-//	Gain est exprime en electron par ADU, RONoise en electron,
-//	Bruit, ValPix et RefFond en ADU.
-//--
+/*! 
+  \class SOPHYA::DynCCD
+  \ingroup NTools
+  
+  Cette classe permet la specification des parametres 
+  definissant la dynamique du CCD, et doit etre utilise
+  pour le calcul des images de bruit.
 
-//++
-// Links	Parents
-// PPersist
-//--
-//++
-// Links	Autres
-// RzImage
-// Image<T> 
-//--
-//++
-// Titre	Methodes
-//--
-//++
-// DynCCD(int_4TypNoise=0, r_8 MinADU=-9.e19, r_8 MaxADU=9.e19, r_8 Gain=1., r_8 RONoise=0., r_8 RefFond=0., r_8 RefSFond=0.);
-//	Creation d'un objet DynCCD ("typ" determine la methode de calcul du bruit)
-//	|Test verbatim 
-//
-// void Set(int_4TypNoise=0, r_8 MinADU=-9.e19, r_8 MaxADU=9.e19, r_8 Gain=1., r_8 RONoise=0., r_8 RefFond=0., r_8 RefSFond=0.);
-//	Modification des parametres de la dynamique
-// void Print()
-// r_8 Noise(r_8 pixel) const
-//	Renvoie la valeur du bruit pour "pixel" en ADU.
-//--
+  - TypNoise = 1 
+  Bruit = Sqrt( (RONoise/Gain)**2 + ValPix/Gain )      
+  - TypNoise = 2 :                                     
+  Bruit = Sqrt( RefSFond**2 + (ValPix-RefFond)/Gain )  
+  - TypNoise = 0 
+  Bruit = 1  (Constant pour tous les pixels) 
+  - TypNoise = 3         
+  Bruit = Sqrt(Abs(ValPix)) 
+  
+  Les pixels hors dynamique sont marques (Bruit = 0)
+  ( < MinADU ou > MaxADU) pour toutes valeurs de TypNoise.
+  Gain est exprime en electron par ADU, RONoise en electron,
+  Bruit, ValPix et RefFond en ADU.
+
+  \sa SOPHYA::Image
+*/
+
 
 /* ............................................................ */
@@ -63,4 +42,5 @@
 
 /* --Methode-- */
+//!  Creation d'un objet DynCCD ("typ" determine la methode de calcul du bruit)
 DynCCD::DynCCD(int_4 typ, r_8 min, r_8 max, r_8 g,
                r_8 ron, r_8 rf, r_8 rfs)
@@ -74,4 +54,5 @@
 
 /* --Methode-- */
+//!	Modification des parametres de la dynamique
 void DynCCD::Set(int_4 typ, r_8 min, r_8 max, r_8 g,
                r_8 ron, r_8 rf, r_8 rfs)
@@ -93,19 +74,21 @@
 }
 
+//!	Renvoie la valeur du bruit pour "pixel" en ADU.
+/*!
+  Cette fonction calcule la valeur du bruit pour pixel 
+  - Si TypNoise = 1 :                                  
+  Bruit = Sqrt( (RONoise/Gain)**2 + ValPix/Gain )      
+  - Si TypNoise = 2 :                                  
+  Bruit = Sqrt( RefSFond**2 + (ValPix-RefFond)/Gain )
+  - Si TypNoise = 0                                       
+  Bruit = 1  (Constant pour tous les pixels)         
+  - Si TypNoise = 3                                       
+  Bruit = Sqrt(Abs(PixelADU))                        
+
+  Les pixels hors dynamique sont marques (Bruit = 0)    
+  ( < MinADU ou > MaxADU) pour tout valeur de TypNoise  
+*/
 /* --Methode-- */
 r_8 DynCCD::Noise(r_8 pixel) const
-
-/* Cette fonction calcule la valeur du bruit pour pixel     */
-/*  Si TypNoise = 1 :                                       */
-/*     Bruit = Sqrt( (RONoise/Gain)**2 + ValPix/Gain )      */
-/*  Si TypNoise = 2 :                                       */
-/*     Bruit = Sqrt( RefSFond**2 + (ValPix-RefFond)/Gain )  */
-/*  Si TypNoise = 0                                         */
-/*     Bruit = 1  (Constant pour tous les pixels)           */
-/*  Si TypNoise = 3                                         */
-/*     Bruit = Sqrt(Abs(PixelADU))                          */
-/*  Les pixels hors dynamique sont marques (Bruit = 0)      */
-/*  ( < MinADU ou > MaxADU) pour tout valeur de TypNoise    */
-
 {
 r_8 h,s,ronsq;
@@ -133,38 +116,15 @@
 /* --------------------------------------------------------------  */
 
-//++
-// Module	Images de bruit 
-// Lib		Images++ 
-// include	dynccd.h
-//
-//	Ces fonctions permettent le calcul d'image de bruit a partir d'une 
-//	image (RzImage ou Image<T>) et d'un objet DynCCD 
-//--
-//++
-// Links 	Voir classes
-// DynCCD
-// RzImage
-// Image<T>
-//--
-//++
-// Titre	Les fonctions 
-//--
-
-//++
-// Function	RzImage * NoiseImage(RzImage const *pim, DynCCD const * dynccd)
-//	Construit et renvoie l'image du bruit pour l'image "*pim" (RzImage)
-// Function	Image<T> * NoiseImage(Image<T> const * pim, DynCCD const * dynccd)
-//      Meme fonctionalite pour une image typee (ImageU2, ImageR4, ...)
-// Function	ImgAddNoise(Image<T>&, DynCCD const&)
-//	Calcule l'image du bruit et le rajoute a l'image originale
-//--
 
 /* Nouvelle-Fonction */
+/*!
+  Construit et renvoie l'image du bruit pour l'image "*pim" 
+  
+  Creation et Calcul d'une image de bruit a partir de l'image 
+  pim et de dynccd. Voir la methode DynCCD::Noise() pour la 
+  description du calcul                                       
+*/
 template <class T>
 Image<T> NoiseImage(Image<T> const & pim, DynCCD const & dynccd)
-
-/* Creation et Calcul d'une image de bruit a partir de l'image */
-/* pim et de dynccd. Voir la methode DynCCD::Noise() pour la   */
-/* description du calcul                                       */
 
 {
@@ -190,6 +150,8 @@
 
 /* Nouvelle-Fonction */
+//!	Calcule l'image du bruit et le rajoute a l'image originale
 template <class T>
 void ImgAddNoise(Image<T>& img, DynCCD const& dyn)
+
 {
   int_4 nPix = img.XSize() * img.YSize();
Index: trunk/SophyaLib/NTools/dynccd.h
===================================================================
--- trunk/SophyaLib/NTools/dynccd.h	(revision 2765)
+++ trunk/SophyaLib/NTools/dynccd.h	(revision 2808)
@@ -11,9 +11,10 @@
 namespace SOPHYA {
 
-enum {kConstantNoise = 0, kPhotonNoise, kSigFondNoise, kSqrtADUNoise};
 
+//! Readout and photon noise calculation for images
 class DynCCD 
 {
   public :
+  enum {kConstantNoise = 0, kPhotonNoise, kSigFondNoise, kSqrtADUNoise};
 
   int_4 TypNoise;      // Type de calcul du bruit 
@@ -37,7 +38,9 @@
 
 
+//! Return an image corresponding to the noise described by \b dynccd
 template <class T>
 Image<T> NoiseImage(Image<T> const & pim, DynCCD const & dynccd);
 
+//! Add noise to the image
 template <class T>
 void ImgAddNoise(Image<T>&, DynCCD const&);
Index: trunk/SophyaLib/NTools/integ.cc
===================================================================
--- trunk/SophyaLib/NTools/integ.cc	(revision 2765)
+++ trunk/SophyaLib/NTools/integ.cc	(revision 2808)
@@ -10,33 +10,22 @@
 //     utilisant le (1)
 
-//++
-// Class	Integrator
-// Lib		Outils++ 
-// include	integ.h
-//
-//	Classe abstraite d'intégration numérique 1D.
-//	On fournit une fonction double f(double) au constructeur, ou
-//	une GeneralFunction avec des paramètres définis.
-//	L'objet Integrator est convertible en valeur double qui est la valeur
-//	de l'intégrale. Diverses méthodes permettent de choisir des options
-//	de calcul, et ces méthodes retournent une référence sur l'objet, pour
-//	permettre une notation chaînée.
-//--
-//++ 
-// Links	Implementations
-// TrpzInteg
-// GLInteg
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::Integrator
+
+  \brief Classe abstraite d'intégration numérique 1D.
+
+  On fournit une fonction double f(double) au constructeur, ou
+  une GeneralFunction avec des paramètres définis.
+  L'objet Integrator est convertible en valeur double qui est la valeur
+  de l'intégrale. Diverses méthodes permettent de choisir des options
+  de calcul, et ces méthodes retournent une référence sur l'objet, pour
+  permettre une notation chaînée.
+
+  \sa TrpzInteg GLInteg
+*/
+
+//!  Constructeur par défaut. L'objet n'est pas utilisable en l'état.
 Integrator::Integrator()
-//
-//	Constructeur par défaut. L'objet n'est pas utilisable en l'état.
-//--
-
 : mFunc(NULL), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
@@ -44,10 +33,6 @@
 {}
 
-//++
+//! Constructeur à partir de la fonction double->double, et des bornes d'intégration.
 Integrator::Integrator(FUNC f, double xmin, double xmax)
-//
-//	Constructeur à partir de la fonction double->double, et des
-//	bornes d'intégration.
-//--
 : mFunc(f), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
@@ -55,9 +40,6 @@
 {}
 
+//! Constructeur à partir de la fonction double->double, et des bornes d'intégration.
 Integrator::Integrator(fun f, double xmin, double xmax)
-//
-//	Constructeur à partir de la fonction double->double, et des
-//	bornes d'intégration.
-//--
 : mFunc(new Function(f)), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
@@ -66,10 +48,9 @@
 
 
-//++
+/*!
+  Constructeur sans spécifier les bornes. Elles sont positionnées
+  à [0,1], et on pourra les modifier plus tard.
+*/
 Integrator::Integrator(FUNC f)
-// 
-//	Constructeur sans spécifier les bornes. Elles sont positionnées
-//	à [0,1], et on pourra les modifier plus tard.
-//--
 : mFunc(f), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
@@ -77,10 +58,9 @@
 {}
 
-//++
+/*!
+  Constructeur sans spécifier les bornes. Elles sont positionnées
+  à [0,1], et on pourra les modifier plus tard.
+*/
 Integrator::Integrator(fun f)
-// 
-//	Constructeur sans spécifier les bornes. Elles sont positionnées
-//	à [0,1], et on pourra les modifier plus tard.
-//--
 : mFunc(new Function(f)), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
@@ -88,11 +68,10 @@
 {}
 
-//++
+/*!
+  Constructeur à partir d'une GeneralFunction. La fonction doit être une
+  fonction de une variable, et on fournit les valeurs des paramètres ainsi
+  que les bornes d'intégration.
+*/
 Integrator::Integrator(GeneralFunction* gff, double* par, double xmin, double xmax)
-//
-//	Constructeur à partir d'une GeneralFunction. La fonction doit être une
-//	fonction de une variable, et on fournit les valeurs des paramètres ainsi
-//	que les bornes d'intégration.
-//--
 : mFunc(NULL), mGFF(gff), mGFFParm(par),
   mNStep(50), mDX(-1), mReqPrec(-1),
@@ -102,12 +81,11 @@
 }
 
-//++
+/*!
+  Constructeur à partir d'une GeneralFunction. La fonction doit être une
+  fonction de une variable, et on fournit les valeurs des paramètres. 
+  On ne spécifie pas les bornes. Elles sont positionnées
+  à [0,1], et on pourra les modifier plus tard.
+*/
 Integrator::Integrator(GeneralFunction* gff, double* par)
-//
-//	Constructeur à partir d'une GeneralFunction. La fonction doit être une
-//	fonction de une variable, et on fournit les valeurs des paramètres. 
-//	On ne spécifie pas les bornes. Elles sont positionnées
-//	à [0,1], et on pourra les modifier plus tard.
-//--
 : mFunc(NULL), mGFF(gff), mGFFParm(par),
   mNStep(50), mDX(-1), mReqPrec(-1),
@@ -120,15 +98,11 @@
 {if(mFunc) delete mFunc;}
 
-//++
-// Titre	Méthodes
-//--
-
-//++
+/*! 
+  \brief Spécifie le nombre de pas pour l'intégration numérique.
+  
+  La signification peut dépendre de la méthode d'intégration.
+*/
 Integrator& 
 Integrator::NStep(int n)
-//
-//	Spécifie le nombre de pas pour l'intégration numérique.
-//	La signification peut dépendre de la méthode d'intégration.
-//--
 {
   mNStep = n;
@@ -138,11 +112,11 @@
 }
 
-//++
+/*! 
+  \brief Spécifie le nombre de pas pour l'intégration numérique.
+  
+  La signification peut dépendre de la méthode d'intégration.
+*/
 Integrator& 
 Integrator::DX(double d)
-//
-//	Spécifie le pas d'intégration.
-//	La signification peut dépendre de la méthode d'intégration.
-//--
 {
   mDX = d;
@@ -152,12 +126,12 @@
 }
 
-//++
+/*!
+  \brief Spécifie la précision souhaitée. 
+
+  La signification peut dépendre de la méthode d'intégration.
+  Non disponible dans toutes les méthodes d'intégration.
+*/
 Integrator& 
 Integrator::ReqPrec(double p)
-//
-//	Spécifie la précision souhaitée. 
-//	La signification peut dépendre de la méthode d'intégration.
-//	Non disponible dans toutes les méthodes d'intégration.
-//--
 {
   DBASSERT( !"Pas encore implemente !");
@@ -168,10 +142,7 @@
 }
 
-//++
+//! Spécifie les bornes de l'intégrale.
 Integrator& 
 Integrator::Limits(double xmin, double xmax)
-//
-//	Spécifie les bornes de l'intégrale.
-//--
 {
   mXMin = xmin;
@@ -181,10 +152,7 @@
 }
 
-//++
+//! Spécifie la fonction à intégrer, sous forme double f(double).
 Integrator& 
 Integrator::Func(FUNC f)
-//
-//	Spécifie la fonction à intégrer, sous forme double f(double).
-//--
 {
   mFunc = f;
@@ -195,11 +163,10 @@
 }
 
-//++
+/*!
+  \brief Spécifie la fonction à intégrer, sous forme de GeneralFunction 
+  à une variable, et les paramètres sont fournis.
+*/
 Integrator& 
 Integrator::Func(GeneralFunction* gff, double* par)
-//
-//	Spécifie la fonction à intégrer, sous forme de GeneralFunction
-//	à une variable, et les paramètres sont fournis.
-//--
 {
   mGFF = gff;
@@ -234,69 +201,44 @@
 }
 
-//++
-// Class	TrpzInteg
-// Lib		Outils++ 
-// include	integ.h
-//
-//	Classe d'intégration par la méthode des trapèzes.
-//	Voir Integrator pour les méthodes. Le nombre de pas
-//	est le nombre de trapèze, le pas d'intégration est
-//	la largeur des trapèzez. Impossible de demander une
-//	précision.
-//
-//--
-//++
-// Links	Parents
-// Integrator
-//--
-
-//++
-// Titre	Constructeurs
-//	Voir Integrator pour les détails.
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::TrpzInteg
+
+  \brief Implementation de Integrator par la methode des trapezes.
+  
+  Classe d'intégration par la méthode des trapèzes.
+  Voir Integrator pour les méthodes. Le nombre de pas
+  est le nombre de trapèze, le pas d'intégration est
+  la largeur des trapèzez. Impossible de demander une
+  précision.
+  
+  \sa SOPHYA::Integrator
+*/
+
+
 TrpzInteg::TrpzInteg()
-//
-//--
-{}
-
-//++
+{}
+
 TrpzInteg::TrpzInteg(FUNC f, double xmin, double xmax)
-//
-//--
 : Integrator(f, xmin, xmax)
 {}
-//++
+
 TrpzInteg::TrpzInteg(fun f, double xmin, double xmax)
-//
-//--
 : Integrator(f, xmin, xmax)
 {}
 
-//++
 TrpzInteg::TrpzInteg(FUNC f)
-//
-//--
 : Integrator(f)
 {}
 
 TrpzInteg::TrpzInteg(fun f)
-//
-//--
 : Integrator(f)
 {}
 
-//++
 TrpzInteg::TrpzInteg(GeneralFunction* gff, double* par, double xmin, double xmax)
-//
-//--
 : Integrator(gff, par, xmin, xmax)
 {}
 
-//++
 TrpzInteg::TrpzInteg(GeneralFunction* gff, double* par)
-//
-//--
 : Integrator(gff, par)
 {}
@@ -305,4 +247,5 @@
 {}
 
+//! Return the value of the integral.
 double
 TrpzInteg::Value()
@@ -329,68 +272,52 @@
 
 
-//++
-// Class	GLInteg
-// Lib		Outils++ 
-// include	integ.h
-//
-//	Classe d'intégration par la méthode de Gauss-Legendre.
-//	Voir Integrator pour les méthodes. 
-//	Pour le moment, nstep est l'ordre de la méthode.
-//	Il est prévu un jour de spécifier l'ordre, et que NStep
-//	découpe en intervalles sur chacun desquels on applique GL.
-//	Le principe de la méthode est de calculer les valeurs de la 
-//	fonction aux zéros des polynomes de Legendre. Avec les poids
-//	qui vont bien, GL d'ordre n est exacte pour des polynomes de 
-//	degré <= 2n+1 (monome le + haut x^(2*n-1).
-//	Impossible de demander une précision donnée.
-//
-//--
-//++
-// Links	Parents
-// Integrator
-//--
-
-//++
-// Titre	Constructeurs
-//	Voir Integrator pour les détails.
-//--
-
-
-
-
-//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::GLInteg
+  
+  \brief Implementation de Integrator par la methode de Gauss-Legendre.
+
+  Classe d'intégration par la méthode de Gauss-Legendre.
+  Voir Integrator pour les méthodes. 
+  Pour le moment, nstep est l'ordre de la méthode.
+  Il est prévu un jour de spécifier l'ordre, et que NStep
+  découpe en intervalles sur chacun desquels on applique GL.
+  Le principe de la méthode est de calculer les valeurs de la 
+  fonction aux zéros des polynomes de Legendre. Avec les poids
+  qui vont bien, GL d'ordre n est exacte pour des polynomes de 
+  degré <= 2n+1 (monome le + haut x^(2*n-1).
+  Impossible de demander une précision donnée.
+
+  \sa SOPHYA::Integrator
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+
+
 GLInteg::GLInteg()
-//
-//--
 : mXPos(NULL), mWeights(NULL)
 {}
 
 
-//++
 GLInteg::GLInteg(FUNC f, double xmin, double xmax)
-//
-//--
 : Integrator(f, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
 {
   NStep(1);
 }
+
 GLInteg::GLInteg(fun f, double xmin, double xmax)
-//
-//--
 : Integrator(f, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
 {
   NStep(1);
 }
-//++
+
 GLInteg::GLInteg(FUNC f)
-//
-//--
 : Integrator(f), mXPos(NULL), mWeights(NULL), mOrder(8)
 {
   NStep(1);
 }
+
 GLInteg::GLInteg(fun f)
-//
-//--
 : Integrator(f), mXPos(NULL), mWeights(NULL), mOrder(8)
 {
@@ -398,8 +325,5 @@
 }
 
-//++
 GLInteg::GLInteg(GeneralFunction* gff, double* par, double xmin, double xmax)
-//
-//--
 : Integrator(gff, par, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
 {
@@ -407,8 +331,5 @@
 }
 
-//++
 GLInteg::GLInteg(GeneralFunction* gff, double* par)
-//
-//--
 : Integrator(gff, par), mXPos(NULL), mWeights(NULL), mOrder(8)
 {
@@ -453,4 +374,5 @@
 
 
+//! Definit l'ordre de la methode d'integration Gauus-Legendre
 GLInteg&
 GLInteg::SetOrder(int order)
@@ -462,5 +384,5 @@
 
 
-
+//! Retourne la valeur de l'integrale
 double
 GLInteg::Value()
@@ -527,4 +449,5 @@
 }
 
+//! Imprime l'ordre et la valeur des poids sur cout
 void
 GLInteg::Print(int lp)
Index: trunk/SophyaLib/NTools/ntoolsinit.cc
===================================================================
--- trunk/SophyaLib/NTools/ntoolsinit.cc	(revision 2765)
+++ trunk/SophyaLib/NTools/ntoolsinit.cc	(revision 2808)
@@ -15,5 +15,4 @@
 /*!
    \defgroup NTools NTools module
-   This module contains various tools for Sophya.
 */
 
@@ -23,5 +22,13 @@
   \class SOPHYA::NToolsInitiator
   \ingroup NTools
-  Tools initiator
+  \brief NTools module initializer.
+
+   This module contains various tools for Sophya, in particular numerical algorithms
+   such as :
+   - Non linear fitting (parameter determination) : GeneralFit , MinZSimplex
+   - FFT (FFTServerInterface, FFTPackServer)
+   - Spline interpolation
+   - Numerical integration and differential equations
+   - Date/time manipulation and some usual astronomical quantities (datime.c .h)
 */
 NToolsInitiator::NToolsInitiator()
Index: trunk/SophyaLib/NTools/poly.cc
===================================================================
--- trunk/SophyaLib/NTools/poly.cc	(revision 2765)
+++ trunk/SophyaLib/NTools/poly.cc	(revision 2808)
@@ -14,4 +14,5 @@
   \ingroup NTools
   One dimensional polynomials class.
+  \warning status EXPERIMENTAL - not fully tested.
 */
 
@@ -350,4 +351,5 @@
   \ingroup NTools
   Two dimensional polynomials class.
+  \warning status EXPERIMENTAL - not fully tested.
 */
 
Index: trunk/SophyaLib/NTools/simplex.cc
===================================================================
--- trunk/SophyaLib/NTools/simplex.cc	(revision 2765)
+++ trunk/SophyaLib/NTools/simplex.cc	(revision 2808)
@@ -10,4 +10,11 @@
 //---------------------------------------------------------------
 // Interface de classe de function multivariable pour le SimplexMinmizer
+/*!
+  \class SOPHYA::MinZFunction
+  \ingroup NTools
+  Interface definition for a function object f(x[]) for which MinZSimplex can 
+  search the minimum.
+  The pure virtual method Value() should be implemented by the derived classes.
+*/
 
 MinZFunction::MinZFunction(unsigned int nvar)
@@ -23,4 +30,10 @@
 //-------------------  Classe   MinZFuncXi2  --------------------
 //---------------------------------------------------------------
+/*!
+  \class SOPHYA::MinZXi2
+  \ingroup NTools
+  Implements the MinZFunction interface using a xi2 calculator 
+  \sa GeneralXi2 GeneralFitData
+*/
 MinZFuncXi2::MinZFuncXi2(GeneralXi2* gxi2, GeneralFitData* gd)
   : mGXi2(gxi2) , mGData(gd), MinZFunction(gxi2->NPar())
@@ -174,4 +187,68 @@
 }
 
+/*!
+  \class SOPHYA::MinZSimplex
+  \ingroup NTools
+  This class implements non linear minimization (optimization)
+  in a multidimensional space following the \b Simplex method.
+  A \b Simplex is a geometrical figure made of N+1 points in a
+  N-dimensional space. (triangle in a plane, tetrahedron in 3-d space).
+  The minimization method implemented in this class is based on the 
+  algorithm described in "Numerical Recipes, Chapter X". 
+
+  The algorithm has been slightly enhanced :
+  - More complex convergence / stop test 
+  - A new transformation of the simplex has been included (ExpandHigh)
+
+  For each step, on of the following geometrical transform is performed
+  on the Simplex figure:
+  - Reflection : reflection away from the high point (expansion by factor Alpha)
+  - ReflecExpand : reflection way from the high point and expansion by factor Beta2
+  - ContractHigh : Contraction along the high point (factor Beta)
+  - ContractLow : Contraction toward the low point (factor Beta2)
+  - ExpandHigh : Expansion along the high point
+
+  \sa GeneralFit
+
+  The following sample code shows a usage example:
+  \code
+  include "simplex.h"
+  ...
+  // Define our function to be minimized:
+  class MySFunc : public MinZFunction {
+  public:
+    MySFunc() : MinZFunction(2) {}
+    virtual double Value(double const xp[]) 
+    { return (xp[0]*xp[0]+2*xp[1]*xp[1]); }
+  };
+
+  ... 
+
+  MySFunc mysf;
+  MinZSimplex simplex(&mysf);
+  // Guess the center and step for constructing the initial simplex
+  Vector x0(2); x0 = 1.;
+  Vector step(2); step = 2.;
+  simplex.SetInitialPoint(x0);
+  simplex.SetInitialStep(step);
+  Vector oparm(2);
+  int rc = simplex.Minimize(oparm);
+  if (rc != 0) {
+    string srt; 
+    int sr = simplex.StopReason(srt);
+    cout << " Convergence Pb, StopReason= " << sr << " : " << srt << endl;
+    }
+  else {
+    cout << " Converged: NStep= " << simplex.NbIter() 
+         << " OParm= " << oparm << endl;
+    }
+  \endcode
+*/
+
+/*!
+  \brief Auto test function
+  \param tsel : select autotest (0,1,2,3,4)  , tsel<0 -> all
+  \param prtlev : printlevel 
+*/
 int MinZSimplex::AutoTest(int tsel, int prtlev)
 {
@@ -214,4 +291,5 @@
 }
 
+//! Constructor from pointer to MinZFunction object 
 MinZSimplex::MinZSimplex(MinZFunction *mzf)
   : mZF(mzf) , mPoint0(mZF->NVar()) , mStep0(mZF->NVar())
@@ -234,4 +312,23 @@
 }
 
+//! Perform the minimization 
+/*!
+  Return 0 if success
+  \param fpoint : vector containing the optimal point 
+  
+  Convergence test :
+  \verbatim
+  On minimise f(x) f=mZF->Value() , 
+              f_max = max(f) sur simplex , f_min = min(f) sur simplex 
+              fm = (abs(f_max)+abs(f_min))
+              [Delta f] = abs(f_max-f_min)
+              [Delta f/f]simplex = 2.*Delta f / fm
+              fm2 = (abs(f_max)+abs(f_max(iter-1)))
+              [Delta f_max/f_max]iter = [f_max(iter-1)-f_max]/fm2 
+  Test d'arret :  
+   fm < mTol0                                                       OU 
+   [Delta f/f]simplex              < mTol1   mRep1 fois de suite    OU 
+   [Delta f_max/f_max]iter         < mTol2   mRep2 fois de suite  
+*/
 int MinZSimplex::Minimize(Vector& fpoint)
 {
@@ -411,4 +508,5 @@
 }
 
+//! Return the stop reason and fills the corresponding string description
 int MinZSimplex::StopReason(string& s)
 {
Index: trunk/SophyaLib/NTools/simplex.h
===================================================================
--- trunk/SophyaLib/NTools/simplex.h	(revision 2765)
+++ trunk/SophyaLib/NTools/simplex.h	(revision 2808)
@@ -28,5 +28,5 @@
 namespace SOPHYA {
 
-//! Interface definition for multivaruable function (used by SimplexMinmizer)
+//! Interface definition for multivariable function (used by SimplexMinmizer)
 class MinZFunction {
 public:
@@ -42,5 +42,5 @@
 };
 
-//!  Classe implementing MinZFunction for a GeneralXi2 associated with a GeneralFitData
+//!  Wrapper class implementing MinZFunction for a GeneralXi2 associated with a GeneralFitData
 class MinZFuncXi2 : public MinZFunction {
 public: 
@@ -61,16 +61,26 @@
   virtual        ~MinZSimplex();
 
+  //! Return the parameter space dimension 
   inline int     NDim() { return mZF->NVar(); }
   // Simplex initial 
+  //! Defines the initial point (center of simplex figure)
   inline void    SetInitialPoint(Vector& point) { mPoint0 = point; }
+  //! Defines the step along each dimension to construct the simplex from initial point
   inline void    SetInitialStep(Vector& step) { mStep0 = step; }
 
+  //! Set the info/debug print level  
   inline void    SetPrtLevel(int lev=0) { mPrt = lev; }
+  //! Return the current print level
   inline int     PrtLevel() { return mPrt; }
 
+  //! Set the maximum number of iteration
   inline void    SetMaxIter(int max = 100000) { mMaxIter = max; }
+  //! Return the current  max iter 
   inline int     MaxIter() { return mMaxIter; }
+  //! Return the number of iterations performed
   inline int     NbIter() { return mIter; }
+  //! Return the stop reason
   inline int     StopReason() { return mStop; }
+  //! Return the stop reason and a description string (\b s)
          int     StopReason(string& s);
 
@@ -86,5 +96,6 @@
   //  [Delta f/f]simplex              < mTol1   mRep1 fois de suite    OU 
   //  [Delta f_max/f_max]iter         < mTol2   mRep2 fois de suite 
-  // 
+
+  //! Define the tolerances for the various convergence tests
   inline void    SetStopTolerance(double tol0=1.e-39, double tol1 = 1.e-3, int rep1=5, 
 				  double tol2=1.e-4, int rep2=5)   
@@ -97,12 +108,19 @@
   // Beta2  = Facteur d'homothetie pour la contraction vers le sommet bas f_min (ContractLow)
   // Gamma2 = Facteur d'homothetie pour la l'extension pour le sommet haut ExpandHigh
+
+  //! Define the similarity (homothetic) factors for the different simplex transformations
   inline void    SetControls(double alpha=1., double beta=0.5, double beta2=0.5, 
 			     double gamma=2.0, double gamma2=2.0)
                  { mAlpha = alpha; mBeta = beta; mBeta2 = beta2;  mGamma = gamma; mGamma2 = gamma2;}  
 
+  //! Return the the homothetic factor for Reflection
   inline double  Alpha() { return mAlpha; }
+  //! Return the the homothetic factor for ContractHigh (contraction away from high point)
   inline double  Beta() { return mBeta; }
+  //! Return the the homothetic factor for ContractLow (contraction toward the low point)
   inline double  Beta2() { return mBeta2; }
+  //! Return the the homothetic factor for ReflecExpand (reflection+expansion)
   inline double  Gamma() { return mGamma; }
+  //! Return the the homothetic factor for ExpandHigh (expansion along high point)
   inline double  Gamma2() { return mGamma2; }
 
