map.h

/*
 *  Definition of Lorene classes Map
 *               Map_radial
 *               Map_af
 *               Map_et
 *                               Map_log
 *
 */

/*
 *   Copyright (c) 1999-2000 Jean-Alain Marck
 *   Copyright (c) 1999-2003 Eric Gourgoulhon
 *   Copyright (c) 1999-2001 Philippe Grandclement
 *   Copyright (c) 2000-2001 Jerome Novak
 *   Copyright (c) 2000-2001 Keisuke Taniguchi
 *
 *   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 __MAP_H_ 
#define __MAP_H_ 

/*
 * $Id: map.h,v 1.56 2012/01/24 14:58:54 j_novak Exp $
 * $Log: map.h,v $
 * Revision 1.56  2012/01/24 14:58:54  j_novak
 * Removed functions XXX_fait_xi()
 *
 * Revision 1.55  2012/01/17 15:34:20  j_penner
 * *** empty log message ***
 *
 * Revision 1.54  2012/01/17 10:20:07  j_penner
 * added a member cxi that allows for direct access to the computational coordinates in each domain
 *
 * Revision 1.53  2008/09/29 13:23:51  j_novak
 * Implementation of the angular mapping associated with an affine
 * mapping. Things must be improved to take into account the domain index.
 *
 * Revision 1.52  2007/10/16 21:52:10  e_gourgoulhon
 * Added method poisson_compact for multi-domains.
 *
 * Revision 1.51  2007/05/15 12:44:18  p_grandclement
 * Scalar version of reevaluate
 *
 * Revision 1.50  2007/05/06 10:48:08  p_grandclement
 * Modification of a few operators for the vorton project
 *
 * Revision 1.49  2007/01/16 15:05:59  n_vasset
 * New constructor (taking a Scalar in mono-domain angular grid for
 * boundary) for function sol_elliptic_boundary
 *
 * Revision 1.48  2006/08/31 12:10:51  j_novak
 * More comments for Map_af::avance_dalembert().
 *
 * Revision 1.47  2006/05/26 09:00:09  j_novak
 * New members for multiplication or division by cos(theta).
 *
 * Revision 1.46  2006/04/25 07:21:54  p_grandclement
 * Various changes for the NS_BH project
 *
 * Revision 1.45  2005/11/30 11:09:03  p_grandclement
 * Changes for the Bin_ns_bh project
 *
 * Revision 1.44  2005/11/24 09:25:06  j_novak
 * Added the Scalar version for the Laplacian
 *
 * Revision 1.43  2005/09/15 15:51:25  j_novak
 * The "rotation" (change of triad) methods take now Scalars as default
 * arguments.
 *
 * Revision 1.42  2005/08/26 14:02:38  p_grandclement
 * Modification of the elliptic solver that matches with an oscillatory exterior solution
 * small correction in Poisson tau also...
 *
 * Revision 1.41  2005/08/25 12:14:07  p_grandclement
 * Addition of a new method to solve the scalar Poisson equation, based on a multi-domain Tau-method
 *
 * Revision 1.40  2005/06/09 07:56:24  f_limousin
 * Implement a new function sol_elliptic_boundary() and
 * Vector::poisson_boundary(...) which solve the vectorial poisson
 * equation (method 6) with an inner boundary condition.
 *
 * Revision 1.39  2005/04/04 21:30:41  e_gourgoulhon
 *  Added argument lambda to method poisson_angu
 *  to treat the generalized angular Poisson equation:
 *     Lap_ang u + lambda u = source.
 *
 * Revision 1.38  2004/12/29 16:37:22  k_taniguchi
 * Addition of some functions with the multipole falloff condition.
 *
 * Revision 1.37  2004/12/02 09:33:04  p_grandclement
 * *** empty log message ***
 *
 * Revision 1.36  2004/11/30 20:42:05  k_taniguchi
 * Addition of some functions with the falloff condition and a method
 * to resize the external shell.
 *
 * Revision 1.35  2004/11/23 12:39:12  f_limousin
 * Intoduce function poisson_dir_neu(...) to solve a scalar poisson
 * equation with a mixed boundary condition (Dirichlet + Neumann).
 *
 * Revision 1.34  2004/10/11 15:08:59  j_novak
 * The radial manipulation functions take Scalar as arguments, instead of Cmp.
 * Added a conversion operator from Scalar to Cmp.
 * The Cmp radial manipulation function make conversion to Scalar, call to the
 * Map_radial version with a Scalar argument and back.
 *
 * Revision 1.33  2004/10/08 13:34:35  j_novak
 * Scalar::div_r() does not need to pass through Cmp version anymore.
 *
 * Revision 1.32  2004/08/24 09:14:40  p_grandclement
 * Addition of some new operators, like Poisson in 2d... It now requieres the
 * GSL library to work.
 *
 * Also, the way a variable change is stored by a Param_elliptic is changed and
 * no longer uses Change_var but rather 2 Scalars. The codes using that feature
 * will requiere some modification. (It should concern only the ones about monopoles)
 *
 * Revision 1.31  2004/07/27 08:24:26  j_novak
 * Modif. comments
 *
 * Revision 1.30  2004/07/26 16:02:21  j_novak
 * Added a flag to specify whether the primitive should be zero either at r=0
 * or at r going to infinity.
 *
 * Revision 1.29  2004/06/22 08:49:57  p_grandclement
 * Addition of everything needed for using the logarithmic mapping
 *
 * Revision 1.28  2004/06/14 15:23:53  e_gourgoulhon
 * Added virtual function primr for computation of radial primitives.
 *
 * Revision 1.27  2004/03/31 11:22:23  f_limousin
 * Methods Map_et::poisson_interne and Map_af::poisson_interne have been
 * implemented to solve the continuity equation for strange stars.
 *
 * Revision 1.26  2004/03/22 13:12:41  j_novak
 * Modification of comments to use doxygen instead of doc++
 *
 * Revision 1.24  2004/03/01 09:57:02  j_novak
 * the wave equation is solved with Scalars. It now accepts a grid with a
 * compactified external domain, which the solver ignores and where it copies
 * the values of the field from one time-step to the next.
 *
 * Revision 1.23  2004/02/11 09:47:44  p_grandclement
 * Addition of a new elliptic solver, matching with the homogeneous solution
 * at the outer shell and not solving in the external domain (more details
 * coming soon ; check your local Lorene dealer...)
 *
 * Revision 1.22  2004/01/29 08:50:01  p_grandclement
 * Modification of Map::operator==(const Map&) and addition of the surface
 * integrales using Scalar.
 *
 * Revision 1.21  2004/01/28 16:46:22  p_grandclement
 * Addition of the sol_elliptic_fixe_der_zero stuff
 *
 * Revision 1.20  2004/01/28 10:35:52  j_novak
 * Added new methods mult_r() for Scalars. These do not change the dzpuis flag.
 *
 * Revision 1.19  2004/01/27 09:33:46  j_novak
 * New method Map_radial::div_r_zec
 *
 * Revision 1.18  2004/01/26 16:16:15  j_novak
 * Methods of gradient for Scalar s. The input can have any dzpuis.
 *
 * Revision 1.17  2004/01/19 21:38:21  e_gourgoulhon
 * Corrected sign error in comments of Map_radial::dxdr.
 *
 * Revision 1.16  2003/12/30 22:52:47  e_gourgoulhon
 * Class Map: added methods flat_met_spher() and flat_met_cart() to get
 * flat metric associated with the coordinates described by the mapping.
 *
 * Revision 1.15  2003/12/11 14:48:47  p_grandclement
 * Addition of ALL (and that is a lot !) the files needed for the general elliptic solver ... UNDER DEVELOPEMENT...
 *
 * Revision 1.14  2003/11/06 14:43:37  e_gourgoulhon
 * Gave a name to const arguments in certain method prototypes (e.g.
 * constructors) to correct a bug of DOC++.
 *
 * Revision 1.13  2003/11/04 22:54:49  e_gourgoulhon
 * Added new virtual methods mult_cost, mult_sint and div_sint.
 *
 * Revision 1.12  2003/10/16 08:49:21  j_novak
 * Added a flag to decide wether the output is in the Ylm or in the standard base.
 *
 * Revision 1.11  2003/10/15 21:08:22  e_gourgoulhon
 * Added method poisson_angu.
 *
 * Revision 1.10  2003/10/15 16:03:35  j_novak
 * Added the angular Laplace operator for Scalar.
 *
 * Revision 1.9  2003/10/15 10:27:33  e_gourgoulhon
 * Classes Map, Map_af and Map_et: added new methods dsdt, stdsdp and div_tant.
 * Class Map_radial: added new Coord's : drdt and stdrdp.
 *
 * Revision 1.8  2003/06/20 14:14:53  f_limousin
 * Add the operator== to compare two Cmp.
 *
 * Revision 1.7  2003/06/20 09:27:09  j_novak
 * Modif commentaires.
 *
 * Revision 1.6  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.5  2002/09/13 09:17:33  j_novak
 * Modif. commentaires
 *
 * Revision 1.4  2002/06/17 14:05:16  j_novak
 * friend functions are now also declared outside the class definition
 *
 * Revision 1.3  2002/05/07 07:06:37  e_gourgoulhon
 * Compatibily with xlC compiler on IBM SP2:
 *   added declaration of functions map_af_fait_* and map_et_fait_*
 *   outside the classes declarations.
 *
 * Revision 1.2  2002/01/15 15:53:06  p_grandclement
 * I have had a constructor fot map_et using the equation of the surface
 * of the star.
 *
 * Revision 1.1.1.1  2001/11/20 15:19:27  e_gourgoulhon
 * LORENE
 *
 * Revision 2.110  2001/10/29  15:31:55  novak
 * Ajout de Map_radial::div_r
 *
 * Revision 2.109  2001/10/16 10:02:49  novak
 * *** empty log message ***
 *
 * Revision 2.108  2001/07/19 14:01:00  novak
 * new arguments for Map_af::dalembert
 *
 * Revision 2.107  2001/02/26 17:28:31  eric
 * Ajout de la fonction virtuelle resize.
 *
 * Revision 2.106  2001/01/10  11:03:00  phil
 * ajout de homothetie interne
 *
 * Revision 2.105  2001/01/02  10:51:55  phil
 * ajout integrale de surface a l'infini
 *
 * Revision 2.104  2000/10/23  13:59:48  eric
 * Map_et::adapt: changement des arguments (en autre, ajout de nz_search).
 *
 * Revision 2.103  2000/10/20  09:39:19  phil
 * changement commentaires
 *
 * Revision 2.102  2000/10/19  14:33:23  novak
 * corrige oubli pour Map_et?
 *
 * Revision 2.101  2000/10/19 14:11:20  novak
 * Ajout des fonctions membres Map::dalembert et Map_af::dalembert
 * (etat experimental)
 *
 * Revision 2.100  2000/10/09  13:46:39  eric
 * Ajout de la fonction virtuelle poisson2d.
 *
 * Revision 2.99  2000/09/19  15:28:55  phil
 * *** empty log message ***
 *
 * Revision 2.98  2000/09/19  15:24:19  phil
 * ajout du passage de cartesienne en spheriques
 *
 * Revision 2.97  2000/09/19  13:05:38  phil
 * ajout integrale_surface
 *
 * Revision 2.96  2000/09/11  15:54:03  eric
 * Suppression des methodes deriv_x, deriv_y et deriv_z.
 * Introduction des methodes comp_x_from_spherical, etc...
 *
 * Revision 2.95  2000/09/07  15:27:58  keisuke
 * Add a new argument Cmp& uu in Map_af::poisson_regular and Map_et::poisson_regular.
 *
 * Revision 2.94  2000/09/04  15:30:56  keisuke
 * Modify the arguments of Map_af::poisson_regular and Map_et::poisson_regular.
 *
 * Revision 2.93  2000/09/04  13:36:19  keisuke
 * Modify the explanation for "uu_div" in Map_et::poisson_regular.
 *
 * Revision 2.92  2000/08/31  15:50:12  keisuke
 * Modify Map_af::poisson_regular.
 * Add Map_et::poisson_regular and Map::poisson_regular.
 *
 * Revision 2.91  2000/08/31  13:03:22  eric
 * Ajout de la fonction virtuelle mult_rsint.
 *
 * Revision 2.90  2000/08/28  16:17:37  keisuke
 * Add "int nzet" in the argumant of Map_af::poisson_regular.
 *
 * Revision 2.89  2000/08/18  11:10:12  eric
 * Classe Map_et: ajout de l'operateur d'affectation a un autre Map_et.
 *
 * Revision 2.88  2000/08/11  08:50:18  keisuke
 * Modif Map_af::poisson_regular
 *
 * Revision 2.87  2000/08/10  12:54:00  keisuke
 * Ajout de Map_af::poisson_regular
 *
 * Revision 2.86  2000/07/20  14:21:07  eric
 * Ajout de la fonction div_rsint.
 *
 * Revision 2.85  2000/05/25  13:54:41  eric
 * Modif commentaires
 *
 * Revision 2.84  2000/05/22  14:38:51  phil
 * ajout de inc_dzpuis et dec_dzpuis
 *
 * Revision 2.83  2000/04/27  15:18:54  phil
 * *** empty log message ***
 *
 * Revision 2.82  2000/03/20  13:33:23  phil
 * commentaires
 *
 * Revision 2.81  2000/03/17  17:32:48  phil
 * *** empty log message ***
 *
 * Revision 2.80  2000/03/17  17:01:54  phil
 * *** empty log message ***
 *
 * Revision 2.79  2000/03/17  16:58:48  phil
 * ajout de poisson_frontiere
 *
 * Revision 2.78  2000/03/06  11:29:51  eric
 * Ajout du membre reeavaluate_symy.
 *
 * Revision 2.77  2000/02/15  15:08:21  eric
 * Changement du Param dans Map_et::adapt : fact_echelle est desormais
 * passe en double_mod.
 *
 * Revision 2.76  2000/02/15  10:26:25  phil
 * commentaire +
 * suppression de poisson_vect et poisson_vect_oohara
 *
 * Revision 2.75  2000/02/11  13:37:43  eric
 * Ajout de la fonction convert_absolute.
 *
 * Revision 2.74  2000/02/09  09:53:37  phil
 * ajout de poisson_vect_oohara
 *
 * Revision 2.73  2000/01/26  13:07:02  eric
 * Reprototypage complet des routines de derivation:
 *  le resultat est desormais suppose alloue a l'exterieur de la routine
 *  et est passe en argument (Cmp& resu), si bien que le prototypage
 *  complet devient:
 *      void DERIV(const Cmp& ci, Cmp& resu)
 *
 * Revision 2.72  2000/01/24  17:08:21  eric
 * Class Map_af : suppression de la fonction convert.
 *                suppression du constructeur par convertion d'un Map_et.
 *                ajout du constructeur par conversion d'un Map.
 *
 * Revision 2.71  2000/01/24  16:41:43  eric
 * Ajout de la fonction virtuelle operator=(const Map_af& ).
 * Classe Map_af : ajout de la fonction convert(const Map& ).
 *
 * Revision 2.70  2000/01/21  12:48:34  phil
 * changement prototypage de Map::poisson_vect
 *
 * Revision 2.69  2000/01/20  16:35:05  phil
 * *** empty log message ***
 *
 * Revision 2.68  2000/01/20  15:44:42  phil
 * *** empty log message ***
 *
 * Revision 2.67  2000/01/20  15:31:56  phil
 * *** empty log message ***
 *
 * Revision 2.66  2000/01/20  14:18:06  phil
 * *** empty log message ***
 *
 * Revision 2.65  2000/01/20  13:16:34  phil
 * *** empty log message ***
 *
 * Revision 2.64  2000/01/20  12:51:24  phil
 * *** empty log message ***
 *
 * Revision 2.63  2000/01/20  12:45:28  phil
 * *** empty log message ***
 *
 * Revision 2.62  2000/01/20  12:40:27  phil
 * *** empty log message ***
 *
 * Revision 2.61  2000/01/20  11:27:54  phil
 * ajout de poisson_vect
 *
 * Revision 2.60  2000/01/13  15:31:55  eric
 * Modif commentaires/
 *
 * Revision 2.59  2000/01/12  16:02:57  eric
 * Modif commentaires poisson_compact.
 *
 * Revision 2.58  2000/01/12  12:54:23  eric
 * Ajout du Cmp null, *p_cmp_zero, et de la methode associee cmp_zero().
 *
 * Revision 2.57  2000/01/10  13:27:43  eric
 * Ajout des bases vectorielles associees aux coordonnees :
 *  membres bvect_spher et bvect_cart.
 *
 * Revision 2.56  2000/01/10  09:12:47  eric
 * Reprototypage de poisson_compact : Valeur -> Cmp, Tenseur.
 * Suppression de poisson_compact_boucle.
 * poisson_compact est desormais implementee au niveau Map_radial.
 *
 * Revision 2.55  2000/01/04  15:23:11  eric
 * Classe Map_radial : les data sont listees en premier
 * Introduction de la fonction reevalutate.
 *
 * Revision 2.54  2000/01/03  13:30:32  eric
 * Ajout de la fonction adapt.
 *
 * Revision 2.53  1999/12/22  17:09:52  eric
 * Modif commentaires.
 *
 * Revision 2.52  1999/12/21  16:26:25  eric
 * Ajout du constructeur par conversion Map_af::Map_af(const Map_et&).
 * Ajout des fonctions Map_af::set_alpha et Map_af::set_beta.
 *
 * Revision 2.51  1999/12/21  13:01:29  eric
 * Changement de prototype de la routine poisson : la solution est
 *  desormais passee en argument (et non plus en valeur de retour)
 *  pour permettre l'initialisation de methodes de resolution iterative.
 *
 * Revision 2.50  1999/12/21  10:12:09  eric
 * Modif commentaires.
 *
 * Revision 2.49  1999/12/21  10:06:05  eric
 * Ajout de l'argument Param& a poisson.
 *
 * Revision 2.48  1999/12/20  15:44:35  eric
 * Modif commentaires.
 *
 * Revision 2.47  1999/12/20  10:47:45  eric
 * Modif commentaires.
 *
 * Revision 2.46  1999/12/20  10:24:12  eric
 * Ajout des fonctions de lecture des parametres de Map_et:
 *   get_alpha(), get_beta(), get_ff(), get_gg().
 *
 * Revision 2.45  1999/12/16  14:50:08  eric
 * Modif commentaires.
 *
 * Revision 2.44  1999/12/16  14:17:54  eric
 * Introduction de l'argument const Param& par dans val_lx et val_lx_jk.
 * (en remplacement de l'argument Tbl& param).
 *
 * Revision 2.43  1999/12/09  10:45:24  eric
 * Ajout de la fonction virtuelle integrale.
 *
 * Revision 2.42  1999/12/07  14:50:47  eric
 * Changement ordre des arguments val_r, val_lx
 * val_r_kj --> val_r_jk
 * val_lx_kj -->val_lx_jk
 *
 * Revision 2.41  1999/12/06  16:45:20  eric
 * Surcharge de val_lx avec la version sans param.
 *
 * Revision 2.40  1999/12/06  15:33:44  eric
 * Ajout des fonctions val_r_kj et val_lx_kj.
 *
 * Revision 2.39  1999/12/06  13:11:54  eric
 * Introduction des fonctions val_r, val_lx et homothetie.
 *
 * Revision 2.38  1999/12/02  14:28:22  eric
 * Reprototypage de la fonction poisson: Valeur -> Cmp.
 *
 * Revision 2.37  1999/11/30  14:19:33  eric
 * Reprototypage complet des fonctions membres mult_r, mult_r_zec,
 *  dec2_dzpuis et inc2_dzpuis : Valeur --> Cmp
 *
 * Revision 2.36  1999/11/29  13:17:57  eric
 * Modif commentaires.
 *
 * Revision 2.35  1999/11/29  12:55:42  eric
 * Changement prototype de la fonction laplacien : Valeur --> Cmp.
 *
 * Revision 2.34  1999/11/25  16:27:27  eric
 * Reorganisation complete du calcul des derivees partielles.
 *
 * Revision 2.33  1999/11/24  16:31:17  eric
 * Map_et: ajout des fonctions set_ff et set_gg.
 *
 * Revision 2.32  1999/11/24  14:31:48  eric
 * Map_af: les membres alpha et beta deviennent prives.
 * Map_af: introduction des fonctions get_alpha() et get_beta().
 *
 * Revision 2.31  1999/11/24  11:22:09  eric
 * Map_et : Coords rendus publics
 * Map_et : fonctions de constructions amies.
 *
 * Revision 2.30  1999/11/22  10:32:39  eric
 * Introduction de la classe Map_et.
 * Constructeurs de Map rendus protected.
 * Fonction del_coord() rebaptisee reset_coord().
 *
 * Revision 2.29  1999/10/27  16:44:41  phil
 * ajout de mult_r_zec
 *
 * Revision 2.28  1999/10/19  14:40:37  phil
 * ajout de inc2_dzpuis()
 *
 * Revision 2.27  1999/10/15  14:12:20  eric
 * *** empty log message ***
 *
 * Revision 2.26  1999/10/14  14:26:06  eric
 * Depoussierage.
 * Documentation.
 *
 * Revision 2.25  1999/10/11  11:16:29  phil
 * changement prototypage de poisson_compact_boucle
 *
 * Revision 2.24  1999/10/11  10:48:51  phil
 * changement de nom pour poisson a support compact
 *
 * Revision 2.23  1999/10/04  09:20:58  phil
 * changement de prototypage de void Map_af::poisson_nul
 *
 * Revision 2.22  1999/09/30  18:38:32  phil
 * *** empty log message ***
 *
 * Revision 2.21  1999/09/30  18:33:10  phil
 * ajout de poisson_nul et poisson_nul_boucle
 *
 * Revision 2.20  1999/09/30  16:45:54  phil
 * ajout de Map_af::poisson_nul(const Valeur&, int, int)
 *
 * Revision 2.19  1999/09/16  13:15:40  phil
 * ajout de Valeur mult_r (const Valeur &)
 *
 * Revision 2.18  1999/09/15  10:42:11  phil
 * ajout de Valeur dec2_dzpuis(const Valeur&)
 *
 * Revision 2.17  1999/09/14  13:45:45  phil
 * suppression de la divergence
 *
 * Revision 2.16  1999/09/13  15:09:07  phil
 * ajout de Map_af::divergence
 *
 * Revision 2.15  1999/09/13  13:52:23  phil
 * ajout des derivations partielles par rapport a x,y et z.
 *
 * Revision 2.14  1999/09/07  14:35:20  phil
 * ajout de la fonction Valeur** gradient(const Valeur&)
 *
 * Revision 2.13  1999/04/26  16:37:43  phil
 * *** empty log message ***
 *
 * Revision 2.12  1999/04/26  16:33:28  phil
 * *** empty log message ***
 *
 * Revision 2.11  1999/04/26  13:53:04  phil
 * *** empty log message ***
 *
 * Revision 2.10  1999/04/26  13:51:19  phil
 * ajout de Map_af::laplacien  (2versions)
 *
 * Revision 2.9  1999/04/14  09:04:01  phil
 * *** empty log message ***
 *
 * Revision 2.8  1999/04/14  08:53:27  phil
 * *** empty log message ***
 *
 * Revision 2.7  1999/04/13  17:45:25  phil
 * *** empty log message ***
 *
 * Revision 2.6  1999/04/13  17:02:41  phil
 * ,
 *
 * Revision 2.5  1999/04/13  17:00:41  phil
 * ajout de la resolution de poisson affine
 *
 * Revision 2.4  1999/03/04  13:10:53  eric
 * Ajout des Coord representant les derivees du changement de variable
 * dans la classe Map_radial.
 *
 * Revision 2.3  1999/03/01  17:00:38  eric
 * *** empty log message ***
 *
 * Revision 2.2  1999/03/01  16:44:41  eric
 * Operateurs << et >> sur les ostream.
 * L'operateur >> est virtuel.
 *
 * Revision 2.1  1999/02/22  15:21:45  hyc
 * *** empty log message ***
 *
 *
 * Revision 2.0  1999/01/15  09:10:39  hyc
 * *** empty log message ***
 *
 * $Header: /cvsroot/Lorene/C++/Include/map.h,v 1.56 2012/01/24 14:58:54 j_novak Exp $
 *
 */

