tbl_val.h

/*
 *  Definition of Lorene class Tbl_val
 *
 */
 
/*
 *   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 __TBL_VAL_H_
#define __TBL_VAL_H_
 
/*
 * $Id: tbl_val.h,v 1.12 2014/10/13 08:52:37 j_novak Exp $
 * $Log: tbl_val.h,v $
 * Revision 1.12  2014/10/13 08:52:37  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.11  2014/10/06 15:09:40  j_novak
 * Modified #include directives to use c++ syntax.
 *
 * Revision 1.10  2012/01/17 10:21:31  j_penner
 * function added: Heaviside
 *
 * Revision 1.9  2010/04/14 11:45:24  j_novak
 * Changed comments
 *
 * Revision 1.8  2007/11/02 15:45:56  j_novak
 * Added an ugly method "append_array", which substitutes the argument to the
 * main array t.
 *
 * 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/11/26 17:02:18  j_novak
 * Added a function giving a smooth transition to the atmosphere.
 *
 * Revision 1.5  2004/03/22 13:12:43  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/11/12 10:03:53  j_novak
 * The method "Tbl_val::get_gval" has been changed to "get_grid".
 *
 * Revision 1.2  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.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/tbl_val.h,v 1.12 2014/10/13 08:52:37 j_novak Exp $
 *
 */
 
// Fichiers includes
#include <cassert>
#include <cstdlib>
 
#include "grille_val.h"
#include "tensor.h"
 
namespace Lorene {
class Grille_val ; 

class Tbl_val {
 
  // Data : 
  // -----
 private:
  int etat ;
  const Dim_tbl* dim ;
  const Grille_val* gval ;  
  
 public:
  double* t ;       
  double* tzri ;    
  double* txti ;    
  double* typi ;    
  
  // Constructors - Destructor
  // -------------------------
  
 public:
  explicit Tbl_val(const Grille_val* ) ; 
  explicit Tbl_val(const Grille_val*, FILE* ) ; 
  Tbl_val(const Tbl_val& ) ;        
  
  ~Tbl_val() ;          
  
  // Assignement
  // -----------
  void operator=(const Tbl_val& ) ; 
  void operator=(double ) ; 
  void operator=(int ) ;     
 
  // Memory management
  // -----------------
 private:
  void del_t() ;        
  
 public:
  
  void set_etat_nondef() ;  
  
  void set_etat_zero() ;            
  
  void set_etat_qcq() ;         
    
  void append_array(double* t_in) ;

  void annule_hard() ;          
  
  // Access to individual elements
  // -----------------------------
 public:
  double& set(int i) {
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 1 ) ;
    int fant = gval->get_fantome() ; 
    assert( i >= - fant) ; 
    assert( i < dim->dim[0] + fant) ;
    return t[i + fant] ;
  } ;
  
