grille_val.h

/*
 *  Definition of Lorene class Grille_val, Gval_cart and Gval_spher
 *
 */

/*
 *   Copyright (c) 2001 Jerome Novak
 *
 *   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
 *
 */


#ifndef __GRILLE_VAL_H_
#define __GRILLE_VAL_H_

/*
 * $Id: grille_val.h,v 1.11 2014/10/13 08:52:35 j_novak Exp $
 * $Log: grille_val.h,v $
 * Revision 1.11  2014/10/13 08:52:35  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.10  2014/10/06 15:09:39  j_novak
 * Modified #include directives to use c++ syntax.
 *
 * Revision 1.9  2008/02/18 13:53:37  j_novak
 * Removal of special indentation instructions.
 *
 * Revision 1.8  2007/11/02 16:49:12  j_novak
 * Suppression of intermediate array for spectral summation.
 *
 * Revision 1.7  2005/06/22 09:09:38  lm_lin
 *
 * Grid wedding: convert from the old C++ object "Cmp" to "Scalar".
 *
 * Revision 1.6  2004/05/07 12:32:12  j_novak
 * New summation from spectral to FD grid. Much faster!
 *
 * Revision 1.5  2004/03/22 13:12:41  j_novak
 * Modification of comments to use doxygen instead of doc++
 *
 * Revision 1.4  2002/11/13 11:22:57  j_novak
 * Version "provisoire" de l'interpolation (sommation depuis la grille
 * spectrale) aux interfaces de la grille de Valence.
 *
 * Revision 1.3  2002/10/16 14:36:29  j_novak
 * Reorganization of #include instructions of standard C++, in order to
 * use experimental version 3 of gcc.
 *
 * Revision 1.2  2002/06/17 14:05:16  j_novak
 * friend functions are now also declared outside the class definition
 *
 * Revision 1.1  2001/11/22 13:38:09  j_novak
 * added Include files for Valencia objects: tbl_val.h and grille_val.h
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/grille_val.h,v 1.11 2014/10/13 08:52:35 j_novak Exp $
 *
 */


#include <cassert>
#include <cmath>
#include "tensor.h"

namespace Lorene {
class Grille_val {
  friend class Tbl_val ;
  
  // Data : 
  // -----
 protected:
  Dim_tbl dim ;
  int nfantome ;
  int type_t ;
  int type_p ;

  double *zrmin;

  double *zrmax ;
  
 public:
  Tbl *zr;
  Tbl *zri ;

  // Constructors - Destructor
  // -------------------------
 protected: 
  Tbl* fait_grille1D(const double rmin, const double rmax, const int n) ;

  Grille_val(const double, const double, const int n1,
         const int fantome = 2) ; 
  
  Grille_val(const double, const double, const int n2, const int n1, 
         const int itype_t, const int fantome = 2) ; 

  Grille_val(const double, const double, const int n3, const int n2, const
         int n1, const int itype_t, const int itype_p, const int
         fantome = 2); 
  

  Grille_val(const Grille_val& ) ;      
  
  Grille_val(FILE* ) ;          
  
  virtual ~Grille_val() ;           
  
  // Mutators / assignment
  // ---------------------
 public:

  void operator=(const Grille_val&) ;   
  
  // Accessors
  // ---------
 public:
  int get_fantome() const {
    return nfantome ;
  } ;
  
  int get_type_t() const {
    return type_t ;
  } ;
  
  int get_type_p() const {
    return type_p ;
  } ;
  
  int get_ndim() const {
    return dim.ndim ;
  } ;
  
  int get_dim(const int i) const {
    assert ( (i>=0) && (i<dim.ndim) ) ;
    return dim.dim[i] ;
  } ;
  
  const Dim_tbl* get_dim_tbl() const {
    return &dim ;
  } ;

  double get_zr(const int i) const {
    assert (i>= -nfantome) ;
    assert (i<dim.dim[0]+nfantome) ;
    
    return zr->t[i+nfantome] ;
  } ;
  
  double get_zri(const int i) const {
    assert (i>= -nfantome) ;
    assert (i<dim.dim[0]+nfantome+1) ;
    
    return zri->t[i+nfantome] ;
  } ;
  
  
  // Outputs
  // -------
 public:
  virtual void sauve(FILE *) const ;        
  