#include <stdio.h>

#include "coord.h"
#include "base_vect.h"
#include "valeur.h"
#include "tbl.h"
#include "itbl.h"

class Scalar ;
class Cmp ;
class Param ; 
class Map_af ; 
class Map_et ; 
class Tenseur ;
class Param_elliptic ;
class Metric_flat ; 
class Tbl ;
class Itbl ;

            //------------------------------------//
            //            class Map               //
            //------------------------------------//

class Map {

    // Data : 
    // ----
    protected:
    const Mg3d* mg ; 
     
    double ori_x ;      
    double ori_y ;      
    double ori_z ;      
    double rot_phi ;    
    
    Base_vect_spher bvect_spher ; 

    Base_vect_cart bvect_cart ; 
    
        mutable Metric_flat* p_flat_met_spher ; 

        mutable Metric_flat* p_flat_met_cart ; 

    Cmp* p_cmp_zero ; 

    mutable Map_af* p_mp_angu ; 

    public:
    Coord r ;   
    Coord tet ; 
    Coord phi ; 
    Coord sint ;    
    Coord cost ;    
    Coord sinp ;    
    Coord cosp ;    

    Coord x ;   
    Coord y ;   
    Coord z ;   

    Coord xa ;  
    Coord ya ;  
    Coord za ;  
    

