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.59 2014/10/13 08:52:35 j_novak Exp $
* $Log: map.h,v $
* Revision 1.59 2014/10/13 08:52:35 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.58 2014/10/06 15:09:40 j_novak
* Modified #include directives to use c++ syntax.
*
* Revision 1.57 2014/01/14 13:24:02 b_peres
* *** empty log message ***
*
* 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.59 2014/10/13 08:52:35 j_novak Exp $
*
*/
#include <cstdio>
#include "coord.h"
#include "base_vect.h"
#include "valeur.h"
#include "tbl.h"
#include "itbl.h"
namespace Lorene {
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 void primr(const Scalar&, Scalar&, bool) 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_falloff(const Cmp&, Param&, Cmp&, int) const ;
virtual void poisson_ylm(const Cmp&, Param&, Cmp&, int, double*) 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
Lorene::Base_vect_cart
Cartesian vectorial bases (triads).
Definition base_vect.h:201
Lorene::Base_vect_spher
Spherical orthonormal vectorial bases (triads).
Definition base_vect.h:308
Lorene::Cmp
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition cmp.h:446
Lorene::Coord
Active physical coordinates and mapping derivatives.
Definition coord.h:90
Lorene::Itbl
Basic integer array class.
Definition itbl.h:122
Lorene::Map_af
Affine radial mapping.
Definition map.h:2027
Lorene::Map_af::sol_elliptic_boundary
void sol_elliptic_boundary(Param_elliptic &params, const Scalar &so, Scalar &uu, const Mtbl_cf &bound, double fact_dir, double fact_neu) const
General elliptic solver including inner boundary conditions.
Definition map_af_elliptic.C:159
Lorene::Map_af::operator>>
virtual ostream & operator>>(ostream &) const
Operator >>.
Definition map_af.C:503
Lorene::Map_af::srstdsdp
virtual void srstdsdp(const Cmp &ci, Cmp &resu) const
Computes of a Cmp.
Definition map_af_deriv.C:633
Lorene::Map_af::get_beta
const double * get_beta() const
Returns the pointer on the array beta.
Definition map_af.C:481
Lorene::Map_af::get_alpha
const double * get_alpha() const
Returns the pointer on the array alpha.
Definition map_af.C:477
Lorene::Map_af::set_beta
void set_beta(double beta0, int l)
Modifies the value of in domain no. l.
Definition map_af.C:641
Lorene::Map_af::poisson_interne
virtual void poisson_interne(const Cmp &source, const Valeur &limite, Param &par, Cmp &pot) const
Computes the solution of a Poisson equation in the shell, imposing a boundary condition at the surfac...
Definition cmp_pde_frontiere.C:474
Lorene::Map_af::adapt
virtual void adapt(const Cmp &ent, const Param &par, int nbr=0)
Adaptation of the mapping to a given scalar field.
Definition map_af.C:673
Lorene::Map_af::set_coord
void set_coord()
Assignment of the building functions to the member Coords.
Definition map_af.C:403
Lorene::Map_af::poisson_frontiere
virtual void poisson_frontiere(const Cmp &, const Valeur &, int, int, Cmp &, double=0., double=0.) const
Solver of the Poisson equation with boundary condition for the affine mapping case.
Definition cmp_pde_frontiere.C:135
Lorene::Map_af::Map_af
Map_af(const Mg3d &mgrille, const double *r_limits)
Standard Constructor.
Definition map_af.C:191
Lorene::Map_af::sol_elliptic
void sol_elliptic(Param_elliptic &params, const Scalar &so, Scalar &uu) const
General elliptic solver.
Definition map_af_elliptic.C:100
Lorene::Map_af::~Map_af
virtual ~Map_af()
Destructor.
Definition map_af.C:368
Lorene::Map_af::poisson_regular
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
Computes the solution of a scalar Poisson equation.
Definition map_af_poisson_regu.C:109
Lorene::Map_af::donne_para_poisson_vect
virtual Param * donne_para_poisson_vect(Param &par, int i) const
Internal function intended to be used by Map::poisson_vect and Map::poisson_vect_oohara .
Definition map_poisson_vect.C:70
Lorene::Map_af::sol_elliptic_sin_zec
void sol_elliptic_sin_zec(Param_elliptic &params, const Scalar &so, Scalar &uu, double *coefs, double *) const
General elliptic solver.
Definition map_af_elliptic.C:426
Lorene::Map_af::sauve
virtual void sauve(FILE *) const
Save in a file.
Definition map_af.C:489
Lorene::Map_af::sol_elliptic_fixe_der_zero
void sol_elliptic_fixe_der_zero(double val, Param_elliptic &params, const Scalar &so, Scalar &uu) const
General elliptic solver fixing the derivative at the origin and relaxing the continuity of the first ...
Definition map_af_elliptic.C:483
Lorene::Map_af::primr
virtual void primr(const Scalar &uu, Scalar &resu, bool null_infty) const
Computes the radial primitive which vanishes for .
Definition map_af_primr.C:74
Lorene::Map_af::beta
double * beta
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:2035
Lorene::Map_af::dalembert
virtual void dalembert(Param &par, Scalar &fJp1, const Scalar &fJ, const Scalar &fJm1, const Scalar &source) const
Performs one time-step integration of the d'Alembert scalar equation.
Definition map_af_dalembert.C:122
Lorene::Map_af::operator=
virtual void operator=(const Map_af &)
Assignment to another affine mapping.
Definition map_af.C:380
Lorene::Map_af::homothetie_interne
void homothetie_interne(double lambda)
Sets a new radial scale at the bondary between the nucleus and the first shell.
Definition map_af.C:614
Lorene::Map_af::homothetie
virtual void homothetie(double lambda)
Sets a new radial scale.
Definition map_af.C:537
Lorene::Map_af::poisson_angu
virtual void poisson_angu(const Scalar &source, Param &par, Scalar &uu, double lambda=0) const
Computes the solution of the generalized angular Poisson equation.
Definition map_af_poisson_angu.C:58
Lorene::Map_af::laplacien
virtual void laplacien(const Scalar &uu, int zec_mult_r, Scalar &lap) const
Computes the Laplacian of a scalar field.
Definition map_af_lap.C:179
Lorene::Map_af::alpha
double * alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:2033
Lorene::Map_af::lapang
virtual void lapang(const Scalar &uu, Scalar &lap) const
Computes the angular Laplacian of a scalar field.
Definition map_af_lap.C:549
Lorene::Map_af::sol_elliptic_2d
void sol_elliptic_2d(Param_elliptic &, const Scalar &, Scalar &) const
General elliptic solver in a 2D case.
Definition map_af_elliptic_2d.C:58
Lorene::Map_af::poisson2d
virtual void poisson2d(const Cmp &source_mat, const Cmp &source_quad, Param &par, Cmp &uu) const
Computes the solution of a 2-D Poisson equation.
Definition map_af_poisson2d.C:81
Lorene::Map_af::val_lx_jk
virtual void val_lx_jk(double rr, int j, int k, const Param &par, int &l, double &xi) const
Computes the domain index l and the value of corresponding to a point of arbitrary r but collocation...
Definition map_af_radius.C:215
Lorene::Map_af::poisson
virtual void poisson(const Cmp &source, Param &par, Cmp &uu) const
Computes the solution of a scalar Poisson equation.
Definition map_af_poisson.C:100
Lorene::Map_af::dsdradial
virtual void dsdradial(const Scalar &, Scalar &) const
Computes of a Scalar.
Definition map_af_deriv.C:417
Lorene::Map_af::dsdr
virtual void dsdr(const Cmp &ci, Cmp &resu) const
Computes of a Cmp.
Definition map_af_deriv.C:279
Lorene::Map_af::dsdt
virtual void dsdt(const Scalar &uu, Scalar &resu) const
Computes of a Scalar.
Definition map_af_deriv.C:797
Lorene::Map_af::operator==
virtual bool operator==(const Map &) const
Comparison operator (egality).
Definition map_af.C:439
Lorene::Map_af::val_lx
virtual void val_lx(double rr, double theta, double pphi, int &l, double &xi) const
Computes the domain index l and the value of corresponding to a point given by its physical coordina...
Definition map_af_radius.C:128
Lorene::Map_af::set_alpha
void set_alpha(double alpha0, int l)
Modifies the value of in domain no. l.
Definition map_af.C:630
Lorene::Map_af::stdsdp
virtual void stdsdp(const Scalar &uu, Scalar &resu) const
Computes of a Scalar.
Definition map_af_deriv.C:823
Lorene::Map_af::integrale
virtual Tbl * integrale(const Cmp &) const
Computes the integral over all space of a Cmp.
Definition map_af_integ.C:81
Lorene::Map_af::sol_elliptic_pseudo_1d
void sol_elliptic_pseudo_1d(Param_elliptic &, const Scalar &, Scalar &) const
General elliptic solver in a pseudo 1d case.
Definition map_af_elliptic_pseudo_1d.C:59
Lorene::Map_af::poisson_tau
virtual void poisson_tau(const Cmp &source, Param &par, Cmp &uu) const
Computes the solution of a scalar Poisson equation using a Tau method.
Definition map_af_poisson.C:165
Lorene::Map_af::integrale_surface_infini
double integrale_surface_infini(const Cmp &ci) const
Performs the surface integration of ci at infinity.
Definition map_af_integ_surf.C:196
Lorene::Map_af::resize
virtual void resize(int l, double lambda)
Rescales the outer boundary of one domain.
Definition map_af.C:560
Lorene::Map_af::val_r_jk
virtual double val_r_jk(int l, double xi, int j, int k) const
Returns the value of the radial coordinate r for a given and a given collocation point in in a give...
Definition map_af_radius.C:205
Lorene::Map_af::sol_elliptic_only_zec
void sol_elliptic_only_zec(Param_elliptic &params, const Scalar &so, Scalar &uu, double val) const
General elliptic solver.
Definition map_af_elliptic.C:368
Lorene::Map_af::srdsdt
virtual void srdsdt(const Cmp &ci, Cmp &resu) const
Computes of a Cmp.
Definition map_af_deriv.C:475
Lorene::Map_af::poisson_frontiere_double
virtual void poisson_frontiere_double(const Cmp &source, const Valeur &lim_func, const Valeur &lim_der, int num_zone, Cmp &pot) const
Solver of the Poisson equation with boundary condition for the affine mapping case,...
Definition cmp_pde_frontiere.C:208
Lorene::Map_af::sol_elliptic_no_zec
void sol_elliptic_no_zec(Param_elliptic &params, const Scalar &so, Scalar &uu, double val) const
General elliptic solver.
Definition map_af_elliptic.C:312
Lorene::Map_af::mp_angu
virtual const Map_af & mp_angu(int) const
Returns the "angular" mapping for the outside of domain l_zone.
Definition map_af.C:656
Lorene::Map_af::dsdxi
virtual void dsdxi(const Cmp &ci, Cmp &resu) const
Computes of a Cmp.
Definition map_af_deriv.C:136
Lorene::Map_af::integrale_surface
double integrale_surface(const Cmp &ci, double rayon) const
Performs the surface integration of ci on the sphere of radius rayon .
Definition map_af_integ_surf.C:90
Lorene::Map_af::val_r
virtual double val_r(int l, double xi, double theta, double pphi) const
Returns the value of the radial coordinate r for a given in a given domain.
Definition map_af_radius.C:96
Lorene::Map_et
Radial mapping of rather general form.
Definition map.h:2752
Lorene::Map_et::get_ff
const Valeur & get_ff() const
Returns a (constant) reference to the function .
Definition map_et.C:1034
Lorene::Map_et::get_alpha
const double * get_alpha() const
Returns a pointer on the array alpha (values of in each domain).
Definition map_et.C:1026
Lorene::Map_et::resize_extr
void resize_extr(double lambda)
Rescales the outer boundary of the outermost domain in the case of non-compactified external domain.
Definition map_et_resize_extr.C:55
Lorene::Map_et::beta
double * beta
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:2760
Lorene::Map_et::poisson_interne
virtual void poisson_interne(const Cmp &source, const Valeur &limite, Param &par, Cmp &pot) const
Computes the solution of a Poisson equation in the shell .
Definition cmp_pde_frontiere.C:274
Lorene::Map_et::val_lx_jk
virtual void val_lx_jk(double rr, int j, int k, const Param &par, int &l, double &xi) const
Computes the domain index l and the value of corresponding to a point of arbitrary r but collocation...
Definition map_et_radius.C:418
Lorene::Map_et::ddaa
Tbl ** ddaa
Array (size: mg->nzone ) of Tbl which stores the values of in each domain.
Definition map.h:2775
Lorene::Map_et::val_r
virtual double val_r(int l, double xi, double theta, double pphi) const
Returns the value of the radial coordinate r for a given in a given domain.
Definition map_et_radius.C:92
Lorene::Map_et::operator=
virtual void operator=(const Map_et &mp)
Assignment to another Map_et.
Definition map_et.C:513
Lorene::Map_et::dsdr
virtual void dsdr(const Cmp &ci, Cmp &resu) const
Computes of a Cmp.
Definition map_et_deriv.C:187
Lorene::Map_et::mp_angu
virtual const Map_af & mp_angu(int) const
Returns the "angular" mapping for the outside of domain l_zone.
Definition map_et.C:1045
Lorene::Map_et::operator>>
virtual ostream & operator>>(ostream &) const
Operator >>.
Definition map_et.C:798
Lorene::Map_et::ddbb
Tbl ** ddbb
Array (size: mg->nzone ) of Tbl which stores the values of in each domain.
Definition map.h:2806
Lorene::Map_et::zaasx2
Tbl zaasx2
Values at the nr collocation points of in the outermost compactified domain.
Definition map.h:2791
Lorene::Map_et::rsx2drdx
Coord rsx2drdx
in the nucleus and the shells; \ in the outermost compactified domain.
Definition map.h:2841
Lorene::Map_et::operator==
virtual bool operator==(const Map &) const
Comparison operator (egality).
Definition map_et.C:984
Lorene::Map_et::poisson_tau
virtual void poisson_tau(const Cmp &source, Param &par, Cmp &uu) const
Computes the solution of a scalar Poisson equation with a Tau method.
Definition map_et_poisson.C:351
Lorene::Map_et::bbsx
Tbl bbsx
Values at the nr collocation points of in the nucleus.
Definition map.h:2809
Lorene::Map_et::srstdsdp
virtual void srstdsdp(const Cmp &ci, Cmp &resu) const
Computes of a Cmp.
Definition map_et_deriv.C:485
Lorene::Map_et::poisson2d
virtual void poisson2d(const Cmp &source_mat, const Cmp &source_quad, Param &par, Cmp &uu) const
Computes the solution of a 2-D Poisson equation.
Definition map_et_poisson2d.C:80
Lorene::Map_et::set_gg
void set_gg(const Valeur &)
Assigns a given value to the function .
Definition map_et.C:570
Lorene::Map_et::donne_para_poisson_vect
virtual Param * donne_para_poisson_vect(Param &para, int i) const
Internal function intended to be used by Map::poisson_vect and Map::poisson_vect_oohara .
Definition map_poisson_vect.C:75
Lorene::Map_et::get_gg
const Valeur & get_gg() const
Returns a (constant) reference to the function .
Definition map_et.C:1038
Lorene::Map_et::Map_et
Map_et(const Mg3d &mgrille, const double *r_limits)
Standard Constructor.
Definition map_et.C:149
Lorene::Map_et::dsdradial
virtual void dsdradial(const Scalar &uu, Scalar &resu) const
Computes of a Scalar if the description is affine and if it is logarithmic.
Definition map_et_deriv.C:274
Lorene::Map_et::lapang
virtual void lapang(const Scalar &uu, Scalar &lap) const
Computes the angular Laplacian of a scalar field.
Definition map_et_lap.C:283
Lorene::Map_et::dbb
Tbl ** dbb
Array (size: mg->nzone ) of Tbl which stores the values of in each domain.
Definition map.h:2801
Lorene::Map_et::laplacien
virtual void laplacien(const Scalar &uu, int zec_mult_r, Scalar &lap) const
Computes the Laplacian of a scalar field.
Definition map_et_lap.C:75
Lorene::Map_et::fait_poly
void fait_poly()
Construction of the polynomials and .
Definition map_et.C:645
Lorene::Map_et::homothetie
virtual void homothetie(double lambda)
Sets a new radial scale.
Definition map_et.C:905
Lorene::Map_et::poisson
virtual void poisson(const Cmp &source, Param &par, Cmp &uu) const
Computes the solution of a scalar Poisson equation.
Definition map_et_poisson.C:102
Lorene::Map_et::stdsdp
virtual void stdsdp(const Scalar &uu, Scalar &resu) const
Computes of a Scalar.
Definition map_et_deriv.C:674
Lorene::Map_et::dsdt
virtual void dsdt(const Scalar &uu, Scalar &resu) const
Computes of a Scalar.
Definition map_et_deriv.C:629
Lorene::Map_et::poisson_regular
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
Computes the solution of a scalar Poisson equation.
Definition map_et_poisson_regu.C:85
Lorene::Map_et::aasx
Tbl aasx
Values at the nr collocation points of in the nucleus.
Definition map.h:2778
Lorene::Map_et::get_beta
const double * get_beta() const
Returns a pointer on the array beta (values of in each domain).
Definition map_et.C:1030
Lorene::Map_et::aasx2
Tbl aasx2
Values at the nr collocation points of in the nucleus.
Definition map.h:2781
Lorene::Map_et::integrale
virtual Tbl * integrale(const Cmp &) const
Computes the integral over all space of a Cmp.
Definition map_et_integ.C:74
Lorene::Map_et::zaasx
Tbl zaasx
Values at the nr collocation points of in the outermost compactified domain.
Definition map.h:2786
Lorene::Map_et::poisson_frontiere
virtual void poisson_frontiere(const Cmp &, const Valeur &, int, int, Cmp &, double=0., double=0.) const
Not yet implemented.
Definition cmp_pde_frontiere.C:124
Lorene::Map_et::adapt
virtual void adapt(const Cmp &ent, const Param &par, int nbr_filtre=0)
Adaptation of the mapping to a given scalar field.
Definition map_et_adapt.C:108
Lorene::Map_et::daa
Tbl ** daa
Array (size: mg->nzone ) of Tbl which stores the values of in each domain.
Definition map.h:2770
Lorene::Map_et::dalembert
virtual void dalembert(Param &par, Scalar &fJp1, const Scalar &fJ, const Scalar &fJm1, const Scalar &source) const
Not yet implemented.
Definition map_et_dalembert.C:69
Lorene::Map_et::set_coord
void set_coord()
Assignement of the building functions to the member Coords.
Definition map_et.C:584
Lorene::Map_et::poisson_angu
virtual void poisson_angu(const Scalar &source, Param &par, Scalar &uu, double lambda=0) const
Computes the solution of the generalized angular Poisson equation.
Definition map_et_poisson.C:593
Lorene::Map_et::rsxdxdr
Coord rsxdxdr
in the nucleus; \ in the shells; \ in the outermost compactified domain.
Definition map.h:2834
Lorene::Map_et::set_beta
void set_beta(double beta0, int l)
Modifies the value of in domain no. l.
Definition map_et.C:435
Lorene::Map_et::aa
Tbl ** aa
Array (size: mg->nzone ) of Tbl which stores the values of in each domain.
Definition map.h:2765
Lorene::Map_et::srdsdt
virtual void srdsdt(const Cmp &ci, Cmp &resu) const
Computes of a Cmp.
Definition map_et_deriv.C:337
Lorene::Map_et::ff
Valeur ff
Values of the function at the nt*np angular collocation points in each domain.
Definition map.h:2819
Lorene::Map_et::set_alpha
void set_alpha(double alpha0, int l)
Modifies the value of in domain no. l.
Definition map_et.C:424
Lorene::Map_et::val_lx
virtual void val_lx(double rr, double theta, double pphi, int &l, double &xi) const
Computes the domain index l and the value of corresponding to a point given by its physical coordina...
Definition map_et_radius.C:146
Lorene::Map_et::primr
virtual void primr(const Scalar &uu, Scalar &resu, bool null_infty) const
Computes the radial primitive which vanishes for .
Definition map_et_integ.C:110
Lorene::Map_et::bb
Tbl ** bb
Array (size: mg->nzone ) of Tbl which stores the values of in each domain.
Definition map.h:2796
Lorene::Map_et::~Map_et
virtual ~Map_et()
Destructor.
Definition map_et.C:486
Lorene::Map_et::alpha
double * alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:2758
Lorene::Map_et::bbsx2
Tbl bbsx2
Values at the nr collocation points of in the nucleus.
Definition map.h:2812
Lorene::Map_et::gg
Valeur gg
Values of the function at the nt*np angular collocation points in each domain.
Definition map.h:2826
Lorene::Map_et::sauve
virtual void sauve(FILE *) const
Save in a file.
Definition map_et.C:779
Lorene::Map_et::set_ff
void set_ff(const Valeur &)
Assigns a given value to the function .
Definition map_et.C:562
Lorene::Map_et::resize
virtual void resize(int l, double lambda)
Rescales the outer boundary of one domain.
Definition map_et.C:928
Lorene::Map_et::val_r_jk
virtual double val_r_jk(int l, double xi, int j, int k) const
Returns the value of the radial coordinate r for a given and a given collocation point in in a give...
Definition map_et_radius.C:367
Lorene::Map_et::reset_coord
virtual void reset_coord()
Resets all the member Coords.
Definition map_et.C:628
Lorene::Map_et::dsdxi
virtual void dsdxi(const Cmp &ci, Cmp &resu) const
Computes of a Cmp.
Definition map_et_deriv.C:95
Lorene::Map_log::poisson2d
virtual void poisson2d(const Cmp &, const Cmp &, Param &, Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:188
Lorene::Map_log::poisson
virtual void poisson(const Cmp &, Param &, Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:154
Lorene::Map_log::get_beta
double get_beta(int l) const
Returns in the domain l.
Definition map.h:3639
Lorene::Map_log::srdsdt
virtual void srdsdt(const Cmp &, Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:113
Lorene::Map_log::get_alpha
double get_alpha(int l) const
Returns in the domain l.
Definition map.h:3637
Lorene::Map_log::donne_para_poisson_vect
virtual Param * donne_para_poisson_vect(Param &, int) const
< Not implemented
Definition map_log_pas_fait.C:171
Lorene::Map_log::dalembert
virtual void dalembert(Param &, Scalar &, const Scalar &, const Scalar &, const Scalar &) const
< Not implemented
Definition map_log_pas_fait.C:192
Lorene::Map_log::srstdsdp
virtual void srstdsdp(const Cmp &, Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:117
Lorene::Map_log::val_r
virtual double val_r(int l, double xi, double theta, double pphi) const
Returns the value of the radial coordinate r for a given in a given domain.
Definition map_log_radius.C:61
Lorene::Map_log::type_var
Itbl type_var
Array (size: mg->nzone ) of the type of variable in each domain.
Definition map.h:3595
Lorene::Map_log::sol_elliptic_boundary
void sol_elliptic_boundary(Param_elliptic &params, const Scalar &so, Scalar &uu, const Mtbl_cf &bound, double fact_dir, double fact_neu) const
General elliptic solver including inner boundary conditions.
Definition map_log_elliptic.C:132
Lorene::Map_log::dsdxi
virtual void dsdxi(const Scalar &ci, Scalar &resu) const
Computes of a Scalar.
Definition map_log_deriv.C:54
Lorene::Map_log::integrale
virtual Tbl * integrale(const Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:149
Lorene::Map_log::adapt
virtual void adapt(const Cmp &, const Param &, int)
< Not implemented
Definition map_log_pas_fait.C:101
Lorene::Map_log::poisson_frontiere_double
virtual void poisson_frontiere_double(const Cmp &, const Valeur &, const Valeur &, int, Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:180
Lorene::Map_log::sauve
virtual void sauve(FILE *) const
Save in a file.
Definition map_log.C:163
Lorene::Map_log::sol_elliptic
void sol_elliptic(Param_elliptic &params, const Scalar &so, Scalar &uu) const
General elliptic solver.
Definition map_log_elliptic.C:75
Lorene::Map_log::sol_elliptic_no_zec
void sol_elliptic_no_zec(Param_elliptic &params, const Scalar &so, Scalar &uu, double) const
General elliptic solver.
Definition map_log_elliptic.C:275
Lorene::Map_log::alpha
Tbl alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:3589
Lorene::Map_log::operator>>
virtual ostream & operator>>(ostream &) const
Operator >>.
Definition map_log.C:204
Lorene::Map_log::Map_log
Map_log(const Mg3d &mgrille, const Tbl &r_limits, const Itbl &typevar)
Standard Constructor.
Definition map_log.C:67
Lorene::Map_log::poisson_tau
virtual void poisson_tau(const Cmp &, Param &, Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:158
Lorene::Map_log::get_type
int get_type(int l) const
Returns the type of description in the domain l.
Definition map.h:3641
Lorene::Map_log::lapang
virtual void lapang(const Scalar &, Scalar &) const
< Not implemented
Definition map_log_pas_fait.C:145
Lorene::Map_log::poisson_ylm
virtual void poisson_ylm(const Cmp &, Param &, Cmp &, int, double *) const
< Not implemented
Definition map_log_pas_fait.C:210
Lorene::Map_log::primr
virtual void primr(const Scalar &, Scalar &, bool) const
< Not implemented
Definition map_log_pas_fait.C:202
Lorene::Map_log::~Map_log
virtual ~Map_log()
Destructor.
Definition map_log.C:160
Lorene::Map_log::dsdradial
virtual void dsdradial(const Scalar &uu, Scalar &resu) const
Computes of a Scalar if the description is affine and if it is logarithmic.
Definition map_log_deriv.C:162
Lorene::Map_log::poisson_angu
virtual void poisson_angu(const Scalar &, Param &, Scalar &, double=0) const
< Not implemented
Definition map_log_pas_fait.C:167
Lorene::Map_log::val_lx
virtual void val_lx(double rr, double theta, double pphi, int &l, double &xi) const
Computes the domain index l and the value of corresponding to a point given by its physical coordina...
Definition map_log_radius.C:118
Lorene::Map_log::dxdlnr
Coord dxdlnr
Same as dxdr if the domains where the description is affine and where it is logarithmic.
Definition map.h:3603
Lorene::Map_log::poisson_regular
virtual void poisson_regular(const Cmp &, int, int, double, Param &, Cmp &, Cmp &, Cmp &, Tenseur &, Cmp &, Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:162
Lorene::Map_log::laplacien
virtual void laplacien(const Scalar &, int, Scalar &) const
< Not implemented
Definition map_log_pas_fait.C:141
Lorene::Map_log::map_log_fait_r
friend Mtbl * map_log_fait_r(const Map *)
< Not implemented
Definition map_log_fait.C:57
Lorene::Map_log::dsdt
virtual void dsdt(const Scalar &, Scalar &) const
< Not implemented
Definition map_log_pas_fait.C:129
Lorene::Map_log::poisson_falloff
virtual void poisson_falloff(const Cmp &, Param &, Cmp &, int) const
< Not implemented
Definition map_log_pas_fait.C:206
Lorene::Map_log::resize
virtual void resize(int, double)
< Not implemented
Definition map_log_pas_fait.C:97
Lorene::Map_log::poisson_interne
virtual void poisson_interne(const Cmp &, const Valeur &, Param &, Cmp &) const
< Not implemented
Definition map_log_pas_fait.C:184
Lorene::Map_log::operator=
virtual void operator=(const Map_af &mpa)
Assignment to an affine mapping.
Definition map_log.C:230
Lorene::Map_log::stdsdp
virtual void stdsdp(const Scalar &, Scalar &) const
< Not implemented
Definition map_log_pas_fait.C:133
Lorene::Map_log::val_lx_jk
virtual void val_lx_jk(double rr, int j, int k, const Param &par, int &l, double &xi) const
Computes the domain index l and the value of corresponding to a point of arbitrary r but collocation...
Definition map_log_radius.C:227
Lorene::Map_log::dsdr
virtual void dsdr(const Scalar &ci, Scalar &resu) const
Computes of a Scalar.
Definition map_log_deriv.C:108
Lorene::Map_log::operator==
virtual bool operator==(const Map &) const
Comparison operator (egality).
Definition map_log.C:172
Lorene::Map_log::val_r_jk
virtual double val_r_jk(int l, double xi, int j, int k) const
< Comparison operator
Definition map_log_radius.C:217
Lorene::Map_log::mp_angu
virtual const Map_af & mp_angu(int) const
Returns the "angular" mapping for the outside of domain l_zone.
Definition map_log_pas_fait.C:196
Lorene::Map_log::beta
Tbl beta
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:3591
Lorene::Map_log::poisson_frontiere
virtual void poisson_frontiere(const Cmp &, const Valeur &, int, int, Cmp &, double=0., double=0.) const
< Not implemented
Definition map_log_pas_fait.C:176
Lorene::Map_radial::d2rdx2
Coord d2rdx2
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1619
Lorene::Map_radial::inc2_dzpuis
virtual void inc2_dzpuis(Scalar &) const
Increases by 2 the value of dzpuis of a Scalar and changes accordingly its values in the compactifi...
Definition map_radial_r_manip.C:799
Lorene::Map_radial::reevaluate_symy
virtual void reevaluate_symy(const Map *mp_prev, int nzet, Cmp &uu) const
Recomputes the values of a Cmp at the collocation points after a change in the mapping.
Definition map_radial_reeval_symy.C:59
Lorene::Map_radial::sr2drdt
Coord sr2drdt
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1600
Lorene::Map_radial::srstdrdp
Coord srstdrdp
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1592
Lorene::Map_radial::mult_r_zec
virtual void mult_r_zec(Scalar &) const
Multiplication by r (in the compactified external domain only) of a Scalar.
Definition map_radial_r_manip.C:296
Lorene::Map_radial::poisson_compact
virtual void poisson_compact(const Cmp &source, const Cmp &aa, const Tenseur &bb, const Param &par, Cmp &psi) const
Resolution of the elliptic equation in the case where the stellar interior is covered by a single do...
Definition map_radial_poisson_cpt.C:155
Lorene::Map_radial::comp_y_from_spherical
virtual void comp_y_from_spherical(const Scalar &v_r, const Scalar &v_theta, const Scalar &v_phi, Scalar &v_y) const
Computes the Cartesian y component (with respect to bvect_cart ) of a vector given by its spherical c...
Definition map_radial_comp_xyz.C:135
Lorene::Map_radial::d2rdtdx
Coord d2rdtdx
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1640
Lorene::Map_radial::mult_r
virtual void mult_r(Scalar &uu) const
Multiplication by r of a Scalar, the dzpuis of uu is not changed.
Definition map_radial_r_manip.C:144
Lorene::Map_radial::div_rsint
virtual void div_rsint(Scalar &) const
Division by of a Scalar.
Definition map_radial_r_manip.C:434
Lorene::Map_radial::dec_dzpuis
virtual void dec_dzpuis(Scalar &) const
Decreases by 1 the value of dzpuis of a Scalar and changes accordingly its values in the compactified...
Definition map_radial_r_manip.C:643
Lorene::Map_radial::operator=
virtual void operator=(const Map_af &)=0
Assignment to an affine mapping.
Lorene::Map_radial::div_r_zec
virtual void div_r_zec(Scalar &) const
Division by r (in the compactified external domain only) of a Scalar.
Definition map_radial_r_manip.C:585
Lorene::Map_radial::div_tant
virtual void div_tant(Scalar &) const
Division by of a Scalar.
Definition map_radial_th_manip.C:158
Lorene::Map_radial::inc_dzpuis
virtual void inc_dzpuis(Scalar &) const
Increases by 1 the value of dzpuis of a Scalar and changes accordingly its values in the compactifi...
Definition map_radial_r_manip.C:696
Lorene::Map_radial::operator==
virtual bool operator==(const Map &) const =0
Comparison operator (egality).
Lorene::Map_radial::sstd2rdpdx
Coord sstd2rdpdx
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1648
Lorene::Map_radial::reset_coord
virtual void reset_coord()
Resets all the member Coords.
Definition map_radial.C:126
Lorene::Map_radial::lapr_tp
Coord lapr_tp
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1631
Lorene::Map_radial::reevaluate
virtual void reevaluate(const Map *mp_prev, int nzet, Cmp &uu) const
Recomputes the values of a Cmp at the collocation points after a change in the mapping.
Definition map_radial_reevaluate.C:58
Lorene::Map_radial::mult_cost
virtual void mult_cost(Scalar &) const
Multiplication by of a Scalar.
Definition map_radial_th_manip.C:61
Lorene::Map_radial::div_r
virtual void div_r(Scalar &) const
Division by r of a Scalar.
Definition map_radial_r_manip.C:514
Lorene::Map_radial::comp_x_from_spherical
virtual void comp_x_from_spherical(const Scalar &v_r, const Scalar &v_theta, const Scalar &v_phi, Scalar &v_x) const
Computes the Cartesian x component (with respect to bvect_cart) of a vector given by its spherical co...
Definition map_radial_comp_xyz.C:76
Lorene::Map_radial::sr2stdrdp
Coord sr2stdrdp
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1608
Lorene::Map_radial::drdt
Coord drdt
in the nucleus and in the non-compactified shells; \ in the compactified external domain (CED).
Definition map.h:1568
Lorene::Map_radial::val_lx_jk
virtual void val_lx_jk(double rr, int j, int k, const Param &par, int &l, double &xi) const =0
Computes the domain index l and the value of corresponding to a point of arbitrary r but collocation...
Lorene::Map_radial::srdrdt
Coord srdrdt
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1584
Lorene::Map_radial::Map_radial
Map_radial(const Mg3d &mgrid)
Constructor from a grid (protected to make Map_radial an abstract class).
Definition map_radial.C:89
Lorene::Map_radial::xsr
Coord xsr
in the nucleus; \ 1/R in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1549
Lorene::Map_radial::comp_r_from_cartesian
virtual void comp_r_from_cartesian(const Scalar &v_x, const Scalar &v_y, const Scalar &v_z, Scalar &v_r) const
Computes the Spherical r component (with respect to bvect_spher ) of a vector given by its cartesian ...
Definition map_radial_comp_rtp.C:72
Lorene::Map_radial::sauve
virtual void sauve(FILE *) const
Save in a file.
Definition map_radial.C:116
Lorene::Map_radial::~Map_radial
virtual ~Map_radial()
Destructor.
Definition map_radial.C:110
Lorene::Map_radial::mult_sint
virtual void mult_sint(Scalar &) const
Multiplication by of a Scalar.
Definition map_radial_th_manip.C:109
Lorene::Map_radial::dxdr
Coord dxdr
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1560
Lorene::Map_radial::sr2d2rdt2
Coord sr2d2rdt2
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1657
Lorene::Map_radial::comp_p_from_cartesian
virtual void comp_p_from_cartesian(const Scalar &v_x, const Scalar &v_y, Scalar &v_p) const
Computes the Spherical component (with respect to bvect_spher ) of a vector given by its cartesian c...
Definition map_radial_comp_rtp.C:183
Lorene::Map_radial::comp_z_from_spherical
virtual void comp_z_from_spherical(const Scalar &v_r, const Scalar &v_theta, Scalar &v_z) const
Computes the Cartesian z component (with respect to bvect_cart ) of a vector given by its spherical c...
Definition map_radial_comp_xyz.C:192
Lorene::Map_radial::dec2_dzpuis
virtual void dec2_dzpuis(Scalar &) const
Decreases by 2 the value of dzpuis of a Scalar and changes accordingly its values in the compactifi...
Definition map_radial_r_manip.C:748
Lorene::Map_radial::div_sint
virtual void div_sint(Scalar &) const
Division by of a Scalar.
Definition map_radial_th_manip.C:133
Lorene::Map_radial::div_cost
virtual void div_cost(Scalar &) const
Division by of a Scalar.
Definition map_radial_th_manip.C:85
Lorene::Map_radial::comp_t_from_cartesian
virtual void comp_t_from_cartesian(const Scalar &v_x, const Scalar &v_y, const Scalar &v_z, Scalar &v_t) const
Computes the Spherical component (with respect to bvect_spher ) of a vector given by its cartesian c...
Definition map_radial_comp_rtp.C:128
Lorene::Map_radial::mult_rsint
virtual void mult_rsint(Scalar &) const
Multiplication by of a Scalar.
Definition map_radial_r_manip.C:355
Lorene::Map_radial::val_r_jk
virtual double val_r_jk(int l, double xi, int j, int k) const =0
Returns the value of the radial coordinate r for a given and a given collocation point in in a give...
Lorene::Map_radial::stdrdp
Coord stdrdp
in the nucleus and in the non-compactified shells; \ in the compactified external domain (CED).
Definition map.h:1576
Lorene::Metric_flat
Flat metric for tensor calculation.
Definition metric.h:261
Lorene::Mg3d
Multi-domain grid.
Definition grilles.h:273
Lorene::Mtbl_cf
Coefficients storage for the multi-domain spectral method.
Definition mtbl_cf.h:186
Lorene::Mtbl
Multi-domain array.
Definition mtbl.h:118
Lorene::Param_elliptic
This class contains the parameters needed to call the general elliptic solver.
Definition param_elliptic.h:135
Lorene::Param
Parameter storage.
Definition param.h:125
Lorene::Scalar
Tensor field of valence 0 (or component of a tensorial field).
Definition scalar.h:387
Lorene::Tbl
Basic array class.
Definition tbl.h:161
Lorene::Tenseur
Tensor handling *** DEPRECATED : use class Tensor instead ***.
Definition tenseur.h:301
Lorene::Valeur
Values and coefficients of a (real-value) function.
Definition valeur.h:287
Lorene::bvect_spher
Base_vect_spher bvect_spher
Base class for coordinate mappings.
Definition map.h:689
Lorene
Lorene prototypes.
Definition app_hor.h:64
Lorene::adapt
virtual void adapt(const Cmp &ent, const Param &par, int nbr=0)=0
Adaptation of the mapping to a given scalar field.
Lorene::p_mp_angu
Map_af * p_mp_angu
Pointer on the "angular" mapping.
Definition map.h:715
Lorene::reset_coord
virtual void reset_coord()
Resets all the member Coords.
Lorene::div_tant
virtual void div_tant(Scalar &) const =0
Division by of a Scalar.
Lorene::z
Coord z
z coordinate centered on the grid
Definition map.h:728
Lorene::poisson_interne
virtual void poisson_interne(const Cmp &source, const Valeur &limite, Param &par, Cmp &pot) const =0
Computes the solution of a Poisson equation in the shell, imposing a boundary condition at the surfac...
Lorene::mp_angu
virtual const Map_af & mp_angu(int) const =0
Returns the "angular" mapping for the outside of domain l_zone.
Lorene::mult_rsint
virtual void mult_rsint(Scalar &) const =0
Multiplication by of a Scalar.
Lorene::reevaluate_symy
virtual void reevaluate_symy(const Map *mp_prev, int nzet, Cmp &uu) const =0
Recomputes the values of a Cmp at the collocation points after a change in the mapping.
Lorene::dsdradial
virtual void dsdradial(const Scalar &uu, Scalar &resu) const =0
Computes of a Scalar if the description is affine and if it is logarithmic.
Lorene::cmp_zero
const Cmp & cmp_zero() const
Returns the null Cmp defined on *this.
Definition map.h:807
Lorene::div_rsint
virtual void div_rsint(Scalar &) const =0
Division by of a Scalar.
Lorene::p_flat_met_spher
Metric_flat * p_flat_met_spher
Pointer onto the flat metric associated with the spherical coordinates and with components expressed ...
Definition map.h:702
Lorene::comp_t_from_cartesian
virtual void comp_t_from_cartesian(const Scalar &v_x, const Scalar &v_y, const Scalar &v_z, Scalar &v_t) const =0
Computes the Spherical component (with respect to bvect_spher ) of a vector given by its cartesian c...
Lorene::bvect_cart
Base_vect_cart bvect_cart
Cartesian basis associated with the coordinates (x,y,z) of the mapping, i.e.
Definition map.h:697
Lorene::dec2_dzpuis
virtual void dec2_dzpuis(Scalar &) const =0
Decreases by 2 the value of dzpuis of a Scalar and changes accordingly its values in the compacti...
Lorene::inc2_dzpuis
virtual void inc2_dzpuis(Scalar &) const =0
Increases by 2 the value of dzpuis of a Scalar and changes accordingly its values in the compacti...
Lorene::reevaluate
virtual void reevaluate(const Map *mp_prev, int nzet, Cmp &uu) const =0
Recomputes the values of a Cmp at the collocation points after a change in the mapping.
Lorene::srstdsdp
virtual void srstdsdp(const Cmp &ci, Cmp &resu) const =0
Computes of a Cmp .
Lorene::homothetie
virtual void homothetie(double lambda)=0
Sets a new radial scale.
Lorene::donne_para_poisson_vect
virtual Param * donne_para_poisson_vect(Param &para, int i) const =0
Function intended to be used by Map::poisson_vect and Map::poisson_vect_oohara .
Lorene::poisson2d
virtual void poisson2d(const Cmp &source_mat, const Cmp &source_quad, Param &par, Cmp &uu) const =0
Computes the solution of a 2-D Poisson equation.
Lorene::get_bvect_cart
const Base_vect_cart & get_bvect_cart() const
Returns the Cartesian basis associated with the coordinates (x,y,z) of the mapping,...
Definition map.h:791
Lorene::cost
Coord cost
Definition map.h:722
Lorene::stdsdp
virtual void stdsdp(const Scalar &uu, Scalar &resu) const =0
Computes of a Scalar .
Lorene::dsdr
virtual void dsdr(const Cmp &ci, Cmp &resu) const =0
Computes of a Cmp .
Lorene::p_flat_met_cart
Metric_flat * p_flat_met_cart
Pointer onto the flat metric associated with the Cartesian coordinates and with components expressed ...
Definition map.h:707
Lorene::get_bvect_spher
const Base_vect_spher & get_bvect_spher() const
Returns the orthonormal vectorial basis associated with the coordinates of the mapping.
Definition map.h:783
Lorene::sauve
virtual void sauve(FILE *) const
Save in a file.
Lorene::comp_r_from_cartesian
virtual void comp_r_from_cartesian(const Scalar &v_x, const Scalar &v_y, const Scalar &v_z, Scalar &v_r) const =0
Computes the Spherical r component (with respect to bvect_spher ) of a vector given by its cartesian ...
Lorene::get_ori_y
double get_ori_y() const
Returns the y coordinate of the origin.
Definition map.h:770
Lorene::p_cmp_zero
Cmp * p_cmp_zero
The null Cmp.
Definition map.h:713
Lorene::div_cost
virtual void div_cost(Scalar &) const =0
Division by of a Scalar.
Lorene::get_mg
const Mg3d * get_mg() const
Gives the Mg3d on which the mapping is defined.
Definition map.h:765
Lorene::y
Coord y
y coordinate centered on the grid
Definition map.h:727
Lorene::cosp
Coord cosp
Definition map.h:724
Lorene::flat_met_cart
const Metric_flat & flat_met_cart() const
Returns the flat metric associated with the Cartesian coordinates and with components expressed in th...
Definition map.C:331
Lorene::convert_absolute
void convert_absolute(double xx, double yy, double zz, double &rr, double &theta, double &pphi) const
Determines the coordinates corresponding to given absolute Cartesian coordinates (X,...
Definition map.C:302
Lorene::val_r
virtual double val_r(int l, double xi, double theta, double pphi) const =0
Returns the value of the radial coordinate r for a given in a given domain.
Lorene::poisson_compact
virtual void poisson_compact(const Cmp &source, const Cmp &aa, const Tenseur &bb, const Param &par, Cmp &psi) const =0
Resolution of the elliptic equation in the case where the stellar interior is covered by a single do...
Lorene::Map
Map(const Mg3d &)
Constructor from a multi-domain 3D grid.
Definition map.C:139
Lorene::operator==
virtual bool operator==(const Map &) const =0
Comparison operator (egality).
Lorene::flat_met_spher
const Metric_flat & flat_met_spher() const
Returns the flat metric associated with the spherical coordinates and with components expressed in th...
Definition map.C:321
Lorene::dsdt
virtual void dsdt(const Scalar &uu, Scalar &resu) const =0
Computes of a Scalar .
Lorene::phi
Coord phi
coordinate centered on the grid
Definition map.h:720
Lorene::integrale
virtual Tbl * integrale(const Cmp &) const =0
Computes the integral over all space of a Cmp .
Lorene::laplacien
virtual void laplacien(const Scalar &uu, int zec_mult_r, Scalar &lap) const =0
Computes the Laplacian of a scalar field.
Lorene::tet
Coord tet
coordinate centered on the grid
Definition map.h:719
Lorene::lapang
virtual void lapang(const Scalar &uu, Scalar &lap) const =0
Computes the angular Laplacian of a scalar field.
Lorene::div_r
virtual void div_r(Scalar &) const =0
Division by r of a Scalar.
Lorene::get_ori_x
double get_ori_x() const
Returns the x coordinate of the origin.
Definition map.h:768
Lorene::mult_r
virtual void mult_r(Scalar &uu) const =0
Multiplication by r of a Scalar , the dzpuis of uu is not changed.
Lorene::poisson_tau
virtual void poisson_tau(const Cmp &source, Param &par, Cmp &uu) const =0
Computes the solution of a scalar Poisson equationwith a Tau method.
Lorene::set_rot_phi
void set_rot_phi(double phi0)
Sets a new rotation angle.
Lorene::poisson
virtual void poisson(const Cmp &source, Param &par, Cmp &uu) const =0
Computes the solution of a scalar Poisson equation.
Lorene::srdsdt
virtual void srdsdt(const Cmp &ci, Cmp &resu) const =0
Computes of a Cmp .
Lorene::~Map
virtual ~Map()
Destructor.
Definition map.C:213
Lorene::get_ori_z
double get_ori_z() const
Returns the z coordinate of the origin.
Definition map.h:772
Lorene::poisson_frontiere
virtual void poisson_frontiere(const Cmp &source, const Valeur &limite, int raccord, int num_front, Cmp &pot, double=0., double=0.) const =0
Computes the solution of a Poisson equation from the domain num_front+1 .
Lorene::mult_cost
virtual void mult_cost(Scalar &) const =0
Multiplication by of a Scalar.
Lorene::x
Coord x
x coordinate centered on the grid
Definition map.h:726
Lorene::val_lx
virtual void val_lx(double rr, double theta, double pphi, int &l, double &xi) const =0
Computes the domain index l and the value of corresponding to a point given by its physical coordina...
Lorene::dec_dzpuis
virtual void dec_dzpuis(Scalar &) const =0
Decreases by 1 the value of dzpuis of a Scalar and changes accordingly its values in the compacti...
Lorene::resize
virtual void resize(int l, double lambda)=0
Rescales the outer boundary of one domain.
Lorene::xa
Coord xa
Absolute x coordinate.
Definition map.h:730
Lorene::mult_r_zec
virtual void mult_r_zec(Scalar &) const =0
Multiplication by r (in the compactified external domain only) of a Scalar.
Lorene::za
Coord za
Absolute z coordinate.
Definition map.h:732
Lorene::comp_x_from_spherical
virtual void comp_x_from_spherical(const Scalar &v_r, const Scalar &v_theta, const Scalar &v_phi, Scalar &v_x) const =0
Computes the Cartesian x component (with respect to bvect_cart ) of a vector given by its spherical c...
Lorene::operator>>
virtual ostream & operator>>(ostream &) const =0
Operator >>.
Lorene::comp_z_from_spherical
virtual void comp_z_from_spherical(const Scalar &v_r, const Scalar &v_theta, Scalar &v_z) const =0
Computes the Cartesian z component (with respect to bvect_cart ) of a vector given by its spherical c...
Lorene::set_ori
void set_ori(double xa0, double ya0, double za0)
Sets a new origin.
Lorene::sinp
Coord sinp
Definition map.h:723
Lorene::r
Coord r
r coordinate centered on the grid
Definition map.h:718
Lorene::comp_y_from_spherical
virtual void comp_y_from_spherical(const Scalar &v_r, const Scalar &v_theta, const Scalar &v_phi, Scalar &v_y) const =0
Computes the Cartesian y component (with respect to bvect_cart ) of a vector given by its spherical c...
Lorene::comp_p_from_cartesian
virtual void comp_p_from_cartesian(const Scalar &v_x, const Scalar &v_y, Scalar &v_p) const =0
Computes the Spherical component (with respect to bvect_spher ) of a vector given by its cartesian c...
Lorene::ya
Coord ya
Absolute y coordinate.
Definition map.h:731
Lorene::poisson_angu
virtual void poisson_angu(const Scalar &source, Param &par, Scalar &uu, double lambda=0) const =0
Computes the solution of the generalized angular Poisson equation.
Lorene::poisson_regular
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
Computes the solution of a scalar Poisson equation.
Lorene::inc_dzpuis
virtual void inc_dzpuis(Scalar &) const =0
Increases by 1 the value of dzpuis of a Scalar and changes accordingly its values in the compacti...
Lorene::mult_sint
virtual void mult_sint(Scalar &) const =0
Multiplication by of a Scalar.
Lorene::primr
virtual void primr(const Scalar &uu, Scalar &resu, bool null_infty) const =0
Computes the radial primitive which vanishes for .
Lorene::div_sint
virtual void div_sint(Scalar &) const =0
Division by of a Scalar.
Lorene::operator=
virtual void operator=(const Map_af &)=0
Assignment to an affine mapping.
Lorene::dsdxi
virtual void dsdxi(const Cmp &ci, Cmp &resu) const =0
Computes of a Cmp .
Lorene::sint
Coord sint
Definition map.h:721
Lorene::div_r_zec
virtual void div_r_zec(Scalar &) const =0
Division by r (in the compactified external domain only) of a Scalar.
Lorene::dalembert
virtual void dalembert(Param &par, Scalar &fJp1, const Scalar &fJ, const Scalar &fJm1, const Scalar &source) const =0
Performs one time-step integration of the d'Alembert scalar equation.
Lorene::get_rot_phi
double get_rot_phi() const
Returns the angle between the x –axis and X –axis.
Definition map.h:775