map_star_radius.C

 /*
 *  Methods of the class Map_star relative to the function
 *      r = R_l(xi, theta', phi')
 */

/*
 *   Copyright (c) 2023 Gael Servignat
 *
 *   This file is part of LORENE.
 *
 *   LORENE is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   LORENE is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with LORENE; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

// Headers Lorene
#include "map.h"

            //------------------------------// 
            //         val_r            //
            //------------------------------// 

 
namespace Lorene {
double Map_star::val_r(int l, double xi, double theta, double pphi) const {

    assert( l>=0 ) ; 
    assert( l<mg->get_nzone() ) ; 
    
    double resu ; 

    switch( mg->get_type_r(l) ) {

    case RARE: {
        resu = alpha.val_point(l, xi, theta, pphi) * xi ;
        break ;
    }
    
    case FIN: {
        resu = alpha.val_point(l, xi, theta, pphi)*xi + beta.val_point(l, xi, theta, pphi) ;
        break ;
    }


    case UNSURR: {
        cout << "Map_star::val_r : Compactified domain not allowed !" << endl;
        abort() ;
        break ;
    }

    default: {
        cout << "Map_star::val_r: unknown type_r ! " << endl ;
        abort () ;
    }      
    }
             
    return resu ;    
}
            
            //------------------------------// 
            //           val_lx         //
            //------------------------------// 

void Map_star::val_lx(double rr, double theta, double pphi, int& lz, double& xi) const {
               
    // In which domain is located r ? 
    // ----------------------------
    int nz = mg->get_nzone() ;
    lz = - 1 ;
    
    for (int l=0; l<nz; l++) {
      double rmin = 0. ;
      double rmax = 0. ; 

      if (mg->get_type_r(l) == RARE){
        rmin = 0. ;
        rmax = alpha.val_point(l,1.,theta,pphi) ;
      }
      if (mg->get_type_r(l) == FIN) {
    rmin = beta.val_point(l,1.,theta,pphi) - alpha.val_point(l,1,theta,pphi) ;
    rmax = beta.val_point(l,1.,theta,pphi) + alpha.val_point(l,1,theta,pphi) ;
      }
      if ((rr - rmin >= -1.e-14*fabs(rmin)) && ( rr <= rmax )) { 
    lz = l ;
    break ; 
      } 
    }       // fin de la boucle sur les zones
    
    if (lz == -1) {         // On n'a pas trouve la zone 
    cout.precision(16);
    cout.setf(ios::showpoint);
    cout << "Map_star::val_lx: the domain containing r = " << rr <<
         " has not been found ! " 
          << endl ;
    abort () ;
    }

    // Computation of xi
    // ----------------- 

    switch( mg->get_type_r(lz) ) {

    case RARE: {
        xi = rr / alpha.val_point(lz,1.,theta,pphi)  ;
        break ;
    }
    
    case FIN: {
        xi = (rr-beta.val_point(lz,1.,theta,pphi))/alpha.val_point(lz,1.,theta,pphi) ;
        break ;
    }


    case UNSURR: {
        cout << "Map_star::val_lx : Compactified domain not allowed !" << endl;
        abort() ;
        break ;
    }

    default: {
        cout << "Map_star::val_lx: unknown type_r ! " << endl ;
        abort () ;
    }      
    }

} 


void Map_star::val_lx(double rr, double theta, double pphi, const Param&,  
                int& lz, double& xi) const {

    val_lx(rr, theta, pphi, lz, xi) ;

}


            //------------------------------// 
            //      val_r_jk                //
            //------------------------------// 

 
double Map_star::val_r_jk(int l, double xi, int j, int k) const {

  assert( l>=0 ) ; 
  assert( l<mg->get_nzone() ) ; 
  
  if (tet.c == 0x0)
    tet.fait() ;
  if (phi.c == 0x0)
    phi.fait() ;

  double resu ; 
  
  switch( mg->get_type_r(l) ) {

  case RARE: {
    resu = alpha(l, k, j, 0) * xi ; 
    break ;
  }
    
  case FIN: {
    resu = alpha(l, k, j, 0)*xi + beta(l, k, j, 0) ; 
    break ;
  }

  case UNSURR: {
    cout << "Map_star::val_r : Compactified domain not allowed !" << endl;
    abort() ;
    break ;
  }

  default: {
    cout << "Map_star::val_r: unknown type_r ! " << endl ;
    abort () ;
  }    
  }
             
  return resu ;       
}
            
            //------------------------------// 
            //      val_lx_jk           //
            //------------------------------// 

void Map_star::val_lx_jk(double rr, int j, int k, const Param&,
                int& lz, double& xi) const {

  if (tet.c == 0x0)
    tet.fait() ;
  if (phi.c == 0x0)
    phi.fait() ;

  // In which domain is located r ? 
  // ----------------------------
  int nz = mg->get_nzone() ;
  lz = - 1 ;
    
  for (int l=0; l<nz; l++) {
    double rmin = 0. ;
    double rmax = 0. ; 
    
    if (mg->get_type_r(l) == RARE){
      rmin = 0. ;
      rmax = alpha(l,k, j, 0) ;
    }
    if (mg->get_type_r(l) == FIN) {
      rmin = beta(l, k, j, 0) - alpha(l, k, j, 0) ; 
      rmax = beta(l, k, j, 0) + alpha(l, k, j, 0) ; 
    }
    if ((rr - rmin >= -1.e-14*fabs(rmin)) && ( rr <= rmax )) { 
      lz = l ;
      break ; 
    }   
  }     // fin de la boucle sur les zones
    
  if (lz == -1) {           // On n'a pas trouve la zone 
    cout.precision(16);
    cout.setf(ios::showpoint);
    cout << "Map_star::val_lx: the domain containing r = " << rr <<
      " has not been found ! " 
     << endl ;
    for (int l=0; l<nz; l++) {
      double rmin = beta(l, k, j, 0) - alpha(l, k, j, 0) ;
      if (mg->get_type_r(l) == RARE) rmin = 0. ;
      cout << "domain " << l << " :  r_min = " << rmin ; 
      double rmax = beta(l, k, j, 0) + alpha(l, k, j, 0) ;; //alpha[l] + beta[l] ;  
      cout << " :  r_max = " << rmax << endl ; 
    }
    abort () ;
  }

  // Computation of xi
  // ----------------- 

  switch( mg->get_type_r(lz) ) {

  case RARE: {
    xi = rr / alpha(lz, k, j, 0) ; 
    break ;
  }
    
  case FIN: {
    xi = (rr - beta(lz, k, j, 0)) / alpha(lz, k, j, 0) ; 
    break ;
  }
    
  case UNSURR: {
    cout << "Map_star::val_lx : Compactified domain not allowed !" << endl;
    abort() ;
    break ;
  }
  default: {
    cout << "Map_star::val_lx: unknown type_r ! " << endl ;
    abort () ;
  }    
  }

} 


}