Index: trunk/SophyaLib/Samba/scan.h
===================================================================
--- trunk/SophyaLib/Samba/scan.h	(revision 564)
+++ trunk/SophyaLib/Samba/scan.h	(revision 565)
@@ -7,6 +7,9 @@
 #include <iostream.h>
 #include "dvlist.h"
-class Scan : public PPersist {
+#include "ndatablock.h"
+//!   Storage and treatment of data for a scanning of a part of the sky with a set of given values for parameters (see constructor)
 
+class Scan :  public AnyDataObj  {
+  //  friend FIO_Scan;
   public  :
     /* 
@@ -22,9 +25,20 @@
   . offset d'antenne en angle phi
   */
+
+    /*!
+\verbatim
+    * Ouv      = aperture angle (rad)
+    * Omega[3] = direction of rotation axis of the satellite (teta,phi)
+                 and rotation velocity (rad/s)
+    * Fech     = sampling frequency  (Hz)
+    * T        = total time of data acquistion (s)
+    * t0       = starting time (s)
+    * phi0     = offset of antenna (rad)
+\endverbatim
+    */
 Scan(float,float*,float,float,float,float);
 Scan(const Scan& );
 Scan() { 
   InitNull();
-  cout << " constructeur de scan par defaut" << endl;
 }
 ~Scan();
@@ -32,23 +46,35 @@
 // ------------ Persistence handling
 
-     enum {classId = 0xF003 };
-int_4                  ClassId() const        { return classId; }
+//     enum {classId = 0xF003 };
+//int_4                  ClassId() const        { return classId; }
 
-virtual void           WriteSelf(POutPersist&) const;
-virtual void           ReadSelf(PInPersist&);
+//virtual void           WriteSelf(POutPersist&) const;
+//virtual void           ReadSelf(PInPersist&);
 
+/*!   Return the number of points in the scan */
 int_4     NbPoints() const;
+/*!    Return total nomber of turns */
 int_4     NbTours() const;
+/*!    Return  nomber of points for 1 turn */
 int_4     NbPts1Tr() const; 
+/*!    Return index of pixel associated to time t */
 int_4     ValueIndex(float) const;
+/*!    Return  (teta,phi) coordinate of pixel related to time t */
 void    Direction(float, float& ,float& );
+/*!    Return  (teta,phi) coordinates of  pixel with index k */
 void    DirectionIndex(int_4,float& ,float& );
-double& PixelValue(int_4 k) const;
+/*!    Return value of pixel with index k */
+r_8  & PixelValue(int_4 k) ;
+/*!    const version of previous method */
+r_8 const & PixelValue(int_4 k) const;
 
 /* Surcharge de la parenthese a un indice entier : remplit ou/et renvoie */
 /* la valeur du contenu du pixel d'indice k                              */ 
-
-  inline  double&        operator()(int_4 k)
+  
+  inline  r_8&    operator()(int_4 k)
                                       { return(PixelValue(k)) ; } ;
+  inline  r_8 const &    operator()(int_4 k) const
+                                      { return(PixelValue(k)) ; } ;
+  Scan& operator = (const Scan& s);
 //++
 DVList&  Info()
@@ -56,31 +82,103 @@
 //      Renvoie une reference sur l'objet DVList Associe
 //--
-{
+{  
 if (mInfo_ == NULL)  mInfo_ = new DVList;
 return(*mInfo_);
 }
 
+const DVList*  ptrInfo() const
+  {
+    return mInfo_;
+  }
+
+
+
+inline  void  SetIntParams(int_4 NmaxPts, int_4 NmaxTrs, int_4 NPts1Tr)
+  {
+    NmaxPts_=NmaxPts;
+    NmaxTrs_=NmaxTrs;
+    NPts1Tr_=NPts1Tr;
+  }
+ inline void SetFloatParams(r_4 Ouverture, r_4 OmegaTeta, r_4 OmegaPhi, 
+			    r_4 OmegaRad, r_4 FrequenceEch, r_4 TempsFinal, 
+			    r_4 TempsInitial, r_4 PhiZero, r_8* Rota)
+   {
+     Ouverture_    = Ouverture;
+     OmegaTeta_    = OmegaTeta;
+     OmegaPhi_     = OmegaPhi;
+     OmegaRad_     = OmegaRad;
+     FrequenceEch_ = FrequenceEch;
+     TempsFinal_   = TempsFinal;
+     TempsInitial_ = TempsInitial;
+     PhiZero_      = PhiZero;
+     for (int k=0; k<9;k++) Rota_[k]=Rota[k];
+   }
+
+ inline void GetFloatParams(r_4& Ouverture, r_4& OmegaTeta, r_4& OmegaPhi, 
+			    r_4& OmegaRad, r_4& FrequenceEch, r_4& TempsFinal, 
+			    r_4& TempsInitial, r_4& PhiZero, r_8* Rota) const
+   {
+     Ouverture    = Ouverture_;
+     OmegaTeta    = OmegaTeta_;
+     OmegaPhi     = OmegaPhi_;
+     OmegaRad     = OmegaRad_;
+     FrequenceEch = FrequenceEch_;
+     TempsFinal   = TempsFinal_;
+     TempsInitial = TempsInitial_;
+     PhiZero      = PhiZero_;
+     for (int k=0; k<9;k++) Rota[k]=Rota_[k];
+   }
+
+/* retourne le pointeur vers/remplit  le vecteur des contenus des pixels */ 
+inline const NDataBlock<r_8>* getDataBlock() const {return (&sPix_);}
+inline void setDataBlock(r_8* data, int n) {sPix_.FillFrom(n,data);}
 
   private :
     
-void          Clear();
+    //void          Clear();
 void          InitNull();
 
-int_4 NmaxPts_;
-int_4 NmaxTrs_;
-int_4 NPts1Tr_;
-r_4   Ouverture_;
-r_4   OmegaTeta_;     /* direction de l'axe de rotation du satellite */
-r_4   OmegaPhi_;      /* (radians)                                   */
-r_4   OmegaRad_;      /* vitesse de rotation du satellite (radians/s) */
-r_4   FrequenceEch_;  /* frequence d'echantillonnage (Hz)*/
-r_4   TempsFinal_;
-r_4   TempsInitial_;
-r_4   PhiZero_;       /* Offset antenne (radians)  */
-r_8*  sPix_;          /* valeurs contenues dans chaque pixel */ 
-r_8   Rota_[9];       /* matrice de passage : [Xf]=[Rota][Xs] */
+
+ int_4 NmaxPts_;
+ int_4 NmaxTrs_;
+ int_4 NPts1Tr_;
+ r_4   Ouverture_;
+ r_4   OmegaTeta_;     /* direction de l'axe de rotation du satellite */
+ r_4   OmegaPhi_;      /* (radians)                                   */
+ r_4   OmegaRad_;      /* vitesse de rotation du satellite (radians/s) */
+ r_4   FrequenceEch_;  /* frequence d'echantillonnage (Hz)*/
+ r_4   TempsFinal_;
+ r_4   TempsInitial_;
+ r_4   PhiZero_;           /* Offset antenne (radians)  */
+ NDataBlock<r_8>  sPix_;   /* valeurs contenues dans chaque pixel */ 
+ //r_8*  sPix_;            /* valeurs contenues dans chaque pixel */ 
+ r_8   Rota_[9];       /* matrice de passage : [Xf]=[Rota][Xs] */
                       /* Xs : coordonnees dans un systeme lie au satellite*/ 
                       /* Xf : coordonnees dans un repere "fixe"           */ 
-DVList* mInfo_;        // Infos (variables) attachees 
+ DVList* mInfo_;        // Infos (variables) attachees 
+};
+
+// ------------- Classe pour la gestion de persistance --
+//!    Delegated objects for persitance management
+
+class FIO_Scan : public PPersist  
+{
+
+public:
+
+FIO_Scan(); 
+FIO_Scan(string const & filename); 
+FIO_Scan(const Scan& obj);
+FIO_Scan(Scan* obj);
+virtual ~FIO_Scan();
+virtual AnyDataObj* DataObj();
+inline operator Scan() {return(*dobj); }
+
+protected :
+
+virtual void ReadSelf(PInPersist&);           
+virtual void WriteSelf(POutPersist&) const;  
+Scan* dobj;
+bool ownobj;
 };
 
Index: trunk/SophyaLib/Samba/spheregorski.cc
===================================================================
--- trunk/SophyaLib/Samba/spheregorski.cc	(revision 564)
+++ trunk/SophyaLib/Samba/spheregorski.cc	(revision 565)
@@ -158,5 +158,5 @@
 //    to phi = 0
 //
-//    nside DOIT OBLIGATOIREMENT ETRE UNE PUISSANCE DE 2 (<= 8192)
+//    nside MUST be a power of 2 (<= 8192)
 //--
 //++
@@ -166,14 +166,8 @@
 //    SphericalMap 
 //-- 
-//++
-//
-// Links	Descendants
-//
-//     
-//-- 
 
 /* --Methode-- */
 //++
-// Titre	Constructeurs
+// Titre	Constructors
 //--
 //++
@@ -191,7 +185,9 @@
 SphereGorski<T>::SphereGorski(int m)
 
-//    Constructeur : m est la variable nside de l'algorithme de Gorski
-//    le nombre total de pixels sera Npix =  12*nside**2
-//    m DOIT OBLIGATOIREMENT ETRE UNE PUISSANCE DE 2 (<= 8192)
+//    m is the "nside" of the Gorski algorithm
+//
+//    The total number of pixels will be Npix =  12*nside**2
+//
+//    nside MUST be a power of 2 (<= 8192)
 //--
 {
@@ -213,7 +209,10 @@
   Pixelize(m);
 }
-
+//++
 template<class T>
 SphereGorski<T>::SphereGorski(const SphereGorski<T>& s)
+
+//    copy constructor
+//--
 {
   cout << " constructeur de recopie " << endl;
@@ -229,5 +228,5 @@
 
 //++
-// Titre	Destructeur
+// Titre	Destructor
 //--
 //++
@@ -241,5 +240,5 @@
 
 //++
-// Titre	Méthodes
+// Titre	Public Methods
 //--
 
@@ -248,7 +247,9 @@
 void SphereGorski<T>::Resize(int m)
 
-//    m est la variable nside de l'algorithme de Gorski
-//    le nombre total de pixels sera Npix =  12*nside**2
-//    m DOIT OBLIGATOIREMENT ETRE UNE PUISSANCE DE 2 (<= 8192)
+//    m is the "nside" of the Gorski algorithm
+//
+//    The total number of pixels will be Npix =  12*nside**2
+//
+//    nside MUST be a power of 2 (<= 8192)
 //--
 {
@@ -276,5 +277,4 @@
 //
 //    
-//--
 {
   // On memorise les arguments d'appel
@@ -325,5 +325,5 @@
 int SphereGorski<T>::NbThetaSlices() const 
 
-//    Retourne le nombre de tranches en theta sur la sphere
+//    Return number of slices in theta direction on the  sphere
 //--
 {
@@ -335,8 +335,12 @@
 void SphereGorski<T>::GetThetaSlice(int index,double& theta,TVector<double>& phi,TVector<T>& value) const 
 
-//    Retourne, pour la tranche en theta d'indice 'index' le theta 
-//    correspondant, un vecteur (Peida) contenant les phi des pixels de 
-//    la tranche, un vecteur (Peida) contenant les valeurs de pixel 
-//    correspondantes
+//    For a theta-slice with index 'index', return : 
+//
+//    the corresponding "theta" 
+//
+//    a vector containing the phi's of the pixels of the slice
+//
+//    a vector containing the corresponding values of pixels 
+//
 //--
 {
@@ -387,5 +391,5 @@
 T& SphereGorski<T>::PixVal(int k)
 
-//    Retourne la valeur du contenu du pixel d'indice "RING" k 
+//    Return value of  pixel with "RING" index k 
 //--
 {
@@ -404,5 +408,5 @@
 T const& SphereGorski<T>::PixVal(int k) const
 
-//    Retourne la valeur du contenu du pixel d'indice "RING" k 
+//    Return value of  pixel with "RING" index k 
 //--
 {
@@ -420,5 +424,5 @@
 T& SphereGorski<T>::PixValNest(int k)
 
-//    Retourne la valeur du contenu du pixel d'indice "NESTED" k 
+//    Return value of  pixel with "NESTED" index k 
 //--
 {
@@ -436,5 +440,5 @@
 T const& SphereGorski<T>::PixValNest(int k) const
 
-//    Retourne la valeur du contenu du pixel d'indice "NESTED" k 
+//    Return value of  pixel with "NESTED" index k 
 //--
 {
@@ -463,6 +467,6 @@
 int SphereGorski<T>::PixIndexSph(double theta,double phi) const
 
-//    Retourne l'indice "RING" du pixel vers lequel pointe une direction 
-//    définie par ses coordonnées sphériques
+//    Return "RING" index of the pixel corresponding to 
+//    direction (theta, phi).
 //--
 {
@@ -474,6 +478,6 @@
 int SphereGorski<T>::PixIndexSphNest(double theta,double  phi) const
 
-//    Retourne l'indice NESTED" du pixel vers lequel pointe une direction 
-//    définie par ses coordonnées sphériques
+//    Return "NESTED" index of the pixel corresponding to 
+//    direction (theta, phi).
 //--
 {
@@ -487,5 +491,5 @@
 void SphereGorski<T>::PixThetaPhi(int k,double& theta,double& phi) const
 
-//   Retourne les coordonnées (theta,phi) du milieu du pixel d'indice "RING" k
+//   Return (theta,phi) coordinates of middle of  pixel with "RING" index k
 //--
 {
@@ -509,6 +513,5 @@
 void SphereGorski<T>::PixThetaPhiNest(int k,double& theta,double& phi) const
 
-//    Retourne les coordonnées (theta,phi) du milieu du pixel d'indice 
-//    NESTED k
+//   Return (theta,phi) coordinates of middle of  pixel with "NESTED" index k
 //--
 {   
@@ -520,5 +523,5 @@
 int SphereGorski<T>::NestToRing(int k) const
 
-//    conversion d'index NESTD en un index RING
+//    translation from NESTED index  into RING index 
 //
 //--
@@ -531,5 +534,5 @@
 int SphereGorski<T>::RingToNest(int k) const
 //
-//    conversion d'index RING en un index NESTED
+//    translation from  RING index  into NESTED index 
 //
 //--
@@ -1140,5 +1143,4 @@
 void FIO_SphereGorski<T>::ReadSelf(PInPersist& is)
 {
-  cout << " FIO_SphereGorski:: ReadSelf " << endl;
 
   if(dobj == NULL) 
@@ -1183,5 +1185,4 @@
 void FIO_SphereGorski<T>::WriteSelf(POutPersist& os) const
 {
-  cout << " FIO_SphereGorski:: WriteSelf " << endl;
 
   if(dobj == NULL) 
Index: trunk/SophyaLib/Samba/spheregorski.h
===================================================================
--- trunk/SophyaLib/Samba/spheregorski.h	(revision 564)
+++ trunk/SophyaLib/Samba/spheregorski.h	(revision 565)
@@ -12,4 +12,42 @@
 // ***************** CLASSE SphereGorski *****************************
 
+//!  class SphereGorski
+/*!
+   Pixelisation Gorski  
+
+
+    -----------------------------------------------------------------------
+     version 0.8.2  Aug97 TAC  Eric Hivon, Kris Gorski
+    -----------------------------------------------------------------------
+
+    the sphere is split in 12 diamond-faces containing nside**2 pixels each
+
+    the numbering of the pixels (in the nested scheme) is similar to
+    quad-cube
+    In each face the first pixel is in the lowest corner of the diamond
+
+    the faces are                    (x,y) coordinate on each face
+\verbatim
+        .   .   .   .   <--- North Pole
+       / \ / \ / \ / \                          ^        ^     
+      . 0 . 1 . 2 . 3 . <--- z = 2/3             \      / 
+       \ / \ / \ / \ /                        y   \    /  x  
+      4 . 5 . 6 . 7 . 4 <--- equator               \  /      
+       / \ / \ / \ / \                              \/      
+      . 8 . 9 .10 .11 . <--- z = -2/3              (0,0) : lowest corner 
+       \ / \ / \ / \ /      
+        .   .   .   .   <--- South Pole
+\endverbatim
+    phi:0               2Pi                                 
+
+   in the ring scheme pixels are numbered along the parallels
+   the first parallel is the one closest to the north pole and so on  
+   on each parallel, pixels are numbered starting from the one closest
+    to phi = 0
+
+    nside MUST be a power of 2 (<= 8192)
+
+*/
+
 template<class T>
 class SphereGorski : public SphericalMap<T>,  public AnyDataObj 
@@ -19,6 +57,14 @@
 
 SphereGorski();
+/*!    
+  m is the "nside" of the Gorski algorithm
+
+  The total number of pixels will be Npix =  12*nside**2
+
+  nside MUST be a power of 2 (<= 8192)
+*/
 SphereGorski(int m);
 SphereGorski(const SphereGorski<T>& s);
+//!	Destructor
 virtual ~SphereGorski();
 
@@ -26,13 +72,24 @@
 
 /* Nombre de pixels du decoupage */
+/*!    Return number of  pixels of the  splitting */
 virtual int NbPixels() const;
 inline void setNbPixels(int n) {nPix_= n;}
 
 /* Valeur du contenu du pixel d'indice "RING" k  */
+/*!    Return value of  pixel with "RING" index k */
 virtual T& PixVal(int k);
 virtual T const& PixVal(int k) const;
 
 /* Nombre de tranches en theta */ 
+/*!    Return number of slices in theta direction on the  sphere */
 int NbThetaSlices() const;
+/*!   For a theta-slice with index 'index', return : 
+
+   the corresponding "theta" 
+
+    a vector containing the phi's of the pixels of the slice
+
+    a vector containing the corresponding values of pixels 
+*/
 void GetThetaSlice(int index,double& theta,TVector<double>& phi,TVector<T>& value) const;
 
@@ -41,4 +98,6 @@
 /* Indice "RING" du pixel vers lequel pointe une direction definie par 
 ses  coordonnees spheriques */                                    
+/*!  Return "RING" index of the pixel corresponding to direction (theta, phi).
+ */
 virtual int PixIndexSph(double theta,double phi) const;
 
@@ -47,4 +106,10 @@
 
 /* Pixel Solid angle  (steradians) */
+/*!    Pixel Solid angle  (steradians)
+
+    All the pixels have the same solid angle. The dummy argument is
+    for compatibility with eventual pixelizations which would not 
+   fulfil this requirement.
+*/
 virtual double PixSolAngle(int dummy) const;
 inline void setPixSolAngle(double x) {omeg_= x;}
@@ -52,4 +117,11 @@
 // --------------- Specific methods 
 
+/*!    
+  m is the "nside" of the Gorski algorithm
+
+  The total number of pixels will be Npix =  12*nside**2
+
+  nside MUST be a power of 2 (<= 8192)
+*/
 virtual void Resize(int m);
 
@@ -57,12 +129,18 @@
 
 /* Valeur du contenu du pixel d'indice "NEST" k */
+/*!    Return value of  pixel with "NESTED" index k */
 virtual T& PixValNest(int k);
+/*!    Return value of  pixel with "NESTED" index k */
 virtual T const& PixValNest(int k) const;
 
 /* Indice "NEST" du pixel vers lequel pointe une direction definie par 
 ses  coordonnees spheriques */                                    
+/*! Return "NESTED" index of the pixel corresponding to direction (theta, phi).
+ */
 virtual int PixIndexSphNest(double theta,double phi) const;
 
 /* Coordonnees spheriques du milieu du pixel d'indice "NEST" k       */
+/*!   Return (theta,phi) coordinates of middle of  pixel with "NESTED" index k
+ */
 virtual void PixThetaPhiNest(int k,double& theta,double& phi) const;
 
@@ -71,7 +149,9 @@
 
 /* convertit index nested en ring  */
+/*!    translation from NESTED index  into RING index */
 int NestToRing(int) const;
 
 /* convertit index ring en nested" */
+/*!    translation from  RING index  into NESTED index */
 int RingToNest(int) const;
 
@@ -127,5 +207,5 @@
 virtual AnyDataObj* DataObj();
 inline operator SphereGorski<T>() { return(*dobj); }
-inline SphereGorski<T> getObj() { return(*dobj); }
+//inline SphereGorski<T> getObj() { return(*dobj); }
 
 protected :
Index: trunk/SophyaLib/Samba/spherethetaphi.cc
===================================================================
--- trunk/SophyaLib/Samba/spherethetaphi.cc	(revision 564)
+++ trunk/SophyaLib/Samba/spherethetaphi.cc	(revision 565)
@@ -13,12 +13,13 @@
 // include      spherethetaphi.h nbmath.h 
 //
-//    Découpage de la sphère selon theta et phi, chaque 
-//    hémisphère étant découpé en (m-1) parallèles (l'équateur compte pour du 
-//    beurre), chacune des m bandes de theta ainsi définies étant découpée par 
-//    des méridiens équirepartis, ce découpage étant fait de sorte que tous 
-//    les pixels aient la même surface et soient le plus carré possible.
-//    On commence par découper l'hémisphère de z positif en partant du pôle et 
-//    en allant vers l'équateur. Le premier pixel est la calotte polaire, 
-//    il est circulaire et centré sur theta=0.
+//    sphere splitted with respect to theta, phi : each hemisphere is 
+//    splitted into (m-1) parallels (equator does not enter into account).
+//    This operation defines m slices, each of which is splitted into 
+//    equidistant meridians. This splitting is realized in such a way that 
+//    all pixels have the same area and are as square as possible.
+
+//    One begins with the hemisphere with positive z, starting from the pole
+//    toward the equator. The first pixel is the polar cap ; it is circular
+//    and centered on theta=0. 
 //--
 //++
@@ -28,14 +29,8 @@
 //    SphericalMap 
 //-- 
-//++
-//
-// Links	Descendants
-//
-//     
-//-- 
-
-/* --Methode-- */
-//++
-// Titre	Constructeurs
+
+/* --Methode-- */
+//++
+// Titre	Constructors
 //--
 //++
@@ -56,8 +51,7 @@
 SphereThetaPhi<T>::SphereThetaPhi(int m)
 
-//    Constructeur : m est le nombre de bandes en theta sur un hémisphère 
-//    (la calotte constituant la premiere bande).
-//    pet est le nombre de pixels (pétales) de la bande en contact avec la 
-//    calotte polaire. Pour l'instant pet est inopérant! 
+//    m is the number of slices in theta on an hemisphere (the polar cap
+//    forms the first slice).
+//    pet is a dummy parameter at the moment. 
 //--
 {
@@ -88,5 +82,5 @@
 
 //++
-// Titre	Destructeur
+// Titre	Destructor
 //--
 //++
@@ -100,5 +94,5 @@
 
 //++
-// Titre	Méthodes
+// Titre	Public Méthods
 //--
 template <class T>
@@ -141,5 +135,5 @@
 int SphereThetaPhi<T>::NbPixels() const
 
-//    Retourne le nombre de pixels du découpage
+//    Return total number of pixels 
 //--
 {
@@ -152,5 +146,5 @@
 T& SphereThetaPhi<T>::PixVal(int k)
 
-//    Retourne la valeur du contenu du pixel d'indice k
+//    Return value of pixel with index k
 //--
 {
@@ -168,5 +162,5 @@
 T const& SphereThetaPhi<T>::PixVal(int k) const
 
-//    Retourne la valeur du contenu du pixel d'indice k
+//    Return value of pixel with index k
 //--
 {
@@ -194,6 +188,6 @@
 int SphereThetaPhi<T>::PixIndexSph(double theta, double phi) const
 
-//  Retourne l'indice du pixel vers lequel pointe une direction définie par 
-//    ses coordonnées sphériques
+//    Return index of the pixel corresponding to 
+//    direction (theta, phi).
 //--
 {
@@ -223,5 +217,5 @@
 void SphereThetaPhi<T>::PixThetaPhi(int k,double& theta,double& phi) const
 
-//    Retourne les coordonnées (theta,phi) du milieu du pixel d'indice k
+//   Return (theta,phi) coordinates of middle of  pixel with  index k
 //--
 {
@@ -264,5 +258,5 @@
 void SphereThetaPhi<T>::Limits(int k,double& tetMin,double& tetMax,double& phiMin,double& phiMax) 
 
-//    Retourne les valeurs de theta et phi limitant le pixel d'indice k
+//   Return values of theta,phi which limit the pixel with  index k
 //--
   {
@@ -317,5 +311,5 @@
 int SphereThetaPhi<T>::NbThetaSlices() const
 
-//    Retourne le nombre de tranches en theta sur la sphere
+//    Return number of theta-slices on the sphere
 //--
 {
@@ -330,5 +324,5 @@
 int SphereThetaPhi<T>::NPhi(int kt) const
 
-//    Retourne le nombre de pixels en phi de la tranche kt
+//    Return number of pixels in phi-direction of the kt-th slice
 //-- 
 {
@@ -353,5 +347,5 @@
 void SphereThetaPhi<T>::Theta(int kt,double& tetMin,double& tetMax) 
 
-//    Retourne les valeurs de theta limitant la tranche kt
+//    Return  theta values which limit the slice kt
 //--
 {
@@ -385,5 +379,5 @@
 void SphereThetaPhi<T>::Phi(int kt,int jp,double& phiMin,double& phiMax) 
 
-//    Retourne les valeurs de phi limitant le pixel jp de la tranche kt
+//   Return values of phi which limit the jp-th pixel of the kt-th slice
 //--
 {
@@ -416,5 +410,5 @@
 int SphereThetaPhi<T>::Index(int kt,int jp) const
 
-//    Retourne l'indice du pixel d'indice jp dans la tranche kt 
+//    Return pixel index  with sequence index jp in the slice kt 
 //--
 {
@@ -449,5 +443,5 @@
 void SphereThetaPhi<T>::ThetaPhiIndex(int k,int& kt,int& jp) 
 
-//    Retourne les indices kt et jp du pixel d'indice k
+//    Return indices kt (theta) and jp (phi) of  pixel with index k
 //--
 {
@@ -477,12 +471,14 @@
 void  SphereThetaPhi<T>::Pixelize(int m) 
 
-//    effectue le découpage en pixels (m et pet ont la même signification 
-//    que pour le constructeur)
+//    achieve the splitting into pixels (m has the same signification 
+//    as for the constructor)
 //
-//    Chaque bande de theta sera découpée en partant de phi=0 ...
-//    L'autre hémisphère est parcourue dans le même sens en phi et de
-//    l'équateur vers le pôle (le pixel qui suit le dernier de la bande la plus
-//    proche de l'équateur a z>0 est celui de plus petit phi de la bande la 
-//    plus proche de l'equateur a z<0).
+//    Each theta-slice of the north hemisphere will be spitted starting f
+//    from  phi=0 ...
+//
+//    South hemisphere is scanned in the same direction according to phi
+//    and from equator to the pole (the pixel following the last one of
+//    the slice closest to the equator with z>0, is the pixel with lowest 
+//    phi of the slice closest of the equator with z<0).
 //--
 {
@@ -554,8 +550,8 @@
 void SphereThetaPhi<T>::GetThetaSlice(int index,double& theta, TVector<double>& phi, TVector<T>& value) const 
 
-//    Retourne, pour la tranche en theta d'indice 'index' le theta 
-//    correspondant, un vecteur (Peida) contenant les phi des pixels de 
-//    la tranche, un vecteur (Peida) contenant les valeurs de pixel 
-//    correspondantes
+//    For a theta-slice with index 'index', return : 
+//    the corresponding "theta" 
+//    a vector containing the phi's of the pixels of the slice
+//    a vector containing the corresponding values of pixels 
 //--
 
@@ -591,5 +587,5 @@
 void SphereThetaPhi<T>::setmNPhi(int* array, int m)
   //remplit le tableau contenant le nombre de pixels en phi de chacune des bandes en theta 
-  //--
+  //
 {
   NPhi_= new int[m];
@@ -600,5 +596,5 @@
 void SphereThetaPhi<T>::setmTNphi(int* array, int m)
   //remplit  le tableau contenant le nombre/Deuxpi total des pixels contenus dans les bandes 
-  //--
+  //
 {
   TNphi_= new int[m];
@@ -609,5 +605,5 @@
 void SphereThetaPhi<T>::setmTheta(double* array, int m)
   //remplit  le tableau contenant les valeurs limites de theta
-  //--
+  //
 {
   Theta_= new double[m];
@@ -715,5 +711,4 @@
 void FIO_SphereThetaPhi<T>::ReadSelf(PInPersist& is)
 {
-  cout << " FIO_SphereThetaPhi:: ReadSelf " << endl;
 
   if(dobj == NULL) 
@@ -772,5 +767,4 @@
 void FIO_SphereThetaPhi<T>::WriteSelf(POutPersist& os) const
 {
-  cout << " FIO_SphereThetaPhi:: WriteSelf " << endl;
 
   if(dobj == NULL) 
Index: trunk/SophyaLib/Samba/spherethetaphi.h
===================================================================
--- trunk/SophyaLib/Samba/spherethetaphi.h	(revision 564)
+++ trunk/SophyaLib/Samba/spherethetaphi.h	(revision 565)
@@ -10,5 +10,14 @@
 
 // ***************** Class SphereThetaPhi *****************************
+/*!    sphere splitted with respect to theta, phi : each hemisphere is 
+    splitted into (m-1) parallels (equator does not enter into account).
+   This operation defines m slices, each of which is splitted into 
+    equidistant meridians. This splitting is realized in such a way that 
+    all pixels have the same area and are as square as possible.
 
+    One begins with the hemisphere with positive z, starting from the pole
+    toward the equator. The first pixel is the polar cap ; it is circular
+    and centered on theta=0. 
+*/
 template <class T>
 class SphereThetaPhi : public SphericalMap<T>, public AnyDataObj
@@ -18,4 +27,8 @@
 
 SphereThetaPhi();
+/*!    m is the number of slices in theta on an hemisphere (the polar cap
+   forms the first slice).
+    pet is a dummy parameter at the moment. 
+*/
 SphereThetaPhi(int m);
 SphereThetaPhi(const SphereThetaPhi<T>& s);
@@ -25,8 +38,10 @@
 
 /* retourne/fixe le nombre de pixels */ 
+/*!    Return total number of pixels  */
 virtual int NbPixels() const;
 inline void setNbPixels(int nbpix) { NPix_= nbpix; }
 
 /* retourne la valeur du pixel d'indice k */ 
+/*!    Return value of pixel with index k */
 virtual T&       PixVal(int k);
 virtual T const& PixVal(int k) const;
@@ -35,10 +50,18 @@
 virtual bool ContainsSph(double theta, double phi) const;
 /* retourne l'indice du pixel a (theta,phi) */ 
+/*    Return index of the pixel corresponding to direction (theta, phi). */
 virtual int PixIndexSph(double theta, double phi) const;
 
 /* retourne les coordonnees Spheriques du centre du pixel d'indice k */ 
+/*!   Return (theta,phi) coordinates of middle of  pixel with  index k */
 virtual void PixThetaPhi(int k, double& theta, double& phi) const;
 
 /* retourne/fixe l'angle Solide de Pixel   (steradians) */ 
+/*!   Pixel Solid angle  (steradians)
+
+    All the pixels have the same solid angle. The dummy argument is
+   for compatibility with eventual pixelizations which would not 
+    fulfil this requirement.
+*/
 virtual double PixSolAngle(int dummy) const;
 inline void setPixSolAngle(double omega) { Omega_= omega; }
@@ -50,4 +73,5 @@
 // ------------- Specific methods  ----------------------
 
+/*!   re-pixelize the sphere */
 virtual void Resize(int m);
 
@@ -55,7 +79,9 @@
 
 /* Valeurs de theta des paralleles et phi des meridiens limitant le pixel d'indice k */
+/*   Return values of theta,phi which limit the pixel with  index k */
 virtual void Limits(int k,double& th1,double& th2,double& phi1,double& phi2);
 
 /* Nombre de tranches en theta */ 
+/*!    Return number of theta-slices on the sphere */
 int NbThetaSlices() const;
 
@@ -65,18 +91,41 @@
 /* Renvoie dans t1,t2 les valeurs respectives de theta min et theta max  */
 /* de la tranche d'indice kt  */ 
+/*!    Return  theta values which limit the slice kt */
 void Theta(int kt, double& t1, double& t2);
 
 /* Renvoie dans p1,p2 les valeurs phimin et phimax du pixel d'indice jp  */
 /* dans la tranche d'indice kt  */ 
+/*!   Return values of phi which limit the jp-th pixel of the kt-th slice */
 void Phi(int kt, int jp, double& p1, double& p2);
 
 /* Renvoie l'indice k du pixel d'indice jp dans la tranche d'indice kt   */
+/*!   Return pixel index  with sequence index jp in the slice kt */
 int Index(int kt, int jp) const;
 
 /* Indice kt de la tranche et indice jp du pixel d'indice k  */ 
+/*!    Return indices kt (theta) and jp (phi) of  pixel with index k */
 void ThetaPhiIndex(int k,int& kt,int& jp);
 
+/*!    achieve the splitting into pixels (m has the same signification 
+    as for the constructor)
+
+    Each theta-slice of the north hemisphere will be spitted starting f
+    from  phi=0 ...
+
+    South hemisphere is scanned in the same direction according to phi
+    and from equator to the pole (the pixel following the last one of
+    the slice closest to the equator with z>0, is the pixel with lowest 
+    phi of the slice closest of the equator with z<0).
+*/
 void Pixelize(int); 
 
+/*!   For a theta-slice with index 'index', return : 
+
+   the corresponding "theta" 
+
+    a vector containing the phi's of the pixels of the slice
+
+    a vector containing the corresponding values of pixels 
+*/
 void GetThetaSlice(int index,double& theta,TVector<double>& phi,TVector<T>& value) const; 
 
@@ -129,5 +178,5 @@
 virtual AnyDataObj* DataObj();
 inline operator SphereThetaPhi<T>() { return(*dobj); }
-inline SphereThetaPhi<T> getObj() { return(*dobj); }
+//inline SphereThetaPhi<T> getObj() { return(*dobj); }
 
 protected :
Index: trunk/SophyaLib/Samba/unitvector.cc
===================================================================
--- trunk/SophyaLib/Samba/unitvector.cc	(revision 564)
+++ trunk/SophyaLib/Samba/unitvector.cc	(revision 565)
@@ -1,25 +1,67 @@
 #include <math.h>
 #include "unitvector.h"
-
+//*****************************************************************************
+//++ 
+// Class	UnitVector
+//
+// include      unitvector.h vector3d.h math.h
+//--
+//++
+//
+// Links	Parents
+//
+//    Vector3d
+//    
+//-- 
+//++
+// Titre	Constructors
+//--
+//++
 UnitVector::UnitVector() : Vector3d(1.,0.,0.) 
+//
+//--
 {
 }
-
+//++
 UnitVector::UnitVector(double x, double y, double z) : Vector3d(x,y,z) 
+//
+//--
 {
   this->Normalize();
 }
-
+//++
 UnitVector::UnitVector(double theta, double phi) : Vector3d(theta,phi) 
+//
+//--
 {
   this->Normalize();
 }
-
+//++
 UnitVector::UnitVector(const Vector3d& v) : Vector3d(v) 
+//
+//--
 {
   this->Normalize();
 }
+//++
+// Titre	Public Method
+//--
+//++
+void UnitVector::Print(ostream& os) const 
+//
+//--
+{
+  os << "UnitVector : (X,Y,Z)= (" << _x << ", " << _y << ", " << _z 
+     << ") Theta,Phi= " << _theta << ", " << _phi << "\n"
+     << "norme =" << this->Norm() << endl;
+}
+//++
+// Titre	Operators
+//--
+//++
+Vector3d& UnitVector::operator = (const Vector3d& v)
+//
+//--
 
-Vector3d& UnitVector::operator=(const Vector3d& v)
 {
   Setxyz(v.X(),v.Y(),v.Z());
@@ -27,6 +69,8 @@
   return *this;
 }
-
-Vector3d& UnitVector::operator+=(const Vector3d& v)
+//++
+Vector3d& UnitVector::operator += (const Vector3d& v)
+//
+//--
 {
   Setxyz(_x+v.X(),_y+v.Y(),_z+v.Z());
@@ -34,6 +78,8 @@
   return *this;
 }
-
-Vector3d& UnitVector::operator-=(const Vector3d& v)
+//++
+Vector3d& UnitVector::operator -= (const Vector3d& v)
+//
+//--
 {
   Setxyz(_x-v.X(),_y-v.Y(),_z-v.Z());
@@ -41,19 +87,16 @@
   return *this;
 }
-
-Vector3d UnitVector::operator+(const Vector3d& v) const
+//++
+Vector3d UnitVector::operator + (const Vector3d& v) const
+//
+//--
 {
   return UnitVector(_x+v.X(),_y+v.Y(),_z+v.Z());
 }
-
-Vector3d UnitVector::operator-(const Vector3d& v) const
+//++
+Vector3d UnitVector::operator - (const Vector3d& v) const
+//
+//--
 {
   return UnitVector(_x-v.X(),_y-v.Y(),_z-v.Z());
 }
-
-void UnitVector::Print(ostream& os) const 
-{
-  os << "UnitVector : (X,Y,Z)= (" << _x << ", " << _y << ", " << _z 
-     << ") Theta,Phi= " << _theta << ", " << _phi << "\n"
-     << "norme =" << this->Norm() << endl;
-}
Index: trunk/SophyaLib/Samba/utilgeom.cc
===================================================================
--- trunk/SophyaLib/Samba/utilgeom.cc	(revision 564)
+++ trunk/SophyaLib/Samba/utilgeom.cc	(revision 565)
@@ -2,22 +2,33 @@
 #include <iostream.h>
 #include "utilgeom.h"
-
+//++
+// Titre	Some utilitary functions for geometry (utilgeom.h)...
+//--
+//++
 int sign(double d) 
+//
+//--
 {
   return (d >= 0) - (d < 0);
 }
-
+//++
 double absd(double d) 
+//
+//--
 {
   return sqrt(d*d);
 }
-
+//++
 double mod(double d, double periode) 
+//
+//--
 {
   if( d >= 0 ) return d-floor(d/periode)*periode;
   else return d-ceil(d/periode)*periode+periode;
 }
-
+//++
 void swap(double& d1, double& d2) 
+//
+//--
 {
   double temp;
@@ -26,22 +37,30 @@
   d1=temp;
 }
-
+//++
 double min(double d1, double d2) 
+//
+//--
 {
   if( d1 >= d2 ) return d2;
   else return d1;
 }
-
+//++
 double max(double d1, double d2) 
+//
+//--
 {
   return -min(-d1,-d2);
 }
-
+//++
 int arrondi(double d) 
+//
+//--
 {
   return (int)(((d-floor(d)) >= 0.5)*ceil(d)+((d-floor(d)) < 0.5)*floor(d));
 }
-
+//++
 long rangijd(int nc, int i, int j, int d) 
+//
+//--
 {
   if( i < j ) return 2*i*(2*nc-i-1)+4*(j-i-1)+d;
@@ -55,6 +74,8 @@
   else return -1;
 }
-
+//++
 long rangdiff(int nc, int i, int j, int d) 
+//
+//--
 {
   if( i == j ) 
@@ -68,16 +89,22 @@
   return indm*(2*nc-indm-1)+2*(indM-indm-1)+d;
 }
-
+//++
 long rangik(int NtotEch, int i, int k)
+//
+//--
 {
   return NtotEch*i+k;
 }
-
+//++
 long ranghk(int NtotEch, int h, int k) 
+//
+//--
 {
   return NtotEch*h+k;
 }
-
+//++
 double scangle(double sinus, double cosinus) 
+//
+//--
 {
   double eps=1e-10;
Index: trunk/SophyaLib/Samba/vector3d.cc
===================================================================
--- trunk/SophyaLib/Samba/vector3d.cc	(revision 564)
+++ trunk/SophyaLib/Samba/vector3d.cc	(revision 565)
@@ -2,11 +2,32 @@
 #include "vector3d.h"
 #include "utilgeom.h"
-
-Vector3d::Vector3d() 
+//++ 
+// Class	Vector3d
+//
+// include      vector3d.h utilgeom.h  longlat.h math.h
+//
+//
+//    3-D geometry. 
+//    All computations are made with angles in radians and with spherical
+//    coordinates theta, phi.
+//
+//    Concerning Euler's angles, the reference is :
+// 
+//    "Classical Mechanics" 2nd edition, H. Goldstein, Addison Wesley
+//--
+//++
+// Titre	Constructors
+//--
+//++
+Vector3d::Vector3d()
+//
+//-- 
 {
   Setxyz(1.,0.,0.);
 }
-
+//++
 Vector3d::Vector3d(double x, double y, double z) 
+//
+//-- 
 {
   _x=x;
@@ -15,6 +36,8 @@
   xyz2ThetaPhi();
 }
-
+//++
 Vector3d::Vector3d(double theta, double phi) 
+//
+//-- 
 {
   _theta=mod(theta,M_PI); // dans [0;pi]
@@ -22,6 +45,8 @@
   ThetaPhi2xyz();
 }
-
+//++
 Vector3d::Vector3d(const LongLat& ll)
+//
+//-- 
 {
   _theta=ll.Theta(); // dans [0;pi]
@@ -29,6 +54,8 @@
   ThetaPhi2xyz();
 }
-
+//++
 Vector3d::Vector3d(const Vector3d& v) 
+//
+//-- 
 {
   _x=v._x;
@@ -38,6 +65,11 @@
   _phi=v._phi;
 }
-
-void Vector3d::SetThetaPhi(double theta, double phi) 
+//++
+// Titre	Public methods
+//--
+//++
+void Vector3d::SetThetaPhi(double theta, double phi)
+//
+//-- 
 {
   _theta=mod(theta,M_PI);
@@ -45,6 +77,8 @@
   ThetaPhi2xyz();
 }
-
+//++
 void Vector3d::Setxyz(double x, double y, double z) 
+//
+//-- 
 {
   _x=x;
@@ -53,6 +87,8 @@
   xyz2ThetaPhi();
 }
-
+//++
 void Vector3d::ThetaPhi2xyz()
+//
+//-- 
 {
   _x=sin(_theta)*cos(_phi);
@@ -60,6 +96,8 @@
   _z=cos(_theta);
 }
-
+//++
 void Vector3d::xyz2ThetaPhi()
+//
+//-- 
 {
   double norm=this->Norm();
@@ -77,6 +115,8 @@
     }
 }
-
+//++
 Vector3d& Vector3d::Normalize() 
+//
+//-- 
 {
   double norm=this->Norm();
@@ -85,16 +125,24 @@
   return *this;
 } 
-
+//++
 double Vector3d::Norm() const 
+//
+//-- 
 {
   return sqrt(_x*_x+_y*_y+_z*_z);
 }
-
+//++
 double Vector3d::Psc(const Vector3d& v) const 
+//
+//    dot product
+//-- 
 {
   return _x*v._x+_y*v._y+_z*v._z;
 }
-
+//++
 double Vector3d::SepAngle(const Vector3d& v) const 
+//
+//    angular gap between 2 vectors in [0,Pi]
+//-- 
 {
   double n1=this->Norm();
@@ -109,6 +157,9 @@
   return ret;
 }
-
+//++
 Vector3d Vector3d::Vect(const Vector3d& v) const 
+//
+//    vector product
+//-- 
 {
   double xo=_y*v._z-_z*v._y;
@@ -117,6 +168,9 @@
   return Vector3d(xo,yo,zo);
 }
-
-Vector3d Vector3d::VperpPhi() const // vecteur perpendiculaire de meme phi
+//++
+Vector3d Vector3d::VperpPhi() const 
+//
+//    perpendicular vector, with equal phi
+//-- 
 {
   double theta;
@@ -125,6 +179,9 @@
   return Vector3d(theta,_phi);
 }
-
-Vector3d Vector3d::VperpTheta() const // vecteur perpendiculaire de meme theta
+//++
+Vector3d Vector3d::VperpTheta() const 
+//
+//    perpendicular vector with equal theta
+//-- 
 {
   double phi=mod(_phi+pi_over_2,pi2); // on tourne phi de pi/2
@@ -147,6 +204,8 @@
   return temp;
 }
-
+//++
 Vector3d Vector3d::ETheta() const 
+//
+//-- 
 {
   Vector3d temp=this->Vect(EPhi());
@@ -155,6 +214,9 @@
 }
 
-
+//++
 Vector3d Vector3d::Euler(double phi, double theta, double psi) const 
+//
+//    Euler's rotations
+//-- 
 {
   double cpsi=cos(psi);
@@ -173,6 +235,9 @@
   return Vector3d(xnew,ynew,znew);
 }
-
+//++
 Vector3d Vector3d::InvEuler(double phi, double theta, double psi) const 
+//
+//    inverse rotation
+//-- 
 {
   double cpsi=cos(psi);
@@ -191,6 +256,9 @@
   return Vector3d(xnew,ynew,znew);
 }
-
+//++
 Vector3d Vector3d::Rotate(const Vector3d& omega, double phi)
+//
+//    rotation of angle phi around an axis omega (Maxwell's rule)
+//-- 
 {
   Vector3d rotationaxis=omega;
@@ -200,25 +268,45 @@
   Vector3d rotate=n*rotationaxis+(myself-n*rotationaxis)*cos(phi)-(myself^rotationaxis)*sin(phi);
   return rotate;
-}   
-
-Vector3d& Vector3d::operator+=(const Vector3d& v) 
+} 
+//++  
+void Vector3d::Print(ostream& os) const 
+//
+//--
+{
+  os << "Vector3: (X,Y,Z)= (" << _x << ", " << _y << ", " << _z 
+     << ") --- Theta,Phi= " << _theta << ", " << _phi << "\n"
+     << "Norme = " << this->Norm() << endl;
+}
+//++
+// Titre	Operators
+//--
+//++
+Vector3d& Vector3d::operator += (const Vector3d& v) 
+//
+//-- 
 {
   *this=*this+v;
   return *this;
 }
-
-Vector3d& Vector3d::operator-=(const Vector3d& v) 
+//++
+Vector3d& Vector3d::operator -= (const Vector3d& v) 
+//
+//-- 
 {
   *this=*this-v;
   return *this;
 }
-
-Vector3d& Vector3d::operator+=(double d) 
+//++
+Vector3d& Vector3d::operator += (double d) 
+//
+//-- 
 {
   Setxyz(_x+d,_y+d,_z+d);
   return *this;
 }
-
-Vector3d& Vector3d::operator/=(double d) 
+//++
+Vector3d& Vector3d::operator /= (double d) 
+//
+//-- 
 {
   if( d != 0. ) Setxyz(_x/d,_y/d,_z/d);
@@ -226,47 +314,67 @@
   return *this;
 }
-
-Vector3d& Vector3d::operator*=(double d) 
+//++
+Vector3d& Vector3d::operator *= (double d) 
+//
+//-- 
 {
   Setxyz(_x*d,_y*d,_z*d);
   return *this;
 }
-
-Vector3d Vector3d::operator^(const Vector3d& v) const 
+//++
+Vector3d Vector3d::operator ^ (const Vector3d& v) const 
+//
+//    vector product
+//-- 
 {
   return this->Vect(v);
 }
-
-Vector3d Vector3d::operator+(double d) const 
+//++
+Vector3d Vector3d::operator + (double d) const 
+//
+//-- 
 {
   return Vector3d(_x+d,_y+d,_z+d);
 }
-
-Vector3d Vector3d::operator+(const Vector3d& v) const 
+//++
+Vector3d Vector3d::operator + (const Vector3d& v) const 
+//
+//-- 
 {
   return Vector3d(_x+v._x,_y+v._y,_z+v._z);
 }
-
-Vector3d Vector3d::operator-(double d) const 
+//++
+Vector3d Vector3d::operator - (double d) const 
+//
+//-- 
 {
   return *this+(-d);
 }
-
-Vector3d Vector3d::operator-(const Vector3d& v) const 
+//++
+Vector3d Vector3d::operator - (const Vector3d& v) const 
+//
+//-- 
 {
   return *this+(v*(-1.));
 }
-
-Vector3d Vector3d::operator*(double d) const 
+//++
+Vector3d Vector3d::operator * (double d) const 
+//
+//-- 
 {
   return Vector3d(d*_x,d*_y,d*_z);
 }
-
-double Vector3d::operator*(const Vector3d& v) const 
+//++
+double Vector3d::operator * (const Vector3d& v) const 
+//
+//    dot product
+//-- 
 {
   return this->Psc(v);
 }
-
-Vector3d Vector3d::operator/(double d) const 
+//++
+Vector3d Vector3d::operator / (double d) const 
+//
+//-- 
 {
   Vector3d ret=*this;
@@ -275,6 +383,8 @@
   return ret;
 }
-
-Vector3d& Vector3d::operator=(const Vector3d& v) 
+//++
+Vector3d& Vector3d::operator = (const Vector3d& v) 
+//
+//-- 
 {
   if( this != &v ) 
@@ -288,14 +398,10 @@
   return *this;
 }
+//++
+bool Vector3d::operator == (const Vector3d& v) 
+//
+//-- 
+{
+  return (this==&v);
+}
 
-bool Vector3d::operator==(const Vector3d& v) 
-{
-  return (this==&v);
-}
-
-void Vector3d::Print(ostream& os) const 
-{
-  os << "Vector3: (X,Y,Z)= (" << _x << ", " << _y << ", " << _z 
-     << ") --- Theta,Phi= " << _theta << ", " << _phi << "\n"
-     << "Norme = " << this->Norm() << endl;
-}
Index: trunk/SophyaLib/Samba/vector3d.h
===================================================================
--- trunk/SophyaLib/Samba/vector3d.h	(revision 564)
+++ trunk/SophyaLib/Samba/vector3d.h	(revision 565)
@@ -18,4 +18,13 @@
   pour les rotations (angles d'Euler) ma source est 
   "Classical Mechanics" 2nd edition, H. Goldstein, Addison Wesley
+*/
+/*!    3-D geometry. 
+
+    All computations are made with angles in radians and with spherical
+    coordinates theta, phi.
+
+    Concerning Euler's angles, the reference is :
+ 
+    "Classical Mechanics" 2nd edition, H. Goldstein, Addison Wesley
 */
 
@@ -51,13 +60,17 @@
 
   // ecart angulaire entre 2 vecteurs dans [0,Pi]
+  /*!   angular gap between 2 vectors in [0,Pi] */
   virtual double SepAngle(const Vector3d&) const;
 
   // produit vectoriel
+  /*!    vector product */
   virtual Vector3d Vect(const Vector3d&) const;
 
   // vecteur perpendiculaire de meme phi
+  /*!    perpendicular vector, with equal phi */
   virtual Vector3d VperpPhi() const;
 
   // vecteur perpendiculaire de meme theta
+  /*!    perpendicular vector with equal theta */
   virtual Vector3d VperpTheta() const;
 
@@ -65,11 +78,15 @@
   virtual Vector3d EPhi() const;
 
+  // rotations d'Euler
+  /*!    Euler's rotations */
   // rotations d Euler
   virtual Vector3d Euler(double, double, double) const;
 
   // rotation inverse
+  /*!    inverse rotation */
   Vector3d InvEuler(double, double, double) const;
 
-  // rotation d angle phi autour d'un axe omega (regle du tire-bouchon)
+  // rotation d'angle phi autour d'un axe omega (regle du tire-bouchon)
+  /*!    rotation of angle phi around an axis omega (Maxwell's rule) */
   Vector3d Rotate(const Vector3d& omega,double phi);
 
@@ -89,5 +106,7 @@
   virtual Vector3d operator/(double) const;
 
+  /*!    vector product */
   virtual Vector3d operator^(const Vector3d&) const; // produit vectoriel
+  /*!    dot product */
   virtual double operator*(const Vector3d&) const; // produit scalaire
 
