Index: trunk/SophyaLib/Samba/spheregorski.cc
===================================================================
--- trunk/SophyaLib/Samba/spheregorski.cc	(revision 470)
+++ trunk/SophyaLib/Samba/spheregorski.cc	(revision 473)
@@ -1,3 +1,2 @@
-//
 #include "spheregorski.h"
 #include "strutil.h"
@@ -14,12 +13,12 @@
 extern "C" 
 {
-void anafast_(int&, int&, int&,double&,float*,float*,float*,float*,float*,float*,float*);
-void synfast_(int&, int&, int&,int&, float&,float*,float*,float*,double*, double*,double*,double*,double*,float*);
+void anafast_(int&,int&,int&,double&,float*,float*,float*,float*,float*,float*,float*);
+void synfast_(int&,int&,int&,int&,float&,float*,float*,float*,double*,double*,double*,double*,double*,float*);
 }
 
 //*******************************************************************
 // Class PIXELS_XY 
-//  Construction des tableaux necessaires a la traduction des indices RING en 
-//  indices NESTED (ou l'inverse)
+// Construction des tableaux necessaires a la traduction des indices RING en 
+// indices NESTED (ou l'inverse)
 //*******************************************************************
 
@@ -57,5 +56,5 @@
     c     one breaks up the pixel number by even and odd bits
     ==================================================
-    */
+  */
   // tranlated from FORTRAN (Gorski) to C, by B. Revenu, revised Guy Le Meur
   //  (16/12/98)
@@ -101,5 +100,5 @@
     c     ix + iy in {0, 128**2 -1}
     =================================================
-    */
+  */
   // tranlated from FORTRAN (Gorski) to C, by B. Revenu, revised Guy Le Meur
   //  (16/12/98)
@@ -196,5 +195,5 @@
 //++
 template<class T>
-SphereGorski<T>::SphereGorski(int_4 m)
+SphereGorski<T>::SphereGorski(int m)
 
 //    Constructeur : m est la variable nside de l'algorithme de Gorski
@@ -211,5 +210,5 @@
     }
   // verifier que m est une puissance de deux 
-  int_4 x=m;
+  int x= m;
   while(x%2 == 0) x/=2;
   if(x != 1) 
@@ -261,5 +260,5 @@
 //++
 template<class T>
-void SphereGorski<T>::Resize(int_4 m)
+void SphereGorski<T>::Resize(int m)
 
 //    m est la variable nside de l'algorithme de Gorski
@@ -273,5 +272,5 @@
   }
   // verifier que m est une puissance de deux 
-  int_4 x=m;
+  int x= m;
   while (x%2==0) x/=2;
   if(x != 1) 
@@ -285,5 +284,5 @@
 
 template<class T>
-void  SphereGorski<T>::Pixelize( int_4 m) 
+void  SphereGorski<T>::Pixelize( int m) 
 
 //    prépare la pixelisation Gorski (m a la même signification 
@@ -294,8 +293,8 @@
 {
   // On memorise les arguments d'appel
-  nSide_ = m;  
+  nSide_= m;  
 
   // Nombre total de pixels sur la sphere entiere
-  nPix_=12*nSide_*nSide_;
+  nPix_= 12*nSide_*nSide_;
 
   // pour le moment les tableaux qui suivent seront ranges dans l'ordre 
@@ -310,5 +309,5 @@
 
   // solid angle per pixel   
-  omeg_= 4*Pi/nPix_;
+  omeg_= 4.0*Pi/nPix_;
 }
 
@@ -335,5 +334,5 @@
 //++
 template<class T>
-int_4 SphereGorski<T>::NbPixels() const
+int SphereGorski<T>::NbPixels() const
 
 //    Retourne le nombre de pixels du découpage
@@ -345,15 +344,15 @@
 //++
 template<class T>
-int_4 SphereGorski<T>::NbThetaSlices() const 
+int SphereGorski<T>::NbThetaSlices() const 
 
 //    Retourne le nombre de tranches en theta sur la sphere
 //--
 {
-  return int_4(4*nSide_-1);
-}
-
-//++
-template<class T>
-void  SphereGorski<T>::GetThetaSlice(int_4 index, r_4& theta, TVector<float>& phi, TVector<T>& value) const 
+  return int(4*nSide_-1);
+}
+
+//++
+template<class T>
+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 
@@ -372,5 +371,5 @@
     }
 
-  int_4 iring= 0;
+  int iring= 0;
   int lring  = 0;
   if(index < nSide_-1) 
@@ -393,10 +392,10 @@
   phi.ReSize(lring);
   value.ReSize(lring);