    // Constructors, destructor : 
    // ------------------------

    protected:
    explicit Map(const Mg3d& ) ;    
    Map(const Map &) ;      
    Map(const Mg3d&, FILE* ) ; 

    public: 
    virtual ~Map() ;        
    
    // Memory management
    // -----------------
    protected:
    virtual void reset_coord() ;  
    
    // Outputs
    // -------
    private:
    virtual ostream& operator>>(ostream &) const = 0 ;    

    public:
    virtual void sauve(FILE* ) const ;  
    

    // Extraction of information
    // -------------------------

    public:
    const Mg3d* get_mg() const {return mg; };

    double get_ori_x() const {return ori_x;} ; 
    double get_ori_y() const {return ori_y;} ; 
    double get_ori_z() const {return ori_z;} ; 

    double get_rot_phi() const {return rot_phi;} ; 
    
    const Base_vect_spher& get_bvect_spher() const {return bvect_spher;} ; 

    const Base_vect_cart& get_bvect_cart() const {return bvect_cart;} ; 

        const Metric_flat& flat_met_spher() const ; 

        const Metric_flat& flat_met_cart() const ; 

    const Cmp& cmp_zero() const {return *p_cmp_zero;} ; 

    virtual const Map_af& mp_angu(int) const = 0 ;
    
