binary_global.C
/*
* Methods of class Binary to compute global quantities
*
* (see file binary.h for documentation)
*/
/*
* Copyright (c) 2004 Francois Limousin
*
* 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 binary_global_C[] = "$Header: /cvsroot/Lorene/C++/Source/Binary/binary_global.C,v 1.16 2014/10/13 08:52:45 j_novak Exp $" ;
/*
* $Id: binary_global.C,v 1.16 2014/10/13 08:52:45 j_novak Exp $
* $Log: binary_global.C,v $
* Revision 1.16 2014/10/13 08:52:45 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.15 2006/08/01 14:26:50 f_limousin
* Small changes
*
* Revision 1.14 2006/04/11 14:25:15 f_limousin
* New version of the code : improvement of the computation of some
* critical sources, estimation of the dirac gauge, helical symmetry...
*
* Revision 1.13 2005/09/18 13:13:41 f_limousin
* Extension of vphi in the compactified domain for the computation
* of J_ADM by a volume integral.
*
* Revision 1.12 2005/09/15 14:41:04 e_gourgoulhon
* The total angular momentum is now computed via a volume integral.
*
* Revision 1.11 2005/09/13 19:38:31 f_limousin
* Reintroduction of the resolution of the equations in cartesian coordinates.
*
* Revision 1.10 2005/04/08 12:36:45 f_limousin
* Just to avoid warnings...
*
* Revision 1.9 2005/02/17 17:35:00 f_limousin
* Change the name of some quantities to be consistent with other classes
* (for instance nnn is changed to nn, shift to beta, beta to lnq...)
*
* Revision 1.8 2004/07/21 11:46:24 f_limousin
* Add function mass_adm_vol() to compute the ADM mass of the system
* with a volume integral instead of a surface one.
*
* Revision 1.7 2004/05/25 14:25:53 f_limousin
* Add the virial theorem for conformally flat configurations.
*
* Revision 1.6 2004/03/31 12:44:54 f_limousin
* Minor modifs.
*
* Revision 1.5 2004/03/25 10:29:01 j_novak
* All LORENE's units are now defined in the namespace Unites (in file unites.h).
*
* Revision 1.4 2004/02/27 10:25:30 f_limousin
* Modif. to avoid an error in compilation.
*
* Revision 1.3 2004/02/27 10:03:04 f_limousin
* The computation of mass_adm() and mass_komar() is now OK !
*
* Revision 1.2 2004/01/20 15:21:36 f_limousin
* First version
*
*
* $Header: /cvsroot/Lorene/C++/Source/Binary/binary_global.C,v 1.16 2014/10/13 08:52:45 j_novak Exp $
*
*/
// Headers C
#include "math.h"
// Headers Lorene
#include "nbr_spx.h"
#include "binary.h"
#include "unites.h"
#include "metric.h"
//---------------------------------//
// ADM mass //
//---------------------------------//
namespace Lorene {
double Binary::mass_adm() const {
using namespace Unites ;
if (p_mass_adm == 0x0) { // a new computation is requireed
p_mass_adm = new double ;
*p_mass_adm = 0 ;
const Map_af map0 (et[0]->get_mp()) ;
const Metric& flat = (et[0]->get_flat()) ;
Vector dpsi(0.5*(et[0]->get_lnq() -
et[0]->get_logn()).derive_cov(flat)) ;
Vector ww (0.125*(contract(et[0]->get_hij().derive_cov(flat), 1, 2)
- (et[0]->get_hij().trace(flat)).derive_con(flat))) ;
dpsi.change_triad(map0.get_bvect_spher()) ;
ww.change_triad(map0.get_bvect_spher()) ;
// ww = 0 in Dirac gauge (Eq 174 of BGGN)
Scalar integrand (dpsi(1) + 0*ww(1)) ;
*p_mass_adm = map0.integrale_surface_infini (integrand) / (-qpig/2.) ;
} // End of the case where a new computation was necessary
return *p_mass_adm ;
}
double Binary::mass_adm_vol() const {
using namespace Unites ;
double massadm ;
massadm = 0. ;
for (int i=0; i<=1; i++) { // loop on the stars
// Declaration of all fields
const Scalar& psi4 = et[i]->get_psi4() ;
Scalar psi (pow(psi4, 0.25)) ;
psi.std_spectral_base() ;
const Scalar& ener_euler = et[i]->get_ener_euler() ;
const Scalar& kcar_auto = et[i]->get_kcar_auto() ;
const Scalar& kcar_comp = et[i]->get_kcar_comp() ;
const Metric& gtilde = et[i]->get_gtilde() ;
const Metric& flat = et[i]->get_flat() ;
const Sym_tensor& hij = et[i]->get_hij() ;
const Sym_tensor& hij_auto = et[i]->get_hij_auto() ;
const Vector& dcov_logn = et[i]->get_dcov_logn() ;
const Vector& dcov_phi = et[i]->get_dcov_phi() ;
const Vector& dcov_lnq = 2*dcov_phi + dcov_logn ;
const Scalar& lnq_auto = et[i]->get_lnq_auto() ;
const Scalar& logn_auto = et[i]->get_logn_auto() ;
const Scalar& phi_auto = 0.5 * (lnq_auto - logn_auto) ;
const Tensor& dcov_hij_auto = hij_auto.derive_cov(flat) ;
const Tensor& dcov_gtilde = gtilde.cov().derive_cov(flat) ;
const Tensor& dcov_phi_auto = phi_auto.derive_cov(flat) ;
const Tensor& dcov_logn_auto = logn_auto.derive_cov(flat) ;
const Tensor& dcov_lnq_auto = lnq_auto.derive_cov(flat) ;
Tensor dcovdcov_lnq_auto = lnq_auto.derive_cov(flat).derive_cov(flat) ;
dcovdcov_lnq_auto.inc_dzpuis() ;
Tensor dcovdcov_logn_auto = logn_auto.derive_cov(flat).derive_cov(flat) ;
dcovdcov_logn_auto.inc_dzpuis() ;
// Source in IWM approximation
Scalar source = - psi4 % (qpig*ener_euler + (kcar_auto + kcar_comp)/4.)
- 0*2*contract(contract(gtilde.con(), 0, dcov_phi, 0),
0, dcov_phi_auto, 0, true) ;
// Source = 0 in IWM
source += 4*contract(hij, 0, 1, dcov_logn * dcov_phi_auto, 0, 1) +
2*contract(hij, 0, 1, dcov_phi * dcov_phi_auto, 0, 1) +
0.0625 * contract(gtilde.con(), 0, 1, contract(
dcov_hij_auto, 0, 1, dcov_gtilde, 0, 1), 0, 1) -
0.125 * contract(gtilde.con(), 0, 1, contract(dcov_hij_auto,
0, 1, dcov_gtilde, 0, 2), 0, 1) -
contract(hij,0,1,dcovdcov_lnq_auto + dcov_lnq_auto*dcov_lnq,0,1) +
contract(hij,0,1,dcovdcov_logn_auto + dcov_logn_auto*dcov_logn,0,1) ;
source = source * psi ;
source.std_spectral_base() ;
massadm += - source.integrale()/qpig ;
}
return massadm ;
}
//---------------------------------//
// Komar mass //
//---------------------------------//
double Binary::mass_kom() const {
using namespace Unites ;
if (p_mass_kom == 0x0) { // a new computation is requireed
p_mass_kom = new double ;
*p_mass_kom = 0 ;
const Tensor& logn = et[0]->get_logn() ;
const Metric& flat = (et[0]->get_flat()) ;
const Sym_tensor& hij = (et[0]->get_hij()) ;
Map_af map0 (et[0]->get_mp()) ;
Vector vect = logn.derive_con(flat) +
contract(hij, 1, logn.derive_cov(flat), 0) ;
vect.change_triad(map0.get_bvect_spher()) ;
Scalar integrant (vect(1)) ;
*p_mass_kom = map0.integrale_surface_infini (integrant) / qpig ;
} // End of the case where a new computation was necessary
return *p_mass_kom ;
}
double Binary::mass_kom_vol() const {
using namespace Unites ;
double masskom ;
masskom = 0. ;
for (int i=0; i<=1; i++) { // loop on the stars
// Declaration of all fields
const Scalar& psi4 = et[i]->get_psi4() ;
const Scalar& ener_euler = et[i]->get_ener_euler() ;
const Scalar& s_euler = et[i]->get_s_euler() ;
const Scalar& kcar_auto = et[i]->get_kcar_auto() ;
const Scalar& kcar_comp = et[i]->get_kcar_comp() ;
const Metric& gtilde = et[i]->get_gtilde() ;
const Metric& flat = et[i]->get_flat() ;
const Sym_tensor& hij = et[i]->get_hij() ;
const Scalar& logn = et[i]->get_logn_auto() + et[i]->get_logn_comp() ;
const Scalar& logn_auto = et[i]->get_logn_auto() ;
Scalar nn = exp(logn) ;
nn.std_spectral_base() ;
const Tensor& dcov_logn_auto = logn_auto.derive_cov(flat) ;
const Vector& dcov_logn = et[i]->get_dcov_logn() ;
const Vector& dcon_logn = et[i]->get_dcon_logn() ;
const Vector& dcov_phi = et[i]->get_dcov_phi() ;
Tensor dcovdcov_logn_auto = (logn_auto.derive_cov(flat))
.derive_cov(flat) ;
dcovdcov_logn_auto.inc_dzpuis() ;
Scalar source = qpig * psi4 % (ener_euler + s_euler) ;
source += psi4 % (kcar_auto + kcar_comp) ;
source += - 0*contract(dcov_logn_auto, 0, dcon_logn, 0, true)
- 2. * contract(contract(gtilde.con(), 0, dcov_phi, 0), 0,
dcov_logn_auto, 0, true) ;
source += - contract(hij, 0, 1, dcovdcov_logn_auto +
dcov_logn_auto*dcov_logn, 0, 1) ;
source = source / qpig * nn ;
source.std_spectral_base() ;
masskom += source.integrale() ;
}
return masskom ;
}
//---------------------------------//
// Total angular momentum //
//---------------------------------//
const Tbl& Binary::angu_mom() const {
using namespace Unites ;
/*
if (p_angu_mom == 0x0) { // a new computation is requireed
p_angu_mom = new Tbl(3) ;
p_angu_mom->annule_hard() ; // fills the double array with zeros
const Sym_tensor& kij_auto = et[0]->get_tkij_auto() ;
const Sym_tensor& kij_comp = et[0]->get_tkij_comp() ;
const Tensor& psi4 = et[0]->get_psi4() ;
const Map_af map0 (kij_auto.get_mp()) ;
Sym_tensor kij = (kij_auto + kij_comp) / psi4 ;
kij.change_triad(map0.get_bvect_cart()) ;
// X component
// -----------
Vector vect_x(et[0]->get_mp(), CON, map0.get_bvect_cart()) ;
for (int i=1; i<=3; i++) {
Scalar kij_1 = kij(3, i) ;
Scalar kij_2 = kij(2, i) ;
kij_1.mult_rsint() ;
Valeur vtmp = kij_1.get_spectral_va().mult_sp() ;
kij_1.set_spectral_va() = vtmp ;
kij_2.mult_r() ;
vtmp = kij_2.get_spectral_va().mult_ct() ;
kij_2.set_spectral_va() = vtmp ;
vect_x.set(i) = kij_1 - kij_2 ;
}
vect_x.change_triad(map0.get_bvect_spher()) ;
Scalar integrant_x (vect_x(1)) ;
p_angu_mom->set(0) = map0.integrale_surface_infini (integrant_x)
/ (8*M_PI) ;
// Y component
// -----------
Vector vect_y(et[0]->get_mp(), CON, map0.get_bvect_cart()) ;
for (int i=1; i<=3; i++) {
Scalar kij_1 = kij(1, i) ;
Scalar kij_2 = kij(3, i) ;
kij_1.mult_r() ;
Valeur vtmp = kij_1.get_spectral_va().mult_ct() ;
kij_1.set_spectral_va() = vtmp ;
kij_2.mult_rsint() ;
vtmp = kij_2.get_spectral_va().mult_cp() ;
kij_2.set_spectral_va() = vtmp ;
vect_y.set(i) = kij_1 - kij_2 ;
}
vect_y.change_triad(map0.get_bvect_spher()) ;
Scalar integrant_y (vect_y(1)) ;
p_angu_mom->set(1) = map0.integrale_surface_infini (integrant_y)
/ (8*M_PI) ;
// Z component
// -----------
Vector vect_z(et[0]->get_mp(), CON, map0.get_bvect_cart()) ;
for (int i=1; i<=3; i++) {
Scalar kij_1 = kij(2, i) ;
Scalar kij_2 = kij(1, i) ;
kij_1.mult_rsint() ;
Valeur vtmp = kij_1.get_spectral_va().mult_cp() ;
kij_1.set_spectral_va() = vtmp ;
kij_2.mult_rsint() ;
vtmp = kij_2.get_spectral_va().mult_sp() ;
kij_2.set_spectral_va() = vtmp ;
vect_z.set(i) = kij_1 - kij_2 ;
}
vect_z.change_triad(map0.get_bvect_spher()) ;
Scalar integrant_z (vect_z(1)) ;
p_angu_mom->set(2) = map0.integrale_surface_infini (integrant_z)
;// (8*M_PI) ;
} // End of the case where a new computation was necessary
*/
/*
if (p_angu_mom == 0x0) { // a new computation is requireed
p_angu_mom = new Tbl(3) ;
p_angu_mom->annule_hard() ; // fills the double array with zeros
p_angu_mom->set(0) = 0. ;
p_angu_mom->set(1) = 0. ;
// Alignement
double orientation_un = et[0]->get_mp().get_rot_phi() ;
assert ((orientation_un==0) || (orientation_un==M_PI)) ;
double orientation_deux = et[1]->get_mp().get_rot_phi() ;
assert ((orientation_deux==0) || (orientation_deux==M_PI)) ;
int same_orient = (orientation_un == orientation_deux) ? 1 : -1 ;
// Construction of an auxiliar grid and mapping
int nzones = et[0]->get_mp().get_mg()->get_nzone() ;
double* bornes = new double [nzones+1] ;
double courant = (et[0]->get_mp().get_ori_x()-et[0]->get_mp().get_ori_x())+1 ;
for (int i=nzones-1 ; i>0 ; i--) {
bornes[i] = courant ;
courant /= 2. ;
}
bornes[0] = 0 ;
bornes[nzones] = __infinity ;
Map_af mapping (*(et[0]->get_mp().get_mg()), bornes) ;
delete [] bornes ;
// Construction of k_total
Sym_tensor k_total (mapping, CON, mapping.get_bvect_cart()) ;
Vector shift_un (mapping, CON, mapping.get_bvect_cart()) ;
Vector shift_deux (mapping, CON, mapping.get_bvect_cart()) ;
Vector beta_un (et[0]->get_beta_auto()) ;
Vector beta_deux (et[1]->get_beta_auto()) ;
beta_un.change_triad(et[0]->get_mp().get_bvect_cart()) ;
beta_deux.change_triad(et[1]->get_mp().get_bvect_cart()) ;
beta_un.std_spectral_base() ;
beta_deux.std_spectral_base() ;
shift_un.set(1).import(beta_un(1)) ;
shift_un.set(2).import(beta_un(2)) ;
shift_un.set(3).import(beta_un(3)) ;
shift_deux.set(1).import(same_orient*beta_deux(1)) ;
shift_deux.set(2).import(same_orient*beta_deux(2)) ;
shift_deux.set(3).import(beta_deux(3)) ;
Vector shift_tot (shift_un+shift_deux) ;
shift_tot.std_spectral_base() ;
shift_tot.annule(0, nzones-2) ;
// Substract the residuals
shift_tot.inc_dzpuis(2) ;
shift_tot.dec_dzpuis(2) ;
Sym_tensor temp_gamt (et[0]->get_gtilde().cov()) ;
temp_gamt.change_triad(mapping.get_bvect_cart()) ;
Metric gamt_cart (temp_gamt) ;
k_total = shift_tot.ope_killing_conf(gamt_cart) / 2. ;
for (int lig=1 ; lig<=3 ; lig++)
for (int col=lig ; col<=3 ; col++)
k_total.set(lig, col).mult_r_ced() ;
Vector vecteur_un (mapping, CON, mapping.get_bvect_cart()) ;
for (int i=1 ; i<=3 ; i++)
vecteur_un.set(i) = k_total(1, i) ;
vecteur_un.change_triad (mapping.get_bvect_spher()) ;
Scalar integrant_un (vecteur_un(1)) ;
Vector vecteur_deux (mapping, CON, mapping.get_bvect_cart()) ;
for (int i=1 ; i<=3 ; i++)
vecteur_deux.set(i) = k_total(2, i) ;
vecteur_deux.change_triad (mapping.get_bvect_spher()) ;
Scalar integrant_deux (vecteur_deux(1)) ;
// Multiplication by y and x :
integrant_un.set_spectral_va() = integrant_un.get_spectral_va()
.mult_st() ;
integrant_un.set_spectral_va() = integrant_un.get_spectral_va()
.mult_sp() ;
integrant_deux.set_spectral_va() = integrant_deux.get_spectral_va()
.mult_st() ;
integrant_deux.set_spectral_va() = integrant_deux.get_spectral_va()
.mult_cp() ;
p_angu_mom->set(2) = mapping.integrale_surface_infini (-integrant_un
+integrant_deux) / (2*qpig) ;
}
*/
if (p_angu_mom == 0x0) { // a new computation is requireed
p_angu_mom = new Tbl(3) ;
p_angu_mom->annule_hard() ; // fills the double array with zeros
// Reference Cartesian vector basis of the Absolute frame
Base_vect_cart bvect_ref(0.) ; // 0. = parallel to the Absolute frame
for (int i=0; i<=1; i++) { // loop on the stars
const Map& mp = et[i]->get_mp() ;
int nzm1 = mp.get_mg()->get_nzone() - 1 ;
// Function exp(-(r-r_0)^2/sigma^2)
// --------------------------------
double r0 = mp.val_r(nzm1-1, 1, 0, 0) ;
double sigma = 1.*r0 ;
Scalar rr (mp) ;
rr = mp.r ;
Scalar ff (mp) ;
ff = exp( -(rr - r0)*(rr - r0)/sigma/sigma ) ;
for (int ii=0; ii<nzm1; ii++)
ff.set_domain(ii) = 1. ;
ff.set_outer_boundary(nzm1, 0) ;
ff.std_spectral_base() ;
// Azimuthal vector d/dphi
Vector vphi(mp, CON, bvect_ref) ;
Scalar yya (mp) ;
yya = mp.ya ;
Scalar xxa (mp) ;
xxa = mp.xa ;
vphi.set(1) = - yya * ff ; // phi^X
vphi.set(2) = xxa * ff ;
vphi.set(3) = 0 ;
vphi.set(1).set_outer_boundary(nzm1, 0) ;
vphi.set(2).set_outer_boundary(nzm1, 0) ;
vphi.std_spectral_base() ;
vphi.change_triad(mp.get_bvect_cart()) ;
// Matter part
// -----------
const Scalar& ee = et[i]->get_ener_euler() ; // E
const Scalar& pp = et[i]->get_press() ; // p
const Scalar& psi4 = et[i]->get_psi4() ; // Psi^4
Scalar rho = pow(psi4, double(2.5)) * (ee+pp) ;
rho.std_spectral_base() ;
Vector jmom = rho * (et[i]->get_u_euler()) ;
const Metric& gtilde = et[i]->get_gtilde() ;
const Metric_flat flat (mp.flat_met_cart()) ;
Vector vphi_cov = vphi.up_down(gtilde) ;
Scalar integrand = contract(jmom, 0, vphi_cov, 0) ;
p_angu_mom->set(2) += integrand.integrale() ;
// Extrinsic curvature part (0 if IWM)
// -----------------------------------
const Sym_tensor& aij = et[i]->get_tkij_auto() ;
rho = pow(psi4, double(1.5)) ;
rho.std_spectral_base() ;
// Construction of D_k \Phi^i
Itbl type (2) ;
type.set(0) = CON ;
type.set(1) = COV ;
Tensor dcov_vphi (mp, 2, type, mp.get_bvect_cart()) ;
dcov_vphi.set(1,1) = 0. ;
dcov_vphi.set(2,1) = ff ;
dcov_vphi.set(3,1) = 0. ;
dcov_vphi.set(2,2) = 0. ;
dcov_vphi.set(3,2) = 0. ;
dcov_vphi.set(3,3) = 0. ;
dcov_vphi.set(1,2) = -ff ;
dcov_vphi.set(1,3) = 0. ;
dcov_vphi.set(2,3) = 0. ;
dcov_vphi.inc_dzpuis(2) ;
Connection gamijk (gtilde, flat) ;
const Tensor& deltaijk = gamijk.get_delta() ;
// Computation of \tilde D_i \tilde \Phi_j
Sym_tensor kill_phi (mp, COV, mp.get_bvect_cart()) ;
kill_phi = contract(gtilde.cov(), 1, dcov_vphi +
contract(deltaijk, 2, vphi, 0), 0) +
contract(dcov_vphi + contract(deltaijk, 2, vphi, 0), 0,
gtilde.cov(), 1) ;
integrand = rho * contract(aij, 0, 1, kill_phi, 0, 1) ;
p_angu_mom->set(2) += integrand.integrale() / (4*qpig) ;
} // End of the loop on the stars
} // End of the case where a new computation was necessary
return *p_angu_mom ;
}
//---------------------------------//
// Total energy //
//---------------------------------//
double Binary::total_ener() const {
/*
if (p_total_ener == 0x0) { // a new computation is requireed
p_total_ener = new double ;
*p_total_ener = mass_adm() - star1.mass_b() - star2.mass_b() ;
} // End of the case where a new computation was necessary
*/
return *p_total_ener ;
}
//---------------------------------//
// Error on the virial theorem //
//---------------------------------//
double Binary::virial() const {
if (p_virial == 0x0) { // a new computation is requireed
p_virial = new double ;
*p_virial = 1. - mass_kom() / mass_adm() ;
}
return *p_virial ;
}
}
Lorene::Base_vect_cart
Cartesian vectorial bases (triads).
Definition base_vect.h:201
Lorene::Binary::mass_adm_vol
double mass_adm_vol() const
Total ADM mass (computed by a volume integral).
Definition binary_global.C:135
Lorene::Binary::mass_kom_vol
double mass_kom_vol() const
Total Komar mass (computed by a volume integral).
Definition binary_global.C:229
Lorene::Binary::et
Star_bin * et[2]
Array of the two stars (to perform loops on the stars): et[0] contains the address of star1 and et[1]...
Definition binary.h:89
Lorene::Binary::p_total_ener
double * p_total_ener
Total energy of the system.
Definition binary.h:114
Lorene::Binary::p_angu_mom
Tbl * p_angu_mom
Total angular momentum of the system.
Definition binary.h:111
Lorene::Binary::total_ener
double total_ener() const
Total energy (excluding the rest mass energy).
Definition binary_global.C:607
Lorene::Binary::angu_mom
const Tbl & angu_mom() const
Total angular momentum.
Definition binary_global.C:285
Lorene::Binary::p_mass_adm
double * p_mass_adm
Total ADM mass of the system.
Definition binary.h:105
Lorene::Binary::p_virial
double * p_virial
Virial theorem error.
Definition binary.h:117
Lorene::Binary::mass_adm
double mass_adm() const
Total ADM mass.
Definition binary_global.C:103
Lorene::Binary::virial
double virial() const
Estimates the relative error on the virial theorem.
Definition binary_global.C:627
Lorene::Binary::p_mass_kom
double * p_mass_kom
Total Komar mass of the system.
Definition binary.h:108
Lorene::Binary::mass_kom
double mass_kom() const
Total Komar mass.
Definition binary_global.C:201
Lorene::Connection
Class Connection.
Definition connection.h:113
Lorene::Connection::get_delta
const Tensor_sym & get_delta() const
Returns the tensor which defines the connection with respect to the flat one: is the difference bet...
Definition connection.h:271
Lorene::Itbl
Basic integer array class.
Definition itbl.h:122
Lorene::Itbl::set
int & set(int i)
Read/write of a particular element (index i ) (1D case).
Definition itbl.h:247
Lorene::Map_af
Affine radial mapping.
Definition map.h:2027
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::Metric_flat
Flat metric for tensor calculation.
Definition metric.h:261
Lorene::Metric
Metric for tensor calculation.
Definition metric.h:90
Lorene::Metric::con
virtual const Sym_tensor & con() const
Read-only access to the contravariant representation.
Definition metric.C:290
Lorene::Metric::cov
virtual const Sym_tensor & cov() const
Read-only access to the covariant representation.
Definition metric.C:280
Lorene::Scalar
Tensor field of valence 0 (or component of a tensorial field).
Definition scalar.h:387
Lorene::Scalar::derive_cov
const Vector & derive_cov(const Metric &gam) const
Returns the gradient (1-form = covariant vector) of *this.
Definition scalar_deriv.C:390
Lorene::Scalar::integrale
double integrale() const
Computes the integral over all space of *this .
Definition scalar_integ.C:61
Lorene::Scalar::std_spectral_base
virtual void std_spectral_base()
Sets the spectral bases of the Valeur va to the standard ones for a scalar field.
Definition scalar.C:784
Lorene::Scalar::set_outer_boundary
void set_outer_boundary(int l, double x)
Sets the value of the Scalar at the outer boundary of a given domain.
Definition scalar_manip.C:315
Lorene::Sym_tensor
Class intended to describe valence-2 symmetric tensors.
Definition sym_tensor.h:223
Lorene::Tbl
Basic array class.
Definition tbl.h:161
Lorene::Tensor
Tensor handling.
Definition tensor.h:288
Lorene::Vector
Tensor field of valence 1.
Definition vector.h:188
Lorene::Vector::std_spectral_base
virtual void std_spectral_base()
Sets the standard spectal bases of decomposition for each component.
Definition vector.C:316
Lorene::Vector::change_triad
virtual void change_triad(const Base_vect &)
Sets a new vectorial basis (triad) of decomposition and modifies the components accordingly.
Definition vector_change_triad.C:75
Lorene::Vector::set
Scalar & set(int)
Read/write access to a component.
Definition vector.C:296
Lorene::exp
Cmp exp(const Cmp &)
Exponential.
Definition cmp_math.C:270
Lorene::pow
Cmp pow(const Cmp &, int)
Power .
Definition cmp_math.C:348
Lorene::Tensor_sym::derive_cov
const Tensor_sym & derive_cov(const Metric &gam) const
Returns the covariant derivative of this with respect to some metric .
Definition tensor_sym_calculus.C:192
Lorene::Tensor::up_down
Tensor up_down(const Metric &gam) const
Computes a new tensor by raising or lowering all the indices of *this .
Definition tensor_calculus.C:305
Lorene::Tensor::derive_con
const Tensor & derive_con(const Metric &gam) const
Returns the "contravariant" derivative of this with respect to some metric , by raising the last inde...
Definition tensor.C:1014
Lorene::Tensor::inc_dzpuis
virtual void inc_dzpuis(int inc=1)
Increases by inc units the value of dzpuis and changes accordingly the values in the compactified ext...
Definition tensor.C:816
Lorene::Tensor::derive_cov
const Tensor & derive_cov(const Metric &gam) const
Returns the covariant derivative of this with respect to some metric .
Definition tensor.C:1002
Lorene::Tensor::set
Scalar & set(const Itbl &ind)
Returns the value of a component (read/write version).
Definition tensor.C:654
Lorene::contract
Tenseur contract(const Tenseur &, int id1, int id2)
Self contraction of two indices of a Tenseur .
Definition tenseur_operateur.C:279
Lorene
Lorene prototypes.
Definition app_hor.h:64
Lorene::Map
Map(const Mg3d &)
Constructor from a multi-domain 3D grid.
Definition map.C:139
Unites
Standard units of space, time and mass.