-  float TH=0.;
-  float F =0.;
+  double TH= 0.;
+  double FI= 0.;
   for(int kk = 0; kk < lring;kk++) 
     {
-      PixThetaPhi(kk+iring,TH,F);
-      phi(kk)= F;
+      PixThetaPhi(kk+iring,TH,FI);
+      phi(kk)= FI;
       value(kk)= PixVal(kk+iring);
     }
@@ -407,5 +406,5 @@
 //++
 template<class T>
-T& SphereGorski<T>::PixVal(int_4 k)
+T& SphereGorski<T>::PixVal(int k)
 
 //    Retourne la valeur du contenu du pixel d'indice "RING" k 
@@ -424,5 +423,5 @@
 //++
 template<class T>
-T const& SphereGorski<T>::PixVal(int_4 k) const
+T const& SphereGorski<T>::PixVal(int k) const
 
 //    Retourne la valeur du contenu du pixel d'indice "RING" k 
@@ -440,5 +439,5 @@
 //++
 template<class T>
-T& SphereGorski<T>::PixValNest(int_4 k)
+T& SphereGorski<T>::PixValNest(int k)
 
 //    Retourne la valeur du contenu du pixel d'indice "NESTED" k 
@@ -456,5 +455,5 @@
 
 template<class T>
-T const& SphereGorski<T>::PixValNest(int_4 k) const
+T const& SphereGorski<T>::PixValNest(int k) const
 
 //    Retourne la valeur du contenu du pixel d'indice "NESTED" k 
@@ -467,5 +466,5 @@
       THROW(rangeCheckErr);
   }
-  int_4 pix= nest2ring(nSide_,k);
+  int pix= nest2ring(nSide_,k);
   return *(pixels_.Data()+pix);
 }
@@ -474,5 +473,5 @@
 //++
 template<class T>
-int_4 SphereGorski<T>::PixIndexSph(r_4 theta, r_4 phi) const
+int SphereGorski<T>::PixIndexSph(double theta,double phi) const
 
 //    Retourne l'indice "RING" du pixel vers lequel pointe une direction 
@@ -480,10 +479,10 @@
 //--
 {
-  return ang2pix_ring(nSide_,double(theta),double(phi));
-}
-
-//++
-template<class T>
-int_4 SphereGorski<T>::PixIndexSphNest(r_4 theta, r_4 phi) const
+  return ang2pix_ring(nSide_,theta,phi);
+}
+
+//++
+template<class T>
+int SphereGorski<T>::PixIndexSphNest(double theta,double  phi) const
 
 //    Retourne l'indice NESTED" du pixel vers lequel pointe une direction 
@@ -491,5 +490,5 @@
 //--
 {
-  return ang2pix_nest(nSide_,double(theta),double(phi));
+  return ang2pix_nest(nSide_,theta,phi);
 }
 
@@ -498,19 +497,15 @@
 //++
 template<class T>
-void SphereGorski<T>::PixThetaPhi(int_4 k, r_4& teta, r_4& phi) const
-
-//    Retourne les coordonnées (teta,phi) du milieu du pixel d'indice "RING" k
-//--
-{
-  double t;
-  double p;
-  pix2ang_ring(nSide_,k, t, p);
-  teta= (r_4)t;
-  phi = (r_4)p;
-}
-
-//++
-template<class T>
-r_8 SphereGorski<T>::PixSolAngle(int_4 dummy) const
+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
+//--
+{
+  pix2ang_ring(nSide_,k,theta,phi);
+}
+
+//++
+template<class T>
+double SphereGorski<T>::PixSolAngle(int dummy) const
 //    Pixel Solid angle  (steradians)
 //    All the pixels have the same solid angle. The dummy argument is
@@ -524,20 +519,16 @@
 //++
 template<class T>
-void SphereGorski<T>::PixThetaPhiNest(int_4 k, float& teta, float& phi)  const
-
-//    Retourne les coordonnées (teta,phi) du milieu du pixel d'indice 
+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
 //--
 {   
-  double t;
-  double p;
-  pix2ang_nest(nSide_, k, t, p);
-  teta= (r_4)t;
-  phi = (r_4)p;
-}
-
-//++
-template<class T>
-int_4 SphereGorski<T>::NestToRing(int_4 k) const
+  pix2ang_nest(nSide_,k,theta,phi);
+}
+
+//++
+template<class T>
+int SphereGorski<T>::NestToRing(int k) const
 
 //    conversion d'index NESTD en un index RING
@@ -550,5 +541,5 @@
 //++
 template<class T>
