Index: trunk/SophyaLib/Samba/spherethetaphi.h
===================================================================
--- trunk/SophyaLib/Samba/spherethetaphi.h	(revision 604)
+++ trunk/SophyaLib/Samba/spherethetaphi.h	(revision 682)
@@ -31,5 +31,5 @@
     pet is a dummy parameter at the moment. 
 */
-SphereThetaPhi(int m);
+SphereThetaPhi(int_4 m);
 SphereThetaPhi(const SphereThetaPhi<T>& s, bool share=false);
 virtual ~SphereThetaPhi();
@@ -39,11 +39,11 @@
 /* retourne/fixe le nombre de pixels */ 
 /*!    Return total number of pixels  */
-virtual int NbPixels() const;
-inline void setNbPixels(int nbpix) { NPix_= nbpix; }
+virtual int_4 NbPixels() const;
+inline void setNbPixels(int_4 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;
+virtual T&       PixVal(int_4 k);
+virtual T const& PixVal(int_4 k) const;
 
 /* Return true if teta,phi in map  */
@@ -51,9 +51,9 @@
 /* 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;
+virtual int_4 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;
+virtual void PixThetaPhi(int_4 k, double& theta, double& phi) const;
 
 /*! Setting pixel values to a constant */
@@ -67,15 +67,15 @@
     fulfil this requirement.
 */
-virtual double PixSolAngle(int dummy) const;
+virtual double PixSolAngle(int_4 dummy) const;
 inline void setPixSolAngle(double omega) { Omega_= omega; }
  
 /* retourne/fixe la valeur du parametre de decoupage m */ 
-inline virtual int SizeIndex() const { return( NTheta_); }
-inline void setSizeIndex(int nbindex) { NTheta_= nbindex; }
+inline virtual int_4 SizeIndex() const { return( NTheta_); }
+inline void setSizeIndex(int_4 nbindex) { NTheta_= nbindex; }
 
 // ------------- Specific methods  ----------------------
 
 /*!   re-pixelize the sphere */
-virtual void Resize(int m);
+virtual void Resize(int_4 m);
 
 inline virtual char* TypeOfMap() const {return "TETAFI";};
@@ -83,30 +83,30 @@
 /* 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);
+virtual void Limits(int_4 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;
+int_4 NbThetaSlices() const;
 
 /* Nombre de pixels en phi de la tranche d'indice kt */ 
-int NPhi(int kt) const;
+int_4 NPhi(int_4 kt) const;
 
 /* 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);
+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 kt, int jp, double& p1, double& p2);
+void Phi(int_4 kt, int_4 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;
+int_4 Index(int_4 kt, int_4 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);
+void ThetaPhiIndex(int_4 k,int_4& kt,int_4& jp);
 
 /*!    achieve the splitting into pixels (m has the same signification 
@@ -121,5 +121,5 @@
     phi of the slice closest of the equator with z<0).
 */
-void Pixelize(int); 
+void Pixelize(int_4); 
 
 /*!   For a theta-slice with index 'index', return : 
@@ -131,21 +131,21 @@
     a vector containing the corresponding values of pixels 
 */
-void GetThetaSlice(int index,double& theta,TVector<double>& phi,TVector<T>& value) const; 
+void GetThetaSlice(int_4 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* getmNPhi() const { return(NPhi_); }
-void setmNPhi(int* array, int m);
+inline const int_4* getmNPhi() const { return(NPhi_); }
+void setmNPhi(int_4* array, int_4 m);
 
 /* retourne/remplit le tableau contenant le nombre/Deuxpi total des pixels contenus dans les bandes */
-inline const int* getmTNphi() const { return(TNphi_); }
-void setmTNphi(int* array, int m);
+inline const int_4* getmTNphi() const { return(TNphi_); }
+void setmTNphi(int_4* array, int_4 m);
 
 /* retourne/remplit le tableau contenant les valeurs limites de theta */
 inline const double* getmTheta() const { return(Theta_); }
-void setmTheta(double* array, int m);
+void setmTheta(double* array, int_4 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 m);
+void setDataBlock(T* data, int_4 m);
 
 /*  Acces to the DataBlock  */
@@ -163,9 +163,9 @@
 
 // ------------- variables internes ---------------------
-int NTheta_;
-int NPix_;
+int_4 NTheta_;
+int_4 NPix_;
 double Omega_;
-int* NPhi_;
-int* TNphi_;
+int_4* NPhi_;
+int_4* TNphi_;
 double* Theta_;
 NDataBlock<T> pixels_;
