map_et_poisson.C
/*
* Method of the class Map_et for the (iterative) resolution of the scalar
* Poisson equation.
*
* (see file map.h for the documentation).
*
*/
/*
* Copyright (c) 2004 Francois Limousin
* Copyright (c) 1999-2003 Eric Gourgoulhon
* Copyright (c) 2000-2001 Philippe Grandclement
*
* 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
*
*/
char map_et_poisson_C[] = "$Header: /cvsroot/Lorene/C++/Source/Map/map_et_poisson.C,v 1.7 2014/10/13 08:53:05 j_novak Exp $" ;
/*
* $Id: map_et_poisson.C,v 1.7 2014/10/13 08:53:05 j_novak Exp $
* $Log: map_et_poisson.C,v $
* Revision 1.7 2014/10/13 08:53:05 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.6 2005/08/25 12:14:09 p_grandclement
* Addition of a new method to solve the scalar Poisson equation, based on a multi-domain Tau-method
*
* Revision 1.5 2005/04/04 21:31:31 e_gourgoulhon
* Added argument lambda to method poisson_angu
* to deal with the generalized angular Poisson equation:
* Lap_ang u + lambda u = source.
*
* Revision 1.4 2004/06/22 12:20:17 j_novak
* *** empty log message ***
*
* Revision 1.3 2004/05/25 14:28:01 f_limousin
* First version of method Map_et::poisson_angu().
*
* Revision 1.2 2003/10/15 21:11:26 e_gourgoulhon
* Added method poisson_angu.
*
* Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
* LORENE
*
* Revision 1.7 2000/05/22 14:55:30 phil
* ajout du cas dzpuis = 3
*
* Revision 1.6 2000/03/30 09:18:37 eric
* Modifs affichage.
*
* Revision 1.5 2000/03/29 12:01:38 eric
* *** empty log message ***
*
* Revision 1.4 2000/03/29 11:48:09 eric
* Modifs affichage.
*
* Revision 1.3 2000/03/10 15:48:25 eric
* MODIFS IMPORTANTES:
* ssj est desormais traitee comme un Cmp (et non plus une Valeur) ce qui
* permet un traitement automatique du dzpuis associe.
* Traitement de dzpuis.
*
* Revision 1.2 2000/03/07 16:50:57 eric
* Possibilite d'avoir une source avec dzpuis = 2.
*
* Revision 1.1 1999/12/22 17:11:24 eric
* Initial revision
*
*
* $Header: /cvsroot/Lorene/C++/Source/Map/map_et_poisson.C,v 1.7 2014/10/13 08:53:05 j_novak Exp $
*
*/
// Header Lorene:
#include "map.h"
#include "cmp.h"
#include "scalar.h"
#include "param.h"
#include "graphique.h"
//*****************************************************************************
namespace Lorene {
void Map_et::poisson(const Cmp& source, Param& par, Cmp& uu) const {
assert(source.get_etat() != ETATNONDEF) ;
assert(source.get_mp() == this) ;
assert( source.check_dzpuis(2) || source.check_dzpuis(4)
|| source.check_dzpuis(3)) ;
assert(uu.get_mp() == this) ;
assert(uu.check_dzpuis(0)) ;
int nz = mg->get_nzone() ;
int nzm1 = nz - 1 ;
// Indicator of existence of a compactified external domain
bool zec = false ;
if (mg->get_type_r(nzm1) == UNSURR) {
zec = true ;
}
//-------------------------------
// Computation of the prefactor a ---> Cmp apre
//-------------------------------
Mtbl unjj = 1 + srdrdt*srdrdt + srstdrdp*srstdrdp ;
Mtbl apre1(*mg) ;
apre1.set_etat_qcq() ;
for (int l=0; l<nz; l++) {
*(apre1.t[l]) = alpha[l]*alpha[l] ;
}
apre1 = apre1 * dxdr * dxdr * unjj ;
Cmp apre(*this) ;
apre = apre1 ;
Tbl amax0 = max(apre1) ; // maximum values in each domain
// The maximum values of a in each domain are put in a Mtbl
Mtbl amax1(*mg) ;
amax1.set_etat_qcq() ;
for (int l=0; l<nz; l++) {
*(amax1.t[l]) = amax0(l) ;
}
Cmp amax(*this) ;
amax = amax1 ;
//-------------------
// Initializations
//-------------------
int nitermax = par.get_int() ;
int& niter = par.get_int_mod() ;
double lambda = par.get_double() ;
double unmlambda = 1. - lambda ;
double precis = par.get_double(1) ;
Cmp& ssj = par.get_cmp_mod() ;
Cmp ssjm1 = ssj ;
Cmp ssjm2 = ssjm1 ;
Valeur& vuu = uu.va ;
Valeur vuujm1(*mg) ;
if (uu.get_etat() == ETATZERO) {
vuujm1 = 1 ; // to take relative differences
vuujm1.set_base( vuu.base ) ;
}
else{
vuujm1 = vuu ;
}
// Affine mapping for the Laplacian-tilde
Map_af mpaff(*this) ;
Param par_nul ;
cout << "Map_et::poisson : relat. diff. u^J <-> u^{J-1} : " << endl ;
//==========================================================================
//==========================================================================
// Start of iteration
//==========================================================================
//==========================================================================
Tbl tdiff(nz) ;
double diff ;
niter = 0 ;
do {
//====================================================================
// Computation of R(u) (the result is put in uu)
//====================================================================
//-----------------------
// First operations on uu
//-----------------------
Valeur duudx = (uu.va).dsdx() ; // d/dx
const Valeur& d2uudtdx = duudx.dsdt() ; // d^2/dxdtheta
const Valeur& std2uudpdx = duudx.stdsdp() ; // 1/sin(theta) d^2/dxdphi
//------------------
// Angular Laplacian
//------------------
Valeur sxlapang = uu.va ;
sxlapang.ylm() ;
sxlapang = sxlapang.lapang() ;
sxlapang = sxlapang.sx() ; // Lap_ang(uu) /x in the nucleus
// Lap_ang(uu) in the shells
// Lap_ang(uu) /(x-1) in the ZEC
//---------------------------------------------------------------
// Computation of
// [ 2 /(dRdx) ( A - 1 ) duu/dx + 1/R (B - 1) Lap_ang(uu) ] / x
//
// with A = 1/(dRdx) R/(x+beta_l/alpha_l) unjj
// B = [1/(dRdx) R/(x+beta_l/alpha_l)]^2 unjj
//
// The result is put in uu (via vuu)
//---------------------------------------------------------------
Valeur varduudx = duudx ;
if (zec) {
varduudx.annule(nzm1) ; // term in d/dx set to zero in the ZEC
}
uu.set_etat_qcq() ;
Base_val sauve_base = varduudx.base ;
vuu = 2. * dxdr * ( rsxdxdr * unjj - 1.) * varduudx
+ ( rsxdxdr*rsxdxdr * unjj - 1.) * xsr * sxlapang ;
vuu.set_base(sauve_base) ;
vuu = vuu.sx() ;
//---------------------------------------
// Computation of R(u)
//
// The result is put in uu (via vuu)
//---------------------------------------
sauve_base = vuu.base ;
vuu = xsr * vuu
+ 2. * dxdr * ( sr2drdt * d2uudtdx
+ sr2stdrdp * std2uudpdx ) ;
vuu += dxdr * ( lapr_tp + dxdr * (
dxdr* unjj * d2rdx2
- 2. * ( sr2drdt * d2rdtdx + sr2stdrdp * sstd2rdpdx ) )
) * duudx ;
vuu.set_base(sauve_base) ;
// Since the assignment is performed on vuu (uu.va), the treatment
// of uu.dzpuis must be performed by hand:
uu.set_dzpuis(4) ;
if (source.get_dzpuis() == 2) {
uu.dec2_dzpuis() ; // uu.dzpuis: 4 -> 2
}
if (source.get_dzpuis() == 3) {
uu.dec_dzpuis() ; //uu.dzpuis 4 -> 3
}
//====================================================================
// Computation of the effective source s^J of the ``affine''
// Poisson equation
//====================================================================
ssj = lambda * ssjm1 + unmlambda * ssjm2 ;
ssj = ( source + uu + (amax - apre) * ssj ) / amax ;
(ssj.va).set_base((source.va).base) ;
//====================================================================
// Resolution of the ``affine'' Poisson equation
//====================================================================
if ( source.get_dzpuis() == 0 ){
ssj.set_dzpuis( 4 ) ;
}
else {
ssj.set_dzpuis( source.get_dzpuis() ) ; // Choice of the resolution
// dzpuis = 2, 3 or 4
}
assert( uu.check_dzpuis( ssj.get_dzpuis() ) ) ;
mpaff.poisson(ssj, par_nul, uu) ;
tdiff = diffrel(vuu, vuujm1) ;
diff = max(tdiff) ;
cout << " step " << niter << " : " ;
for (int l=0; l<nz; l++) {
cout << tdiff(l) << " " ;
}
cout << endl ;
//=================================
// Updates for the next iteration
//=================================
ssjm2 = ssjm1 ;
ssjm1 = ssj ;
vuujm1 = vuu ;
niter++ ;
} // End of iteration
while ( (diff > precis) && (niter < nitermax) ) ;
//==========================================================================
//==========================================================================
// End of iteration
//==========================================================================
//==========================================================================
}
//*****************************************************************************
// VERSION WITH A TAU METHOD
//*****************************************************************************
void Map_et::poisson_tau(const Cmp& source, Param& par, Cmp& uu) const {
assert(source.get_etat() != ETATNONDEF) ;
assert(source.get_mp() == this) ;
assert( source.check_dzpuis(2) || source.check_dzpuis(4)
|| source.check_dzpuis(3)) ;
assert(uu.get_mp() == this) ;
assert(uu.check_dzpuis(0)) ;
int nz = mg->get_nzone() ;
int nzm1 = nz - 1 ;
// Indicator of existence of a compactified external domain
bool zec = false ;
if (mg->get_type_r(nzm1) == UNSURR) {
zec = true ;
}
//-------------------------------
// Computation of the prefactor a ---> Cmp apre
//-------------------------------
Mtbl unjj = 1 + srdrdt*srdrdt + srstdrdp*srstdrdp ;
Mtbl apre1(*mg) ;
apre1.set_etat_qcq() ;
for (int l=0; l<nz; l++) {
*(apre1.t[l]) = alpha[l]*alpha[l] ;
}
apre1 = apre1 * dxdr * dxdr * unjj ;
Cmp apre(*this) ;
apre = apre1 ;
Tbl amax0 = max(apre1) ; // maximum values in each domain
// The maximum values of a in each domain are put in a Mtbl
Mtbl amax1(*mg) ;
amax1.set_etat_qcq() ;
for (int l=0; l<nz; l++) {
*(amax1.t[l]) = amax0(l) ;
}
Cmp amax(*this) ;
amax = amax1 ;
//-------------------
// Initializations
//-------------------
int nitermax = par.get_int() ;
int& niter = par.get_int_mod() ;
double lambda = par.get_double() ;
double unmlambda = 1. - lambda ;
double precis = par.get_double(1) ;
Cmp& ssj = par.get_cmp_mod() ;
Cmp ssjm1 = ssj ;
Cmp ssjm2 = ssjm1 ;
Valeur& vuu = uu.va ;
Valeur vuujm1(*mg) ;
if (uu.get_etat() == ETATZERO) {
vuujm1 = 1 ; // to take relative differences
vuujm1.set_base( vuu.base ) ;
}
else{
vuujm1 = vuu ;
}
// Affine mapping for the Laplacian-tilde
Map_af mpaff(*this) ;
Param par_nul ;
cout << "Map_et::poisson_tau : relat. diff. u^J <-> u^{J-1} : " << endl ;
//==========================================================================
//==========================================================================
// Start of iteration
//==========================================================================
//==========================================================================
Tbl tdiff(nz) ;
double diff ;
niter = 0 ;
do {
//====================================================================
// Computation of R(u) (the result is put in uu)
//====================================================================
//-----------------------
// First operations on uu
//-----------------------
Valeur duudx = (uu.va).dsdx() ; // d/dx
const Valeur& d2uudtdx = duudx.dsdt() ; // d^2/dxdtheta
const Valeur& std2uudpdx = duudx.stdsdp() ; // 1/sin(theta) d^2/dxdphi
//------------------
// Angular Laplacian
//------------------
Valeur sxlapang = uu.va ;
sxlapang.ylm() ;
sxlapang = sxlapang.lapang() ;
sxlapang = sxlapang.sx() ; // Lap_ang(uu) /x in the nucleus
// Lap_ang(uu) in the shells
// Lap_ang(uu) /(x-1) in the ZEC
//---------------------------------------------------------------
// Computation of
// [ 2 /(dRdx) ( A - 1 ) duu/dx + 1/R (B - 1) Lap_ang(uu) ] / x
//
// with A = 1/(dRdx) R/(x+beta_l/alpha_l) unjj
// B = [1/(dRdx) R/(x+beta_l/alpha_l)]^2 unjj
//
// The result is put in uu (via vuu)
//---------------------------------------------------------------
Valeur varduudx = duudx ;
if (zec) {
varduudx.annule(nzm1) ; // term in d/dx set to zero in the ZEC
}
uu.set_etat_qcq() ;
Base_val sauve_base = varduudx.base ;
vuu = 2. * dxdr * ( rsxdxdr * unjj - 1.) * varduudx
+ ( rsxdxdr*rsxdxdr * unjj - 1.) * xsr * sxlapang ;
vuu.set_base(sauve_base) ;
vuu = vuu.sx() ;
//---------------------------------------
// Computation of R(u)
//
// The result is put in uu (via vuu)
//---------------------------------------
sauve_base = vuu.base ;
vuu = xsr * vuu
+ 2. * dxdr * ( sr2drdt * d2uudtdx
+ sr2stdrdp * std2uudpdx ) ;
vuu += dxdr * ( lapr_tp + dxdr * (
dxdr* unjj * d2rdx2
- 2. * ( sr2drdt * d2rdtdx + sr2stdrdp * sstd2rdpdx ) )
) * duudx ;
vuu.set_base(sauve_base) ;
// Since the assignment is performed on vuu (uu.va), the treatment
// of uu.dzpuis must be performed by hand:
uu.set_dzpuis(4) ;
if (source.get_dzpuis() == 2) {
uu.dec2_dzpuis() ; // uu.dzpuis: 4 -> 2
}
if (source.get_dzpuis() == 3) {
uu.dec_dzpuis() ; //uu.dzpuis 4 -> 3
}
//====================================================================
// Computation of the effective source s^J of the ``affine''
// Poisson equation
//====================================================================
ssj = lambda * ssjm1 + unmlambda * ssjm2 ;
ssj = ( source + uu + (amax - apre) * ssj ) / amax ;
(ssj.va).set_base((source.va).base) ;
//====================================================================
// Resolution of the ``affine'' Poisson equation
//====================================================================
if ( source.get_dzpuis() == 0 ){
ssj.set_dzpuis( 4 ) ;
}
else {
ssj.set_dzpuis( source.get_dzpuis() ) ; // Choice of the resolution
// dzpuis = 2, 3 or 4
}
assert( uu.check_dzpuis( ssj.get_dzpuis() ) ) ;
mpaff.poisson_tau(ssj, par_nul, uu) ;
tdiff = diffrel(vuu, vuujm1) ;
diff = max(tdiff) ;
cout << " step " << niter << " : " ;
for (int l=0; l<nz; l++) {
cout << tdiff(l) << " " ;
}
cout << endl ;
//=================================
// Updates for the next iteration
//=================================
ssjm2 = ssjm1 ;
ssjm1 = ssj ;
vuujm1 = vuu ;
niter++ ;
} // End of iteration
while ( (diff > precis) && (niter < nitermax) ) ;
//==========================================================================
//==========================================================================
// End of iteration
//==========================================================================
//==========================================================================
}
void Map_et::poisson_angu(const Scalar& source, Param& par, Scalar& uu,
double lambda) const {
if (lambda != double(0)) {
cout <<
"Map_et::poisson_angu : the case lambda != 0 is not treated yet !"
<< endl ;
abort() ;
}
assert(source.get_mp() == *this) ;
assert(uu.get_mp() == *this) ;
int nz = mg->get_nzone() ;
int nzm1 = nz - 1 ;
int* nrm6 = new int[nz];
for (int l=0; l<=nzm1; l++)
nrm6[l] = mg->get_nr(l) - 6 ;
//## // Indicator of existence of a compactified external domain
// bool zec = false ;
// if (mg->get_type_r(nzm1) == UNSURR) {
// zec = true ;
// }
//-------------------
// Initializations
//-------------------
int nitermax = par.get_int() ;
int& niter = par.get_int_mod() ;
double relax = par.get_double() ;
double precis = par.get_double(1) ;
Cmp& ssjcmp = par.get_cmp_mod() ;
Scalar ssj (ssjcmp) ;
Scalar ssjm1 (ssj) ;
int dzpuis = source.get_dzpuis() ;
ssj.set_dzpuis(dzpuis) ;
uu.set_dzpuis(dzpuis) ;
ssjm1.set_dzpuis(dzpuis) ;
Valeur& vuu = uu.set_spectral_va() ;
Valeur vuujm1(*mg) ;
if (uu.get_etat() == ETATZERO) {
vuujm1 = 1 ; // to take relative differences
vuujm1.set_base( vuu.base ) ;
}
else{
vuujm1 = vuu ;
}
// Affine mapping for the Laplacian-tilde
Map_af mpaff(*this) ;
Param par_nul ;
cout << "Map_et::poisson angu : relat. diff. u^J <-> u^{J-1} : " << endl ;
//==========================================================================
//==========================================================================
// Start of iteration
//==========================================================================
//==========================================================================
Tbl tdiff(nz) ;
double diff ;
niter = 0 ;
do {
//====================================================================
// Computation of R(u) (the result is put in uu)
//====================================================================
//-----------------------
// First operations on uu
//-----------------------
Valeur duudx = (uu.set_spectral_va()).dsdx() ; // d/dx
const Valeur& d2uudxdx = duudx.dsdx() ; // d^2/dxdx
const Valeur& d2uudtdx = duudx.dsdt() ; // d^2/dxdtheta
const Valeur& std2uudpdx = duudx.stdsdp() ; // 1/sin(theta) d^2/dxdphi
//---------------------------------------
// Computation of R(u)
//
// The result is put in uu (via vuu)
//---------------------------------------
Mtbl unjj = srdrdt*srdrdt + srstdrdp*srstdrdp ;
Base_val sauve_base = vuu.base ;
vuu = - d2uudxdx * dxdr * dxdr * unjj
+ 2. * dxdr * ( sr2drdt * d2uudtdx
+ sr2stdrdp * std2uudpdx ) ;
vuu.set_base(sauve_base) ;
vuu += dxdr * ( lapr_tp + dxdr * (
dxdr * unjj * d2rdx2
- 2. * ( sr2drdt * d2rdtdx + sr2stdrdp * sstd2rdpdx ) )
) * duudx ;
vuu.set_base(sauve_base) ;
uu.mult_r() ;
uu.mult_r() ;
//====================================================================
// Computation of the effective source s^J of the ``affine''
// Poisson equation
//====================================================================
uu.filtre_r(nrm6) ;
// uu.filtre_phi(1) ;
// uu.filtre_theta(1) ;
ssj = source + uu ;
ssj = (1-relax) * ssj + relax * ssjm1 ;
(ssj.set_spectral_va()).set_base((source.get_spectral_va()).base) ;
//====================================================================
// Resolution of the ``affine'' Poisson equation
//====================================================================
mpaff.poisson_angu(ssj, par_nul, uu) ;
tdiff = diffrel(vuu, vuujm1) ;
diff = max(tdiff) ;
cout << " step " << niter << " : " ;
for (int l=0; l<nz; l++) {
cout << tdiff(l) << " " ;
}
cout << endl ;
//=================================
// Updates for the next iteration
//=================================
vuujm1 = vuu ;
ssjm1 = ssj ;
niter++ ;
} // End of iteration
while ( (diff > precis) && (niter < nitermax) ) ;
//==========================================================================
//==========================================================================
// End of iteration
//==========================================================================
//==========================================================================
uu.set_dzpuis( source.get_dzpuis() ) ; // dzpuis unchanged
}
}
Lorene::Base_val
Bases of the spectral expansions.
Definition base_val.h:322
Lorene::Cmp
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition cmp.h:446
Lorene::Cmp::dec_dzpuis
void dec_dzpuis()
Decreases by 1 the value of dzpuis and changes accordingly the values of the Cmp in the external comp...
Definition cmp_r_manip.C:154
Lorene::Cmp::get_etat
int get_etat() const
Returns the logical state.
Definition cmp.h:899
Lorene::Cmp::va
Valeur va
The numerical value of the Cmp.
Definition cmp.h:464
Lorene::Cmp::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition cmp.C:304
Lorene::Cmp::get_dzpuis
int get_dzpuis() const
Returns dzpuis.
Definition cmp.h:903
Lorene::Cmp::set_dzpuis
void set_dzpuis(int)
Set a value to dzpuis.
Definition cmp.C:654
Lorene::Cmp::check_dzpuis
bool check_dzpuis(int dzi) const
Returns false if the last domain is compactified and *this is not zero in this domain and dzpuis is n...
Definition cmp.C:715
Lorene::Cmp::get_mp
const Map * get_mp() const
Returns the mapping.
Definition cmp.h:901
Lorene::Cmp::dec2_dzpuis
void dec2_dzpuis()
Decreases by 2 the value of dzpuis and changes accordingly the values of the Cmp in the external comp...
Definition cmp_r_manip.C:180
Lorene::Map_af
Affine radial mapping.
Definition map.h:2027
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::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::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_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::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::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::alpha
double * alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:2758
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::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::d2rdtdx
Coord d2rdtdx
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1640
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::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::sr2stdrdp
Coord sr2stdrdp
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1608
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::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::dxdr
Coord dxdr
in the nucleus and in the non-compactified shells; \ in the compactified outer domain.
Definition map.h:1560
Lorene::Mtbl
Multi-domain array.
Definition mtbl.h:118
Lorene::Mtbl::t
Tbl ** t
Array (size nzone ) of pointers on the Tbl 's.
Definition mtbl.h:132
Lorene::Mtbl::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition mtbl.C:299
Lorene::Param
Parameter storage.
Definition param.h:125
Lorene::Param::get_cmp_mod
Cmp & get_cmp_mod(int position=0) const
Returns the reference of a modifiable Cmp stored in the list.
Definition param.C:1049
Lorene::Param::get_int
const int & get_int(int position=0) const
Returns the reference of a int stored in the list.
Definition param.C:292
Lorene::Param::get_double
const double & get_double(int position=0) const
Returns the reference of a double stored in the list.
Definition param.C:361
Lorene::Param::get_int_mod
int & get_int_mod(int position=0) const
Returns the reference of a modifiable int stored in the list.
Definition param.C:430
Lorene::Scalar
Tensor field of valence 0 (or component of a tensorial field).
Definition scalar.h:387
Lorene::Scalar::get_dzpuis
int get_dzpuis() const
Returns dzpuis.
Definition scalar.h:557
Lorene::Scalar::set_spectral_va
Valeur & set_spectral_va()
Returns va (read/write version).
Definition scalar.h:604
Lorene::Scalar::get_spectral_va
const Valeur & get_spectral_va() const
Returns va (read only version).
Definition scalar.h:601
Lorene::Scalar::get_etat
int get_etat() const
Returns the logical state ETATNONDEF (undefined), ETATZERO (null) or ETATQCQ (ordinary).
Definition scalar.h:554
Lorene::Scalar::set_dzpuis
void set_dzpuis(int)
Modifies the dzpuis flag.
Definition scalar.C:808
Lorene::Scalar::filtre_r
void filtre_r(int *nn)
Sets the n lasts coefficients in r to 0 in all domains.
Definition scalar_manip.C:180
Lorene::Scalar::mult_r
void mult_r()
Multiplication by r everywhere; dzpuis is not changed.
Definition scalar_r_manip.C:208
Lorene::Tbl
Basic array class.
Definition tbl.h:161
Lorene::Valeur
Values and coefficients of a (real-value) function.
Definition valeur.h:287
Lorene::Valeur::sx
const Valeur & sx() const
Returns (r -sampling = RARE ) \ Id (r sampling = FIN ) \ (r -sampling = UNSURR ).
Definition valeur_sx.C:110
Lorene::Valeur::stdsdp
const Valeur & stdsdp() const
Returns of *this.
Definition valeur_stdsdp.C:60
Lorene::Valeur::set_base
void set_base(const Base_val &)
Sets the bases for spectral expansions (member base ).
Definition valeur.C:810
Lorene::Valeur::ylm
void ylm()
Computes the coefficients of *this.
Definition valeur_ylm.C:138
Lorene::Valeur::dsdt
const Valeur & dsdt() const
Returns of *this.
Definition valeur_dsdt.C:112
Lorene::Valeur::annule
void annule(int l)
Sets the Valeur to zero in a given domain.
Definition valeur.C:744
Lorene::Valeur::dsdx
const Valeur & dsdx() const
Returns of *this.
Definition valeur_dsdx.C:111
Lorene::Valeur::base
Base_val base
Bases on which the spectral expansion is performed.
Definition valeur.h:305
Lorene::Valeur::lapang
const Valeur & lapang() const
Returns the angular Laplacian of *this.
Definition valeur_lapang.C:72
Lorene::diffrel
Tbl diffrel(const Cmp &a, const Cmp &b)
Relative difference between two Cmp (norme version).
Definition cmp_math.C:504
Lorene::max
Tbl max(const Cmp &)
Maximum values of a Cmp in each domain.
Definition cmp_math.C:435
Lorene::Tensor::get_mp
const Map & get_mp() const
Returns the mapping.
Definition tensor.h:861
Lorene
Lorene prototypes.
Definition app_hor.h:64