Index: /trunk/SophyaLib/Samba/geometry.h
===================================================================
--- /trunk/SophyaLib/Samba/geometry.h	(revision 473)
+++ /trunk/SophyaLib/Samba/geometry.h	(revision 473)
@@ -0,0 +1,16 @@
+#ifndef GEOMETRY_SEEN
+#define GEOMETRY_SEEN
+
+
+#include "unitvector.h"
+
+class Geometry
+{
+public: 
+Geometry() {;}
+virtual ~Geometry() {;}
+virtual UnitVector  ConvToSphere(double psi) const = 0;
+};
+
+
+#endif
Index: /trunk/SophyaLib/Samba/localmap.cc
===================================================================
--- /trunk/SophyaLib/Samba/localmap.cc	(revision 472)
+++ /trunk/SophyaLib/Samba/localmap.cc	(revision 473)
@@ -89,5 +89,5 @@
 //++
 template<class T>
-LocalMap<T>::LocalMap(int_4 nx, int_4 ny) : nSzX_(nx), nSzY_(ny)
+LocalMap<T>::LocalMap(int nx, int ny) : nSzX_(nx), nSzY_(ny)
 //
 // Constructeur
@@ -155,5 +155,5 @@
 //++
 template<class T>
-void LocalMap<T>::ReSize(int_4 nx, int_4 ny) 
+void LocalMap<T>::ReSize(int nx, int ny) 
 //
 // Redimensionne l'espace de stokage des pixels
@@ -175,5 +175,5 @@
 //++
 template<class T>
-int_4 LocalMap<T>::NbPixels() const
+int LocalMap<T>::NbPixels() const
 //
 //    Retourne le nombre de pixels du découpage
@@ -185,5 +185,5 @@
 //++
 template<class T>
-T& LocalMap<T>::PixVal(int_4 k)
+T& LocalMap<T>::PixVal(int k)
 //
 //    Retourne la valeur du contenu du pixel d'indice k
@@ -203,5 +203,5 @@
 
 template<class T>
-T const& LocalMap<T>::PixVal(int_4 k) const
+T const& LocalMap<T>::PixVal(int k) const
 //
 //    Retourne la valeur du contenu du pixel d'indice k
@@ -220,5 +220,5 @@
 //++
 template<class T>
-int_4 LocalMap<T>::PixIndexSph(float theta, float phi) const
+int LocalMap<T>::PixIndexSph(double theta,double phi) const
 //
 //    Retourne l'indice du pixel vers lequel pointe une direction définie par 
@@ -234,16 +234,16 @@
 
   // theta et phi en coordonnees relatives (on se ramene a une situation par rapport au plan de reference)
-  float theta_aux=theta;
-  float phi_aux=phi;
+  double theta_aux= theta;
+  double phi_aux  = phi;
   UserToReference(theta_aux, phi_aux);
 
   // coordonnees dans le plan local en unites de pixels
-  float x,y;
-  AngleProjToPix(theta_aux, phi_aux, x, y);
-
-  float xmin= -x0_-0.5;
-  float xmax= xmin+nSzX_;
-  if((x >  xmax) || (x < xmin)) return(-1);
-  float xcurrent= xmin;
+  double x,y;
+  AngleProjToPix(theta_aux,phi_aux, x, y);
+
+  double xmin= -x0_-0.5;
+  double xmax= xmin+nSzX_;
+  if((x > xmax) || (x < xmin)) return(-1);
+  double xcurrent= xmin;
   for(i = 0; i < nSzX_; i++ ) 
     {
@@ -251,8 +251,8 @@
       if( x < xcurrent ) break;
     }
-  float ymin= -y0_-0.5;
-  float ymax= ymin+nSzY_;
+  double ymin= -y0_-0.5;
+  double ymax= ymin+nSzY_;
   if((y >  ymax) || (y < ymin)) return(-1);