  friend ostream& operator<<(ostream& , const Grille_val& ) ;   

 protected:
  virtual ostream& operator>>(ostream& ) const ;    
  
  // Interpolation
  // -------------
 public:
  virtual bool compatible(const Map* mp, const int lmax, const int lmin=0) 
    const = 0 ;

  Tbl interpol1(const Tbl& rdep, const Tbl& rarr, const Tbl& fdep, 
           int flag, const int type_inter) const ;

  virtual Tbl interpol2(const Tbl& fdep, const Tbl& rarr, 
               const Tbl& tetarr, const int type_inter) const = 0 ;
  virtual Tbl interpol3(const Tbl& fdep, const Tbl& rarr, 
               const Tbl& tetarr, const Tbl& phiarr, 
               const int type_inter) const = 0 ;

  virtual bool contenue_dans(const Map& mp, const int lmax, const int lmin=0) 
    const = 0 ;

 protected:
  void somme_spectrale1(const Scalar& meudon, double* t, int taille) const ;

  virtual void somme_spectrale2(const Scalar& meudon, double* t, int taille) const = 0 ;

  virtual void somme_spectrale3(const Scalar& meudon, double* t, int taille) const = 0 ;
  
};
ostream& operator<<(ostream& , const Grille_val& ) ;    


            //------------------------------------//
            //      class Gval_cart       //
            //------------------------------------//

class Gval_cart : public Grille_val {
  friend class Tbl_val ;

  // Data : 
  // -----
 protected:
  double *xmin ;
  double *xmax ;
  double *ymin ;
  double *ymax ;
  
 public:
  Tbl *x ;
  Tbl *xi ;
  Tbl *y ; 
  Tbl *yi ;

  // Constructors - Destructor
  // -------------------------

  Gval_cart(const double izmin, const double izmax, const int n1,
        const int fantome = 2) ; 
  
  Gval_cart(const double ixmin, const double ixmax, const double izmin, 
        const double izmax, const int nx, const int nz, const int type_t, 
        const int fantome = 2) ; 

  Gval_cart(const double iymin, const double iymax, const double ixmin, 
        const double ixmax, const double izmin, const double izmax, 
        const int ny, const int nx, const int nz, const int itype_t, 
        const int itype_p, const int fantome = 2); 
  
  Gval_cart(const Gval_cart& ) ;        
  
  Gval_cart(FILE* ) ;           
  
  virtual ~Gval_cart() ;            
  
  // Mutators / assignment
  // ---------------------
 public:

  void operator=(const Gval_cart&) ;    
  
  // Accessors
  // ---------
 public:
  double get_x(const int i) const {
    assert (i>= -nfantome) ;
    assert (i<dim.dim[1]+nfantome) ;
    assert (dim.ndim >= 2) ;
    
    return (*x)(i+nfantome) ;
  } ;
  
  double get_y(const int i) const {
    assert (i>= -nfantome) ;
    assert (i<dim.dim[2]+nfantome) ;
    assert (dim.ndim == 3) ;
    
    return (*y)(i+nfantome) ;
  } ;
  
  double get_xi(const int i) const {
    assert (i>= -nfantome) ;
    assert (i<dim.dim[1]+nfantome+1) ;
    assert (dim.ndim >= 2) ;
    
    return (*xi)(i+nfantome) ;
  } ;
  
  double get_yi(const int i) const {
    assert (i>= -nfantome) ;
    assert (i<dim.dim[2]+nfantome+1) ;
    assert (dim.ndim == 3) ;
    
    return (*yi)(i+nfantome) ;
  } ;   
  
  double get_xmin() const {
    return *xmin ;
  } ;
  
  double get_xmax() const {
    return *xmax ;
  } ;
  
  double get_ymin() const {
    return *ymin ;
  } ;

  double get_ymax() const {
    return *ymax ;
  } ;
  
  // Outputs
  // -------
 public:
  virtual void sauve(FILE *) const ;        
  
 protected:
  virtual ostream& operator>>(ostream& ) const ;    
  
  // Interpolation
  // -------------
 public:
  virtual bool compatible(const Map* mp, const int lmax, const int lmin=0) 
    const ;

  virtual Tbl interpol2(const Tbl& fdep, const Tbl& rarr, 
               const Tbl& tetarr, const int type_inter) const ;

