bin_ns_bh.C
/*
* Basic methods for class Bin_ns_bh
*
*/
/*
* Copyright (c) 2002 Philippe Grandclement, Keisuke Taniguchi,
* 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 version 2
* as published by the Free Software Foundation.
*
* 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 bin_ns_bh_C[] = "$Header: /cvsroot/Lorene/C++/Source/Bin_ns_bh/bin_ns_bh.C,v 1.15 2014/10/13 08:52:42 j_novak Exp $" ;
/*
* $Id: bin_ns_bh.C,v 1.15 2014/10/13 08:52:42 j_novak Exp $
* $Log: bin_ns_bh.C,v $
* Revision 1.15 2014/10/13 08:52:42 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.14 2014/10/06 15:13:01 j_novak
* Modified #include directives to use c++ syntax.
*
* Revision 1.13 2007/04/26 14:14:59 f_limousin
* The function fait_tkij now have default values for bound_nn and lim_nn
*
* Revision 1.12 2007/04/24 20:13:53 f_limousin
* Implementation of Dirichlet and Neumann BC for the lapse
*
* Revision 1.11 2006/09/25 10:01:49 p_grandclement
* Addition of N-dimensional Tbl
*
* Revision 1.10 2006/03/30 07:33:45 p_grandclement
* *** empty log message ***
*
* Revision 1.9 2005/12/06 07:01:58 p_grandclement
* addition of Bhole::mp scaling in affecte()
*
* Revision 1.8 2005/12/01 12:59:10 p_grandclement
* Files for bin_ns_bh project
*
* Revision 1.6 2005/08/29 15:10:15 p_grandclement
* Addition of things needed :
* 1) For BBH with different masses
* 2) Provisory files for the mixted binaries (Bh and NS) : THIS IS NOT
* WORKING YET !!!
*
* Revision 1.5 2004/03/25 10:28:58 j_novak
* All LORENE's units are now defined in the namespace Unites (in file unites.h).
*
* Revision 1.4 2003/02/13 16:40:25 p_grandclement
* Addition of various things for the Bin_ns_bh project, non of them being
* completely tested
*
* Revision 1.3 2002/12/19 14:51:19 e_gourgoulhon
* Added the new functions set_omega and set_x_axe
*
* Revision 1.2 2002/12/18 10:31:15 e_gourgoulhon
* irrot : int -> bool
*
* Revision 1.1 2002/12/17 13:10:11 e_gourgoulhon
* Methods for class Bin_ns_bh
*
*
*
*
* $Header: /cvsroot/Lorene/C++/Source/Bin_ns_bh/bin_ns_bh.C,v 1.15 2014/10/13 08:52:42 j_novak Exp $
*
*/
// C++ headers
#include "headcpp.h"
// C headers
#include <cmath>
// Lorene headers
#include "map.h"
#include "bhole.h"
#include "bin_ns_bh.h"
#include "utilitaires.h"
#include "unites.h"
#include "graphique.h"
#include "param.h"
//--------------//
// Constructors //
//--------------//
// Standard constructor
// --------------------
namespace Lorene {
Bin_ns_bh::Bin_ns_bh(Map& mp_ns, int nzet, const Eos& eos, bool irrot_ns,
Map_af& mp_bh)
: ref_triad(0., "Absolute frame Cartesian basis"),
star(mp_ns, nzet, true, eos, irrot_ns, ref_triad),
hole(mp_bh),
omega(0),
x_axe(0) {
// Pointers of derived quantities initialized to zero :
set_der_0x0() ;
}
// Copy constructor
// ----------------
Bin_ns_bh::Bin_ns_bh(const Bin_ns_bh& bibi)
: ref_triad(0., "Absolute frame Cartesian basis"),
star(bibi.star),
hole(bibi.hole),
omega(bibi.omega),
x_axe(bibi.x_axe) {
// Pointers of derived quantities initialized to zero :
set_der_0x0() ;
}
// Constructor from a file
// -----------------------
Bin_ns_bh::Bin_ns_bh(Map& mp_ns, const Eos& eos, Map_af& mp_bh, FILE* fich, bool old)
: ref_triad(0., "Absolute frame Cartesian basis"),
star(mp_ns, eos, ref_triad, fich, old),
hole(mp_bh, fich, old) {
// omega and x_axe are read in the file:
fread_be(&omega, sizeof(double), 1, fich) ;
fread_be(&x_axe, sizeof(double), 1, fich) ;
assert(hole.get_omega() == omega) ;
// Pointers of derived quantities initialized to zero :
set_der_0x0() ;
}
//------------//
// Destructor //
//------------//
Bin_ns_bh::~Bin_ns_bh(){
del_deriv() ;
}
//----------------------------------//
// Management of derived quantities //
//----------------------------------//
void Bin_ns_bh::del_deriv() const {
if (p_mass_adm != 0x0) delete p_mass_adm ;
if (p_mass_kom != 0x0) delete p_mass_kom ;
if (p_angu_mom != 0x0) delete p_angu_mom ;
if (p_total_ener != 0x0) delete p_total_ener ;
if (p_virial != 0x0) delete p_virial ;
if (p_virial_gb != 0x0) delete p_virial_gb ;
if (p_virial_fus != 0x0) delete p_virial_fus ;
if (p_ham_constr != 0x0) delete p_ham_constr ;
if (p_mom_constr != 0x0) delete p_mom_constr ;
set_der_0x0() ;
}
void Bin_ns_bh::set_der_0x0() const {
p_mass_adm = 0x0 ;
p_mass_kom = 0x0 ;
p_angu_mom = 0x0 ;
p_total_ener = 0x0 ;
p_virial = 0x0 ;
p_virial_gb = 0x0 ;
p_virial_fus = 0x0 ;
p_ham_constr = 0x0 ;
p_mom_constr = 0x0 ;
}
//--------------//
// Assignment //
//--------------//
// Assignment to another Binaire
// -----------------------------
void Bin_ns_bh::operator=(const Bin_ns_bh& bibi) {
assert( bibi.ref_triad == ref_triad ) ;
star = bibi.star ;
hole = bibi.hole ;
omega = bibi.omega ;
x_axe = bibi.x_axe ;
// ref_triad remains unchanged
del_deriv() ; // Deletes all derived quantities
}
void Bin_ns_bh::set_omega(double omega_i) {
omega = omega_i ;
hole.set_omega(omega) ;
del_deriv() ;
}
void Bin_ns_bh::set_x_axe(double x_axe_i) {
x_axe = x_axe_i ;
del_deriv() ;
}
double Bin_ns_bh::separation() const {
return star.mp.get_ori_x() - hole.mp.get_ori_x() ;
}
//--------------//
// Outputs //
//--------------//
// Save in a file
// --------------
void Bin_ns_bh::sauve(FILE* fich) const {
star.sauve(fich) ;
hole.sauve(fich) ;
fwrite_be(&omega, sizeof(double), 1, fich) ;
fwrite_be(&x_axe, sizeof(double), 1, fich) ;
}
void Bin_ns_bh::init_auto () {
// On doit faire fonction pour assurer que tout va bien sur les trucs limites
Cmp filtre_ns(star.get_mp()) ;
Cmp radius_ns (star.get_mp()) ;
radius_ns = star.get_mp().r ;
double rlim_ns = star.get_mp().val_r (0, 1, 0, 0) ;
filtre_ns = 0.5 * (1 + exp(-radius_ns*radius_ns/rlim_ns/rlim_ns)) ;
filtre_ns.std_base_scal() ;
Cmp filtre_bh(hole.get_mp()) ;
Cmp radius_bh (hole.get_mp()) ;
radius_bh = hole.get_mp().r ;
double rlim_bh = hole.get_mp().val_r (0, 1, 0, 0) ;
filtre_bh = 0.5 * (1 + exp(-radius_bh*radius_bh/rlim_bh/rlim_bh)) ;
filtre_bh.std_base_scal() ;
// Facteur conforme : pas de soucis
star.set_confpsi_auto() = sqrt(exp(star.get_beta_auto()()-star.get_logn_auto()()))*filtre_ns ;
star.set_confpsi_auto().set_std_base() ;
hole.set_psi_auto() = hole.get_psi_auto()() * filtre_bh ;
hole.set_psi_auto().std_base_scal() ;
// Le lapse
star.set_n_auto() = sqrt(exp(star.get_beta_auto()()-star.get_logn_auto()()))*filtre_ns ;
star.set_n_auto().set_std_base() ;
hole.set_n_auto() = hole.get_n_auto()() * filtre_bh ;
hole.set_n_auto().std_base_scal() ;
// On doit assurer que le lapse tot est bien zero sur l'horizon...
Cmp soustrait ((filtre_bh-0.5)*2*exp(1.)) ;
int nz = hole.get_mp().get_mg()->get_nzone() ;
Mtbl xa_hole (hole.get_mp().get_mg()) ;
xa_hole = hole.get_mp().xa ;
Mtbl ya_hole (hole.get_mp().get_mg()) ;
ya_hole = hole.get_mp().ya ;
Mtbl za_hole (hole.get_mp().get_mg()) ;
za_hole = hole.get_mp().za ;
double xa_abs, ya_abs, za_abs ;
double air, tet, phi ;
int np = hole.get_mp().get_mg()->get_np(0) ;
int nt = hole.get_mp().get_mg()->get_nt(0) ;
for (int k=0 ; k<np ; k++)
for (int j=0 ; j<nt ; j++) {
double val_hole = hole.n_auto()(1, k,j,0) ;
xa_abs = xa_hole(1,k,j,0) ;
ya_abs = ya_hole(1,k,j,0) ;
za_abs = za_hole(1,k,j,0) ;
star.get_mp().convert_absolute (xa_abs, ya_abs, za_abs, air, tet, phi) ;
double val_star = star.get_n_auto()().val_point (air, tet, phi) ;
for (int l=1 ; l<nz ; l++)
for (int i=0 ; i<hole.get_mp().get_mg()->get_nr(l) ; i++)
hole.set_n_auto().set(l,k,j,i) -= (val_star+val_hole)*soustrait(l,k,j,i) ;
}
hole.set_n_auto().std_base_scal() ;
hole.set_n_auto().raccord(1) ;
}
// *********************************
// Affectation to another Bin_ns_bh
//**********************************
void Bin_ns_bh::affecte(const Bin_ns_bh& so) {
// Kinematic quantities :
star.nzet = so.star.nzet ;
set_omega(so.omega) ;
x_axe = so.x_axe ;
star.set_mp().set_ori (so.star.mp.get_ori_x(), 0., 0.) ;
hole.set_mp().set_ori (so.hole.mp.get_ori_x(), 0., 0.) ;
star.set_mp().set_rot_phi (so.star.mp.get_rot_phi()) ;
hole.set_mp().set_rot_phi (so.hole.mp.get_rot_phi()) ;
hole.set_mp().homothetie_interne (so.hole.get_rayon()/hole.rayon) ;
hole.set_rayon(so.hole.get_rayon()) ;
// Faut gêrer le map_et :
Map_et* map_et = dynamic_cast<Map_et*>(&star.mp) ;
Map_et* map_et_so = dynamic_cast<Map_et*>(&so.star.mp) ;
int kmax = -1 ;
int jmax = -1 ;
int np = map_et->get_mg()->get_np(star.nzet-1) ;
int nt = map_et->get_mg()->get_nt(star.nzet-1) ;
Mtbl phi (map_et->get_mg()) ;
phi = map_et->phi ;
Mtbl tet (map_et->get_mg()) ;
tet = map_et->tet ;
double rmax = 0 ;
for (int k=0 ; k<np ; k++)
for (int j=0 ; j<nt ; j++) {
double rcourant = map_et_so->val_r(star.nzet-1, 1, tet(0,k,j,0), phi(0,k,j,0)) ;
if (rcourant > rmax) {
rmax = rcourant ;
kmax = k ;
jmax = j ;
}
}
double old_r = map_et->val_r(star.nzet-1, 1, tet(0,kmax,jmax,0), phi(0,kmax,jmax,0)) ;
map_et->homothetie (rmax/old_r) ;
star.ent.allocate_all() ;
star.ent.set().import(star.nzet, so.star.ent()) ;
star.ent.set_std_base() ;
Param par_adapt ;
int nitermax = 100 ;
int niter_adapt ;
int adapt_flag = 1 ;
int nz_search = star.nzet + 1 ;
double precis_secant = 1.e-14 ;
double alpha_r = 1. ;
double reg_map = 1. ;
Tbl ent_limit(star.nzet) ;
par_adapt.add_int(nitermax, 0) ;
par_adapt.add_int(star.nzet, 1) ;
par_adapt.add_int(nz_search, 2) ;
par_adapt.add_int(adapt_flag, 3) ;
par_adapt.add_int(jmax, 4) ;
par_adapt.add_int(kmax, 5) ;
par_adapt.add_int_mod(niter_adapt, 0) ;
par_adapt.add_double(precis_secant, 0) ;
par_adapt.add_double(reg_map, 1) ;
par_adapt.add_double(alpha_r, 2) ;
par_adapt.add_tbl(ent_limit, 0) ;
Map_et mp_prev = *map_et ;
ent_limit.set_etat_qcq() ;
for (int l=0; l<star.nzet-1; l++) {
int nr = map_et->get_mg()->get_nr(l) ;
ent_limit.set(l) = star.ent()(l, kmax, jmax, nr-1) ;
}
ent_limit.set(star.nzet-1) = 0 ;
// On adapte :
map_et->adapt(star.ent(), par_adapt) ;
mp_prev.homothetie(alpha_r) ;
map_et->reevaluate_symy (&mp_prev, star.nzet, star.ent.set()) ;
star.ent.set().import(star.nzet, so.star.ent()) ;
// The BH part :
// Lapse :
hole.n_auto.allocate_all() ;
Cmp auxi_n (so.hole.n_auto()) ;
auxi_n.raccord(1) ;
hole.n_auto.set().import(auxi_n) ;
hole.n_auto.set().std_base_scal() ;
hole.n_auto.set().raccord(1) ;
// Psi :
hole.psi_auto.allocate_all() ;
Cmp auxi_psi (so.hole.psi_auto()) ;
auxi_psi.raccord(1) ;
hole.psi_auto.set().import(auxi_psi) ;
hole.psi_auto.set().std_base_scal() ;
hole.psi_auto.set().raccord(1) ;
// Shift :
hole.shift_auto.allocate_all() ;
Tenseur auxi_shift (so.hole.shift_auto) ;
for (int i=0 ; i<3 ; i++)
auxi_shift.set(i).raccord(1) ;
hole.shift_auto.set(0).import(auxi_shift(0)) ;
hole.shift_auto.set(1).import(auxi_shift(1)) ;
hole.shift_auto.set(2).import(auxi_shift(2)) ;
hole.shift_auto.set_std_base() ;
// The NS part :
star.n_auto.allocate_all() ;
star.n_auto.set().import(so.star.n_auto()) ;
star.n_auto.set().std_base_scal() ;
// Psi :
star.confpsi_auto.allocate_all() ;
star.confpsi_auto.set().import(so.star.confpsi_auto()) ;
star.confpsi_auto.set().std_base_scal() ;
// Shift :
star.w_shift.allocate_all() ;
star.w_shift.set(0).import(so.star.w_shift(0)) ;
star.w_shift.set(1).import(so.star.w_shift(1)) ;
star.w_shift.set(2).import(so.star.w_shift(2)) ;
star.w_shift.set_std_base() ;
star.khi_shift.allocate_all() ;
star.khi_shift.set().import(so.star.khi_shift()) ;
star.khi_shift.set().std_base_scal() ;
star.fait_shift_auto() ;
Tenseur copie_dpsi (so.star.d_psi) ;
copie_dpsi.set(2).dec2_dzpuis() ;
if (so.star.is_irrotational()) {
star.d_psi.allocate_all() ;
star.d_psi.set(0).import(star.nzet, copie_dpsi(0)) ;
star.d_psi.set(1).import(star.nzet, copie_dpsi(1)) ;
star.d_psi.set(2).import(star.nzet, copie_dpsi(2)) ;
star.d_psi.set_std_base() ;
}
// Reconstruction of the fields :
hole.update_metric(star) ;
star.update_metric(hole) ;
star.update_metric_der_comp(hole) ;
fait_tkij() ;
star.kinematics(omega, x_axe) ;
star.equation_of_state() ;
star.hydro_euler() ;
}
// Printing
// --------
ostream& operator<<(ostream& ost, const Bin_ns_bh& bibi) {
bibi >> ost ;
return ost ;
}
ostream& Bin_ns_bh::operator>>(ostream& ost) const {
using namespace Unites ;
ost << endl ;
ost << "Neutron star - black hole binary system" << endl ;
ost << "=======================================" << endl ;
ost << endl <<
"Orbital angular velocity : " << omega * f_unit << " rad/s" << endl ;
ost <<
"Absolute coordinate X of the rotation axis : " << x_axe / km
<< " km" << endl ;
ost << endl << "Neutron star : " << endl ;
ost << "============ " << endl ;
ost << star << endl ;
ost << "Black hole : " << endl ;
ost << "========== " << endl ;
ost << "Coordinate radius of the throat : " << hole.get_rayon() / km << " km" << endl ;
ost << "Absolute abscidia of the throat center : " << (hole.get_mp()).get_ori_x() / km
<< " km" << endl ;
return ost ;
}
}
Lorene::Bhole::get_n_auto
const Tenseur & get_n_auto() const
Returns the part of N generated by the hole.
Definition bhole.h:395
Lorene::Bhole::get_mp
const Map_af & get_mp() const
Returns the mapping (readonly).
Definition bhole.h:339
Lorene::Bhole::n_auto
Tenseur n_auto
Part of N generated by the hole.
Definition bhole.h:286
Lorene::Bhole::get_psi_auto
const Tenseur & get_psi_auto() const
Returns the part of generated by the hole.
Definition bhole.h:412
Lorene::Bhole::sauve
void sauve(FILE *fich) const
Write on a file.
Definition bhole.C:482
Lorene::Bin_ns_bh
Neutron star - black hole binary system.
Definition bin_ns_bh.h:117
Lorene::Bin_ns_bh::operator<<
friend ostream & operator<<(ostream &, const Bin_ns_bh &)
Save in a file.
Definition bin_ns_bh.C:475
Lorene::Bin_ns_bh::p_mass_kom
double * p_mass_kom
Total Komar mass of the system.
Definition bin_ns_bh.h:149
Lorene::Bin_ns_bh::p_virial
double * p_virial
Virial theorem error.
Definition bin_ns_bh.h:158
Lorene::Bin_ns_bh::fait_tkij
void fait_tkij(int bound_nn=-1, double lim_nn=0)
Computation of the extrinsic curvature tensor for both {\tt star} and {\tt bhole}.
Definition bin_ns_bh_kij.C:257
Lorene::Bin_ns_bh::set_omega
void set_omega(double)
Sets the orbital angular velocity [{\tt f_unit}].
Definition bin_ns_bh.C:218
Lorene::Bin_ns_bh::p_total_ener
double * p_total_ener
Total energy of the system.
Definition bin_ns_bh.h:155
Lorene::Bin_ns_bh::operator=
void operator=(const Bin_ns_bh &)
Assignment to another Bin_ns_bh.
Definition bin_ns_bh.C:202
Lorene::Bin_ns_bh::operator>>
ostream & operator>>(ostream &) const
Operator >> (function called by the operator <<).
Definition bin_ns_bh.C:481
Lorene::Bin_ns_bh::x_axe
double x_axe
Absolute X coordinate of the rotation axis.
Definition bin_ns_bh.h:140
Lorene::Bin_ns_bh::set_x_axe
void set_x_axe(double)
Sets the absolute coordinate X of the rotation axis [{\tt r_unit}].
Definition bin_ns_bh.C:227
Lorene::Bin_ns_bh::star
Et_bin_nsbh star
The neutron star.
Definition bin_ns_bh.h:128
Lorene::Bin_ns_bh::p_virial_gb
double * p_virial_gb
Virial theorem error by E.Gourgoulhon and S.Bonazzola.
Definition bin_ns_bh.h:161
Lorene::Bin_ns_bh::hole
Bhole hole
The black hole.
Definition bin_ns_bh.h:131
Lorene::Bin_ns_bh::p_mom_constr
Tbl * p_mom_constr
Relative error on the momentum constraint.
Definition bin_ns_bh.h:170
Lorene::Bin_ns_bh::p_mass_adm
double * p_mass_adm
Total ADM mass of the system.
Definition bin_ns_bh.h:146
Lorene::Bin_ns_bh::separation
double separation() const
Return the separation.
Definition bin_ns_bh.C:235
Lorene::Bin_ns_bh::p_ham_constr
double * p_ham_constr
Relative error on the Hamiltonian constraint.
Definition bin_ns_bh.h:167
Lorene::Bin_ns_bh::ref_triad
const Base_vect_cart ref_triad
Cartesian triad of the absolute reference frame.
Definition bin_ns_bh.h:125
Lorene::Bin_ns_bh::set_der_0x0
void set_der_0x0() const
Sets to {\tt 0x0} all the pointers on derived quantities.
Definition bin_ns_bh.C:181
Lorene::Bin_ns_bh::del_deriv
void del_deriv() const
Destructor.
Definition bin_ns_bh.C:163
Lorene::Bin_ns_bh::p_virial_fus
double * p_virial_fus
Virial theorem error by J.L.Friedman, K.Uryu, and M.Shibata.
Definition bin_ns_bh.h:164
Lorene::Bin_ns_bh::p_angu_mom
Tbl * p_angu_mom
Total angular momentum of the system.
Definition bin_ns_bh.h:152
Lorene::Bin_ns_bh::Bin_ns_bh
Bin_ns_bh(Map &mp_ns, int nzet, const Eos &eos, bool irrot_ns, Map_af &mp_bh)
Standard constructor.
Definition bin_ns_bh.C:107
Lorene::Bin_ns_bh::omega
double omega
Angular velocity with respect to an asymptotically inertial observer.
Definition bin_ns_bh.h:136
Lorene::Cmp::std_base_scal
void std_base_scal()
Sets the spectral bases of the Valeur va to the standard ones for a scalar.
Definition cmp.C:644
Lorene::Cmp::set
Tbl & set(int l)
Read/write of the value in a given domain.
Definition cmp.h:724
Lorene::Eos
Equation of state base class.
Definition eos.h:190
Lorene::Et_bin_nsbh::get_n_auto
const Tenseur & get_n_auto() const
Returns the part of the lapse {\it N} generated principaly by the star.
Definition et_bin_nsbh.h:239
Lorene::Et_bin_nsbh::set_n_auto
Tenseur & set_n_auto()
Read/write the lapse {\it N} generated principaly by the star.
Definition et_bin_nsbh.C:278
Lorene::Et_bin_nsbh::set_confpsi_auto
Tenseur & set_confpsi_auto()
Read/write the conformal factor $\Psi$ generated principaly by the star.
Definition et_bin_nsbh.C:292
Lorene::Et_bin_nsbh::sauve
virtual void sauve(FILE *) const
Save in a file.
Definition et_bin_nsbh.C:312
Lorene::Etoile::get_mp
const Map & get_mp() const
Returns the mapping.
Definition etoile.h:659
Lorene::Etoile::get_beta_auto
const Tenseur & get_beta_auto() const
Returns the logarithm of the part of the product AN generated principaly by the star.
Definition etoile.h:724
Lorene::Etoile::get_logn_auto
const Tenseur & get_logn_auto() const
Returns the logarithm of the part of the lapse N generated principaly by the star.
Definition etoile.h:701
Lorene::Map_af
Affine radial mapping.
Definition map.h:2027
Lorene::Map_af::val_r
virtual double val_r(int l, double xi, double theta, double pphi) const
Returns the value of the radial coordinate r for a given in a given domain.
Definition map_af_radius.C:96
Lorene::Tenseur::set_std_base
void set_std_base()
Set the standard spectal basis of decomposition for each component.
Definition tenseur.C:1170
Lorene::sqrt
Cmp sqrt(const Cmp &)
Square root.
Definition cmp_math.C:220
Lorene::exp
Cmp exp(const Cmp &)
Exponential.
Definition cmp_math.C:270
Lorene::fread_be
int fread_be(int *aa, int size, int nb, FILE *fich)
Reads integer(s) from a binary file according to the big endian convention.
Definition fread_be.C:69
Lorene::fwrite_be
int fwrite_be(const int *aa, int size, int nb, FILE *fich)
Writes integer(s) into a binary file according to the big endian convention.
Definition fwrite_be.C:70
Lorene
Lorene prototypes.
Definition app_hor.h:64
Lorene::get_mg
const Mg3d * get_mg() const
Gives the Mg3d on which the mapping is defined.
Definition map.h:765
Lorene::Map
Map(const Mg3d &)
Constructor from a multi-domain 3D grid.
Definition map.C:139
Lorene::phi
Coord phi
coordinate centered on the grid
Definition map.h:720
Lorene::tet
Coord tet
coordinate centered on the grid
Definition map.h:719
Unites
Standard units of space, time and mass.