map_af_poisson_regu.C
/*
* Method of the class Map_af for the resolution of the scalar Poisson
* equation by using regularized source.
*/
/*
* 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
*
*/
char map_af_poisson_regu_C[] = "$Header: /cvsroot/Lorene/C++/Source/Map/map_af_poisson_regu.C,v 1.5 2014/10/13 08:53:03 j_novak Exp $" ;
/*
* $Id: map_af_poisson_regu.C,v 1.5 2014/10/13 08:53:03 j_novak Exp $
* $Log: map_af_poisson_regu.C,v $
* Revision 1.5 2014/10/13 08:53:03 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.4 2014/10/06 15:13:12 j_novak
* Modified #include directives to use c++ syntax.
*
* Revision 1.3 2003/12/19 16:21:43 j_novak
* Shadow hunt
*
* Revision 1.2 2003/10/03 15:58:48 j_novak
* Cleaning of some headers
*
* Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
* LORENE
*
* Revision 2.13 2000/10/25 16:05:11 keisuke
* Remake for the arbitrary regularization degree (k_div).
*
* Revision 2.12 2000/10/06 15:31:41 keisuke
* Suppress assertions for nilm_cos and nilm_sin.
* Add warnings for nilm_cos and nilm_sin.
*
* Revision 2.11 2000/09/25 15:02:48 keisuke
* modify the derivative duu_div.
*
* Revision 2.10 2000/09/11 13:50:57 keisuke
* Set the basis of duu_div to the spherical one.
*
* Revision 2.9 2000/09/11 10:15:06 keisuke
* Change the method to reconstruct source_regu.
*
* Revision 2.8 2000/09/09 14:51:20 keisuke
* Suppress uu_regu.set_dzpuis(0).
*
* Revision 2.7 2000/09/07 15:29:50 keisuke
* Add a new argument Cmp& uu.
*
* Revision 2.6 2000/09/06 10:28:42 keisuke
* Modify the scaling for derivatives.
*
* Revision 2.5 2000/09/04 15:55:38 keisuke
* Include the polar and azimuthal parts of duu_div.
*
* Revision 2.4 2000/09/04 13:08:39 keisuke
* Change alpha[0] into mp_radial->dxdr.
*
* Revision 2.3 2000/09/01 08:55:55 keisuke
* Change val_r into alpha[0].
*
* Revision 2.2 2000/08/31 15:59:51 keisuke
* Modify the arguments.
*
* Revision 2.1 2000/08/28 16:11:44 keisuke
* Add "int nzet" in the argumant.
*
* Revision 2.0 2000/08/25 08:48:36 keisuke
* *** empty log message ***
*
*
* $Header: /cvsroot/Lorene/C++/Source/Map/map_af_poisson_regu.C,v 1.5 2014/10/13 08:53:03 j_novak Exp $
*
*/
// headers C
#include <cmath>
// Header Lorene
#include "tenseur.h"
#include "matrice.h"
#include "param.h"
#include "proto.h"
//******************************************************************
namespace Lorene {
void Map_af::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 {
assert(source.get_etat() != ETATNONDEF) ;
assert(source.get_mp()->get_mg() == mg) ;
assert(k_div > 0) ;
double aa = unsgam1 ; // exponent of the specific enthalpy
int nzm1 = mg->get_nzone() - 1;
int nr = mg->get_nr(0) ;
int nt = mg->get_nt(0) ;
int np = mg->get_np(0) ;
assert(nr-k_div > 0) ;
// --------------------------------------------
// Expansion of "source" by T_i Y_l^m
// --------------------------------------------
// Expansion by cos(j \theta) and sin(j \theta) for theta direction
// ----------------------------------------------------------------
const Valeur& sourva = source.va ;
assert(sourva.get_etat() == ETATQCQ) ;
Valeur rho(sourva.get_mg()) ;
sourva.coef() ;
rho = *(sourva.c_cf) ;
// Expansion by Legendre function for theta direction
// --------------------------------------------------
rho.ylm() ;
// Obtaining the coefficients of the given source
// ----------------------------------------------
Tbl& ccf = *((rho.c_cf)->t[0]) ;
Tbl nilm_cos(np/2+1, 2*nt, nr) ;
Tbl nilm_sin(np/2+1, 2*nt, nr) ;
nilm_cos.set_etat_qcq() ;
nilm_sin.set_etat_qcq() ;
for (int k=0; k<=np; k+=2) {
int m = k / 2 ;
for (int j=0; j<nt; j++) {
int l ;
if(m%2 == 0) {
l = 2 * j ;
}
else
l = 2 * j + 1 ;
for (int i=0; i<nr; i++) {
nilm_cos.set(m, l, i) = ccf(k, j, i) ;
nilm_sin.set(m, l, i) = ccf(k+1, j, i) ;
}
}
}
// -----------------------------------------------------
// Expansion of "analytic source" by T_i Y_l^m
// -----------------------------------------------------
const Grille3d& grid = *(mg->get_grille3d(0)) ;
Tbl cf_cil(2*nt, nr, k_div) ;
cf_cil.set_etat_qcq() ;
int deg[3] ;
int dim[3] ;
deg[0] = 1 ;
deg[1] = 1 ;
deg[2] = nr ;
dim[0] = 1 ;
dim[1] = 1 ;
dim[2] = nr ;
double* tmp1 = new double[nr] ;
for (int k_deg=1; k_deg<=k_div; k_deg++) {
for (int l=0; l<2*nt; l++) {
for (int i=0; i<nr; i++) {
double xi = grid.x[i] ;
tmp1[i] = (aa + k_deg + 1.) *
( -(4. * l + 6.) * pow(1. - xi * xi, aa + k_deg) * pow(xi, l)
+ 4. * (aa + k_deg) * pow(1. - xi * xi, aa + k_deg - 1.) *
pow(xi, l + 2.) ) ;
}
if (l%2 == 0) {
cfrchebp(deg, dim, tmp1, dim, tmp1) ;
}
else
cfrchebi(deg, dim, tmp1, dim, tmp1) ;
for (int i=0; i<nr; i++) {
cf_cil.set(l, i, k_deg-1) = tmp1[i] ;
}
}
}
// Calculation of the coefficients : Solve the simultaneous equations
// -------------------------------
Tbl alm_cos(np/2+1, 2*nt, k_div) ;
Tbl alm_sin(np/2+1, 2*nt, k_div) ;
alm_cos.set_etat_qcq() ;
alm_sin.set_etat_qcq() ;
Matrice matrix(k_div, k_div) ;
matrix.set_etat_qcq() ;
Tbl rhs_cos(k_div) ;
Tbl rhs_sin(k_div) ;
rhs_cos.set_etat_qcq() ;
rhs_sin.set_etat_qcq() ;
for (int k=0; k<=np; k+=2) {
int m = k / 2 ;
for (int j=0; j<nt; j++) {
int l ;
if(m%2 == 0) {
l = 2 * j ;
}
else
l = 2 * j + 1 ;
for (int i=0; i<k_div; i++) {
for (int j2=0; j2<k_div; j2++) {
matrix.set(i, j2) = cf_cil(l, nr-1-i, j2) ;
}
}
matrix.set_band(k_div, k_div) ;
matrix.set_lu() ;
for (int i=0; i<k_div; i++) {
rhs_cos.set(i) = nilm_cos(m, l, nr-1-i) ;
rhs_sin.set(i) = nilm_sin(m, l, nr-1-i) ;
}
Tbl sol_cos = matrix.inverse(rhs_cos) ;
Tbl sol_sin = matrix.inverse(rhs_sin) ;
for (int i=0; i<k_div; i++) {
alm_cos.set(m, l, i) = sol_cos(i) ;
alm_sin.set(m, l, i) = sol_sin(i) ;
}
}
}
// -------------------------------------------------------
// Construction of the diverging analytic source
// -------------------------------------------------------
source_div.set_etat_qcq() ;
(source_div.va).set_etat_cf_qcq() ;
(source_div.va).c_cf->set_etat_qcq() ;
(source_div.va).c_cf->t[0]->set_etat_qcq() ;
Valeur& sdva = source_div.va ;
Mtbl_cf& sdva_cf = *(sdva.c_cf) ;
// Initialization
for (int k=0; k<=np; k+=2) {
for (int j=0; j<nt; j++) {
for (int i=0; i<nr; i++) {
sdva_cf.set(0, k, j, i) = 0 ;
sdva_cf.set(0, k+1, j, i) = 0 ;
}
}
}
for (int k=0; k<=np; k+=2) {
int m = k / 2 ;
for (int j=0; j<nt; j++) {
int l ;
if (m%2 == 0) {
l = 2 * j ;
}
else
l = 2 * j + 1 ;
for (int i=0; i<nr; i++) {
for (int k_deg=1; k_deg<=k_div; k_deg++) {
sdva_cf.set(0, k, j, i) = sdva_cf(0, k, j, i)
+ alm_cos(m, l, k_deg-1) * cf_cil(l, i, k_deg-1) ;
sdva_cf.set(0, k+1, j, i) = sdva_cf(0, k+1, j, i)
+ alm_sin(m, l, k_deg-1) * cf_cil(l, i, k_deg-1) ;
}
}
}
}
source_div.annule(nzet, nzm1) ;
Base_val base_std = mg->std_base_scal() ;
Base_val& base_s_div = sdva.base ;
for (int l=0; l<=nzm1; l++) {
int base_s_div_r = base_std.b[l] & MSQ_R ;
int base_s_div_p = base_std.b[l] & MSQ_P ;
base_s_div.b[l] = base_s_div_r | T_LEG_P | base_s_div_p ;
}
sdva_cf.base = base_s_div ; // copy of the base in the Mtbl_cf
sdva.ylm_i() ;
// ------------------------------------------------
// Construction of the regularized source
// ------------------------------------------------
source_regu.set_etat_qcq() ;
source_regu = source - source_div ;
// -------------------------------------------------------------
// Solving the Poisson equation for regularized source
// -------------------------------------------------------------
source_regu.set_dzpuis(4) ;
assert(uu_regu.get_mp()->get_mg() == mg) ;
(*this).poisson(source_regu, par, uu_regu) ;
// ----------------------------------------------------------
// Construction of the diverging analytic potential
// ----------------------------------------------------------
Tbl cf_pil(2*nt, nr, k_div) ;
cf_pil.set_etat_qcq() ;
double* tmp2 = new double[nr] ;
for (int k_deg=1; k_deg<=k_div; k_deg++) {
for (int l=0; l<2*nt; l++) {
for (int i=0; i<nr; i++) {
double xi = grid.x[i] ;
tmp2[i] = pow(xi, l) * pow(1. - xi * xi, aa + 1. + k_deg) ;
}
if (l%2 == 0) {
cfrchebp(deg, dim, tmp2, dim, tmp2) ;
}
else
cfrchebi(deg, dim, tmp2, dim, tmp2) ;
for (int i=0; i<nr; i++) {
cf_pil.set(l, i, k_deg-1) = tmp2[i] ;
}
}
}
uu_div.set_etat_qcq() ;
(uu_div.va).set_etat_cf_qcq() ;
((uu_div.va).c_cf)->set_etat_qcq() ;
((uu_div.va).c_cf)->t[0]->set_etat_qcq() ;
Valeur& udva = uu_div.va ;
Mtbl_cf& udva_cf = *(udva.c_cf) ;
// Initialization
for (int k=0; k<=np; k+=2) {
for (int j=0; j<nt; j++) {
for (int i=0; i<nr; i++) {
udva_cf.set(0, k, j, i) = 0 ;
udva_cf.set(0, k+1, j, i) = 0 ;
}
}
}
for (int k=0; k<=np; k+=2) {
int m = k / 2 ;
for (int j=0; j<nt; j++) {
int l ;
if (m%2 == 0) {
l = 2 * j ;
}
else
l = 2 * j + 1 ;
for (int i=0; i<nr; i++) {
for (int k_deg=1; k_deg<=k_div; k_deg++) {
udva_cf.set(0, k, j, i) = udva_cf(0, k, j, i)
+ alm_cos(m, l, k_deg-1) * cf_pil(l, i, k_deg-1) ;
udva_cf.set(0, k+1, j, i) = udva_cf(0, k+1, j, i)
+ alm_sin(m, l, k_deg-1) * cf_pil(l, i, k_deg-1) ;
}
}
}
}
uu_div.annule(nzet, nzm1) ;
Base_val& base_uu_div = (uu_div.va).base ;
for (int l=0; l<=nzm1; l++) {
int base_uu_r = base_std.b[l] & MSQ_R ;
int base_uu_p = base_std.b[l] & MSQ_P ;
base_uu_div.b[l] = base_uu_r | T_LEG_P | base_uu_p ;
}
udva_cf.base = base_uu_div ; // copy of the base in the Mtbl_cf
udva.ylm_i() ;
// Changing the radial coordinate from "xi" to "r"
// -----------------------------------------------
udva = udva * alpha[0] * alpha[0] ;
// ---------------------------------------------
// Construction of the total potential
// ---------------------------------------------
uu.set_etat_qcq() ;
uu = uu_regu + uu_div ;
// -------------------------------------------------------------------
// Construction of the derivative of the diverging potential
// -------------------------------------------------------------------
duu_div.set_etat_qcq() ;
duu_div.set(0).set_etat_qcq() ;
(duu_div.set(0).va).set_etat_cf_qcq() ;
((duu_div.set(0).va).c_cf)->set_etat_qcq() ;
((duu_div.set(0).va).c_cf)->t[0]->set_etat_qcq() ;
duu_div.set(1).set_etat_qcq() ;
(duu_div.set(1).va).set_etat_cf_qcq() ;
((duu_div.set(1).va).c_cf)->set_etat_qcq() ;
((duu_div.set(1).va).c_cf)->t[0]->set_etat_qcq() ;
duu_div.set(2).set_etat_qcq() ;
(duu_div.set(2).va).set_etat_cf_qcq() ;
((duu_div.set(2).va).c_cf)->set_etat_qcq() ;
((duu_div.set(2).va).c_cf)->t[0]->set_etat_qcq() ;
Valeur& vr = duu_div.set(0).va ;
Valeur& vt = duu_div.set(1).va ;
Valeur& vp = duu_div.set(2).va ;
Mtbl_cf& vr_cf = *(vr.c_cf) ;
Mtbl_cf& vt_cf = *(vt.c_cf) ;
Mtbl_cf& vp_cf = *(vp.c_cf) ;
// -----------
// Radial part
// -----------
Tbl cf_dril(2*nt, nr, k_div) ;
cf_dril.set_etat_qcq() ;
double* tmp3 = new double[nr] ;
for (int k_deg=1; k_deg<=k_div; k_deg++) {
for (int i=0; i<nr; i++) {
double xi = grid.x[i] ;
tmp3[i] = -2. * (aa + 1. + k_deg) * xi
* pow(1. - xi * xi, aa + k_deg) ;
}
cfrchebi(deg, dim, tmp3, dim, tmp3) ;
for (int i=0; i<nr; i++) {
cf_dril.set(0, i, k_deg-1) = tmp3[i] ;
}
for (int l=1; l<2*nt; l++) {
for (int i=0; i<nr; i++) {
double xi = grid.x[i] ;
tmp3[i] = l * pow(xi, l - 1.) * pow(1. - xi * xi, aa + 1. + k_deg)
-2. * (aa + 1. + k_deg) * pow(xi, l + 1.)
* pow(1. - xi * xi, aa + k_deg) ;
}
if (l%2 == 0) {
cfrchebi(deg, dim, tmp3, dim, tmp3) ;
}
else
cfrchebp(deg, dim, tmp3, dim, tmp3) ;
for (int i=0; i<nr; i++) {
cf_dril.set(l, i, k_deg-1) = tmp3[i] ;
}
}
}
// Initialization
for (int k=0; k<=np; k+=2) {
for (int j=0; j<nt; j++) {
for (int i=0; i<nr; i++) {
vr_cf.set(0, k, j, i) = 0 ;
vr_cf.set(0, k+1, j, i) = 0 ;
}
}
}
for (int k=0; k<=np; k+=2) {
int m = k / 2 ;
for (int j=0; j<nt; j++) {
int l ;
if (m%2 == 0) {
l = 2 * j ;
}
else
l = 2 * j + 1 ;
for (int i=0; i<nr; i++) {
for (int k_deg=1; k_deg<=k_div; k_deg++) {
vr_cf.set(0, k, j, i) = vr_cf(0, k, j, i)
+ alm_cos(m, l, k_deg-1) * cf_dril(l, i, k_deg-1) ;
vr_cf.set(0, k+1, j, i) = vr_cf(0, k+1, j, i)
+ alm_sin(m, l, k_deg-1) * cf_dril(l, i, k_deg-1) ;
}
}
}
}
(duu_div.set(0)).annule(nzet, nzm1) ;
// Reconstruction of the basis of the radial part
// ----------------------------------------------
Base_val& base_duu_div_r = vr.base ;
for (int l=0; l<=nzm1; l++) {
int base_duu_r_p = base_std.b[l] & MSQ_P ;
base_duu_div_r.b[l] = R_CHEBPIM_I | T_LEG_P | base_duu_r_p ;
}
vr_cf.base = base_duu_div_r ;
vr.ylm_i() ;
const Coord& RR = dxdr ;
// Changing the radial coordinate from "xi" to "r"
// -----------------------------------------------
Base_val sauve_base( vr.base ) ;
vr = duu_div(0).va * alpha[0] * alpha[0] * RR ;
vr.base = sauve_base ;
// -------------------------
// Polar and azimuthal parts
// -------------------------
Tbl cf_dpil(2*nt, nr, k_div) ;
cf_dpil.set_etat_qcq() ;
double* tmp4 = new double[nr] ;
for (int k_deg=1; k_deg<=k_div; k_deg++) {
for (int i=0; i<nr; i++) {
tmp4[i] = 0 ;
}
cfrchebi(deg, dim, tmp4, dim, tmp4) ;
for (int i=0; i<nr; i++) {
cf_dpil.set(0, i, k_deg-1) = tmp4[i] ;
}
for (int l=1; l<2*nt; l++) {
for (int i=0; i<nr; i++) {
double xi = grid.x[i] ;
tmp4[i] = pow(xi, l - 1.) * pow(1. - xi * xi, aa + 1. + k_deg) ;
}
if (l%2 == 0) {
cfrchebi(deg, dim, tmp4, dim, tmp4) ;
}
else
cfrchebp(deg, dim, tmp4, dim, tmp4) ;
for (int i=0; i<nr; i++) {
cf_dpil.set(l, i, k_deg-1) = tmp4[i] ;
}
}
}
// Initialization
for (int k=0; k<=np; k+=2) {
for (int j=0; j<nt; j++) {
for (int i=0; i<nr; i++) {
vt_cf.set(0, k, j, i) = 0 ;
vt_cf.set(0, k+1, j, i) = 0 ;
vp_cf.set(0, k, j, i) = 0 ;
vp_cf.set(0, k+1, j, i) = 0 ;
}
}
}
for (int k=0; k<=np; k+=2) {
int m = k / 2 ;
for (int j=0; j<nt; j++) {
int l ;
if (m%2 == 0) {
l = 2 * j ;
}
else
l = 2 * j + 1 ;
for (int i=0; i<nr; i++) {
for (int k_deg=1; k_deg<=k_div; k_deg++) {
vt_cf.set(0, k, j, i) = vt_cf(0, k, j, i)
+ alm_cos(m, l, k_deg-1) * cf_dpil(l, i, k_deg-1) ;
vt_cf.set(0, k+1, j, i) = vt_cf(0, k+1, j, i)
+ alm_sin(m, l, k_deg-1) * cf_dpil(l, i, k_deg-1) ;
vp_cf.set(0, k, j, i) = vp_cf(0, k, j, i)
+ alm_cos(m, l, k_deg-1) * cf_dpil(l, i, k_deg-1) ;
vp_cf.set(0, k+1, j, i) = vp_cf(0, k+1, j, i)
+ alm_sin(m, l, k_deg-1) * cf_dpil(l, i, k_deg-1) ;
}
}
}
}
(duu_div.set(1)).annule(nzet, nzm1) ;
(duu_div.set(2)).annule(nzet, nzm1) ;
// Reconstruction of the basis of the polar part
// ---------------------------------------------
Base_val& base_duu_div_p = vt.base ;
for (int l=0; l<=nzm1; l++) {
int base_duu_p_p = base_std.b[l] & MSQ_P ;
base_duu_div_p.b[l] = R_CHEBPIM_I | T_LEG_P | base_duu_p_p ;
}
vt_cf.base = base_duu_div_p ;
vt.ylm_i() ;
// Reconstruction of the basis of the azimuthal part
// -------------------------------------------------
Base_val& base_duu_div_t = vp.base ;
for (int l=0; l<=nzm1; l++) {
int base_duu_t_p = base_std.b[l] & MSQ_P ;
base_duu_div_t.b[l] = R_CHEBPIM_I | T_LEG_P | base_duu_t_p ;
}
vp_cf.base = base_duu_div_t ;
vp.ylm_i() ;
// Calculation of the derivatives
// ------------------------------
vt = (duu_div(1).va).dsdt() ;
vp = (duu_div(2).va).stdsdp() ;
// Changing the radial coordinate from "xi" to "r"
// -----------------------------------------------
vt = duu_div(1).va * alpha[0] ;
vp = duu_div(2).va * alpha[0] ;
// Set the basis of duu_div to the spherical one
// ---------------------------------------------
duu_div.set_triad( (*this).get_bvect_spher() ) ;
delete [] tmp1 ;
delete [] tmp2 ;
delete [] tmp3 ;
delete [] tmp4 ;
}
}
Lorene::Base_val
Bases of the spectral expansions.
Definition base_val.h:322
Lorene::Base_val::b
int * b
Array (size: nzone ) of the spectral basis in each domain.
Definition base_val.h:331
Lorene::Cmp
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition cmp.h:446
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::annule
void annule(int l)
Sets the Cmp to zero in a given domain.
Definition cmp.C:348
Lorene::Cmp::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition cmp.C:304
Lorene::Cmp::set_dzpuis
void set_dzpuis(int)
Set a value to dzpuis.
Definition cmp.C:654
Lorene::Cmp::get_mp
const Map * get_mp() const
Returns the mapping.
Definition cmp.h:901
Lorene::Coord
Active physical coordinates and mapping derivatives.
Definition coord.h:90
Lorene::Grille3d
3D grid class in one domain.
Definition grilles.h:194
Lorene::Grille3d::x
double * x
Array of values of at the nr collocation points.
Definition grilles.h:209
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::alpha
double * alpha
Array (size: mg->nzone ) of the values of in each domain.
Definition map.h:2033
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::stdsdp
virtual void stdsdp(const Scalar &uu, Scalar &resu) const
Computes of a Scalar.
Definition map_af_deriv.C:823
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::Matrice
Matrix handling.
Definition matrice.h:152
Lorene::Matrice::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition matrice.C:175
Lorene::Matrice::set
double & set(int j, int i)
Read/write of a particuliar element.
Definition matrice.h:277
Lorene::Matrice::inverse
Tbl inverse(const Tbl &sec_membre) const
Solves the linear system represented by the matrix.
Definition matrice.C:424
Lorene::Matrice::set_band
void set_band(int up, int low) const
Calculate the band storage of *std.
Definition matrice.C:364
Lorene::Matrice::set_lu
void set_lu() const
Calculate the LU-representation, assuming the band-storage has been done.
Definition matrice.C:392
Lorene::Mtbl_cf
Coefficients storage for the multi-domain spectral method.
Definition mtbl_cf.h:186
Lorene::Mtbl_cf::base
Base_val base
Bases of the spectral expansions.
Definition mtbl_cf.h:200
Lorene::Mtbl_cf::set
Tbl & set(int l)
Read/write of the Tbl containing the coefficients in a given domain.
Definition mtbl_cf.h:294
Lorene::Param
Parameter storage.
Definition param.h:125
Lorene::Tbl
Basic array class.
Definition tbl.h:161
Lorene::Tbl::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition tbl.C:361
Lorene::Tbl::set
double & set(int i)
Read/write of a particular element (index i) (1D case).
Definition tbl.h:281
Lorene::Tenseur
Tensor handling *** DEPRECATED : use class Tensor instead ***.
Definition tenseur.h:301
Lorene::Tenseur::set
Cmp & set()
Read/write for a scalar (see also operator=(const Cmp&) ).
Definition tenseur.C:824
Lorene::Tenseur::set_etat_qcq
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition tenseur.C:636
Lorene::Tenseur::set_triad
void set_triad(const Base_vect &new_triad)
Assigns a new vectorial basis (triad) of decomposition.
Definition tenseur.C:674
Lorene::Valeur
Values and coefficients of a (real-value) function.
Definition valeur.h:287
Lorene::Valeur::get_etat
int get_etat() const
Returns the logical state.
Definition valeur.h:726
Lorene::Valeur::ylm
void ylm()
Computes the coefficients of *this.
Definition valeur_ylm.C:138
Lorene::Valeur::c_cf
Mtbl_cf * c_cf
Coefficients of the spectral expansion of the function.
Definition valeur.h:302
Lorene::Valeur::coef
void coef() const
Computes the coeffcients of *this.
Definition valeur_coef.C:148
Lorene::Valeur::get_mg
const Mg3d * get_mg() const
Returns the Mg3d on which the this is defined.
Definition valeur.h:729
Lorene::Valeur::ylm_i
void ylm_i()
Inverse of ylm().
Definition valeur_ylm_i.C:131
Lorene::Valeur::base
Base_val base
Bases on which the spectral expansion is performed.
Definition valeur.h:305
Lorene::pow
Cmp pow(const Cmp &, int)
Power .
Definition cmp_math.C:348
MSQ_R
#define MSQ_R
Extraction de l'info sur R.
Definition type_parite.h:152
R_CHEBPIM_I
#define R_CHEBPIM_I
Cheb. pair-impair suivant m, impair pour m=0.
Definition type_parite.h:178
T_LEG_P
#define T_LEG_P
fct. de Legendre associees paires
Definition type_parite.h:216
MSQ_P
#define MSQ_P
Extraction de l'info sur Phi.
Definition type_parite.h:156
Lorene
Lorene prototypes.
Definition app_hor.h:64