  Tbl interpol2c(const Tbl& xdep, const Tbl& zdep, const Tbl& fdep, 
        const Tbl& rarr, const Tbl& tetarr, 
        const int type_inter) const ;
  virtual Tbl interpol3(const Tbl& fdep, const Tbl& rarr, 
               const Tbl& tetarr, const Tbl& phiarr, 
               const int type_inter) const ;
  virtual bool contenue_dans(const Map& mp, const int lmax, const int lmin=0) 
    const ;

 protected:
  virtual void somme_spectrale2(const Scalar& meudon, double* t, int taille) const  ;

  virtual void somme_spectrale3(const Scalar& meudon, double* t, int taille) const  ;
};

            //------------------------------------//
            //      class Gval_spher          //
            //------------------------------------//

class Gval_spher : public Grille_val {
  friend class Tbl_val ;
  
  // Data : 
  // -----
 public:
  Tbl *tet ;
  Tbl *teti ;
  Tbl *phi ;
  Tbl *phii ;

  // Constructors - Destructor
  // -------------------------

  Gval_spher(const double irmin, const double irmax, const int nr,
         const int fantome = 2) ; 
  
  Gval_spher(const double irmin, const double irmax, const int nt, const 
         int nr, const int type_t, const int fantome = 2) ; 

  Gval_spher(const double irmin, const double irmax, const int np, const 
         int nt, const int nr, const int itype_t, const int itype_p, 
         const int fantome = 2); 
  
  Gval_spher(const Gval_spher& ) ;      
  
  Gval_spher(FILE* ) ;          
  
  virtual ~Gval_spher() ;           
  
  // Mutators / assignment
  // ---------------------
 public:

  void operator=(const Gval_spher&) ;   
  
  // Accessors
  // ---------
 public:

  double get_tet(const int i) const {
    assert (i>= -nfantome) ;
    assert (dim.ndim >= 2) ;
    assert (i<dim.dim[1]+nfantome) ;
    
    return tet->t[i+nfantome] ;
  } ;
  
  double get_phi(const int i) const {
    assert (i>= -nfantome) ;
    assert (dim.ndim == 3) ;
    assert (i<dim.dim[2]+nfantome) ;
    
    return phi->t[i+nfantome] ;
  } ;
  
  double get_teti(const int i) const {
    assert (i>= -nfantome) ;
    assert (dim.ndim >= 2) ;
    assert (i<dim.dim[1]+nfantome+1) ;
    
    return teti->t[i+nfantome] ;
  } ;
  
  double get_phii(const int i) const {
    assert (i>= -nfantome) ;
    assert (dim.ndim == 3) ;
    assert (i<dim.dim[2]+nfantome+1) ;
    
    return phii->t[i+nfantome] ;
  } ;   
  
  // Outputs
  // -------
 public:
  virtual void sauve(FILE *) const ;        
  
 protected:
  virtual ostream& operator>>(ostream& ) const ;    
  
  // Interpolation
  // -------------
 public:
  virtual bool compatible(const Map* mp, const int lmax, const int lmin=0) 
    const ;

  virtual Tbl interpol2(const Tbl& fdep, const Tbl& rarr, const Tbl& tetarr, 
               const int type_inter) const ;
 virtual Tbl interpol3(const Tbl& fdep, const Tbl& rarr, const Tbl& tetarr, 
               const Tbl& phiarr, const int type_inter) const ;

 virtual bool contenue_dans(const Map& mp, const int lmax, const int lmin=0) 
    const ;

 protected:
  virtual void somme_spectrale2(const Scalar& meudon, double* t, int taille) const  ;

  double* somme_spectrale2ri(const Scalar& meudon) const ;

  double* somme_spectrale2ti(const Scalar& meudon) const ;

  virtual void somme_spectrale3(const Scalar& meudon, double* t, int taille) const  ;

  void initialize_spectral_r(const Map& mp, const Base_val& base, int*& idom, 
                 double*& chebnri) const ;
  void initialize_spectral_theta(const Map& mp, const Base_val& base, 
                 double*& tetlj) const ;
  void initialize_spectral_phi(const Map& mp, const Base_val& base,
                   double*& expmk) const ;

 };

}
#endif