  double& set_zri(int i) {
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 1 ) ; 
    int fant = gval->get_fantome() ; 
    assert( i >= -fant ) ; 
    assert( i < dim->dim[0] + fant + 1) ;
    return tzri[i+fant] ;
  } ;
  
  double operator()(int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 1 ) ; 
    int fant = gval->get_fantome() ; 
    assert( i >= -fant ) ; 
    assert( i < dim->dim[0] + fant ) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return t[i+fant] ;
  };
  
  double get_zri(int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 1 ) ; 
    int fant = gval->get_fantome() ; 
    assert( i >= -fant ) ; 
    assert( i < dim->dim[0] + fant +1) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return tzri[i+fant] ;
  };
  
  double& set(int j, int i) {
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 2 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0]+fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1]+fant) ) ;
    return t[(dim->dim[0] +2*fant)* (j+fant) + i + fant] ;
  };

  double& set_xti(int j, int i) {
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 2 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0]+fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1]+fant+1) ) ;
    return txti[(dim->dim[0] +2*fant)*(j+fant) + i + fant] ;
  };
  
  double& set_zri(int j, int i) {
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 2 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant+1) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    return tzri[(dim->dim[0] +2*fant+1)*(j+fant) + i + fant] ;
  };
  
  double operator()(int j, int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 2 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return t[(dim->dim[0] + 2*fant) *(j+fant) + i + fant] ;
  };
  
  double get_xti(int j, int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 2 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant + 1) ) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return txti[(dim->dim[0] + 2*fant) *(j+fant) + i + fant] ;
  };
  
  double get_zri(int j, int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 2 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant + 1) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return tzri[(dim->dim[0] + 2*fant + 1) *(j+fant) + i + fant] ;
  };
  
  double& set(int k, int j, int i) {    
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 3 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
    return t[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant)*(k+fant) + 
        (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
  };
  
  double& set_ypi(int k, int j, int i) {    
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 3 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    assert( (k>=-fant) && (k<dim->dim[2] + fant + 1) ) ;
    return typi[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant)*(k+fant) + 
          (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
  };

  double& set_xti(int k, int j, int i) {    
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 3 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant + 1) ) ;
    assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
    return txti[(dim->dim[1]+2*fant+1)*(dim->dim[0]+2*fant)*(k+fant) + 
          (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
  };

  double& set_zri(int k, int j, int i) {    
    assert (etat == ETATQCQ) ;
    assert( dim->ndim == 3 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant + 1) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
    return tzri[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant+1)*(k+fant) + 
          (dim->dim[0]+2*fant+1)*(j+fant) + i +fant] ;
  };
  
  double operator()(int k, int j, int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 3 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return t[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant)*(k+fant) 
         + (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
  };

  double get_ypi(int k, int j, int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 3 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    assert( (k>=-fant) && (k<dim->dim[2] + fant + 1) ) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return typi[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant)*(k+fant) 
           + (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
  };
  
  double get_xti(int k, int j, int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 3 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant + 1) ) ;
    assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return txti[(dim->dim[1]+2*fant+1)*(dim->dim[0]+2*fant)*(k+fant) 
           + (dim->dim[0]+2*fant)*(j+fant) + i +fant] ;
  };
  
  double get_zri(int k, int j, int i) const {
    assert(etat != ETATNONDEF) ;
    assert( dim->ndim == 3 ) ;
    int fant = gval->get_fantome() ; 
    assert( (i>=-fant) && (i<dim->dim[0] + fant + 1) ) ;
    assert( (j>=-fant) && (j<dim->dim[1] + fant) ) ;
    assert( (k>=-fant) && (k<dim->dim[2] + fant) ) ;
    if (etat == ETATZERO) {
      double zero = 0. ;
      return zero ; 
    }
    else return tzri[(dim->dim[1]+2*fant)*(dim->dim[0]+2*fant+1)*(k+fant) 
           + (dim->dim[0]+2*fant+1)*(j+fant) + i +fant] ;
  };
 
  // Extraction of information
  // -------------------------
  int get_etat() const { return etat ; };       
  
  int get_taille() const { 
    int resu = 1 ;
    for (int i=0; i<dim->ndim; i++) 
      resu *= dim->dim[i] + 2*(gval->get_fantome()) ;
    return resu ; }; 
  
  int get_taille_i(int i) const {
    assert (i<dim->ndim) ; 
    int resu = 1 ;
    for (int j=0; j<dim->ndim; j++) 
      if (j!=i) {
    resu *= dim->dim[j] + 2*gval->get_fantome() ;
      }
      else {
    resu *= dim->dim[j] + 2*gval->get_fantome() + 1 ;
      }
    return resu ; }; 
  
  int get_ndim() const { return dim->ndim ; };  
  
  int get_dim(int i) const {    
    assert( (i>=0) && (i<dim->ndim) ) ;
    return dim->dim[i] ;
  };

  const Grille_val* get_grille() const { return gval ; } ;
  
  // Outputs
  // -------
 public:
  void sauve(FILE* ) const ;    
  
  void affiche_seuil(ostream& ostr, int precision = 4, 
             double threshold = 1.e-7) const ;
  friend ostream& operator<<(ostream& , const Tbl_val& ) ;  
  
  // Member arithmetics
  // ------------------
 public:
  
  void operator+=(const Tbl_val &) ;    
  void operator+=(double) ; 
  void operator-=(const Tbl_val &) ;    
  void operator-=(double) ; 
  void operator*=(const Tbl_val &) ;    
  void operator*=(double) ; 
  void operator/=(const Tbl_val &) ;    
  void operator/=(double) ; 

  Scalar to_spectral(const Map& map, const int lmax, const int lmin=0, 
              int type_inter = 2) const ;
  
  void from_spectral(const Scalar& meudon, int lmax, int lmin=0,
             bool interfr = false, bool interft = false) ;
 
 
  void smooth_atmosphere(double atmosphere_thr) ;
} ;
 


Tbl_val operator+(const Tbl_val&) ;         
Tbl_val operator-(const Tbl_val&) ;         
Tbl_val operator+(const Tbl_val&, const Tbl_val&) ; 
Tbl_val operator+(const Tbl_val&, double) ;     
Tbl_val operator+(double, const Tbl_val&) ;     
Tbl_val operator+(const Tbl_val&, int) ;        
Tbl_val operator+(int, const Tbl_val&) ;        
Tbl_val operator-(const Tbl_val&, const Tbl_val&) ; 
Tbl_val operator-(const Tbl_val&, double) ;     
Tbl_val operator-(double, const Tbl_val&) ;     
Tbl_val operator-(const Tbl_val&, int) ;        
Tbl_val operator-(int, const Tbl_val&) ;        
Tbl_val operator*(const Tbl_val&, const Tbl_val&) ; 
Tbl_val operator*(const Tbl_val&, double) ;     
Tbl_val operator*(double, const Tbl_val&) ;     
Tbl_val operator*(const Tbl_val&, int) ;        
Tbl_val operator*(int, const Tbl_val&) ;        
Tbl_val operator/(const Tbl_val&, const Tbl_val&) ; 
Tbl_val operator/(const Tbl_val&, double) ;     
Tbl_val operator/(double, const Tbl_val&) ;     
Tbl_val operator/(const Tbl_val&, int) ;        
Tbl_val operator/(int, const Tbl_val&) ;        

Tbl_val sin(const Tbl_val& ) ;      
Tbl_val cos(const Tbl_val& ) ;      
Tbl_val tan(const Tbl_val& ) ;      
Tbl_val asin(const Tbl_val& ) ;     
Tbl_val acos(const Tbl_val& ) ;     
Tbl_val atan(const Tbl_val& ) ;     
Tbl_val exp(const Tbl_val& ) ;      
Tbl_val Heaviside(const Tbl_val& ) ;        
Tbl_val log(const Tbl_val& ) ;      
Tbl_val log10(const Tbl_val& ) ;    
Tbl_val sqrt(const Tbl_val& ) ;     
Tbl_val racine_cubique (const Tbl_val&) ; 
Tbl_val pow(const Tbl_val& , int ) ;  
Tbl_val pow(const Tbl_val& , double ) ; 
Tbl_val abs(const Tbl_val& ) ;      
double max(const Tbl_val& ) ;   
double min(const Tbl_val& ) ;   

double norme(const Tbl_val& ) ;   

double diffrel(const Tbl_val& a, const Tbl_val& b) ; 

double diffrelmax(const Tbl_val& a, const Tbl_val& b) ; 

 
}
#endif