Index: trunk/SophyaLib/Samba/spherethetaphi.cc
===================================================================
--- trunk/SophyaLib/Samba/spherethetaphi.cc	(revision 470)
+++ 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);