    void convert_absolute(double xx, double yy, double zz, 
                  double& rr, double& theta, double& pphi) const ; 

    virtual double val_r(int l, double xi, double theta, double pphi) 
                 const = 0 ; 
    
    virtual void val_lx(double rr, double theta, double pphi, 
                int& l, double& xi) const = 0 ; 
    
    virtual void val_lx(double rr, double theta, double pphi, 
                const Param& par, int& l, double& xi) const = 0 ;


    virtual bool operator==(const Map& ) const = 0;  

 
    
    // Modification of the origin, the orientation and the radial scale:
    // ----------------------------------------------------------------
    public:
    void set_ori(double xa0, double ya0, double za0) ;  
    void set_rot_phi(double phi0) ;     

    virtual void homothetie(double lambda) = 0 ;    

    virtual void resize(int l, double lambda) = 0 ; 

    // Modification of the mapping
    // ---------------------------
    public:
    virtual void operator=(const Map_af& ) = 0 ;

    virtual void adapt(const Cmp& ent, const Param& par, int nbr=0) = 0 ; 

    // Values of a Cmp at the new grid points
    // --------------------------------------

    virtual void reevaluate(const Map* mp_prev, int nzet, 
                Cmp& uu) const = 0 ; 

    virtual void reevaluate_symy(const Map* mp_prev, int nzet, 
                Cmp& uu) const = 0 ; 

    virtual void reevaluate(const Map* mp_prev, int nzet, 
                Scalar& uu) const = 0 ; 

    virtual void reevaluate_symy(const Map* mp_prev, int nzet, 
                Scalar& uu) const = 0 ; 

    // Differential operators:
    // ----------------------
    public:
    virtual void dsdxi(const Cmp& ci, Cmp& resu) const = 0 ;        

    virtual void dsdr(const Cmp& ci, Cmp& resu) const = 0 ;         

    virtual void srdsdt(const Cmp& ci, Cmp& resu) const = 0 ;       
    
    virtual void srstdsdp(const Cmp& ci, Cmp& resu) const = 0 ;         
    
    virtual void dsdxi(const Scalar& uu, Scalar& resu) const = 0 ;

    virtual void dsdr(const Scalar& uu, Scalar& resu) const = 0 ;   
    
    virtual void dsdradial(const Scalar& uu, Scalar& resu) const = 0 ;  

    virtual void srdsdt(const Scalar& uu, Scalar& resu) const = 0 ;         
    
    virtual void srstdsdp(const Scalar& uu, Scalar& resu) const = 0 ;       
    
    virtual void dsdt(const Scalar& uu, Scalar& resu) const = 0 ;       

    virtual void stdsdp(const Scalar& uu, Scalar& resu) const = 0 ;         

    virtual void laplacien(const Scalar& uu, int zec_mult_r, 
                   Scalar& lap) const = 0 ; 
    
    virtual void laplacien(const Cmp& uu, int zec_mult_r, 
                   Cmp& lap) const = 0 ; 
    
    virtual void lapang(const Scalar& uu, Scalar& lap) const = 0 ; 


    virtual void primr(const Scalar& uu, Scalar& resu, 
               bool null_infty) const = 0 ;         

     
    // Various linear operators
    // ------------------------
    public: 
    virtual void mult_r(Scalar& uu) const = 0 ; 

    virtual void mult_r(Cmp& ci) const = 0 ; 

    virtual void mult_r_zec(Scalar& ) const = 0 ;

    virtual void mult_rsint(Scalar& ) const = 0 ; 

    virtual void div_rsint(Scalar& ) const = 0 ; 

    virtual void div_r(Scalar& ) const = 0 ; 

    virtual void div_r_zec(Scalar& ) const = 0 ;

    virtual void mult_cost(Scalar& ) const = 0 ; 

    virtual void div_cost(Scalar& ) const = 0 ; 

    virtual void mult_sint(Scalar& ) const = 0 ; 

    virtual void div_sint(Scalar& ) const = 0 ; 

    virtual void div_tant(Scalar& ) const = 0 ; 

    virtual void comp_x_from_spherical(const Scalar& v_r, const Scalar& v_theta, 
                       const Scalar& v_phi, Scalar& v_x) const = 0 ; 
    virtual void comp_x_from_spherical(const Cmp& v_r, const Cmp& v_theta, 
                       const Cmp& v_phi, Cmp& v_x) const = 0 ; 

    virtual void comp_y_from_spherical(const Scalar& v_r, const Scalar& v_theta, 
                       const Scalar& v_phi, Scalar& v_y) const = 0 ; 
    
    virtual void comp_y_from_spherical(const Cmp& v_r, const Cmp& v_theta, 
                       const Cmp& v_phi, Cmp& v_y) const = 0 ; 
    
    virtual void comp_z_from_spherical(const Scalar& v_r, const Scalar& v_theta, 
                       Scalar& v_z) const = 0 ; 
    
    virtual void comp_z_from_spherical(const Cmp& v_r, const Cmp& v_theta, 
                       Cmp& v_z) const = 0 ; 
    
    virtual void comp_r_from_cartesian(const Scalar& v_x, const Scalar& v_y, 
                       const Scalar& v_z, Scalar& v_r) const = 0 ; 
    virtual void comp_r_from_cartesian(const Cmp& v_x, const Cmp& v_y, 
                       const Cmp& v_z, Cmp& v_r) const = 0 ; 
    
    virtual void comp_t_from_cartesian(const Scalar& v_x, const Scalar& v_y, 
                       const Scalar& v_z, Scalar& v_t) const = 0 ; 
    
    virtual void comp_t_from_cartesian(const Cmp& v_x, const Cmp& v_y, 
                       const Cmp& v_z, Cmp& v_t) const = 0 ; 
    
    virtual void comp_p_from_cartesian(const Scalar& v_x, const Scalar& v_y, 
                       Scalar& v_p) const = 0 ; 
    
    virtual void comp_p_from_cartesian(const Cmp& v_x, const Cmp& v_y, 
                       Cmp& v_p) const = 0 ; 
    
    virtual void dec_dzpuis(Scalar& ) const = 0 ; 
    
    virtual void dec2_dzpuis(Scalar& ) const = 0 ; 
    
    virtual void inc_dzpuis(Scalar& ) const = 0 ; 
    
    virtual void inc2_dzpuis(Scalar& ) const = 0 ; 
    
    virtual Tbl* integrale(const Cmp&) const = 0 ; 
    
    // PDE resolution :
    // --------------
    public:
    virtual void poisson(const Cmp& source, Param& par, Cmp& uu) const = 0 ;
    
    virtual void poisson_tau(const Cmp& source, Param& par, Cmp& uu) const = 0 ;
    
    virtual void poisson_falloff(const Cmp& source, Param& par, Cmp& uu,
                     int k_falloff) const = 0 ;

    virtual void poisson_ylm(const Cmp& source, Param& par, Cmp& pot,
                 int nylm, double* intvec) const = 0 ;

    virtual void poisson_regular(const Cmp& source, int k_div, int nzet,
                     double unsgam1, Param& par, Cmp& uu,
                     Cmp& uu_regu, Cmp& uu_div,
                     Tenseur& duu_div, Cmp& source_regu,
                     Cmp& source_div) const = 0 ;

    virtual void poisson_compact(const Cmp& source, const Cmp& aa, 
                     const Tenseur& bb, const Param& par, 
                     Cmp& psi) const = 0 ;

    virtual void poisson_compact(int nzet, const Cmp& source, const Cmp& aa, 
                     const Tenseur& bb, const Param& par, 
                     Cmp& psi) const = 0 ;

    virtual void poisson_angu(const Scalar& source, Param& par, 
                    Scalar& uu, double lambda=0) const = 0 ;

    
    public:
    virtual Param* donne_para_poisson_vect (Param& para, int i) const = 0;
    
    virtual void poisson_frontiere (const Cmp& source,const Valeur& limite,
                    int raccord, int num_front, Cmp& pot, 
                    double = 0., double = 0.) const = 0 ;
    
    virtual void poisson_frontiere_double (const Cmp& source, const Valeur& lim_func,
            const Valeur& lim_der, int num_zone, Cmp& pot) const = 0 ;
    

    virtual void poisson_interne (const Cmp& source, const Valeur& limite,
             Param& par, Cmp& pot) const = 0 ;


