Index: trunk/SophyaLib/SkyMap/spherethetaphi.h
===================================================================
--- trunk/SophyaLib/SkyMap/spherethetaphi.h	(revision 2433)
+++ trunk/SophyaLib/SkyMap/spherethetaphi.h	(revision 2960)
@@ -21,14 +21,4 @@
 
 // ***************** 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>
@@ -38,8 +28,4 @@
 
 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_4 m);
 SphereThetaPhi(const SphereThetaPhi<T>& s, bool share);
@@ -68,9 +54,7 @@
 
 /* retourne le nombre de pixels */ 
-/*!    Return total number of pixels  */
 virtual int_4 NbPixels() const;
 
 /* retourne la valeur du pixel d'indice k */ 
-/*!    Return value of pixel with index k */
 virtual T&       PixVal(int_4 k);
 virtual T const& PixVal(int_4 k) const;
@@ -83,29 +67,24 @@
 
 /* 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_4 k, double& theta, double& phi) const;
 
-/*! Setting pixel values to a constant */
+/* Setting pixel values to a constant */
 virtual T SetPixels(T v);
 
 /* 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_4 dummy=0) const;
  
 /* retourne/fixe la valeur du parametre de decoupage m */ 
+//! Return the pixelisation parameter (number of slices in a hemisphere)
 inline virtual int_4 SizeIndex() const { return( NTheta_); }
 
 /*  Acces to the DataBlock  */
+//! Acces to the pixel data NDataBlock<T> object
 inline       NDataBlock<T>& DataBlock()       {return pixels_;}
+//! Acces to the pixel data NDataBlock<T> object (const version)
 inline const NDataBlock<T>& DataBlock() const {return pixels_;}
 
 // ------------- Specific methods  ----------------------
 
-/*!   re-pixelize the sphere */
 virtual void Resize(int_4 m);
 
@@ -117,5 +96,5 @@
 
 /* Nombre de tranches en theta */ 
-/*!    Return number of theta-slices on the sphere */
+/*    Return number of theta-slices on the sphere */
 uint_4 NbThetaSlices() const;
 
@@ -125,10 +104,8 @@
 /* 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_4 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_4 kt, int_4 jp, double& p1, double& p2);
 
@@ -138,46 +115,13 @@
 
 /* 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_4 k,int_4& kt,int_4& 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_4); 
 
-/*!   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 
-*/
 virtual void GetThetaSlice(int_4 index,r_8& theta,TVector<r_8>& phi,TVector<T>& value) const; 
-
-/*!   For a theta-slice with index 'index', return : 
-
-   the corresponding "theta" 
-
-   the corresponding "phi" for first pixel of the slice 
-
-    a vector containing indices of the pixels of the slice
-
-   (equally distributed in phi)
-
-    a vector containing the corresponding values of pixels 
-*/
 virtual void GetThetaSlice(int_4 index, r_8& theta, r_8& phi0,TVector<int_4>& pixelIndices, TVector<T>& value) const ;
 
 
-/* impression */ 
+//! ASCII dump (print) of the pixel map
 void print(ostream& os) const;
 
@@ -331,6 +275,5 @@
 inline SphereThetaPhi<T> operator - (const SphereThetaPhi<T>& a,const SphereThetaPhi<T>& b)
     { SphereThetaPhi<T> result; result.SetTemp(true); 
-    if (b.IsTemp())  { result.Share(b); result.SubElt(a, true); }
-    else { result.CloneOrShare(a); result.SubElt(b); }
+    result.CloneOrShare(a); result.SubElt(b); 
     return result; }
 