-int_4 SphereGorski<T>::RingToNest(int_4 k) const
+int SphereGorski<T>::RingToNest(int k) const
 //
 //    conversion d'index RING en un index NESTED
@@ -687,5 +678,6 @@
 
 template<class T>
-int SphereGorski<T>::nest2ring(int nside, int ipnest) const {
+int SphereGorski<T>::nest2ring(int nside, int ipnest) const 
+{
   /*
     ====================================================
@@ -694,5 +686,5 @@
     c     conversion from NESTED to RING pixel number
     ====================================================
-    */
+  */
   // tranlated from FORTRAN (Gorski) to C, by B. Revenu, revised Guy Le Meur
   //  (16/12/98)
@@ -776,5 +768,5 @@
     c     conversion from RING to NESTED pixel number
     ==================================================
-    */
+  */
   // tranlated from FORTRAN (Gorski) to C, by B. Revenu, revised Guy Le Meur
   //  (16/12/98)
@@ -884,5 +876,5 @@
     c     corresponding to angles theta and phi
     c==================================================
-    */
+  */
   // tranlated from FORTRAN (Gorski) to C, by B. Revenu, revised Guy Le Meur
   //  (16/12/98)
@@ -968,5 +960,5 @@
     c     for every resolution
     ==================================================
-    */
+  */
   // tranlated from FORTRAN (Gorski) to C, by B. Revenu, revised Guy Le Meur
   //  (16/12/98)
@@ -1004,5 +996,5 @@
     ifp = jp / ns_max;//  ! in {0,4}
     ifm = jm / ns_max;
-    if( ifp==ifm ) face_num = (int)fmod(ifp,4) + 4; //then          ! faces 4 to 7
+    if( ifp==ifm ) face_num = (int)fmod(ifp,4) + 4; //then  ! faces 4 to 7
     else if( ifp<ifm ) face_num = (int)fmod(ifp,4); // (half-)faces 0 to 3
     else face_num = (int)fmod(ifm,4) + 8;//! (half-)faces 8 to 11
@@ -1053,5 +1045,5 @@
     c     for a parameter nside
     ===================================================
-    */
+  */
   // tranlated from FORTRAN (Gorski) to C, by B. Revenu, revised Guy Le Meur
   //  (16/12/98)
@@ -1123,5 +1115,5 @@
     c     for a parameter nside
     ==================================================
-    */
+  */
   // tranlated from FORTRAN (Gorski) to C, by B. Revenu, revised Guy Le Meur
   //  (16/12/98)
@@ -1227,5 +1219,5 @@
 
 template<class T>
-void SphereGorski<T>::getParafast(int_4& nlmax,int_4& nmmax,int_4& iseed,float& fwhm,float& quadr,float& cut) const
+void SphereGorski<T>::getParafast(int& nlmax,int& nmmax,int& iseed,float& fwhm,float& quadr,float& cut) const
 {
   nlmax= nlmax_;
@@ -1238,5 +1230,5 @@
 
 template<class T>
-void SphereGorski<T>::setParafast(int_4 nlmax,int_4 nmmax,int_4 iseed,float fwhm,float quadr,float cut,char* filename)
+void SphereGorski<T>::setParafast(int nlmax,int nmmax,int iseed,float fwhm,float quadr,float cut,char* filename)
 {
   nlmax_= nlmax;
@@ -1348,13 +1340,13 @@
     }
 
-  int_4 nSide;
+  int nSide;
   is.GetI4(nSide);
   dobj->setSizeIndex(nSide);
 
-  int_4 nPix;
+  int nPix;
   is.GetI4(nPix);
   dobj->setNbPixels(nPix);
 
-  r_8 Omega;
+  double Omega;
   is.GetR8(Omega);
   dobj->setPixSolAngle(Omega);
@@ -1365,5 +1357,5 @@
   delete [] pixels;
 
-  int_4 nlmax,nmmax,iseed;
+  int nlmax,nmmax,iseed;
   is.GetI4(nlmax);
   is.GetI4(nmmax);
@@ -1393,6 +1385,6 @@
 
   char strg[256];
-  int_4 nSide= dobj->SizeIndex();
-  int_4 nPix = dobj->NbPixels();
+  int nSide= dobj->SizeIndex();
+  int nPix = dobj->NbPixels();
  
   if(dobj->ptrInfo()) 
@@ -1414,5 +1406,5 @@
   PIOSWriteArray(os,(dobj->getDataBlock())->Data(), nPix);
 
-  int_4 nlmax,nmmax,iseed;
+  int nlmax,nmmax,iseed;
   float fwhm,quadr,cut;
   dobj->getParafast(nlmax,nmmax,iseed,fwhm,quadr,cut);