    virtual void poisson2d(const Cmp& source_mat, const Cmp& source_quad, 
                   Param& par, Cmp& uu) const = 0 ;

    virtual void dalembert(Param& par, Scalar& fJp1, const Scalar& fJ, 
                   const Scalar& fJm1, const Scalar& source) const = 0 ;

    // Friend functions : 
    // ----------------
    friend ostream& operator<<(ostream& , const Map& ) ;    
};
ostream& operator<<(ostream& , const Map& ) ; 



            //------------------------------------//
            //          class Map_radial          //
            //------------------------------------//



class Map_radial : public Map {

    // Data : 
    // ----

    // 0th order derivatives of the mapping
    // - - - - - - - - - - - - - - - - - - 
    public:
    Coord xsr ;     
    
    // 1st order derivatives of the mapping
    // - - - - - - - - - - - - - - - - - - 
    public:
    Coord dxdr ;        
    
    Coord drdt ; 

    Coord stdrdp ; 

    Coord srdrdt ;      

    Coord srstdrdp ;        

    Coord sr2drdt ;     
    
    Coord sr2stdrdp ;   

    // 2nd order derivatives of the mapping
    // - - - - - - - - - - - - - - - - - - 
    public:
    Coord d2rdx2 ;      
    
    Coord lapr_tp ;     
    

    Coord d2rdtdx ;     
    
    Coord sstd2rdpdx ;  


    Coord sr2d2rdt2 ;
    

    // Constructors, destructor : 
    // ------------------------

    protected:
    Map_radial(const Mg3d& mgrid ) ;            
    Map_radial(const Map_radial& mp) ;   
    Map_radial (const Mg3d&, FILE* ) ; 

    public: 
    virtual ~Map_radial() ;         

    // Memory management
    // -----------------
    protected:
    virtual void reset_coord() ;  
    // Modification of the mapping
    // ---------------------------
    public:
    virtual void operator=(const Map_af& ) = 0 ;
        
    // Outputs
    // -------
    public:  
    virtual void sauve(FILE* ) const ;  
   
    // Extraction of information
    // -------------------------
    virtual double val_r_jk(int l, double xi, int j, int k) const = 0 ; 
    
    virtual void val_lx_jk(double rr, int j, int k, const Param& par, 
                   int& l, double& xi) const = 0 ; 

    virtual bool operator==(const Map& ) const = 0;  

    // Values of a Cmp at the new grid points
    // --------------------------------------
    virtual void reevaluate(const Map* mp_prev, int nzet, Cmp& uu) const ; 

    virtual void reevaluate_symy(const Map* mp_prev, int nzet, Cmp& uu) 
                    const ; 
    
    virtual void reevaluate(const Map* mp_prev, int nzet, Scalar& uu) const ; 

    virtual void reevaluate_symy(const Map* mp_prev, int nzet, Scalar& uu) 
                    const ; 

    // Various linear operators
    // ------------------------
    public: 
    virtual void mult_r(Scalar& uu) const ; 

    virtual void mult_r(Cmp& ci) const ; 

    virtual void mult_r_zec(Scalar& ) const ;

    virtual void mult_rsint(Scalar& ) const ; 

    virtual void div_rsint(Scalar& ) const ; 

    virtual void div_r(Scalar& ) const ; 

    virtual void div_r_zec(Scalar& ) const ;

    virtual void mult_cost(Scalar& ) const ; 

    virtual void div_cost(Scalar& ) const  ; 

    virtual void mult_sint(Scalar& ) const ; 

    virtual void div_sint(Scalar& ) const  ; 

    virtual void div_tant(Scalar& ) const  ; 

    virtual void comp_x_from_spherical(const Scalar& v_r, const Scalar& v_theta, 
                       const Scalar& v_phi, Scalar& v_x) const ; 
    
    virtual void comp_x_from_spherical(const Cmp& v_r, const Cmp& v_theta, 
                       const Cmp& v_phi, Cmp& v_x) const ; 
    
    virtual void comp_y_from_spherical(const Scalar& v_r, const Scalar& v_theta, 
                       const Scalar& v_phi, Scalar& v_y) const ; 
    
    virtual void comp_y_from_spherical(const Cmp& v_r, const Cmp& v_theta, 
                       const Cmp& v_phi, Cmp& v_y) const ; 
    
    virtual void comp_z_from_spherical(const Scalar& v_r, const Scalar& v_theta, 
                       Scalar& v_z) const ; 
    
    virtual void comp_z_from_spherical(const Cmp& v_r, const Cmp& v_theta, 
                       Cmp& v_z) const ; 
    
    virtual void comp_r_from_cartesian(const Scalar& v_x, const Scalar& v_y, 
                       const Scalar& v_z, Scalar& v_r) const ; 
    
    virtual void comp_r_from_cartesian(const Cmp& v_x, const Cmp& v_y, 
                       const Cmp& v_z, Cmp& v_r) const ; 
    
    virtual void comp_t_from_cartesian(const Scalar& v_x, const Scalar& v_y, 
                       const Scalar& v_z, Scalar& v_t) const ; 
    
    virtual void comp_t_from_cartesian(const Cmp& v_x, const Cmp& v_y, 
                       const Cmp& v_z, Cmp& v_t) const ; 
    
    virtual void comp_p_from_cartesian(const Scalar& v_x, const Scalar& v_y, 
                       Scalar& v_p) const ; 
    
    virtual void comp_p_from_cartesian(const Cmp& v_x, const Cmp& v_y, 
                       Cmp& v_p) const ; 
    
    virtual void dec_dzpuis(Scalar& ) const ; 

    virtual void dec2_dzpuis(Scalar& ) const ; 

    virtual void inc_dzpuis(Scalar& ) const ; 
    
    virtual void inc2_dzpuis(Scalar& ) const ; 
    

    // PDE resolution :
    // --------------
    public:
    virtual void poisson_compact(const Cmp& source, const Cmp& aa, 
                     const Tenseur& bb, const Param& par, 
                     Cmp& psi) const ;

    virtual void poisson_compact(int nzet, const Cmp& source, const Cmp& aa, 
                     const Tenseur& bb, const Param& par, 
                     Cmp& psi) const ;

};


            //------------------------------------//
            //            class Map_af            //
            //------------------------------------//



class Map_af : public Map_radial {

    // Data :
    // ----
    private:
    double* alpha ;  
    double* beta ;    
    
    // Constructors, destructor : 
    // ------------------------
    public:
    Map_af(const Mg3d& mgrille, const double* r_limits) ;   
    Map_af(const Mg3d& mgrille, const Tbl& r_limits) ;  
    
    Map_af(const Map_af& ) ;      
    Map_af(const Mg3d&, FILE* ) ; 
    
    explicit Map_af(const Map& ) ;      

    virtual ~Map_af() ;       

    // Assignment
    // ----------
    public: 
    virtual void operator=(const Map_af& ) ;
        
    // Memory management
    // -----------------
    private:
    void set_coord() ;  

    // Extraction of information
    // -------------------------
    public:
    const double* get_alpha() const ; 

    const double* get_beta() const ; 

    virtual const Map_af& mp_angu(int) const ;
    
    virtual double val_r(int l, double xi, double theta, double pphi) const ; 

    virtual void val_lx(double rr, double theta, double pphi,
                int& l, double& xi) const ; 
    
    virtual void val_lx(double rr, double theta, double pphi, 
                const Param& par, int& l, double& xi) const ; 
        
    virtual double val_r_jk(int l, double xi, int j, int k) const ; 
    
    virtual void val_lx_jk(double rr, int j, int k, const Param& par, 
                   int& l, double& xi) const ; 

    virtual bool operator==(const Map& ) const ;  


    // Outputs
    // -------
    public:
    virtual void sauve(FILE* ) const ;    
    
    private:
    virtual ostream& operator>>(ostream &) const ;    

    // Modification of the mapping
    // ---------------------------
    public:
    virtual void homothetie(double lambda) ;
    
    virtual void resize(int l, double lambda) ; 

    void homothetie_interne(double lambda) ;
    
    virtual void adapt(const Cmp& ent, const Param& par, int nbr=0) ; 

    void set_alpha(double alpha0, int l) ;

    void set_beta(double beta0, int l) ;  

    // Differential operators:
    // ----------------------
    public:
    virtual void dsdxi(const Cmp& ci, Cmp& resu) const ;        

    virtual void dsdr(const Cmp& ci, Cmp& resu) const ;         

    virtual void srdsdt(const Cmp& ci, Cmp& resu) const ;       
    
    virtual void srstdsdp(const Cmp& ci, Cmp& resu) const ;         

    virtual void dsdr(const Scalar& uu, Scalar& resu) const  ;  

    virtual void dsdxi(const Scalar& uu, Scalar& resu) const  ;  
        
    virtual void dsdradial(const Scalar&, Scalar&) const  ;         