-  float ycurrent= ymin;
+  double ycurrent= ymin;
   for(j = 0; j < nSzY_; j++ ) 
     {
@@ -265,5 +265,5 @@
 //++
 template<class T>
-void LocalMap<T>::PixThetaPhi(int_4 k, float& theta, float& phi) const
+void LocalMap<T>::PixThetaPhi(int k,double& theta,double& phi) const
 //
 //    Retourne les coordonnées (theta,phi) du milieu du pixel d'indice k
@@ -279,9 +279,9 @@
   Getij(k,i,j);
 
-  float X= float(i-x0_);
-  float Y= float(j-y0_);
+  double X= double(i-x0_);
+  double Y= double(j-y0_);
   // situation de ce pixel dans le plan de reference
-  float x= X*cos_angle_-Y*sin_angle_;
-  float y= X*sin_angle_+Y* cos_angle_;
+  double x= X*cos_angle_-Y*sin_angle_;
+  double y= X*sin_angle_+Y* cos_angle_;
   // projection sur la sphere
   PixProjToAngle(x, y, theta, phi);
@@ -292,5 +292,5 @@
 //++
 template<class T>
-r_8 LocalMap<T>::PixSolAngle(int_4 k) const
+double LocalMap<T>::PixSolAngle(int k) const
 //
 // Pixel Solid angle  (steradians)
@@ -301,41 +301,44 @@
   int i,j;
   Getij(k,i,j);
-  float X= float(i-x0_);
-  float Y= float(j-y0_);
-  float XR= X+float(i)*0.5;
-  float XL= X-float(i)*0.5;
-  float YU= Y+float(j)*0.5;
-  float YL= Y-float(j)*0.5;
+  double X= double(i-x0_);
+  double Y= double(j-y0_);
+  double XR= X+double(i)*0.5;
+  double XL= X-double(i)*0.5;
+  double YU= Y+double(j)*0.5;
+  double YL= Y-double(j)*0.5;
+
   // situation  dans le plan de reference
-  float x0= XL*cos_angle_-YL*sin_angle_;
-  float y0= XL*sin_angle_+YL*cos_angle_;
-  float xa= XR*cos_angle_-YL*sin_angle_;
-  float ya= XR*sin_angle_+YL*cos_angle_;
-  float xb= XL*cos_angle_-YU*sin_angle_;
-  float yb= XL*sin_angle_+YU*cos_angle_;
+  double x0= XL*cos_angle_-YL*sin_angle_;
+  double y0= XL*sin_angle_+YL*cos_angle_;
+  double xa= XR*cos_angle_-YL*sin_angle_;
+  double ya= XR*sin_angle_+YL*cos_angle_;
+  double xb= XL*cos_angle_-YU*sin_angle_;
+  double yb= XL*sin_angle_+YU*cos_angle_;
+
   // projection sur la sphere
-  float tet0,phi0,teta,phia,tetb,phib;
-  PixProjToAngle(x0, y0, tet0, phi0);
-  PixProjToAngle(xa, ya, teta, phia);
-  PixProjToAngle(xb, yb, tetb, phib);
+  double thet0,phi0,theta,phia,thetb,phib;
+  PixProjToAngle(x0, y0, thet0, phi0);
+  PixProjToAngle(xa, ya, theta, phia);
+  PixProjToAngle(xb, yb, thetb, phib);
+
   // angle solide
-  float sol= fabs((xa-x0)*(yb-y0)-(xb-x0)*(ya-y0));
-  return r_8(sol);
-}
-
-//++
-template<class T>
-void  LocalMap<T>::SetOrigin(float theta0, float phi0, float angle)
+  double sol= fabs((xa-x0)*(yb-y0)-(xb-x0)*(ya-y0));
+  return sol;
+}
+
+//++
+template<class T>
+void LocalMap<T>::SetOrigin(double theta0,double phi0,double angle)
 //
 // Fixe la repere de reference ( angles en degres) 
 //--
 {
-  theta0_= (double)theta0;
-  phi0_  = (double)phi0;
-  angle_ = (double)angle;
+  theta0_= theta0;
+  phi0_  = phi0;
+  angle_ = angle;
   x0_= nSzX_/2;
   y0_= nSzY_/2;
-  cos_angle_= cosdf(angle);
-  sin_angle_= sindf(angle);
+  cos_angle_= cos(angle*Pi/180.);
+  sin_angle_= sin(angle*Pi/180.);
   originFlag_= true; 
   cout << " LocalMap:: set origin 1 done" << endl;
@@ -344,16 +347,16 @@
 //++
 template<class T>
-void  LocalMap<T>::SetOrigin(float theta0, float phi0, int_4 x0, int_4 y0, float angle)
+void LocalMap<T>::SetOrigin(double theta0,double phi0,int x0,int y0,double angle)
 //
 // Fixe le repere de reference (angles en degres)  
 //--
 {
-  theta0_= (double)theta0;
-  phi0_  = (double)phi0;
-  angle_ = (double)angle;
+  theta0_= theta0;
+  phi0_  = phi0;
+  angle_ = angle;
   x0_= x0;
   y0_= y0;
-  cos_angle_= cosdf(angle);
-  sin_angle_= sindf(angle);
+  cos_angle_= cos(angle*Pi/180.);
+  sin_angle_= sin(angle*Pi/180.);
   originFlag_= true;
   cout << " LocalMap:: set origin 2 done" << endl;
@@ -362,19 +365,15 @@
 //++
 template<class T>
-void LocalMap<T>::SetSize(float angleX, float angleY)
+void LocalMap<T>::SetSize(double angleX,double angleY)
 //
 // Fixe l'extension de la carte (angles en degres)
 //--
 {
-  angleX_= (double)angleX;
-  angleY_= (double)angleY;
-
-  //tgAngleX_= T(tan(angleX*Pi/360.));
-  //tgAngleY_= T(tan(angleY*Pi/360.));
-
+  angleX_= angleX;
+  angleY_= angleY;
 
   // tangente de la moitie de l'ouverture angulaire totale
-  tgAngleX_= tand(0.5*angleX_);
-  tgAngleY_= tand(0.5*angleY_);
+  tgAngleX_= tan(0.5*angleX_*Pi/180.);
+  tgAngleY_= tan(0.5*angleY_*Pi/180.);
 
   extensFlag_= true;
@@ -391,5 +390,5 @@
   for(int m = 0; m < nPix_; m++) 
     {
-      float theta,phi;
+      double theta,phi;
       PixThetaPhi(m,theta,phi);
       sphere(theta,phi)= pixels_(m);
@@ -400,5 +399,5 @@
 //++
 template<class T>
-void LocalMap<T>::Getij(int k, int& i, int& j) const
+void LocalMap<T>::Getij(int k,int& i,int& j) const
 //
 //--
@@ -411,35 +410,32 @@
 //++
 template<class T>
-void  LocalMap<T>::ReferenceToUser(float &theta, float &phi) const
+void  LocalMap<T>::ReferenceToUser(double& theta,double& phi) const
 //
 // --     
 {
-  if(theta > (r_4)Pi || theta < 0.  || phi < 0. || phi >= 2*(r_4)Pi) 
-    {
-      //cout << " LocalMap::ReferenceToUser : exceptions  a mettre en place" <<endl;
-      //    THROW(out_of_range("LocalMap::PIxVal Pixel index out of range"));
+  if(theta > Pi || theta < 0. || phi < 0. || phi >= 2*Pi) 
+    {
       throw "LocalMap::ReferenceToUser (theta,phi) out of range"; 
     } 
 
-  //cout << " ReferenceToUser entree, t= " << theta << " phi= " << phi << endl;
-  theta= (r_4)theta0_*Pi/180.+theta-(r_4)Pi*0.5;
+  theta= theta0_*Pi/180.+theta-Pi*0.5;
   if(theta < 0.) 
     {
       theta= -theta;
-      phi += (r_4)Pi;
+      phi += Pi;
     } 
   else 
     {
-      if(theta > (r_4)Pi) 
+      if(theta > Pi) 
 	{
-	  theta= 2.*(r_4)Pi-theta;
-	  phi += (r_4)Pi;
+	  theta= 2.*Pi-theta;
+	  phi += Pi;
 	} 
     }
 
-  phi= (r_4)phi0_*Pi/180.+phi;
-  while(phi >= 2.*(r_4)Pi) phi-=2.*(r_4)Pi;
-
-  if(theta > (r_4)Pi || theta < 0.  || phi < 0. || phi >= 2*(r_4)Pi) 
+  phi= phi0_*Pi/180.+phi;
+  while(phi >= 2.*Pi) phi-= 2.*Pi;
+
+  if(theta > Pi || theta < 0. || phi < 0. || phi >= 2*Pi) 
     {
       cout <<  " LocalMap::ReferenceToUser : erreur bizarre dans le transfert a la carte utilisateur " << endl;
@@ -447,41 +443,40 @@
       exit(0);
     }
-  //cout << " ReferenceToUser sortie, t= " << theta << " phi= " << phi << endl;
-}
-
-//++
-template<class T>
-void  LocalMap<T>::UserToReference(float &theta, float &phi) const
+}
+
+//++
+template<class T>
+void  LocalMap<T>::UserToReference(double& theta,double& phi) const
 //
 // --     
 {
-  if(theta > (r_4)Pi || theta < 0.  || phi<0. || phi >= 2*(r_4)Pi ) 
-    {
-      cout << " LocalMap::UserToReference : exceptions  a mettre en place" <<endl;
-      //    THROW(out_of_range("LocalMap::PIxVal Pixel index out of range"));
+  if(theta > Pi || theta < 0. || phi < 0. || phi >= 2*Pi) 
+    {
+      cout<<" LocalMap::UserToReference: exceptions a mettre en place" <<endl;
+      // THROW(out_of_range("LocalMap::PIxVal Pixel index out of range"));
       throw "LocalMap::UserToReference (theta,phi) out of range"; 
     }
 
-  float phi1=phi-(r_4)phi0_*Pi/180.;
-  if(phi1 < 0.) phi1+=2.*(r_4)Pi;
-
-  float theta1= theta-(r_4)theta0_*Pi/180.+(r_4)Pi*0.5;
+  double phi1= phi-phi0_*Pi/180.;
+  if(phi1 < 0.) phi1+= 2.*Pi;
+
+  double theta1= theta-theta0_*Pi/180.+Pi*0.5;
   if(theta1 < 0.) 
     {
       theta= -theta1;
-      phi1+= (r_4)Pi;
+      phi1+= Pi;
     } 
   else
     { 
-      if(theta1 > (r_4)Pi) 
+      if(theta1 > Pi) 
 	{
-	  theta= 2.*(r_4)Pi-theta1;
-	  phi1+= (r_4)Pi;
+	  theta= 2.*Pi-theta1;
+	  phi1+= Pi;
 	}
     }
 
-  while(phi1 >= 2.*(r_4)Pi) phi1-=2.*(r_4)Pi;
+  while(phi1 >= 2.*Pi) phi1-= 2.*Pi;
   phi= phi1;
-  if(theta > (r_4)Pi || theta < 0.  || phi < 0. || phi >= 2*(r_4)Pi ) 
+  if(theta > Pi || theta < 0. || phi < 0. || phi >= 2*Pi) 
     {
       cout <<  " LocalMap::UserToReference : erreur bizarre dans le transfert a la carte de reference " << endl;
@@ -493,12 +488,12 @@
 //++
 template<class T>
-void LocalMap<T>::PixProjToAngle(float x, float y, float& theta, float& phi) const
-//
-// (x,y) representent les coordonnees en unites de pixels d'un point DANS  LE PLAN DE REFERENCE. 
+void LocalMap<T>::PixProjToAngle(double x,double y,double& theta,double& phi) const
+//
+// (x,y) representent les coordonnees en unites de pixels d'un point DANS LE PLAN DE REFERENCE. 
 // On recupere (theta,phi) par rapport au repere "absolu" theta=pi/2 et phi=0.
 //--
 {
-  theta= (r_4)Pi*0.5-atan(2*y*tgAngleY_/(float)nSzY_);
-  phi= atan2(2*x*tgAngleX_,(float)nSzX_);
+  theta= Pi*0.5-atan(2.*y*tgAngleY_/(double)nSzY_);
+  phi= atan2(2.*x*tgAngleX_,(double)nSzX_);
   if(phi < 0.) phi += DeuxPi;
 }
@@ -506,5 +501,5 @@
 //++
 template<class T>
-void LocalMap<T>::AngleProjToPix(float theta, float phi, float& x, float& y) const
+void LocalMap<T>::AngleProjToPix(double theta,double phi,double& x,double& y) const
 //
 // (theta,phi) par rapport au repere "absolu" theta=pi/2,phi=0. On recupere 
@@ -512,5 +507,5 @@
 //--
 {
-  if(phi >= (r_4)Pi) phi-= DeuxPi;
+  if(phi >= Pi) phi-= DeuxPi;
   //  y=0.5*mSzY_*cot(theta)/tgAngleY_;  $CHECK-REZA-04/99$
   y= 0.5*nSzY_/tan(theta)/tgAngleY_;  // ? cot = 1/tan ?  
@@ -606,13 +601,13 @@
     }
 
-  int_4 nSzX;
+  int nSzX;
   is.GetI4(nSzX);
   dobj->setSize_x(nSzX);
 
-  int_4 nSzY;
+  int nSzY;
   is.GetI4(nSzY);
   dobj->setSize_y(nSzY);
 
-  int_4 nPix;
+  int nPix;
   is.GetI4(nPix);
   dobj->setNbPixels(nPix);
@@ -624,16 +619,16 @@
     {
       cout<<" ReadSelf:: local mapping"<<endl;
-      int_4 x0, y0;
-      float theta, phi, angle;
+      int x0, y0;
+      double theta, phi, angle;
       is.GetI4(x0);
       is.GetI4(y0);
-      is.GetR4(theta);
-      is.GetR4(phi);
-      is.GetR4(angle);
+      is.GetR8(theta);
+      is.GetR8(phi);
+      is.GetR8(angle);
       dobj->SetOrigin(theta, phi, x0, y0, angle);
 
-      float angleX, angleY;
-      is.GetR4(angleX);
-      is.GetR4(angleY);
+      double angleX, angleY;
+      is.GetR8(angleX);
+      is.GetR8(angleY);
       dobj->SetSize(angleX, angleY);
     }
@@ -657,7 +652,7 @@
 
   char strg[256];
-  int_4 nSzX= dobj->Size_x();
-  int_4 nSzY= dobj->Size_y();
-  int_4 nPix= dobj->NbPixels();
+  int nSzX= dobj->Size_x();
+  int nSzY= dobj->Size_y();
+  int nPix= dobj->NbPixels();
  
   if(dobj->ptrInfo()) 
@@ -681,17 +676,17 @@
       string ss("local mapping is done");
       os.PutStr(ss);
-      int_4 x0, y0;
-      float theta, phi, angle;
+      int x0, y0;
+      double theta, phi, angle;
       dobj->Origin(theta, phi, x0, y0, angle);
       os.PutI4(x0);
       os.PutI4(y0);
-      os.PutR4(theta);
-      os.PutR4(phi);
-      os.PutR4(angle);
-
-      float angleX, angleY;
+      os.PutR8(theta);
+      os.PutR8(phi);
+      os.PutR8(angle);
+
+      double angleX, angleY;
       dobj->Aperture(angleX, angleY);
-      os.PutR4(angleX);
-      os.PutR4(angleY);
+      os.PutR8(angleX);
+      os.PutR8(angleY);
     }
   else
Index: /trunk/SophyaLib/Samba/localmap.h
===================================================================
--- /trunk/SophyaLib/Samba/localmap.h	(revision 472)
+++ /trunk/SophyaLib/Samba/localmap.h	(revision 473)
@@ -42,5 +42,5 @@
 
 LocalMap();
-LocalMap(int_4 nx, int_4 ny);
+LocalMap(int nx, int ny);
 LocalMap(const LocalMap<T>& lm);
 virtual ~LocalMap();
@@ -48,6 +48,6 @@
 // ---------- Overloading of () to access pixel number k ----
 
-inline T& operator()(int_4 k) {return(PixVal(k));}
-inline T const& operator()(int_4 k) const {return(PixVal(k));}
+inline T& operator()(int k) {return(PixVal(k));}
+inline T const& operator()(int k) const {return(PixVal(k));}
 inline T& operator()(int ix, int iy) {return PixVal(iy*nSzX_+ix);};
 inline T const& operator()(int ix, int iy) const {return PixVal(iy*nSzX_+ix);};
@@ -56,32 +56,32 @@
 
 /* return/set the number of pixels */
-virtual int_4 NbPixels() const;
-inline void setNbPixels(int_4 n) {nPix_= n;}
+virtual int NbPixels() const;
+inline void setNbPixels(int n) {nPix_= n;}
   
 /* return the value of pixel number k */
-virtual T& PixVal(int_4 k);
-virtual T const& PixVal(int_4 k) const;
+virtual T& PixVal(int k);
+virtual T const& PixVal(int k) const;
 
 /* return the index of pixel at (theta,phi) */
-virtual int_4 PixIndexSph(float theta, float phi) const;
+virtual int PixIndexSph(double theta,double phi) const;
    
 /* return the spherical coordinates of center of pixel number k */
-virtual void PixThetaPhi(int_4 k, float& theta, float& phi) const;
+virtual void PixThetaPhi(int k,double& theta,double& phi) const;
 
 /* return the Pixel Solid angle  (steradians) */
-virtual r_8 PixSolAngle(int_4 k) const; 
+virtual double PixSolAngle(int k) const; 
 
 // ---------- Specific methods ------------------------------
 
-void ReSize(int_4 nx, int_4 ny);
+void ReSize(int nx, int ny);
 
 inline virtual char* TypeOfMap() const {return "LOCAL";};
  
 /* Origin (with angle between x axis and phi axis, in degrees)  x0,y0  the default: middle of map*/
-virtual void SetOrigin(float theta=90., float phi=0., float angle=0.);
-virtual void SetOrigin(float theta,float phi,int_4 x0,int_4 y0,float angle=0.);
+virtual void SetOrigin(double theta=90.,double phi=0.,double angle=0.);
+virtual void SetOrigin(double theta,double phi,int x0,int y0,double angle=0.);
 
 /* Pixel size (degres) */ 
-virtual void SetSize(float angleX, float angleY);
+virtual void SetSize(double angleX,double angleY);
 
 /* Check to see if the local mapping is done */
@@ -95,17 +95,17 @@
   
 /* provides a integer characterizing the pixelization refinement  (here : number of pixels) */
-inline virtual int_4 SizeIndex() const {return(nPix_);}
-inline int_4 Size_x() const {return nSzX_;}
-inline void setSize_x(int_4 n) {nSzX_= n;}
-inline int_4 Size_y() const {return nSzY_;}
-inline void setSize_y(int_4 n) {nSzY_= n;}
+inline virtual int SizeIndex() const {return(nPix_);}
+inline int Size_x() const {return nSzX_;}
+inline void setSize_x(int n) {nSzX_= n;}
+inline int Size_y() const {return nSzY_;}
+inline void setSize_y(int n) {nSzY_= n;}
 
-inline void Origin(float& theta, float& phi,int& x0, int& y0, float& angle) const {theta= (float)theta0_; phi= (float)phi0_; x0= x0_; y0= y0_;angle= (float)angle_;}
+inline void Origin(double& theta,double& phi,int& x0,int& y0,double& angle) const {theta= theta0_; phi= phi0_; x0= x0_; y0= y0_;angle= angle_;}
 
-inline void Aperture(float& anglex, float& angley) const {anglex= (float)angleX_; angley= (float)angleY_;}
+inline void Aperture(double& anglex,double& angley) const {anglex= angleX_; angley= angleY_;}
 
 /* retourne le pointeur vers/remplit  le vecteur des contenus des pixels */ 
 inline const NDataBlock<T>* getDataBlock() const {return (&pixels_);}
-inline void setDataBlock(T* data, int_4 n) {pixels_.FillFrom(n,data);}
+inline void setDataBlock(T* data, int n) {pixels_.FillFrom(n,data);}
 
 /* impression */ 
@@ -117,28 +117,28 @@
 
 void InitNul();
-void Getij(int k, int& i, int& j) const;
-void ReferenceToUser(float &theta, float &phi) const; 
-void UserToReference(float &theta, float &phi) const;
-void PixProjToAngle(float x, float y,float &theta, float &phi) const; 
-void AngleProjToPix(float theta, float phi, float& x, float& y) const; 
+void Getij(int k,int& i,int& j) const;
+void ReferenceToUser(double& theta,double& phi) const; 
+void UserToReference(double& theta,double& phi) const;
+void PixProjToAngle(double x,double y,double& theta,double& phi) const; 
+void AngleProjToPix(double theta,double phi,double& x,double& y) const; 
 
 // ---------- Variables internes ----------------------------
 
-int_4 nSzX_;
-int_4 nSzY_;
-int_4 nPix_;
+int nSzX_;
+int nSzY_;
+int nPix_;
 bool originFlag_;
 bool extensFlag_;
-int_4 x0_;
-int_4 y0_;
-r_8 theta0_;
-r_8 phi0_;
-r_8 angle_;
-r_4 cos_angle_;
-r_4 sin_angle_;
-r_8 angleX_;
-r_8 angleY_;
-r_8 tgAngleX_;
-r_8 tgAngleY_;
+int x0_;
+int y0_;
+double theta0_;
+double phi0_;
+double angle_;
+double cos_angle_;
+double sin_angle_;
+double angleX_;
+double angleY_;
+double tgAngleX_;
+double tgAngleY_;
 NDataBlock<T> pixels_;
 };
Index: /trunk/SophyaLib/Samba/pixelmap.h
===================================================================
--- /trunk/SophyaLib/Samba/pixelmap.h	(revision 472)
+++ /trunk/SophyaLib/Samba/pixelmap.h	(revision 473)
@@ -25,36 +25,36 @@
   
 // Number of pixels
-virtual int_4 NbPixels() const=0;
+virtual int NbPixels() const=0;
    
 // Value of pixel number k
-virtual T& PixVal(int_4 k)=0;
-virtual T const& PixVal(int_4 k) const=0;
+virtual T& PixVal(int k)=0;
+virtual T const& PixVal(int k) const=0;
    
 // Index of pixel at (theta,phi)
-virtual int_4 PixIndexSph(float theta, float phi) const=0;
+virtual int PixIndexSph(double theta, double phi) const=0;
 
 // Value of pixel number at (theta,phi)
-virtual T& PixValSph(float theta, float phi)
+virtual T& PixValSph(double theta, double phi)
                            {return PixVal(PixIndexSph(theta,phi));}
-virtual T const& PixValSph(float theta, float phi) const
+virtual T const& PixValSph(double theta, double phi) const
                            {return PixVal(PixIndexSph(theta,phi));}
 
 // Spherical coordinates of center of pixel number k
-virtual void PixThetaPhi(int_4 k, float& theta, float& phi) const=0;
+virtual void PixThetaPhi(int k, double& theta, double& phi) const=0;
 
 // provides a integer characterizing the pixelization refinement 
 // (depending of the type of the map)              
-virtual int_4 SizeIndex() const=0;
+virtual int SizeIndex() const=0;
 virtual char* TypeOfMap() const =0;
 
 // Pixel  (steradians)
-virtual r_8 PixSolAngle(int_4 k) const =0; 
+virtual double PixSolAngle(int k) const =0; 
 
 // Overloading of () to access pixel number k.
-inline T& operator()(int_4 k) {return(PixVal(k));}
-inline T const& operator()(int_4 k) const {return(PixVal(k));}
+inline T& operator()(int k) {return(PixVal(k));}
+inline T const& operator()(int k) const {return(PixVal(k));}
 
-// Note : no overloading of (float,float) to access pixel (theta,phi).
-// overloading of (float,float) in SphericalMap
+// Note : no overloading of (double,double) to access pixel (theta,phi).
+// overloading of (double,double) in SphericalMap
 // overloading of (int,int)     in CartesianMap
 
Index: /trunk/SophyaLib/Samba/spheregorski.cc
===================================================================
--- /trunk/SophyaLib/Samba/spheregorski.cc	(revision 472)
+++ /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);
Index: /trunk/SophyaLib/Samba/spheregorski.h
===================================================================
--- /trunk/SophyaLib/Samba/spheregorski.h	(revision 472)
+++ /trunk/SophyaLib/Samba/spheregorski.h	(revision 473)
@@ -32,5 +32,5 @@
 
 SphereGorski();
-SphereGorski(int_4 m);
+SphereGorski(int m);
 SphereGorski(const SphereGorski<T>& s);
 virtual ~SphereGorski();
@@ -39,53 +39,53 @@
 
 /* Nombre de pixels du decoupage */
-virtual int_4 NbPixels() const;
-inline void setNbPixels(int_4 n) {nPix_= n;}
+virtual int NbPixels() const;
+inline void setNbPixels(int n) {nPix_= n;}
 
 /* Valeur du contenu du pixel d'indice "RING" k  */
-virtual T& PixVal(int_4 k);
-virtual T const& PixVal(int_4 k) const;
+virtual T& PixVal(int k);
+virtual T const& PixVal(int k) const;
 
 /* Nombre de tranches en theta */ 
-int_4 NbThetaSlices() const;
-void GetThetaSlice(int_4 index,r_4& theta,TVector<float>& phi,TVector<T>& value) const;
+int NbThetaSlices() const;
+void GetThetaSlice(int index,double& theta,TVector<double>& phi,TVector<T>& value) const;
 
 /* Indice "RING" du pixel vers lequel pointe une direction definie par 
 ses  coordonnees spheriques */                                    
-virtual int_4 PixIndexSph(float theta, float phi) const;
+virtual int PixIndexSph(double theta,double phi) const;
 
 /* Coordonnees spheriques du milieu du pixel d'indice "RING" k   */
-virtual void PixThetaPhi(int_4 k, float& teta, float& phi) const;
+virtual void PixThetaPhi(int k,double& theta,double& phi) const;
 
 /* Pixel Solid angle  (steradians) */
-virtual r_8 PixSolAngle(int_4 dummy) const;
-inline void setPixSolAngle(r_8 x) {omeg_= x;}
+virtual double PixSolAngle(int dummy) const;
+inline void setPixSolAngle(double x) {omeg_= x;}
 
 // --------------- Specific methods 
 
-virtual void Resize(int_4 m);
+virtual void Resize(int m);
 
 inline virtual char* TypeOfMap() const {return "RING";};
 
-/* Valeur du contenu du pixel d'indice "NEST" k                                 */
-virtual T& PixValNest(int_4 k);
-virtual T const& PixValNest(int_4 k) const;
+/* Valeur du contenu du pixel d'indice "NEST" k */
+virtual T& PixValNest(int k);
+virtual T const& PixValNest(int k) const;
 
 /* Indice "NEST" du pixel vers lequel pointe une direction definie par 
 ses  coordonnees spheriques */                                    
-virtual int_4 PixIndexSphNest(float theta, float phi) const;
+virtual int PixIndexSphNest(double theta,double phi) const;
 
 /* Coordonnees spheriques du milieu du pixel d'indice "NEST" k       */
-virtual void PixThetaPhiNest(int_4 k, float& teta, float& phi) const;
+virtual void PixThetaPhiNest(int k,double& theta,double& phi) const;
 
 /* algorithme de pixelisation */
-void Pixelize(int_4); 
+void Pixelize(int); 
 
 /* convertit index nested en ring  */
-int_4 NestToRing(int_4 ) const;
+int NestToRing(int) const;
 
 /* convertit index ring en nested" */
-int_4 RingToNest(int_4 ) const;
+int RingToNest(int) const;
 
-/*    analyse en harmoniques spheriques des valeurs des pixels de la 
+/* analyse en harmoniques spheriques des valeurs des pixels de la 
    sphere : appel du module anafast (Gorski-Hivon) */
 //void anharm(int, float, float*);
@@ -97,14 +97,14 @@
 
 /* retourne/fixe la valeur du parametre Gorski */
-inline virtual int_4 SizeIndex() const {return(nSide_);}
-inline void setSizeIndex(int_4 n) {nSide_= n;}
+inline virtual int SizeIndex() const {return(nSide_);}
+inline void setSizeIndex(int n) {nSide_= n;}
 
 /* retourne les pointeurs /remplit les tableaux */
 inline const NDataBlock<T>* getDataBlock() const { return (&pixels_); }
-inline void setDataBlock(T* data, int_4 m) { pixels_.FillFrom(m,data); }
+inline void setDataBlock(T* data,int m) { pixels_.FillFrom(m,data); }
 
 /* retourne/fixe les parametres des modules anafast et synfast */
-void getParafast(int_4& nlmax,int_4& nmmax,int_4& iseed,float& fwhm,float& quadr,float& cut) const;
-void setParafast(int_4 nlmax,int_4 nmmax,int_4 iseed,float fwhm,float quadr,float cut,char* filename);
+void getParafast(int& nlmax,int& nmmax,int& iseed,float& fwhm,float& quadr,float& cut) const;
+void setParafast(int nlmax,int nmmax,int iseed,float fwhm,float quadr,float cut,char* filename);
 
 /* retourne/fixe le nom du fichier qui contient le spectre de puissance */
@@ -119,16 +119,16 @@
 void InitNul();
 
-int  nest2ring(int nside, int ipnest) const;
-int  ring2nest(int nside, int ipring) const;
+int  nest2ring(int nside,int ipnest) const;
+int  ring2nest(int nside,int ipring) const;
 
-int  ang2pix_ring(int nside, double theta, double phi) const;
-int  ang2pix_nest(int nside, double theta, double phi) const;
-void pix2ang_ring(int nside, int ipix, double& theta,  double& phi) const;
-void pix2ang_nest(int nside, int ipix, double& theta, double& phi) const;
+int  ang2pix_ring(int nside,double theta,double phi) const;
+int  ang2pix_nest(int nside,double theta,double phi) const;
+void pix2ang_ring(int nside,int ipix,double& theta,double& phi) const;
+void pix2ang_nest(int nside,int ipix,double& theta,double& phi) const;
 
 // ------------- variables internes -----------------------
-int_4 nSide_;
-int_4 nPix_;
-r_8 omeg_;
+int nSide_;
+int nPix_;
+double omeg_;
 
 NDataBlock<T> pixels_;
Index: /trunk/SophyaLib/Samba/spherethetaphi.cc
===================================================================
--- /trunk/SophyaLib/Samba/spherethetaphi.cc	(revision 472)
+++ /trunk/SophyaLib/Samba/spherethetaphi.cc	(revision 473)
@@ -87,5 +87,5 @@
 //++
 template <class T>
-SphereThetaPhi<T>::SphereThetaPhi(int_4 m)
+SphereThetaPhi<T>::SphereThetaPhi(int m)
 
 //    Constructeur : m est le nombre de bandes en theta sur un hémisphère 
@@ -105,7 +105,7 @@
   NTheta_= s.NTheta_;
   NPix_  = s.NPix_;
-  NPhi_  = new int_4[NTheta_];
-  Theta_ = new r_4[NTheta_+1];
-  TNphi_ = new int_4[NTheta_+1];
+  NPhi_  = new int[NTheta_];
+  Theta_ = new double[NTheta_+1];
+  TNphi_ = new int[NTheta_+1];
   for(int k = 0; k < NTheta_; k++) 
     {
@@ -161,5 +161,5 @@
 //++
 template <class T>
-void SphereThetaPhi<T>::Resize(int_4 m)
+void SphereThetaPhi<T>::Resize(int m)
 //   re-pixelize the sphere
 //--
@@ -172,5 +172,5 @@
 //++
 template <class T>
-int_4 SphereThetaPhi<T>::NbPixels() const
+int SphereThetaPhi<T>::NbPixels() const
 
 //    Retourne le nombre de pixels du découpage
@@ -183,5 +183,5 @@
 //++
 template <class T>
-T& SphereThetaPhi<T>::PixVal(int_4 k)
+T& SphereThetaPhi<T>::PixVal(int k)
 
 //    Retourne la valeur du contenu du pixel d'indice k
@@ -190,22 +190,22 @@
   if((k < 0) || (k >= NPix_)) 
     {
-      //  THROW(out_of_range("SphereThetaPhi::PIxVal Pixel index out of range"));
+      //THROW(out_of_range("SphereThetaPhi::PIxVal Pixel index out of range"));
+      cout << " SphereThetaPhi::PIxVal : exceptions a mettre en place" <<endl;
+      THROW(rangeCheckErr);
+    }
+  return pixels_(k);
+}
+
+//++
+template <class T>
+T const& SphereThetaPhi<T>::PixVal(int k) const
+
+//    Retourne la valeur du contenu du pixel d'indice k
+//--
+{
+  if((k < 0) || (k >= NPix_)) 
+    {
       cout << " SphereThetaPhi::PIxVal : exceptions  a mettre en place" <<endl;
-      THROW(rangeCheckErr);
-    }
-  return pixels_(k);
-}
-
-//++
-template <class T>
-T const& SphereThetaPhi<T>::PixVal(int_4 k) const
-
-//    Retourne la valeur du contenu du pixel d'indice k
-//--
-{
-  if((k < 0) || (k >= NPix_)) 
-    {
-      cout << " SphereThetaPhi::PIxVal : exceptions  a mettre en place" <<endl;
-      //    THROW(out_of_range("SphereThetaPhi::PIxVal Pixel index out of range"));
+      //THROW(out_of_range("SphereThetaPhi::PIxVal Pixel index out of range"));
       throw "SphereThetaPhi::PIxVal Pixel index out of range"; 
     } 
@@ -216,17 +216,17 @@
 //++
 template <class T>
-int_4 SphereThetaPhi<T>::PixIndexSph(r_4 theta, r_4 phi) const
-
-//    Retourne l'indice du pixel vers lequel pointe une direction définie par 
+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
 //--
 {
-  r_4 dphi;
-  int_4 i,j,k;
+  double dphi;
+  int i,j,k;
   bool fgzn = false;
 
-  if( (theta > (r_4)Pi) || (theta < 0. ) ) return(-1);
-  if( (phi < 0.) || (phi > DeuxPi) )  return(-1);
-  if( theta > (r_4)Pi*0.5)  { fgzn = true;  theta = Pi-theta; }
+  if((theta > Pi) || (theta < 0.)) return(-1);
+  if((phi < 0.) || (phi > DeuxPi)) return(-1);
+  if(theta > Pi*0.5) {fgzn = true; theta = Pi-theta;}
   
   // La bande d'indice kt est limitée par les valeurs de theta contenues dans
@@ -235,8 +235,8 @@
     if( theta < Theta_[i] ) break;
   
-  dphi= (r_4)DeuxPi/(r_4)NPhi_[i-1];
-  
-  if (fgzn)  k= NPix_-TNphi_[i]+(int_4)(phi/dphi);
-  else k= TNphi_[i-1]+(int_4)(phi/dphi); 
+  dphi= DeuxPi/(double)NPhi_[i-1];
+  
+  if (fgzn)  k= NPix_-TNphi_[i]+(int)(phi/dphi);
+  else k= TNphi_[i-1]+(int)(phi/dphi); 
   return(k);
 }
@@ -245,14 +245,14 @@
 //++
 template <class T>
-void SphereThetaPhi<T>::PixThetaPhi(int_4 k, r_4& theta, r_4& phi) const
+void SphereThetaPhi<T>::PixThetaPhi(int k,double& theta,double& phi) const
 
 //    Retourne les coordonnées (theta,phi) du milieu du pixel d'indice k
 //--
 {
-  int_4 i; 
+  int i; 
   bool fgzn = false;
   
-  if( (k < 0) || (k >= NPix_) ) {theta = -99999.; phi = -99999.;  return; }
-  if( k >= NPix_/2)  {fgzn = true;  k = NPix_-1-k; }
+  if((k < 0) || (k >= NPix_)) {theta = -99999.; phi = -99999.; return; }
+  if( k >= NPix_/2)  {fgzn = true; k = NPix_-1-k;}
 
   // recupère l'indice i de la tranche qui contient le pixel k
@@ -266,5 +266,5 @@
   // angle phi
   k -= TNphi_[i];
-  phi= (r_4)DeuxPi/(r_4)NPhi_[i]*(r_4)(k+.5);
+  phi= DeuxPi/(double)NPhi_[i]*(double)(k+.5);
   if (fgzn) phi= DeuxPi-phi;
 }
@@ -272,5 +272,5 @@
 //++
 template <class T>
-r_8  SphereThetaPhi<T>::PixSolAngle(int_4 dummy) const
+double SphereThetaPhi<T>::PixSolAngle(int dummy) const
 
 //    Pixel Solid angle  (steradians)
@@ -286,14 +286,14 @@
 //++
 template <class T>
-void SphereThetaPhi<T>::Limits(int_4 k, r_4& tetMin, r_4& tetMax, r_4& phiMin, r_4& phiMax) 
+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
 //--
   {
-  int_4 j;
-  r_4 dphi;
+  int j;
+  double dphi;
   bool fgzn= false;
   
-  if( (k< 0) || (k >= NPix_) ) {
+  if((k < 0) || (k >= NPix_)) {
     tetMin= -99999.; 
     phiMin= -99999.;  
@@ -304,5 +304,5 @@
   
   // si on se trouve dans l'hémisphère Sud
-  if( k >= NPix_/2 ) { 
+  if(k >= NPix_/2) { 
     fgzn= true; 
     k= NPix_-1-k; 
@@ -312,5 +312,5 @@
   int i;
   for( i=0; i< NTheta_; i++ ) 
-    if( k< TNphi_[i+1] ) break;
+    if(k < TNphi_[i+1]) break;
   
   // valeurs limites de theta dans l'hemisphere Nord
@@ -328,9 +328,9 @@
   // indice j de discretisation ( phi= j*dphi )
   j= k-TNphi_[i];
-  dphi= (r_4)DeuxPi/(r_4)NPhi_[i];
+  dphi= DeuxPi/(double)NPhi_[i];
   
   // valeurs limites de phi 
-  phiMin= dphi*(r_4)(j);
-  phiMax= dphi*(r_4)(j+1);
+  phiMin= dphi*(double)(j);
+  phiMax= dphi*(double)(j+1);
   return;
 }
@@ -339,10 +339,10 @@
 //++
 template <class T>
-int_4 SphereThetaPhi<T>::NbThetaSlices() const
+int SphereThetaPhi<T>::NbThetaSlices() const
 
 //    Retourne le nombre de tranches en theta sur la sphere
 //--
 {
-  int_4 nbslices;
+  int nbslices;
   nbslices= 2*NTheta_;
   return(nbslices);
@@ -352,15 +352,15 @@
 //++
 template <class T>
-int_4 SphereThetaPhi<T>::NPhi(int_4 kt) const
+int SphereThetaPhi<T>::NPhi(int kt) const
 
 //    Retourne le nombre de pixels en phi de la tranche kt
 //-- 
 {
-  int_4 nbpix;  
+  int nbpix;  
   // verification
-  if( (kt< 0) || (kt>= 2*NTheta_) ) return(-1);
+  if((kt < 0) || (kt >= 2*NTheta_)) return(-1);
   
   // si on se trouve dans l'hemisphere Sud
-  if( kt >= NTheta_ ) {
+  if(kt >= NTheta_) {
     kt= 2*NTheta_-1-kt; 
   }
@@ -375,5 +375,5 @@
 //++
 template <class T>
-void SphereThetaPhi<T>::Theta(int_4 kt,r_4& tetMin,r_4& tetMax) 
+void SphereThetaPhi<T>::Theta(int kt,double& tetMin,double& tetMax) 
 
 //    Retourne les valeurs de theta limitant la tranche kt
@@ -407,5 +407,5 @@
 //++
 template <class T>
-void SphereThetaPhi<T>::Phi(int_4 kt,int_4 jp,r_4& phiMin,r_4& phiMax) 
+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
@@ -413,5 +413,5 @@
 {
   // verification
-  if( (kt< 0) || (kt>= 2*NTheta_) ) {
+  if((kt < 0) || (kt >= 2*NTheta_)) {
     phiMin= -99999.; 
     phiMax= -99999.; 
@@ -420,5 +420,5 @@
   
   // si on se trouve dans l'hemisphere Sud
-  if( kt >= NTheta_ ) kt= 2*NTheta_-1-kt;
+  if(kt >= NTheta_) kt= 2*NTheta_-1-kt;
   
   // verifie si la tranche kt contient au moins jp pixels
@@ -429,7 +429,7 @@
   }
   
-  r_4 dphi= (r_4)DeuxPi/(r_4)NPhi_[kt];
-  phiMin= dphi*(r_4)(jp);
-  phiMax= dphi*(r_4)(jp+1);
+  double dphi= DeuxPi/(double)NPhi_[kt];
+  phiMin= dphi*(double)(jp);
+  phiMax= dphi*(double)(jp+1);
   return;
 }
@@ -438,14 +438,14 @@
 //++
 template <class T>
-int_4 SphereThetaPhi<T>::Index(int_4 kt,int_4 jp) const
+int SphereThetaPhi<T>::Index(int kt,int jp) const
 
 //    Retourne l'indice du pixel d'indice jp dans la tranche kt 
 //--
 {
-  int_4 k;
+  int k;
   bool fgzn= false;
   
   // si on se trouve dans l'hemisphere Sud
-  if( kt >= NTheta_ ) {
+  if(kt >= NTheta_) {
     fgzn= true; 
     kt= 2*NTheta_-1-kt;
@@ -471,5 +471,5 @@
 //++
 template <class T>
-void SphereThetaPhi<T>::ThetaPhiIndex(int_4 k,int_4& kt,int_4& jp) 
+void SphereThetaPhi<T>::ThetaPhiIndex(int k,int& kt,int& jp) 
 
 //    Retourne les indices kt et jp du pixel d'indice k
@@ -478,13 +478,14 @@
   bool fgzn= false;  
   // si on se trouve dans l'hemisphere Sud
-  if( k >= NPix_/2 ) { 
-    fgzn= true; 
-    k= NPix_-1-k; 
-  }
+  if(k >= NPix_/2) 
+    { 
+      fgzn= true; 
+      k= NPix_-1-k; 
+    }
   
   // on recupere l'indice kt de la tranche qui contient le pixel k
   int i;
-  for( i=0; i< NTheta_; i++ ) 
-    if( k< TNphi_[i+1] ) break;
+  for(i = 0; i < NTheta_; i++) 
+    if(k < TNphi_[i+1]) break;
   
   // indice  kt de tranche
@@ -494,10 +495,9 @@
   // indice jp de pixel
   if (fgzn) jp= TNphi_[i+1]-k-1;
-  else jp= k-TNphi_[i];
-  
-}
-//++
-template <class T>
-void  SphereThetaPhi<T>::Pixelize( int_4 m) 
+  else jp= k-TNphi_[i];  
+}
+//++
+template <class T>
+void  SphereThetaPhi<T>::Pixelize(int m) 
 
 //    effectue le découpage en pixels (m et pet ont la même signification 
@@ -511,5 +511,5 @@
 //--
 {
-  int_4 ntotpix,i,j;
+  int ntotpix,i,j;
   
   // Decodage et controle des arguments d'appel :
@@ -524,12 +524,12 @@
   // Creation des vecteurs contenant :
   // Les valeurs limites de theta (une valeur de plus que le nombre de bandes...)
-  Theta_= new r_4[m+1];
+  Theta_= new double[m+1];
   
   // Le nombre de pixels en phi de chacune des bandes en theta
-  NPhi_ = new int_4[m];
+  NPhi_ = new int[m];
   
   // Le nombre/Deuxpi total des pixels contenus dans les bandes de z superieur a une
   // bande donnee (mTPphi[m] contient le nombre de pixels total de l'hemisphere)
-  TNphi_= new int_4[m+1];
+  TNphi_= new int[m+1];
   
   // Calcul du nombre total de pixels dans chaque bande pour optimiser
@@ -544,5 +544,5 @@
     {
       TNphi_[j]= TNphi_[j-1]+NPhi_[j-1];
-      NPhi_[j] = (int_4)(.5+4.*(double)(m-.5)*sin(Pi*(double)j/(double)(2.*m-1.))) ;
+      NPhi_[j] = (int)(.5+4.*(double)(m-.5)*sin(Pi*(double)j/(double)(2.*m-1.))) ;
     }
   
@@ -576,5 +576,5 @@
 //++
 template <class T>
-void  SphereThetaPhi<T>::GetThetaSlice(int_4 index, r_4& theta, TVector<float>& phi, TVector<T>& value) const 
+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 
@@ -594,6 +594,6 @@
     }
 
-  int_4 iring= Index(index,0);
-  int_4 bid  = this->NPhi(index);
+  int iring= Index(index,0);
+  int bid  = this->NPhi(index);
   int lring  = bid;
   cout << " iring= " << iring << " lring= " << lring << endl;
@@ -601,6 +601,6 @@
   phi.ReSize(lring);
   value.ReSize(lring);
-  float Te= 0.;
-  float Fi= 0.;
+  double Te= 0.;
+  double Fi= 0.;
   for(int kk = 0; kk < lring; kk++) 
     {
@@ -613,32 +613,32 @@
 
 template <class T>
-void SphereThetaPhi<T>::setmNPhi(int_4* array, int_4 m)
-  //remplit  le tableau contenant le nombre de pixels en phi de chacune des bandes en theta 
+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_4[m];
+  NPhi_= new int[m];
   for(int k = 0; k < m; k++) NPhi_[k]= array[k];
 }
 
 template <class T>
-void SphereThetaPhi<T>::setmTNphi(int_4* array, int_4 m)
+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_4[m];
+  TNphi_= new int[m];
   for(int k = 0; k < m; k++) TNphi_[k]= array[k];
 }
 
 template <class T>
-void SphereThetaPhi<T>::setmTheta(r_4* array, int_4 m)
+void SphereThetaPhi<T>::setmTheta(double* array, int m)
   //remplit  le tableau contenant les valeurs limites de theta
   //--
 {
-  Theta_= new r_4[m];
+  Theta_= new double[m];
   for(int k = 0; k < m; k++) Theta_[k]= array[k];
 }
 
 template <class T>
-void SphereThetaPhi<T>::setDataBlock(T* data, int_4 m)
+void SphereThetaPhi<T>::setDataBlock(T* data, int m)
   // remplit  le vecteur des contenus des pixels 
 {
@@ -755,33 +755,32 @@
     }
 
-  int_4 mNTheta;
+  int mNTheta;
   is.GetI4(mNTheta);  
   dobj->setSizeIndex(mNTheta);
 
-  int_4 mNPix;
+  int mNPix;
   is.GetI4(mNPix);
   dobj->setNbPixels(mNPix);
 
-  r_8 mOmeg;
+  double mOmeg;
   is.GetR8(mOmeg);
   dobj->setPixSolAngle(mOmeg);
 
-  int_4* mNphi= new int_4[mNTheta];
+  int* mNphi= new int[mNTheta];
   is.GetI4s(mNphi, mNTheta);
   dobj->setmNPhi(mNphi, mNTheta);
   delete [] mNphi;
 
-  int_4* mTNphi= new int_4[mNTheta+1];
+  int* mTNphi= new int[mNTheta+1];
   is.GetI4s(mTNphi, mNTheta+1);
   dobj->setmTNphi(mTNphi, mNTheta+1);
   delete [] mTNphi;
 
-  r_4* mTheta= new r_4[mNTheta+1];
-  is.GetR4s(mTheta, mNTheta+1);
+  double* mTheta= new double[mNTheta+1];
+  is.GetR8s(mTheta, mNTheta+1);
   dobj->setmTheta(mTheta, mNTheta+1);
   delete [] mTheta;
 
   T* mPixels= new T[mNPix];
-  //is.Get(mPixels, mNPix);
   PIOSReadArray(is, mPixels, mNPix);
   dobj->setDataBlock(mPixels, mNPix);
@@ -801,6 +800,6 @@
 
   char strg[256];
-  int_4 mNTheta= dobj->SizeIndex();
-  int_4 mNPix  = dobj->NbPixels();
+  int mNTheta= dobj->SizeIndex();
+  int mNPix  = dobj->NbPixels();
  
   if(dobj->ptrInfo()) 
@@ -821,5 +820,5 @@
   os.PutI4s(dobj->getmNPhi() , mNTheta);
   os.PutI4s(dobj->getmTNphi(), mNTheta+1);
-  os.PutR4s(dobj->getmTheta(), mNTheta+1);
+  os.PutR8s(dobj->getmTheta(), mNTheta+1);
   //os.Put((dobj->getDataBlock())->Data(), mNPix);
   PIOSWriteArray(os,(dobj->getDataBlock())->Data(), mNPix);
Index: /trunk/SophyaLib/Samba/spherethetaphi.h
===================================================================
--- /trunk/SophyaLib/Samba/spherethetaphi.h	(revision 472)
+++ /trunk/SophyaLib/Samba/spherethetaphi.h	(revision 473)
@@ -18,5 +18,5 @@
 
 SphereThetaPhi();
-SphereThetaPhi(int_4 m);
+SphereThetaPhi(int m);
 SphereThetaPhi(char* flnm);
 SphereThetaPhi(const SphereThetaPhi<T>& s);
@@ -26,73 +26,73 @@
 
 /* retourne/fixe le nombre de pixels */ 
-virtual int_4 NbPixels() const;
-inline void setNbPixels(int_4 nbpix) { NPix_= nbpix; }
+virtual int NbPixels() const;
+inline void setNbPixels(int nbpix) { NPix_= nbpix; }
 
 /* retourne la valeur du pixel d'indice k */ 
-virtual T&       PixVal(int_4 k);
-virtual T const& PixVal(int_4 k) const;
+virtual T&       PixVal(int k);
+virtual T const& PixVal(int k) const;
 
 /* retourne l'indice du pixel a (theta,phi) */ 
-virtual int_4 PixIndexSph(float theta, float phi) const;
+virtual int PixIndexSph(double theta, double phi) const;
 
 /* retourne les coordonnees Spheriques du centre du pixel d'indice k */ 
-virtual void PixThetaPhi(int_4 k, float& theta, float& phi) const;
+virtual void PixThetaPhi(int k, double& theta, double& phi) const;
 
 /* retourne/fixe l'angle Solide de Pixel   (steradians) */ 
-virtual r_8 PixSolAngle(int_4 dummy) const;
-inline void setPixSolAngle(r_8 omega) { Omega_= omega; }
+virtual double PixSolAngle(int dummy) const;
+inline void setPixSolAngle(double omega) { Omega_= omega; }
  
 /* retourne/fixe la valeur du parametre de decoupage m */ 
-inline virtual int_4 SizeIndex() const { return( NTheta_); }
-inline void setSizeIndex(int_4 nbindex) { NTheta_= nbindex; }
+inline virtual int SizeIndex() const { return( NTheta_); }
+inline void setSizeIndex(int nbindex) { NTheta_= nbindex; }
 
 // ------------- Specific methods  ----------------------
 
-virtual void Resize(int_4 m);
+virtual void Resize(int m);
 
 inline virtual char* TypeOfMap() const {return "TETAFI";};
 
-/* Valeurs de theta des paralleles et phi des meridiens limitant  le pixel d'indice k */
-virtual void Limits(int_4 k,float& tet1,float& tet2,float& phi1,float& phi2);
+/* Valeurs de theta des paralleles et phi des meridiens limitant le pixel d'indice k */
+virtual void Limits(int k,double& th1,double& th2,double& phi1,double& phi2);
 
 /* Nombre de tranches en theta */ 
-int_4 NbThetaSlices() const;
+int NbThetaSlices() const;
 
 /* Nombre de pixels en phi de la tranche d'indice kt */ 
-int_4 NPhi(int_4 kt) const;
+int NPhi(int kt) const;
 
 /* Renvoie dans t1,t2 les valeurs respectives de theta min et theta max  */
 /* de la tranche d'indice kt  */ 
-void Theta(int_4 kt, float& t1, float& t2);
+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  */ 
-void Phi(int_4 kt, int_4 jp, float& p1, float& p2);
+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   */
-int_4 Index(int_4 kt, int_4 jp) const;
+int Index(int kt, int jp) const;
 
 /* Indice kt de la tranche et indice jp du pixel d'indice k  */ 
-void ThetaPhiIndex(int_4 k,int_4& kt,int_4& jp);
+void ThetaPhiIndex(int k,int& kt,int& jp);
 
-void Pixelize(int_4); 
+void Pixelize(int); 
 
-void GetThetaSlice(int_4 index,r_4& theta,TVector<float>& phi,TVector<T>& value) const; 
+void GetThetaSlice(int index,double& theta,TVector<double>& phi,TVector<T>& value) const; 
 
 /*retourne le tableau contenant le nombre de pixels en phi de chacune des bandes en theta */
-inline const int_4* getmNPhi() const { return(NPhi_); }
-void setmNPhi(int_4* array, int_4 m);
+inline const int* getmNPhi() const { return(NPhi_); }
+void setmNPhi(int* array, int m);
 
 /* retourne/remplit le tableau contenant le nombre/Deuxpi total des pixels contenus dans les bandes */
-inline const int_4* getmTNphi() const { return(TNphi_); }
-void setmTNphi(int_4* array, int_4 m);
+inline const int* getmTNphi() const { return(TNphi_); }
+void setmTNphi(int* array, int m);
 
 /* retourne/remplit le tableau contenant les valeurs limites de theta */
-inline const r_4* getmTheta() const { return(Theta_); }
-void setmTheta(r_4* array, int_4 m);
+inline const double* getmTheta() const { return(Theta_); }
+void setmTheta(double* array, int m);
 
 /* retourne le pointeur vers/remplit  le vecteur des contenus des pixels */ 
 inline const NDataBlock<T>* getDataBlock() const { return (&pixels_); }
-void setDataBlock(T* data, int_4 m);
+void setDataBlock(T* data, int m);
 
 /* impression */ 
@@ -106,10 +106,10 @@
 
 // ------------- variables internes ---------------------
-int_4 NTheta_;
-int_4 NPix_;
-r_8 Omega_;
-int_4* NPhi_;
-int_4* TNphi_;
-r_4* Theta_;
+int NTheta_;
+int NPix_;
+double Omega_;
+int* NPhi_;
+int* TNphi_;
+double* Theta_;
 NDataBlock<T> pixels_;
 };
Index: /trunk/SophyaLib/Samba/sphericalmap.h
===================================================================
--- /trunk/SophyaLib/Samba/sphericalmap.h	(revision 472)
+++ /trunk/SophyaLib/Samba/sphericalmap.h	(revision 473)
@@ -27,14 +27,14 @@
 
 // Overloading of () to access pixel number k.
-inline T& operator()(int_4 k) {return(PixVal(k));}
-inline T  const& operator()(int_4 k) const {return(PixVal(k));}
-inline T& operator()(float theta,float phi) {return(PixValSph(theta,phi));};
-inline T  const& operator()(float theta,float phi) const {return(PixValSph(theta,phi));};
+inline T& operator()(int k) {return(PixVal(k));}
+inline T  const& operator()(int k) const {return(PixVal(k));}
+inline T& operator()(double theta,double phi) {return(PixValSph(theta,phi));};
+inline T  const& operator()(double theta,double phi) const {return(PixValSph(theta,phi));};
 
 // index characterizing the size pixelization : m for SphereThetaPhi
 // nside for Gorski sphere...
-virtual void Resize(int_4 m)=0;
-virtual int_4 NbThetaSlices() const=0;
-virtual void GetThetaSlice(int_4 index, r_4& theta, TVector<float>& phi, TVector<T>& value) const=0; 
+virtual void Resize(int m)=0;
+virtual int NbThetaSlices() const=0;
+virtual void GetThetaSlice(int index,double& theta, TVector<double>& phi, TVector<T>& value) const=0; 
 };
 #endif
