star_rot_global.C
/*
* Methods for computing global quantities within the class Star_rot
*
* (see file star_rot.h for documentation)
*/
/*
* Copyright (c) 2010 Eric Gourgoulhon
*
* 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 star_rot_global_C[] = "$Header: /cvsroot/Lorene/C++/Source/Star/star_rot_global.C,v 1.5 2015/05/19 09:30:56 j_novak Exp $" ;
/*
* $Id: star_rot_global.C,v 1.5 2015/05/19 09:30:56 j_novak Exp $
* $Log: star_rot_global.C,v $
* Revision 1.5 2015/05/19 09:30:56 j_novak
* New methods for computing the area of the star and its mean radius.
*
* Revision 1.4 2014/10/13 08:53:39 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.3 2014/10/06 15:13:17 j_novak
* Modified #include directives to use c++ syntax.
*
* Revision 1.2 2010/01/25 22:33:35 e_gourgoulhon
* Debugging...
*
* Revision 1.1 2010/01/25 18:15:52 e_gourgoulhon
* First version.
*
*
*
* $Header: /cvsroot/Lorene/C++/Source/Star/star_rot_global.C,v 1.5 2015/05/19 09:30:56 j_novak Exp $
*
*/
// Headers C
#include <cstdlib>
#include <cmath>
// Headers Lorene
#include "star_rot.h"
#include "unites.h"
//--------------------------//
// Stellar surface //
//--------------------------//
namespace Lorene {
const Itbl& Star_rot::l_surf() const {
if (p_l_surf == 0x0) { // a new computation is required
assert(p_xi_surf == 0x0) ; // consistency check
int np = mp.get_mg()->get_np(0) ;
int nt = mp.get_mg()->get_nt(0) ;
p_l_surf = new Itbl(np, nt) ;
p_xi_surf = new Tbl(np, nt) ;
double ent0 = 0 ; // definition of the surface
double precis = 1.e-15 ;
int nitermax = 100 ;
int niter ;
(ent.get_spectral_va()).equipot(ent0, nzet, precis, nitermax, niter, *p_l_surf,
*p_xi_surf) ;
}
return *p_l_surf ;
}
//------------------------------//
// Baryon mass //
//------------------------------//
double Star_rot::mass_b() const {
if (p_mass_b == 0x0) { // a new computation is required
if (relativistic) {
Scalar dens = a_car * bbb * gam_euler * nbar ;
p_mass_b = new double( dens.integrale() ) ;
}
else{ // Newtonian case
assert(nbar.get_etat() == ETATQCQ) ;
p_mass_b = new double( nbar.integrale() ) ;
}
}
return *p_mass_b ;
}
//----------------------------//
// Gravitational mass //
//----------------------------//
double Star_rot::mass_g() const {
if (p_mass_g == 0x0) { // a new computation is required
if (relativistic) {
Scalar source = nn * (ener_euler + s_euler)
+ 2 * bbb * (ener_euler + press)
* tnphi * uuu ;
source = a_car * bbb * source ;
source.std_spectral_base() ;
p_mass_g = new double( source.integrale() ) ;
}
else{ // Newtonian case
p_mass_g = new double( mass_b() ) ; // in the Newtonian case
// M_g = M_b
}
}
return *p_mass_g ;
}
//----------------------------//
// Angular momentum //
//----------------------------//
double Star_rot::angu_mom() const {
if (p_angu_mom == 0x0) { // a new computation is required
Scalar dens = uuu ;
dens.mult_r() ; // Multiplication by
dens.set_spectral_va() = (dens.get_spectral_va()).mult_st() ; // r sin(theta)
if (relativistic) {
dens = a_car * b_car * (ener_euler + press) * dens ;
}
else { // Newtonian case
dens = nbar * dens ;
}
p_angu_mom = new double( dens.integrale() ) ;
}
return *p_angu_mom ;
}
//----------------------------//
// T/W //
//----------------------------//
double Star_rot::tsw() const {
if (p_tsw == 0x0) { // a new computation is required
double tcin = 0.5 * omega * angu_mom() ;
if (relativistic) {
Scalar dens = a_car * bbb * gam_euler * ener ;
double mass_p = dens.integrale() ;
p_tsw = new double( tcin / ( mass_p + tcin - mass_g() ) ) ;
}
else { // Newtonian case
Scalar dens = 0.5 * nbar * logn ;
double wgrav = dens.integrale() ;
p_tsw = new double( tcin / fabs(wgrav) ) ;
}
}
return *p_tsw ;
}
//----------------------------//
// GRV2 //
//----------------------------//
double Star_rot::grv2() const {
using namespace Unites ;
if (p_grv2 == 0x0) { // a new computation is required
Scalar sou_m(mp) ;
if (relativistic) {
sou_m = 2 * qpig * a_car * (press + (ener_euler+press)
* uuu*uuu ) ;
}
else {
sou_m = 2 * qpig * (press + nbar * uuu*uuu ) ;
}
Vector dlogn = logn.derive_cov( mp.flat_met_spher() ) ;
Scalar sou_q = 1.5 * ak_car
- dlogn(1)*dlogn(1) - dlogn(2)*dlogn(2) - dlogn(3)*dlogn(3) ;
p_grv2 = new double( double(1) - lambda_grv2(sou_m, sou_q) ) ;
}
return *p_grv2 ;
}
//----------------------------//
// GRV3 //
//----------------------------//
double Star_rot::grv3(ostream* ost) const {
using namespace Unites ;
if (p_grv3 == 0x0) { // a new computation is required
Scalar source(mp) ;
// Gravitational term [cf. Eq. (43) of Gourgoulhon & Bonazzola
// ------------------ Class. Quantum Grav. 11, 443 (1994)]
Vector dlogn = logn.derive_cov( mp.flat_met_spher() ) ;
if (relativistic) {
Scalar alpha = dzeta - logn ;
Scalar bet = log( bbb ) ;
bet.std_spectral_base() ;
Vector dalpha = alpha.derive_cov( mp.flat_met_spher() ) ;
Vector dbet = bet.derive_cov( mp.flat_met_spher() ) ;
source = 0.75 * ak_car
- dlogn(1)*dlogn(1) - dlogn(2)*dlogn(2) - dlogn(3)*dlogn(3)
+ 0.5 * ( dalpha(1)*dbet(1) + dalpha(2)*dbet(2) + dalpha(3)*dbet(3) ) ;
Scalar aa = alpha - 0.5 * bet ;
Scalar daadt = aa.srdsdt() ; // 1/r d/dth
// What follows is valid only for a mapping of class Map_radial :
const Map_radial* mpr = dynamic_cast<const Map_radial*>(&mp) ;
if (mpr == 0x0) {
cout << "Star_rot::grv3: the mapping does not belong"
<< " to the class Map_radial !" << endl ;
abort() ;
}
// Computation of 1/tan(theta) * 1/r daa/dtheta
if (daadt.get_etat() == ETATQCQ) {
Valeur& vdaadt = daadt.set_spectral_va() ;
vdaadt = vdaadt.ssint() ; // division by sin(theta)
vdaadt = vdaadt.mult_ct() ; // multiplication by cos(theta)
}
Scalar temp = aa.dsdr() + daadt ;
temp = ( bbb - a_car/bbb ) * temp ;
temp.std_spectral_base() ;
// Division by r
Valeur& vtemp = temp.set_spectral_va() ;
vtemp = vtemp.sx() ; // division by xi in the nucleus
// Id in the shells
// division by xi-1 in the ZEC
vtemp = (mpr->xsr) * vtemp ; // multiplication by xi/r in the nucleus
// by 1/r in the shells
// by r(xi-1) in the ZEC
// In the ZEC, a multiplication by r has been performed instead
// of the division:
temp.set_dzpuis( temp.get_dzpuis() + 2 ) ;
source = bbb * source + 0.5 * temp ;
}
else{
source = - 0.5 * ( dlogn(1)*dlogn(1) + dlogn(2)*dlogn(2) + dlogn(3)*dlogn(3) ) ;
}
source.std_spectral_base() ;
double int_grav = source.integrale() ;
// Matter term
// -----------
if (relativistic) {
source = qpig * a_car * bbb * s_euler ;
}
else{
source = qpig * ( 3 * press + nbar * uuu * uuu ) ;
}
source.std_spectral_base() ;
double int_mat = source.integrale() ;
// Virial error
// ------------
if (ost != 0x0) {
*ost << "Star_rot::grv3 : gravitational term : " << int_grav
<< endl ;
*ost << "Star_rot::grv3 : matter term : " << int_mat
<< endl ;
}
p_grv3 = new double( (int_grav + int_mat) / int_mat ) ;
}
return *p_grv3 ;
}
//----------------------------//
// R_circ //
//----------------------------//
double Star_rot::r_circ() const {
if (p_r_circ == 0x0) { // a new computation is required
// Index of the point at phi=0, theta=pi/2 at the surface of the star:
const Mg3d* mg = mp.get_mg() ;
assert(mg->get_type_t() == SYM) ;
int l_b = nzet - 1 ;
int i_b = mg->get_nr(l_b) - 1 ;
int j_b = mg->get_nt(l_b) - 1 ;
int k_b = 0 ;
p_r_circ = new double( bbb.val_grid_point(l_b, k_b, j_b, i_b) * ray_eq() ) ;
}
return *p_r_circ ;
}
//----------------------------//
// Surface area //
//----------------------------//
double Star_rot::area() const {
if (p_area == 0x0) { // a new computation is required
const Mg3d& mg = *(mp.get_mg()) ;
int np = mg.get_np(0) ;
int nt = mg.get_nt(0) ;
assert(np == 1) ; //Only valid for axisymmetric configurations
const Map_radial* mp_rad = dynamic_cast<const Map_radial*>(&mp) ;
assert(mp_rad != 0x0) ;
Valeur va_r(mg.get_angu()) ;
va_r.annule_hard() ;
Itbl lsurf = l_surf() ;
Tbl xisurf = xi_surf() ;
for (int k=0; k<np; k++) {
for (int j=0; j<nt; j++) {
int l_star = lsurf(k, j) ;
double xi_star = xisurf(k, j) ;
va_r.set(0, k, j, 0) = mp_rad->val_r_jk(l_star, xi_star, j, k) ;
}
}
va_r.std_base_scal() ;
Valeur integ(mg.get_angu()) ;
Valeur dr = va_r.dsdt() ;
integ = sqrt(va_r*va_r + dr*dr) ;
Valeur a2 = get_a_car().get_spectral_va() ; a2.std_base_scal() ;
Valeur b = get_bbb().get_spectral_va() ; b.std_base_scal() ;
for (int k=0; k<np; k++) {
for (int j=0; j<nt; j++) {
integ.set(0, k, j, 0) *= sqrt(a2.val_point_jk(lsurf(k, j), xisurf(k, j), j, k))
* b.val_point_jk(lsurf(k, j), xisurf(k, j), j, k) * va_r(0, k, j, 0) ;
}
}
integ.std_base_scal() ;
Valeur integ2 = integ.mult_st() ;
double surftot = 0. ;
for (int j=0; j<nt; j++) {
surftot += (*integ2.c_cf)(0, 0, j, 0) / double(2*j+1) ;
}
p_area = new double( 4*M_PI*surftot) ;
}
return *p_area ;
}
double Star_rot::mean_radius() const {
return sqrt(area()/(4*M_PI)) ;
}
//----------------------------//
// Flattening //
//----------------------------//
double Star_rot::aplat() const {
if (p_aplat == 0x0) { // a new computation is required
p_aplat = new double( ray_pole() / ray_eq() ) ;
}
return *p_aplat ;
}
//----------------------------//
// Z_eq_f //
//----------------------------//
double Star_rot::z_eqf() const {
if (p_z_eqf == 0x0) { // a new computation is required
// Index of the point at phi=0, theta=pi/2 at the surface of the star:
const Mg3d* mg = mp.get_mg() ;
assert(mg->get_type_t() == SYM) ;
int l_b = nzet - 1 ;
int i_b = mg->get_nr(l_b) - 1 ;
int j_b = mg->get_nt(l_b) - 1 ;
int k_b = 0 ;
double u_eq = uuu.val_grid_point(l_b, k_b, j_b, i_b) ;
double n_eq = nn.val_grid_point(l_b, k_b, j_b, i_b) ;
double nphi_eq = nphi.val_grid_point(l_b, k_b, j_b, i_b) ;
p_z_eqf = new double( sqrt((1.-u_eq)/(1.+u_eq))
/ (n_eq + nphi_eq * r_circ() )
- 1. ) ;
}
return *p_z_eqf ;
}
//----------------------------//
// Z_eq_b //
//----------------------------//
double Star_rot::z_eqb() const {
if (p_z_eqb == 0x0) { // a new computation is required
// Index of the point at phi=0, theta=pi/2 at the surface of the star:
const Mg3d* mg = mp.get_mg() ;
assert(mg->get_type_t() == SYM) ;
int l_b = nzet - 1 ;
int i_b = mg->get_nr(l_b) - 1 ;
int j_b = mg->get_nt(l_b) - 1 ;
int k_b = 0 ;
double u_eq = uuu.val_grid_point(l_b, k_b, j_b, i_b) ;
double n_eq = nn.val_grid_point(l_b, k_b, j_b, i_b) ;
double nphi_eq = nphi.val_grid_point(l_b, k_b, j_b, i_b) ;
p_z_eqb = new double( sqrt((1.+u_eq)/(1.-u_eq))
/ (n_eq - nphi_eq * r_circ() )
- 1. ) ;
}
return *p_z_eqb ;
}
//----------------------------//
// Z_pole //
//----------------------------//
double Star_rot::z_pole() const {
if (p_z_pole == 0x0) { // a new computation is required
double n_pole = nn.val_point(ray_pole(), 0., 0.) ;
p_z_pole = new double( 1. / n_pole - 1. ) ;
}
return *p_z_pole ;
}
//----------------------------//
// Quadrupole moment //
//----------------------------//
double Star_rot::mom_quad() const {
using namespace Unites ;
if (p_mom_quad == 0x0) { // a new computation is required
// Source for of the Poisson equation for nu
// -----------------------------------------
Scalar source(mp) ;
if (relativistic) {
Scalar bet = log(bbb) ;
bet.std_spectral_base() ;
Vector dlogn = logn.derive_cov( mp.flat_met_spher() ) ;
Vector dlogn_bet = dlogn + bet.derive_cov( mp.flat_met_spher() ) ;
source = qpig * a_car *( ener_euler + s_euler ) + ak_car
- dlogn(1)*dlogn_bet(1) - dlogn(2)*dlogn_bet(2) - dlogn(3)*dlogn_bet(3) ;
}
else {
source = qpig * nbar ;
}
source.std_spectral_base() ;
// Multiplication by -r^2 P_2(cos(theta))
// [cf Eq.(7) of Salgado et al. Astron. Astrophys. 291, 155 (1994) ]
// ------------------------------------------------------------------
// Multiplication by r^2 :
// ----------------------
source.mult_r() ;
source.mult_r() ;
if (source.check_dzpuis(2)) {
source.inc_dzpuis(2) ;
}
// Muliplication by cos^2(theta) :
// -----------------------------
Scalar temp = source ;
// What follows is valid only for a mapping of class Map_radial :
assert( dynamic_cast<const Map_radial*>(&mp) != 0x0 ) ;
if (temp.get_etat() == ETATQCQ) {
Valeur& vtemp = temp.set_spectral_va() ;
vtemp = vtemp.mult_ct() ; // multiplication by cos(theta)
vtemp = vtemp.mult_ct() ; // multiplication by cos(theta)
}
// Muliplication by -P_2(cos(theta)) :
// ----------------------------------
source = 0.5 * source - 1.5 * temp ;
// Final result
// ------------
p_mom_quad = new double( source.integrale() / qpig ) ;
}
return *p_mom_quad ;
}
}
Lorene::Itbl
Basic integer array class.
Definition itbl.h:122
Lorene::Map_radial
Base class for pure radial mappings.
Definition map.h:1536
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::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::Mg3d
Multi-domain grid.
Definition grilles.h:273
Lorene::Mg3d::get_angu
const Mg3d * get_angu() const
Returns the pointer on the associated angular grid.
Definition mg3d.C:473
Lorene::Mg3d::get_type_t
int get_type_t() const
Returns the type of sampling in the direction: SYM : : symmetry with respect to the equatorial pl...
Definition grilles.h:485
Lorene::Mg3d::get_np
int get_np(int l) const
Returns the number of points in the azimuthal direction ( ) in domain no. l.
Definition grilles.h:462
Lorene::Mg3d::get_nt
int get_nt(int l) const
Returns the number of points in the co-latitude direction ( ) in domain no. l.
Definition grilles.h:457
Lorene::Mg3d::get_nr
int get_nr(int l) const
Returns the number of points in the radial direction ( ) in domain no. l.
Definition grilles.h:452
Lorene::Scalar
Tensor field of valence 0 (or component of a tensorial field).
Definition scalar.h:387
Lorene::Scalar::srdsdt
const Scalar & srdsdt() const
Returns of *this .
Definition scalar_deriv.C:145
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::get_dzpuis
int get_dzpuis() const
Returns dzpuis.
Definition scalar.h:557
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::inc_dzpuis
virtual void inc_dzpuis(int inc=1)
Increases by inc units the value of dzpuis and changes accordingly the values of the Scalar in the co...
Definition scalar_r_manip.C:470
Lorene::Scalar::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 scalar.C:873
Lorene::Scalar::dsdr
const Scalar & dsdr() const
Returns of *this .
Definition scalar_deriv.C:113
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::mult_r
void mult_r()
Multiplication by r everywhere; dzpuis is not changed.
Definition scalar_r_manip.C:208
Lorene::Star_rot::p_angu_mom
double * p_angu_mom
Angular momentum.
Definition star_rot.h:232
Lorene::Star_rot::mean_radius
virtual double mean_radius() const
Mean star radius from the area .
Definition star_rot_global.C:416
Lorene::Star_rot::p_aplat
double * p_aplat
Flatening r_pole/r_eq.
Definition star_rot.h:237
Lorene::Star_rot::p_mom_quad
double * p_mom_quad
Quadrupole moment.
Definition star_rot.h:242
Lorene::Star_rot::mom_quad
virtual double mom_quad() const
Quadrupole moment.
Definition star_rot_global.C:521
Lorene::Star_rot::p_z_eqf
double * p_z_eqf
Forward redshift factor at equator.
Definition star_rot.h:239
Lorene::Star_rot::tnphi
Scalar tnphi
Component of the shift vector.
Definition star_rot.h:118
Lorene::Star_rot::z_pole
virtual double z_pole() const
Redshift factor at North pole.
Definition star_rot_global.C:502
Lorene::Star_rot::z_eqb
virtual double z_eqb() const
Backward redshift factor at equator.
Definition star_rot_global.C:471
Lorene::Star_rot::b_car
Scalar b_car
Square of the metric factor B.
Definition star_rot.h:110
Lorene::Star_rot::bbb
Scalar bbb
Metric factor B.
Definition star_rot.h:107
Lorene::Star_rot::mass_b
virtual double mass_b() const
Baryon mass.
Definition star_rot_global.C:98
Lorene::Star_rot::omega
double omega
Rotation angular velocity ([f_unit] ).
Definition star_rot.h:101
Lorene::Star_rot::ak_car
Scalar ak_car
Scalar .
Definition star_rot.h:186
Lorene::Star_rot::r_circ
virtual double r_circ() const
Circumferential radius.
Definition star_rot_global.C:342
Lorene::Star_rot::uuu
Scalar uuu
Norm of u_euler.
Definition star_rot.h:121
Lorene::Star_rot::z_eqf
virtual double z_eqf() const
Forward redshift factor at equator.
Definition star_rot_global.C:443
Lorene::Star_rot::nphi
Scalar nphi
Metric coefficient .
Definition star_rot.h:113
Lorene::Star_rot::mass_g
virtual double mass_g() const
Gravitational mass.
Definition star_rot_global.C:124
Lorene::Star_rot::p_area
double * p_area
Integrated surface area.
Definition star_rot.h:238
Lorene::Star_rot::aplat
virtual double aplat() const
Flatening r_pole/r_eq.
Definition star_rot_global.C:426
Lorene::Star_rot::p_grv3
double * p_grv3
Error on the virial identity GRV3.
Definition star_rot.h:235
Lorene::Star_rot::get_a_car
const Scalar & get_a_car() const
Returns the square of the metric factor A.
Definition star_rot.h:319
Lorene::Star_rot::l_surf
virtual const Itbl & l_surf() const
Description of the stellar surface: returns a 2-D Itbl containing the values of the domain index l on...
Definition star_rot_global.C:68
Lorene::Star_rot::p_tsw
double * p_tsw
Ratio T/W.
Definition star_rot.h:233
Lorene::Star_rot::relativistic
bool relativistic
Indicator of relativity: true for a relativistic star, false for a Newtonian one.
Definition star_rot.h:94
Lorene::Star_rot::tsw
virtual double tsw() const
Ratio T/W.
Definition star_rot_global.C:176
Lorene::Star_rot::grv3
virtual double grv3(ostream *ost=0x0) const
Error on the virial identity GRV3.
Definition star_rot_global.C:235
Lorene::Star_rot::dzeta
Scalar dzeta
Metric potential .
Definition star_rot.h:134
Lorene::Star_rot::area
virtual double area() const
Integrated surface area in .
Definition star_rot_global.C:366
Lorene::Star_rot::a_car
Scalar a_car
Square of the metric factor A.
Definition star_rot.h:104
Lorene::Star_rot::p_grv2
double * p_grv2
Error on the virial identity GRV2.
Definition star_rot.h:234
Lorene::Star_rot::get_bbb
const Scalar & get_bbb() const
Returns the metric factor B.
Definition star_rot.h:316
Lorene::Star_rot::p_r_circ
double * p_r_circ
Circumferential radius.
Definition star_rot.h:236
Lorene::Star_rot::grv2
virtual double grv2() const
Error on the virial identity GRV2.
Definition star_rot_global.C:204
Lorene::Star_rot::angu_mom
virtual double angu_mom() const
Angular momentum.
Definition star_rot_global.C:150
Lorene::Star_rot::p_z_eqb
double * p_z_eqb
Backward redshift factor at equator.
Definition star_rot.h:240
Lorene::Star_rot::p_z_pole
double * p_z_pole
Redshift factor at North pole.
Definition star_rot.h:241
Lorene::Star_rot::lambda_grv2
static double lambda_grv2(const Scalar &sou_m, const Scalar &sou_q)
Computes the coefficient which ensures that the GRV2 virial identity is satisfied.
Definition star_rot_lambda_grv2.C:62
Lorene::Star::ener
Scalar ener
Total energy density in the fluid frame.
Definition star.h:193
Lorene::Star::logn
Scalar logn
Logarithm of the lapse N .
Definition star.h:222
Lorene::Star::nn
Scalar nn
Lapse function N .
Definition star.h:225
Lorene::Star::p_mass_b
double * p_mass_b
Baryon mass.
Definition star.h:268
Lorene::Star::nbar
Scalar nbar
Baryon density in the fluid frame.
Definition star.h:192
Lorene::Star::ener_euler
Scalar ener_euler
Total energy density in the Eulerian frame.
Definition star.h:198
Lorene::Star::xi_surf
const Tbl & xi_surf() const
Description of the stellar surface: returns a 2-D Tbl containing the values of the radial coordinate ...
Definition star_global.C:89
Lorene::Star::p_l_surf
Itbl * p_l_surf
Description of the stellar surface: 2-D Itbl containing the values of the domain index l on the surfa...
Definition star.h:260
Lorene::Star::gam_euler
Scalar gam_euler
Lorentz factor between the fluid and Eulerian observers.
Definition star.h:204
Lorene::Star::ray_eq
double ray_eq() const
Coordinate radius at , [r_unit].
Definition star_global.C:108
Lorene::Star::s_euler
Scalar s_euler
Trace of the stress scalar in the Eulerian frame.
Definition star.h:201
Lorene::Star::p_mass_g
double * p_mass_g
Gravitational mass.
Definition star.h:269
Lorene::Star::p_xi_surf
Tbl * p_xi_surf
Description of the stellar surface: 2-D Tbl containing the values of the radial coordinate on the su...
Definition star.h:266
Lorene::Star::press
Scalar press
Fluid pressure.
Definition star.h:194
Lorene::Star::ent
Scalar ent
Log-enthalpy.
Definition star.h:190
Lorene::Star::mp
Map & mp
Mapping associated with the star.
Definition star.h:180
Lorene::Star::nzet
int nzet
Number of domains of *mp occupied by the star.
Definition star.h:183
Lorene::Star::ray_pole
double ray_pole() const
Coordinate radius at [r_unit].
Definition star_global.C:278
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::mult_ct
const Valeur & mult_ct() const
Returns applied to *this.
Definition valeur_mult_ct.C:98
Lorene::Valeur::val_point_jk
double val_point_jk(int l, double x, int j, int k) const
Computes the value of the field represented by *this at an arbitrary point in , but collocation point...
Definition valeur.C:900
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::dsdt
const Valeur & dsdt() const
Returns of *this.
Definition valeur_dsdt.C:112
Lorene::Valeur::set
Tbl & set(int l)
Read/write of the value in a given domain (configuration space).
Definition valeur.h:363
Lorene::Valeur::ssint
const Valeur & ssint() const
Returns of *this.
Definition valeur_ssint.C:112
Lorene::Valeur::c_cf
Mtbl_cf * c_cf
Coefficients of the spectral expansion of the function.
Definition valeur.h:302
Lorene::Valeur::mult_st
const Valeur & mult_st() const
Returns applied to *this.
Definition valeur_mult_st.C:97
Lorene::Valeur::std_base_scal
void std_base_scal()
Sets the bases for spectral expansions (member base ) to the standard ones for a scalar.
Definition valeur.C:824
Lorene::Valeur::annule_hard
void annule_hard()
Sets the Valeur to zero in a hard way.
Definition valeur.C:723
Lorene::Vector
Tensor field of valence 1.
Definition vector.h:188
Lorene::sqrt
Cmp sqrt(const Cmp &)
Square root.
Definition cmp_math.C:220
Lorene::log
Cmp log(const Cmp &)
Neperian logarithm.
Definition cmp_math.C:296
Lorene
Lorene prototypes.
Definition app_hor.h:64
Unites
Standard units of space, time and mass.