    virtual void srdsdt(const Scalar& uu, Scalar& resu) const  ;        
    
    virtual void srstdsdp(const Scalar& uu, Scalar& resu) const ;       
        
    virtual void dsdt(const Scalar& uu, Scalar& resu) const ;       

    virtual void stdsdp(const Scalar& uu, Scalar& resu) const ;         

    virtual void laplacien(const Scalar& uu, int zec_mult_r, 
                   Scalar& lap) const ; 
    
    virtual void laplacien(const Cmp& uu, int zec_mult_r, 
                   Cmp& lap) const  ; 
    
    virtual void lapang(const Scalar& uu, Scalar& lap) const ; 
    

    virtual void primr(const Scalar& uu, Scalar& resu,
               bool null_infty) const ;         

     
    virtual Tbl* integrale(const Cmp&) const ; 
    
     
    // PDE resolution :
    // --------------
    public:
    virtual void poisson(const Cmp& source, Param& par, Cmp& uu) const ;

    virtual void poisson_tau(const Cmp& source, Param& par, Cmp& uu) const ;
    
    virtual void poisson_falloff(const Cmp& source, Param& par, Cmp& uu,
                     int k_falloff) const ;

    virtual void poisson_ylm(const Cmp& source, Param& par, Cmp& pot,
                 int nylm, double* intvec) const ;

    virtual void poisson_regular(const Cmp& source, int k_div, int nzet,
                     double unsgam1, Param& par, Cmp& uu,
                     Cmp& uu_regu, Cmp& uu_div,
                     Tenseur& duu_div, Cmp& source_regu,
                     Cmp& source_div) const ;

    virtual void poisson_angu(const Scalar& source, Param& par, 
                    Scalar& uu, double lambda=0) const ;

    virtual Param* donne_para_poisson_vect (Param& par, int i) const ;
    
    virtual void poisson_frontiere (const Cmp&, const Valeur&, int, int, Cmp&, double = 0., double = 0.) const ;

    virtual void poisson_frontiere_double (const Cmp& source, const Valeur& lim_func,
            const Valeur& lim_der, int num_zone, Cmp& pot) const  ;

    virtual void poisson_interne (const Cmp& source, const Valeur& limite,
             Param& par, Cmp& pot) const ;

    double integrale_surface (const Cmp& ci, double rayon) const ;
    
    double integrale_surface (const Scalar& ci, double rayon) const ;
    
    double integrale_surface_falloff (const Cmp& ci) const ;

    double integrale_surface_infini (const Cmp& ci) const ;
    
    double integrale_surface_infini (const Scalar& ci) const ;
    
    void sol_elliptic (Param_elliptic& params, 
               const Scalar& so,  Scalar& uu) const ;


    void sol_elliptic_boundary (Param_elliptic& params, 
               const Scalar& so,  Scalar& uu, const Mtbl_cf& bound, 
               double fact_dir, double fact_neu ) const ;

    void sol_elliptic_boundary (Param_elliptic& params, 
               const Scalar& so,  Scalar& uu, const Scalar& bound, 
               double fact_dir, double fact_neu ) const ;

    void sol_elliptic_no_zec (Param_elliptic& params, 
                  const Scalar& so, Scalar& uu, double val) const ;

    void sol_elliptic_only_zec (Param_elliptic& params, 
                  const Scalar& so, Scalar& uu, double val) const ;

    void sol_elliptic_sin_zec (Param_elliptic& params, 
                  const Scalar& so, Scalar& uu, 
                    double* coefs, double*) const ;
    void sol_elliptic_fixe_der_zero (double val, 
                     Param_elliptic& params, 
                     const Scalar& so, Scalar& uu) const ;
    
    virtual void poisson2d(const Cmp& source_mat, const Cmp& source_quad, 
                   Param& par, Cmp& uu) const ;
    void sol_elliptic_2d(Param_elliptic&, 
                 const Scalar&, Scalar&) const ;
    void sol_elliptic_pseudo_1d(Param_elliptic&, 
                 const Scalar&, Scalar&) const ;

    virtual void dalembert(Param& par, Scalar& fJp1, const Scalar& fJ, 
                   const Scalar& fJm1, const Scalar& source) const ;

    // Building functions for the Coord's
    // ----------------------------------
    friend Mtbl* map_af_fait_r(const Map* ) ;
    friend Mtbl* map_af_fait_tet(const Map* ) ;
    friend Mtbl* map_af_fait_phi(const Map* ) ;
    friend Mtbl* map_af_fait_sint(const Map* ) ;
    friend Mtbl* map_af_fait_cost(const Map* ) ;
    friend Mtbl* map_af_fait_sinp(const Map* ) ;
    friend Mtbl* map_af_fait_cosp(const Map* ) ;

    friend Mtbl* map_af_fait_x(const Map* ) ;
    friend Mtbl* map_af_fait_y(const Map* ) ;
    friend Mtbl* map_af_fait_z(const Map* ) ;

    friend Mtbl* map_af_fait_xa(const Map* ) ;
    friend Mtbl* map_af_fait_ya(const Map* ) ;
    friend Mtbl* map_af_fait_za(const Map* ) ;

    friend Mtbl* map_af_fait_xsr(const Map* ) ;
    friend Mtbl* map_af_fait_dxdr(const Map* ) ;
    friend Mtbl* map_af_fait_drdt(const Map* ) ;
    friend Mtbl* map_af_fait_stdrdp(const Map* ) ;
    friend Mtbl* map_af_fait_srdrdt(const Map* ) ;
    friend Mtbl* map_af_fait_srstdrdp(const Map* ) ;
    friend Mtbl* map_af_fait_sr2drdt(const Map* ) ;
    friend Mtbl* map_af_fait_sr2stdrdp(const Map* ) ;
    friend Mtbl* map_af_fait_d2rdx2(const Map* ) ;
    friend Mtbl* map_af_fait_lapr_tp(const Map* ) ;
    friend Mtbl* map_af_fait_d2rdtdx(const Map* ) ;
    friend Mtbl* map_af_fait_sstd2rdpdx(const Map* ) ;
    friend Mtbl* map_af_fait_sr2d2rdt2(const Map* ) ;

};

     Mtbl* map_af_fait_r(const Map* ) ;
     Mtbl* map_af_fait_tet(const Map* ) ;
     Mtbl* map_af_fait_phi(const Map* ) ;
     Mtbl* map_af_fait_sint(const Map* ) ;
     Mtbl* map_af_fait_cost(const Map* ) ;
     Mtbl* map_af_fait_sinp(const Map* ) ;
     Mtbl* map_af_fait_cosp(const Map* ) ;

     Mtbl* map_af_fait_x(const Map* ) ;
     Mtbl* map_af_fait_y(const Map* ) ;
     Mtbl* map_af_fait_z(const Map* ) ;

     Mtbl* map_af_fait_xa(const Map* ) ;
     Mtbl* map_af_fait_ya(const Map* ) ;
     Mtbl* map_af_fait_za(const Map* ) ;

     Mtbl* map_af_fait_xsr(const Map* ) ;
     Mtbl* map_af_fait_dxdr(const Map* ) ;
     Mtbl* map_af_fait_drdt(const Map* ) ;
     Mtbl* map_af_fait_stdrdp(const Map* ) ;
     Mtbl* map_af_fait_srdrdt(const Map* ) ;
     Mtbl* map_af_fait_srstdrdp(const Map* ) ;
     Mtbl* map_af_fait_sr2drdt(const Map* ) ;
     Mtbl* map_af_fait_sr2stdrdp(const Map* ) ;
     Mtbl* map_af_fait_d2rdx2(const Map* ) ;
     Mtbl* map_af_fait_lapr_tp(const Map* ) ;
     Mtbl* map_af_fait_d2rdtdx(const Map* ) ;
     Mtbl* map_af_fait_sstd2rdpdx(const Map* ) ;
     Mtbl* map_af_fait_sr2d2rdt2(const Map* ) ;




            //------------------------------------//
            //            class Map_et            //
            //------------------------------------//



class Map_et : public Map_radial {

    // Data :
    // ----
    private:
    double* alpha ;   
    double* beta ;    

    Tbl** aa ;    

    Tbl** daa ;   
    
    Tbl** ddaa ;      
    
    Tbl aasx ; 
     
    Tbl aasx2 ; 
     
    Tbl zaasx ; 
      
    Tbl zaasx2 ; 
      
    Tbl** bb ;    

    Tbl** dbb ;   
    
    Tbl** ddbb ;      
    
    Tbl bbsx ; 
     
    Tbl bbsx2 ; 
     
    Valeur ff ; 
      
    Valeur gg ; 
      
    public:
    Coord rsxdxdr ;
     
    Coord rsx2drdx ;
      
    // Constructors, destructor : 
    // ------------------------
    public:
    Map_et(const Mg3d& mgrille, const double* r_limits) ;   
    
    Map_et(const Mg3d& mgrille, const double* r_limits,const Tbl& tab); 
    Map_et(const Map_et& ) ;      
    Map_et(const Mg3d&, FILE* ) ; 

    virtual ~Map_et() ;       

    // Assignment
    // ----------
    public:
    virtual void operator=(const Map_et& mp) ;
    
    virtual void operator=(const Map_af& mpa) ;
    
    void set_ff(const Valeur& ) ; 
    void set_gg(const Valeur& ) ; 

    // Memory management
    // -----------------
    private:
    void set_coord() ;      
    protected:
    virtual void reset_coord() ;
    
    private: 
    void fait_poly() ;  
    
    // Extraction of information
    // -------------------------
    public:
    virtual const Map_af& mp_angu(int) const ;
    
    const double* get_alpha() const ; 

    const double* get_beta() const ; 

    const Valeur& get_ff() const ; 

    const Valeur& get_gg() const ; 
    
    virtual double val_r(int l, double xi, double theta, double pphi) const ; 

    virtual void val_lx(double rr, double theta, double pphi,
                int& l, double& xi) const ; 
    
    virtual void val_lx(double rr, double theta, double pphi, 
                const Param& par, int& l, double& xi) const ; 
        
    virtual bool operator==(const Map& ) const ;  

    virtual double val_r_jk(int l, double xi, int j, int k) const ; 
    
    virtual void val_lx_jk(double rr, int j, int k, const Param& par, 
                   int& l, double& xi) const ; 



    // Outputs
    // -------
    public:
    virtual void sauve(FILE* ) const ;    
    
    private:
    virtual ostream& operator>>(ostream &) const ;    

    // Modification of the radial scale
    // --------------------------------
    public:
    virtual void homothetie(double lambda) ;    

    virtual void resize(int l, double lambda) ; 

    void resize_extr(double lambda) ;

    void set_alpha(double alpha0, int l) ;

    void set_beta(double beta0, int l) ;  

    // Modification of the mapping
    // ---------------------------
    virtual void adapt(const Cmp& ent, const Param& par, int nbr_filtre = 0)  ; 

    // Differential operators:
    // ----------------------
    public:
    virtual void dsdxi(const Cmp& ci, Cmp& resu) const ;        

    virtual void dsdr(const Cmp& ci, Cmp& resu) const ;         

    virtual void srdsdt(const Cmp& ci, Cmp& resu) const ;       
    
    virtual void srstdsdp(const Cmp& ci, Cmp& resu) const ;             

    virtual void dsdxi(const Scalar& uu, Scalar& resu) const ;

    virtual void dsdr(const Scalar& uu, Scalar& resu) const ;
    
    virtual void dsdradial(const Scalar& uu, Scalar& resu) const ;          
    
    virtual void srdsdt(const Scalar& uu, Scalar& resu) const ;         
    
    virtual void srstdsdp(const Scalar& uu, Scalar& resu) const ;       
    
    virtual void dsdt(const Scalar& uu, Scalar& resu) const ;       

    virtual void stdsdp(const Scalar& uu, Scalar& resu) const ;         

    virtual void laplacien(const Scalar& uu, int zec_mult_r, 
                   Scalar& lap) const ; 
    
    virtual void laplacien(const Cmp& uu, int zec_mult_r, 
                   Cmp& lap) const  ; 
    
    virtual void lapang(const Scalar& uu, Scalar& lap) const ; 
    

    virtual void primr(const Scalar& uu, Scalar& resu,
               bool null_infty) const ;         

     
    virtual Tbl* integrale(const Cmp&) const ; 
    
     
    // PDE resolution :
    // --------------
    public:
    virtual void poisson(const Cmp& source, Param& par, Cmp& uu) const ;

    virtual void poisson_tau(const Cmp& source, Param& par, Cmp& uu) const ;
    
    virtual void poisson_falloff(const Cmp& source, Param& par, Cmp& uu,
                     int k_falloff) const ;

    virtual void poisson_ylm(const Cmp& source, Param& par, Cmp& uu,
                 int nylm, double* intvec) const ;

    virtual void poisson_regular(const Cmp& source, int k_div, int nzet,
                     double unsgam1, Param& par, Cmp& uu,
                     Cmp& uu_regu, Cmp& uu_div,
                     Tenseur& duu_div, Cmp& source_regu,
                     Cmp& source_div) const ;

    virtual void poisson_angu(const Scalar& source, Param& par, 
                    Scalar& uu, double lambda=0) const ;

    virtual Param* donne_para_poisson_vect (Param& para, int i) const ;
    
    virtual void poisson_frontiere (const Cmp&, const Valeur&, int, int, 
                    Cmp&, double = 0., double = 0.) const ;
    virtual void poisson_frontiere_double (const Cmp& source, 
            const Valeur& lim_func, const Valeur& lim_der, 
            int num_zone, Cmp& pot) const  ;

    virtual void poisson_interne (const Cmp& source, const Valeur& limite,
             Param& par, Cmp& pot) const ;


    virtual void poisson2d(const Cmp& source_mat, const Cmp& source_quad, 
                   Param& par, Cmp& uu) const ;

    virtual void dalembert(Param& par, Scalar& fJp1, const Scalar& fJ, 
                   const Scalar& fJm1, const Scalar& source) const ;




    // Building functions for the Coord's
    // ----------------------------------
    friend Mtbl* map_et_fait_r(const Map* ) ;
    friend Mtbl* map_et_fait_tet(const Map* ) ;
    friend Mtbl* map_et_fait_phi(const Map* ) ;
    friend Mtbl* map_et_fait_sint(const Map* ) ;
    friend Mtbl* map_et_fait_cost(const Map* ) ;
    friend Mtbl* map_et_fait_sinp(const Map* ) ;
    friend Mtbl* map_et_fait_cosp(const Map* ) ;

    friend Mtbl* map_et_fait_x(const Map* ) ;
    friend Mtbl* map_et_fait_y(const Map* ) ;
    friend Mtbl* map_et_fait_z(const Map* ) ;

    friend Mtbl* map_et_fait_xa(const Map* ) ;
    friend Mtbl* map_et_fait_ya(const Map* ) ;
    friend Mtbl* map_et_fait_za(const Map* ) ;

    friend Mtbl* map_et_fait_xsr(const Map* ) ;
    friend Mtbl* map_et_fait_dxdr(const Map* ) ;
    friend Mtbl* map_et_fait_drdt(const Map* ) ;
    friend Mtbl* map_et_fait_stdrdp(const Map* ) ;
    friend Mtbl* map_et_fait_srdrdt(const Map* ) ;
    friend Mtbl* map_et_fait_srstdrdp(const Map* ) ;
    friend Mtbl* map_et_fait_sr2drdt(const Map* ) ;
    friend Mtbl* map_et_fait_sr2stdrdp(const Map* ) ;
    friend Mtbl* map_et_fait_d2rdx2(const Map* ) ;
    friend Mtbl* map_et_fait_lapr_tp(const Map* ) ;
    friend Mtbl* map_et_fait_d2rdtdx(const Map* ) ;
    friend Mtbl* map_et_fait_sstd2rdpdx(const Map* ) ;
    friend Mtbl* map_et_fait_sr2d2rdt2(const Map* ) ;

    friend Mtbl* map_et_fait_rsxdxdr(const Map* ) ;
    friend Mtbl* map_et_fait_rsx2drdx(const Map* ) ;

};

     Mtbl* map_et_fait_r(const Map* ) ;
     Mtbl* map_et_fait_tet(const Map* ) ;
     Mtbl* map_et_fait_phi(const Map* ) ;
     Mtbl* map_et_fait_sint(const Map* ) ;
     Mtbl* map_et_fait_cost(const Map* ) ;
     Mtbl* map_et_fait_sinp(const Map* ) ;
     Mtbl* map_et_fait_cosp(const Map* ) ;

     Mtbl* map_et_fait_x(const Map* ) ;
     Mtbl* map_et_fait_y(const Map* ) ;
     Mtbl* map_et_fait_z(const Map* ) ;

     Mtbl* map_et_fait_xa(const Map* ) ;
     Mtbl* map_et_fait_ya(const Map* ) ;
     Mtbl* map_et_fait_za(const Map* ) ;

     Mtbl* map_et_fait_xsr(const Map* ) ;
     Mtbl* map_et_fait_dxdr(const Map* ) ;
     Mtbl* map_et_fait_drdt(const Map* ) ;
     Mtbl* map_et_fait_stdrdp(const Map* ) ;
     Mtbl* map_et_fait_srdrdt(const Map* ) ;
     Mtbl* map_et_fait_srstdrdp(const Map* ) ;
     Mtbl* map_et_fait_sr2drdt(const Map* ) ;
     Mtbl* map_et_fait_sr2stdrdp(const Map* ) ;
     Mtbl* map_et_fait_d2rdx2(const Map* ) ;
     Mtbl* map_et_fait_lapr_tp(const Map* ) ;
     Mtbl* map_et_fait_d2rdtdx(const Map* ) ;
     Mtbl* map_et_fait_sstd2rdpdx(const Map* ) ;
     Mtbl* map_et_fait_sr2d2rdt2(const Map* ) ;

     Mtbl* map_et_fait_rsxdxdr(const Map* ) ;
     Mtbl* map_et_fait_rsx2drdx(const Map* ) ;

            //------------------------------------//
            //            class Map_log            //
            //------------------------------------//

#define AFFINE 0
#define LOG 1

class Map_log : public Map_radial {

    // Data :
    // ----
    private:
    Tbl alpha ;  
    Tbl beta ;
    Itbl type_var ;

 public:
    Coord dxdlnr ;

 private:
    void set_coord() ;

    // Constructors, destructor : 
    // ------------------------
    public:
    Map_log (const Mg3d& mgrille, const Tbl& r_limits, const Itbl& typevar) ;   
    
    
    Map_log (const Map_log& ) ;      
    Map_log (const Mg3d&, FILE* ) ; 

    virtual ~Map_log() ;          
    
    virtual const Map_af& mp_angu(int) const ;
    
    double get_alpha (int l) const {return alpha(l) ;} ;
    double get_beta (int l) const {return beta(l) ;} ;
    int get_type (int l) const {return type_var(l) ;} ;
    
    void sol_elliptic (Param_elliptic& params, 
               const Scalar& so,  Scalar& uu) const ;


    void sol_elliptic_boundary (Param_elliptic& params, 
               const Scalar& so,  Scalar& uu, const Mtbl_cf& bound, 
               double fact_dir, double fact_neu ) const ;

    void sol_elliptic_boundary (Param_elliptic& params, 
               const Scalar& so,  Scalar& uu, const Scalar& bound, 
               double fact_dir, double fact_neu ) const ;


    void sol_elliptic_no_zec (Param_elliptic& params, 
               const Scalar& so,  Scalar& uu, double) const ;

    
    virtual void sauve(FILE*) const ; 

    virtual void operator=(const Map_af& mpa) ;

    
    virtual ostream& operator>> (ostream&) const ; 

    virtual double val_r (int l, double xi, double theta, double pphi) const ;

    virtual void val_lx (double rr, double theta, double pphi, int& l, double& xi) const ;
    
    virtual void val_lx (double rr, double theta, double pphi, const Param& par, int& l, double& xi) const ;

    
    virtual bool operator== (const Map&) const ;   
    
    virtual double val_r_jk (int l, double xi, int j, int k) const ;
    
    virtual void val_lx_jk (double rr, int j, int k, const Param& par, int& l, double& xi) const ;
    
    virtual void dsdr (const Scalar& ci, Scalar& resu) const ;
    
    virtual void dsdxi (const Scalar& ci, Scalar& resu) const ;
    
    virtual void dsdradial (const Scalar& uu, Scalar& resu) const ;

    virtual void homothetie (double) ; 
    virtual void resize (int, double) ;
    virtual void adapt (const Cmp&, const Param&, int) ;
    virtual void dsdr (const Cmp&, Cmp&) const ;
    virtual void dsdxi (const Cmp&, Cmp&) const ;
    virtual void srdsdt (const Cmp&, Cmp&) const ;
    virtual void srstdsdp (const Cmp&, Cmp&) const ;
    virtual void srdsdt (const Scalar&, Scalar&) const ;
    virtual void srstdsdp (const Scalar&, Scalar&) const ;
    virtual void dsdt (const Scalar&, Scalar&) const ;
    virtual void stdsdp (const Scalar&, Scalar&) const ;
    virtual void laplacien (const Scalar&, int, Scalar&) const ;
    virtual void laplacien (const Cmp&, int, Cmp&) const ;
    virtual void lapang (const Scalar&, Scalar&) const ;
    virtual Tbl* integrale (const Cmp&) const ;
    virtual void poisson (const Cmp&, Param&, Cmp&) const ;
    virtual void poisson_tau (const Cmp&, Param&, Cmp&) const ;
    virtual void poisson_regular (const Cmp&, int, int, double, Param&, Cmp&, Cmp&, Cmp&, 
                      Tenseur&, Cmp&, Cmp&) const ;
    virtual void poisson_angu (const Scalar&, Param&, Scalar&, double=0) const ;
    virtual Param* donne_para_poisson_vect (Param&, int) const ;
    virtual void poisson_frontiere (const Cmp&, const Valeur&, int, int, Cmp&, double = 0., double = 0.) const ;
    virtual void poisson_frontiere_double (const Cmp&, const Valeur&, const Valeur&, int, Cmp&) const ;
    virtual void poisson_interne (const Cmp&, const Valeur&, Param&, Cmp&) const ;
    virtual void poisson2d (const Cmp&, const Cmp&, Param&, Cmp&) const ;
    virtual void dalembert (Param&, Scalar&, const Scalar&, const Scalar&, const Scalar&) const ;


    // Building functions for the Coord's
    // ----------------------------------
    friend Mtbl* map_log_fait_r(const Map* ) ;
    friend Mtbl* map_log_fait_tet(const Map* ) ;
    friend Mtbl* map_log_fait_phi(const Map* ) ;
    friend Mtbl* map_log_fait_sint(const Map* ) ;
    friend Mtbl* map_log_fait_cost(const Map* ) ;
    friend Mtbl* map_log_fait_sinp(const Map* ) ;
    friend Mtbl* map_log_fait_cosp(const Map* ) ;
    
    friend Mtbl* map_log_fait_x(const Map* ) ;
    friend Mtbl* map_log_fait_y(const Map* ) ;
    friend Mtbl* map_log_fait_z(const Map* ) ;
    
    friend Mtbl* map_log_fait_xa(const Map* ) ;
    friend Mtbl* map_log_fait_ya(const Map* ) ;
    friend Mtbl* map_log_fait_za(const Map* ) ;
    
    friend Mtbl* map_log_fait_xsr(const Map* ) ;
    friend Mtbl* map_log_fait_dxdr(const Map* ) ;
    friend Mtbl* map_log_fait_drdt(const Map* ) ;
    friend Mtbl* map_log_fait_stdrdp(const Map* ) ;
    friend Mtbl* map_log_fait_srdrdt(const Map* ) ;
    friend Mtbl* map_log_fait_srstdrdp(const Map* ) ;
    friend Mtbl* map_log_fait_sr2drdt(const Map* ) ;
    friend Mtbl* map_log_fait_sr2stdrdp(const Map* ) ;
    friend Mtbl* map_log_fait_d2rdx2(const Map* ) ;
    friend Mtbl* map_log_fait_lapr_tp(const Map* ) ;
    friend Mtbl* map_log_fait_d2rdtdx(const Map* ) ;
    friend Mtbl* map_log_fait_sstd2rdpdx(const Map* ) ;
    friend Mtbl* map_log_fait_sr2d2rdt2(const Map* ) ;
    friend Mtbl* map_log_fait_dxdlnr(const Map* ) ;
    
};

Mtbl* map_log_fait_r(const Map* ) ;
Mtbl* map_log_fait_tet(const Map* ) ;
Mtbl* map_log_fait_phi(const Map* ) ;
Mtbl* map_log_fait_sint(const Map* ) ;
Mtbl* map_log_fait_cost(const Map* ) ;
Mtbl* map_log_fait_sinp(const Map* ) ;
Mtbl* map_log_fait_cosp(const Map* ) ;

Mtbl* map_log_fait_x(const Map* ) ;
Mtbl* map_log_fait_y(const Map* ) ;
Mtbl* map_log_fait_z(const Map* ) ;

Mtbl* map_log_fait_xa(const Map* ) ;
Mtbl* map_log_fait_ya(const Map* ) ;
Mtbl* map_log_fait_za(const Map* ) ;

Mtbl* map_log_fait_xsr(const Map* ) ;
Mtbl* map_log_fait_dxdr(const Map* ) ;
Mtbl* map_log_fait_drdt(const Map* ) ;
Mtbl* map_log_fait_stdrdp(const Map* ) ;
Mtbl* map_log_fait_srdrdt(const Map* ) ;
Mtbl* map_log_fait_srstdrdp(const Map* ) ;
Mtbl* map_log_fait_sr2drdt(const Map* ) ;
Mtbl* map_log_fait_sr2stdrdp(const Map* ) ;
Mtbl* map_log_fait_d2rdx2(const Map* ) ;
Mtbl* map_log_fait_lapr_tp(const Map* ) ;
Mtbl* map_log_fait_d2rdtdx(const Map* ) ;
Mtbl* map_log_fait_sstd2rdpdx(const Map* ) ;
Mtbl* map_log_fait_sr2d2rdt2(const Map* ) ;

Mtbl* map_log_fait_dxdlnr (const Map*) ;

#endif

---