LORENE
et_rot_mag_global.C
1 /*
2  * Methods for computing global quantities within the class Etoile_rot
3  *
4  * (see file etoile.h for documentation)
5  */
6 
7 /*
8  * Copyright (c) 2000-2001 Eric Gourgoulhon
9  * Copyright (c) 2002 Emmanuel Marcq
10  * Copyright (c) 2002 Jerome Novak
11  *
12  * This file is part of LORENE.
13  *
14  * LORENE is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * LORENE is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with LORENE; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27  *
28  */
29 
30 
31 
32 
33 /*
34  * $Id: et_rot_mag_global.C,v 1.24 2016/12/05 16:17:54 j_novak Exp $
35  * $Log: et_rot_mag_global.C,v $
36  * Revision 1.24 2016/12/05 16:17:54 j_novak
37  * Suppression of some global variables (file names, loch, ...) to prevent redefinitions
38  *
39  * Revision 1.23 2016/11/01 09:12:59 j_novak
40  * Correction of a missing '-' in mom_quad_old().
41  *
42  * Revision 1.22 2015/06/12 12:38:25 j_novak
43  * Implementation of the corrected formula for the quadrupole momentum.
44  *
45  * Revision 1.21 2014/10/13 08:52:58 j_novak
46  * Lorene classes and functions now belong to the namespace Lorene.
47  *
48  * Revision 1.20 2014/05/13 10:06:13 j_novak
49  * Change of magnetic units, to make the Lorene unit system coherent. Magnetic field is now expressed in Lorene units. Improvement on the comments on units.
50  *
51  * Revision 1.19 2012/08/12 17:48:35 p_cerda
52  * Magnetstar: New classes for magnetstar. Allowing for non-equatorial symmetry in Etoile et al. Adding B_phi in Et_rot_mag.
53  *
54  * Revision 1.18 2006/01/31 15:54:57 j_novak
55  * Corrected a missing '-' sign for the theta component of the magnetic field in
56  * Et_rot_mag::Magn(). This had no influence in the calculations, only in the
57  * display of B values.
58  *
59  * Revision 1.17 2004/03/25 10:29:06 j_novak
60  * All LORENE's units are now defined in the namespace Unites (in file unites.h).
61  *
62  * Revision 1.16 2003/10/27 10:52:19 e_gourgoulhon
63  * Suppressed the global #include "unites.h"
64  * and made it local to each function.
65  *
66  * Revision 1.15 2002/10/17 11:30:54 j_novak
67  * Corrected mistake in angu_mom()
68  *
69  * Revision 1.14 2002/06/03 13:00:45 e_marcq
70  *
71  * conduc parameter read in parmag.d
72  *
73  * Revision 1.12 2002/05/22 12:20:17 j_novak
74  * *** empty log message ***
75  *
76  * Revision 1.11 2002/05/20 15:44:55 e_marcq
77  *
78  * Dimension errors corrected, parmag.d input file created and read
79  *
80  * Revision 1.10 2002/05/20 10:31:59 j_novak
81  * *** empty log message ***
82  *
83  * Revision 1.9 2002/05/20 08:27:59 j_novak
84  * *** empty log message ***
85  *
86  * Revision 1.8 2002/05/17 15:08:01 e_marcq
87  *
88  * Rotation progressive plug-in, units corrected, Q and a_j new member data
89  *
90  * Revision 1.7 2002/05/16 13:27:11 j_novak
91  * *** empty log message ***
92  *
93  * Revision 1.6 2002/05/16 10:02:09 j_novak
94  * Errors in stress energy tensor corrected
95  *
96  * Revision 1.5 2002/05/15 09:53:59 j_novak
97  * First operational version
98  *
99  * Revision 1.4 2002/05/14 13:45:30 e_marcq
100  *
101  * Correction de la formule du rapport gyromagnetique
102  *
103  * Revision 1.1 2002/05/10 09:26:52 j_novak
104  * Added new class Et_rot_mag for magnetized rotating neutron stars (under development)
105  *
106  *
107  * $Header: /cvsroot/Lorene/C++/Source/Etoile/et_rot_mag_global.C,v 1.24 2016/12/05 16:17:54 j_novak Exp $
108  *
109  */
110 
111 // Headers C
112 #include <cstdlib>
113 #include <cmath>
114 
115 // Headers Lorene
116 #include "et_rot_mag.h"
117 #include "unites.h"
118 
119 // Definition des fonctions membres differentes ou nouvelles
120 
121 namespace Lorene {
123  // Calcule les grandeurs du tenseur impulsion-energie EM a partir des champs
124 
125  using namespace Unites_mag ;
126 
127  Tenseur ATTENS(A_t) ;
128 
129  Tenseur APTENS(A_phi) ;
130 
132  APTENS.gradient_spher())() );
134  ATTENS.gradient_spher())() );
136  ATTENS.gradient_spher())() );
137 
138  if (ApAp.get_etat() != ETATZERO) {
139  ApAp.set().div_rsint() ;
140  ApAp.set().div_rsint() ;
141  }
142  if (ApAt.get_etat() != ETATZERO)
143  ApAt.set().div_rsint() ;
144 
145  E_em = 0.5*mu0 * ( 1/(a_car*nnn*nnn) * (AtAt + 2*tnphi*ApAt)
146  + ( (tnphi*tnphi/(a_car*nnn*nnn)) + 1/(a_car*b_car) )*ApAp );
147  Jp_em = -mu0 * (ApAt + tnphi*ApAp) /(a_car*nnn) ;
148  if (Jp_em.get_etat() != ETATZERO) Jp_em.set().mult_rsint() ;
149  Srr_em = 0 ;
150  // Stt_em = -Srr_em
151  Spp_em = E_em ;
152 }
153 
155 
156  using namespace Unites_mag ;
157 
158  Cmp E_r(mp); Cmp E_t(mp);
159  E_r = 1/(sqrt(a_car())*nnn())*(A_t.dsdr()+nphi()*A_phi.dsdr()) ;
160  E_t = 1/(sqrt(a_car())*nnn())*(A_t.srdsdt()+nphi()*A_phi.srdsdt()) ;
161  E_r.va.set_base((A_t.dsdr()).va.base) ;
162  E_t.va.set_base((A_t.srdsdt()).va.base) ;
163  Tenseur Elect(mp, 1, CON, mp.get_bvect_spher()) ;
164  Elect.set_etat_qcq() ;
165  Elect.set(0) = E_r ;
166  Elect.set(1) = E_t ;
167  Elect.set(2) = 0. ;
168 
169  return Elect*mu0 ;
170 
171 }
172 
174 
175  using namespace Unites_mag ;
176 
177  Cmp B_r(mp); Cmp B_t(mp);
178  B_r = 1/(sqrt(a_car())*bbb())*A_phi.srdsdt();
179  B_r.va.set_base((A_phi.srdsdt()).va.base) ;
180  B_r.div_rsint();
181  B_t = 1/(sqrt(a_car())*bbb())*A_phi.dsdr();
182  B_t.va.set_base((A_phi.dsdr()).va.base) ;
183  B_t.div_rsint();
184 
185  Tenseur Bmag(mp, 1, CON, mp.get_bvect_spher()) ;
186  Bmag.set_etat_qcq() ;
187  Bmag.set(0) = B_r ;
188  Bmag.set(1) = -B_t ;
189  Bmag.set(2) = B_phi ;
190 
191  return Bmag*mu0 ;
192 
193 }
194 
195 double Et_rot_mag::MagMom() const {
196 
197  using namespace Unites_mag ;
198 
199  int Z = mp.get_mg()->get_nzone();
200  double mm ;
201 
202  if(A_phi.get_etat()==ETATZERO) {
203 
204  mm = 0 ;
205  }else{
206 
207  Valeur** asymp = A_phi.asymptot(1) ;
208  mm = 4*M_PI*(*asymp[1])(Z-1,0,mp.get_mg()->get_nt(Z-1)-1,0) ;
209 
210  delete asymp[0] ;
211  delete asymp[1] ;
212 
213  delete [] asymp ;
214  }
215 
216  return mm*j_unit*pow(r_unit,4) ;
217 
218 }
219 
220 double Et_rot_mag::Q_comput() const {
221 
222  using namespace Unites_mag ;
223 
224  int Z = mp.get_mg()->get_nzone();
225 
226  if(A_t.get_etat()==ETATZERO) {
227  return 0 ;
228  }else{
229  Valeur** asymp = A_t.asymptot(1) ;
230 
231  double Q_c = -4*M_PI*(*asymp[1])(Z-1,0,0,0) ;
232  delete asymp[0] ;
233  delete asymp[1] ;
234 
235  delete [] asymp ;
236 
237  return Q_c *(j_unit/v_unit*pow(r_unit,3)) ;}
238  }
239 
240 
241 double Et_rot_mag::Q_int() const {
242 
243  using namespace Unites_mag ;
244 
245  double Qi = 0. ;
246 
247  if (relativistic) {
248 
249  Cmp dens = a_car() * bbb() * nnn() * j_t ;
250 
251  dens.std_base_scal() ;
252 
253  Qi = dens.integrale() ;
254 
255 
256  }
257  else{ // Newtonian case
258  assert(nbar.get_etat() == ETATQCQ) ;
259 
260  Qi = ( j_t.integrale() ) ;
261 
262  }
263 
264 
265 
266  return Qi * (j_unit/v_unit*pow(r_unit,3)) ;
267 
268 }
269 
270 
271 double Et_rot_mag::GyroMag() const {
272 
273  using namespace Unites_mag ;
274 
275  return 2*MagMom()*mass_g()/(Q_comput()*angu_mom()*v_unit*r_unit);
276 
277 }
278  //----------------------------//
279  // Gravitational mass //
280  //----------------------------//
281 
282 double Et_rot_mag::mass_g() const {
283 
284  if (p_mass_g == 0x0) { // a new computation is required
285 
286  if (relativistic) {
287 
288  Tenseur source = nnn * (ener_euler + E_em + s_euler + Spp_em) +
289  nphi * Jp_em + 2 * bbb * (ener_euler + press) * tnphi * uuu ;
290 
291  source = a_car * bbb * source ;
292 
293  source.set_std_base() ;
294 
295  p_mass_g = new double( source().integrale() ) ;
296 
297 
298  }
299  else{ // Newtonian case
300  p_mass_g = new double( mass_b() ) ; // in the Newtonian case
301  // M_g = M_b
302  }
303  }
304 
305  return *p_mass_g ;
306 
307 }
308 
309  //----------------------------//
310  // Angular momentum //
311  //----------------------------//
312 
313 double Et_rot_mag::angu_mom() const {
314 
315  if (p_angu_mom == 0x0) { // a new computation is required
316 
317  Cmp dens = uuu() ;
318 
319  dens.mult_r() ; // Multiplication by
320  dens.va = (dens.va).mult_st() ; // r sin(theta)
321 
322  if (relativistic) {
323  dens = a_car() * (b_car() * (ener_euler() + press())
324  * dens + bbb() * Jp_em()) ;
325  }
326  else { // Newtonian case
327  dens = nbar() * dens ;
328  }
329 
330  dens.std_base_scal() ;
331 
332  p_angu_mom = new double( dens.integrale() ) ;
333 
334  }
335 
336  return *p_angu_mom ;
337 
338 }
339 
340 
341  //----------------------------//
342  // T/W //
343  //----------------------------//
344 
345 // Redefini en virtual dans le .h : A CHANGER
346 
347 double Et_rot_mag::tsw() const {
348 
349  if (p_tsw == 0x0) { // a new computation is required
350 
351  double tcin = 0.5 * omega * angu_mom() ;
352 
353  if (relativistic) {
354 
355  Cmp dens = a_car() * bbb() * gam_euler() * ener() ;
356  dens.std_base_scal() ;
357  double mass_p = dens.integrale() ;
358 
359  p_tsw = new double( tcin / ( mass_p + tcin - mass_g() ) ) ;
360 
361  }
362  else { // Newtonian case
363  Cmp dens = 0.5 * nbar() * logn() ;
364  dens.std_base_scal() ;
365  double wgrav = dens.integrale() ;
366  p_tsw = new double( tcin / fabs(wgrav) ) ;
367  }
368 
369 
370  }
371 
372  return *p_tsw ;
373 
374 }
375 
376 
377  //----------------------------//
378  // GRV2 //
379  //----------------------------//
380 
381 double Et_rot_mag::grv2() const {
382 
383  if (p_grv2 == 0x0) { // a new computation is required
384 
385  // To get qpig:
386  using namespace Unites ;
387 
388  Tenseur sou_m = 2 * qpig * a_car * (press + (ener_euler+press)
389  * uuu*uuu ) ;
390 
391  Tenseur sou_q = 2 * qpig * a_car * Spp_em + 1.5 * ak_car
393 
394  p_grv2 = new double( double(1) - lambda_grv2(sou_m(), sou_q()) ) ;
395 
396  }
397 
398  return *p_grv2 ;
399 
400 }
401 
402 
403  //----------------------------//
404  // GRV3 //
405  //----------------------------//
406 
407 double Et_rot_mag::grv3(ostream* ost) const {
408 
409  if (p_grv3 == 0x0) { // a new computation is required
410 
411  // To get qpig:
412  using namespace Unites ;
413 
414  Tenseur source(mp) ;
415 
416  // Gravitational term [cf. Eq. (43) of Gourgoulhon & Bonazzola
417  // ------------------ Class. Quantum Grav. 11, 443 (1994)]
418 
419  if (relativistic) {
420  Tenseur alpha = dzeta - logn ;
421  Tenseur beta = log( bbb ) ;
422  beta.set_std_base() ;
423 
424  source = 0.75 * ak_car
426  logn.gradient_spher() )
427  + 0.5 * flat_scalar_prod(alpha.gradient_spher(),
428  beta.gradient_spher() ) ;
429 
430  Cmp aa = alpha() - 0.5 * beta() ;
431  Cmp daadt = aa.srdsdt() ; // 1/r d/dth
432 
433  // What follows is valid only for a mapping of class Map_radial :
434  const Map_radial* mpr = dynamic_cast<const Map_radial*>(&mp) ;
435  if (mpr == 0x0) {
436  cout << "Etoile_rot::grv3: the mapping does not belong"
437  << " to the class Map_radial !" << endl ;
438  abort() ;
439  }
440 
441  // Computation of 1/tan(theta) * 1/r daa/dtheta
442  if (daadt.get_etat() == ETATQCQ) {
443  Valeur& vdaadt = daadt.va ;
444  vdaadt = vdaadt.ssint() ; // division by sin(theta)
445  vdaadt = vdaadt.mult_ct() ; // multiplication by cos(theta)
446  }
447 
448  Cmp temp = aa.dsdr() + daadt ;
449  temp = ( bbb() - a_car()/bbb() ) * temp ;
450  temp.std_base_scal() ;
451 
452  // Division by r
453  Valeur& vtemp = temp.va ;
454  vtemp = vtemp.sx() ; // division by xi in the nucleus
455  // Id in the shells
456  // division by xi-1 in the ZEC
457  vtemp = (mpr->xsr) * vtemp ; // multiplication by xi/r in the nucleus
458  // by 1/r in the shells
459  // by r(xi-1) in the ZEC
460 
461  // In the ZEC, a multiplication by r has been performed instead
462  // of the division:
463  temp.set_dzpuis( temp.get_dzpuis() + 2 ) ;
464 
465  source = bbb() * source() + 0.5 * temp ;
466 
467  }
468  else{
469  source = - 0.5 * flat_scalar_prod(logn.gradient_spher(),
470  logn.gradient_spher() ) ;
471  }
472 
473  source.set_std_base() ;
474 
475  double int_grav = source().integrale() ;
476 
477  // Matter term
478  // -----------
479 
480  if (relativistic) {
481  source = qpig * a_car * bbb * ( s_euler + Spp_em ) ;
482  }
483  else{
484  source = qpig * ( 3 * press + nbar * uuu * uuu ) ;
485  }
486 
487  source.set_std_base() ;
488 
489  double int_mat = source().integrale() ;
490 
491  // Virial error
492  // ------------
493  if (ost != 0x0) {
494  *ost << "Etoile_rot::grv3 : gravitational term : " << int_grav
495  << endl ;
496  *ost << "Etoile_rot::grv3 : matter term : " << int_mat
497  << endl ;
498  }
499 
500  p_grv3 = new double( (int_grav + int_mat) / int_mat ) ;
501 
502  }
503 
504  return *p_grv3 ;
505 
506 }
507 
508  //----------------------------//
509  // Quadrupole moment //
510  //----------------------------//
511 
512  double Et_rot_mag::mom_quad_old() const {
513 
514  if (p_mom_quad_old == 0x0) { // a new computation is required
515 
516  // To get qpig:
517  using namespace Unites ;
518 
519  // Source for of the Poisson equation for nu
520  // -----------------------------------------
521 
522  Tenseur source(mp) ;
523 
524  if (relativistic) {
525  Tenseur beta = log(bbb) ;
526  beta.set_std_base() ;
527  source = qpig * a_car *( ener_euler + s_euler + Spp_em )
529  logn.gradient_spher() + beta.gradient_spher()) ;
530  }
531  else {
532  source = qpig * nbar ;
533  }
534  source.set_std_base() ;
535 
536  // Multiplication by -r^2 P_2(cos(theta))
537  // [cf Eq.(7) of Salgado et al. Astron. Astrophys. 291, 155 (1994) ]
538  // ------------------------------------------------------------------
539 
540  // Multiplication by r^2 :
541  // ----------------------
542  Cmp& csource = source.set() ;
543  csource.mult_r() ;
544  csource.mult_r() ;
545  if (csource.check_dzpuis(2)) {
546  csource.inc2_dzpuis() ;
547  }
548 
549  // Muliplication by cos^2(theta) :
550  // -----------------------------
551  Cmp temp = csource ;
552 
553  // What follows is valid only for a mapping of class Map_radial :
554  assert( dynamic_cast<const Map_radial*>(&mp) != 0x0 ) ;
555 
556  if (temp.get_etat() == ETATQCQ) {
557  Valeur& vtemp = temp.va ;
558  vtemp = vtemp.mult_ct() ; // multiplication by cos(theta)
559  vtemp = vtemp.mult_ct() ; // multiplication by cos(theta)
560  }
561 
562  // Muliplication by -P_2(cos(theta)) :
563  // ----------------------------------
564  source = 0.5 * source() - 1.5 * temp ;
565 
566  // Final result
567  // ------------
568 
569  p_mom_quad_old = new double( - source().integrale() / qpig ) ;
570 
571  }
572 
573  return *p_mom_quad_old ;
574 
575  }
576 
577 }
const Cmp & dsdr() const
Returns of *this .
Definition: cmp_deriv.C:87
double * p_mom_quad_old
Part of the quadrupole moment.
Definition: etoile.h:1646
Cmp log(const Cmp &)
Neperian logarithm.
Definition: cmp_math.C:299
virtual double grv3(ostream *ost=0x0) const
Error on the virial identity GRV3.
Tenseur E_em
electromagnetic energy density in the Eulerian frame
Definition: et_rot_mag.h:161
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition: cmp.h:446
Tenseur tnphi
Component of the shift vector.
Definition: etoile.h:1518
double GyroMag() const
Gyromagnetic ratio .
const Tenseur & gradient_spher() const
Returns the gradient of *this (Spherical coordinates) (scalar field only).
Definition: tenseur.C:1564
virtual double angu_mom() const
Angular momentum.
Cmp sqrt(const Cmp &)
Square root.
Definition: cmp_math.C:223
void set_std_base()
Set the standard spectal basis of decomposition for each component.
Definition: tenseur.C:1186
const Base_vect_spher & get_bvect_spher() const
Returns the orthonormal vectorial basis associated with the coordinates of the mapping.
Definition: map.h:801
Lorene prototypes.
Definition: app_hor.h:67
Standard units of space, time and mass.
const Mg3d * get_mg() const
Gives the Mg3d on which the mapping is defined.
Definition: map.h:783
int get_etat() const
Returns the logical state.
Definition: cmp.h:899
Tenseur nnn
Total lapse function.
Definition: etoile.h:512
Tenseur nphi
Metric coefficient .
Definition: etoile.h:1513
Tenseur s_euler
Trace of the stress tensor in the Eulerian frame.
Definition: etoile.h:471
Tenseur flat_scalar_prod(const Tenseur &t1, const Tenseur &t2)
Scalar product of two Tenseur when the metric is : performs the contraction of the last index of t1 w...
const Cmp & srdsdt() const
Returns of *this .
Definition: cmp_deriv.C:108
Tenseur b_car
Square of the metric factor B.
Definition: etoile.h:1510
virtual double mass_g() const
Gravitational mass.
Tenseur Magn() const
Computes the magnetic field spherical components in Lorene&#39;s units.
const Valeur & sx() const
Returns (r -sampling = RARE ) \ Id (r sampling = FIN ) \ (r -sampling = UNSURR ) ...
Definition: valeur_sx.C:113
Values and coefficients of a (real-value) function.
Definition: valeur.h:297
Tenseur press
Fluid pressure.
Definition: etoile.h:464
void set_base(const Base_val &)
Sets the bases for spectral expansions (member base )
Definition: valeur.C:813
Cmp A_phi
-component of the electromagnetic potential 1-form divided by .
Definition: et_rot_mag.h:155
virtual double grv2() const
Error on the virial identity GRV2.
Tenseur Srr_em
rr component of the electromagnetic stress 3-tensor, as measured in the Eulerian frame. (not used and set to 0, should be supressed)
Definition: et_rot_mag.h:170
void mult_r()
Multiplication by r everywhere.
Definition: cmp_r_manip.C:94
Cmp & set()
Read/write for a scalar (see also operator=(const Cmp&) ).
Definition: tenseur.C:840
double * p_grv3
Error on the virial identity GRV3.
Definition: etoile.h:1637
Tenseur flat_scalar_prod_desal(const Tenseur &t1, const Tenseur &t2)
Same as flat_scalar_prod but with desaliasing.
const Valeur & ssint() const
Returns of *this.
Definition: valeur_ssint.C:115
Tenseur nbar
Baryon density in the fluid frame.
Definition: etoile.h:462
Tenseur gam_euler
Lorentz factor between the fluid and Eulerian observers.
Definition: etoile.h:474
double * p_tsw
Ratio T/W.
Definition: etoile.h:1635
virtual double mass_b() const
Baryon mass.
Base class for pure radial mappings.
Definition: map.h:1557
void mult_rsint()
Multiplication by .
Definition: cmp_r_manip.C:119
Map & mp
Mapping associated with the star.
Definition: etoile.h:432
int get_nzone() const
Returns the number of domains.
Definition: grilles.h:465
double integrale() const
Computes the integral over all space of *this .
Definition: cmp_integ.C:58
Tenseur ak_car
Scalar .
Definition: etoile.h:1589
int get_etat() const
Returns the logical state.
Definition: tenseur.h:710
static double lambda_grv2(const Cmp &sou_m, const Cmp &sou_q)
Computes the coefficient which ensures that the GRV2 virial identity is satisfied.
Coord xsr
in the nucleus; \ 1/R in the non-compactified shells; \ in the compactified outer domain...
Definition: map.h:1570
Tenseur bbb
Metric factor B.
Definition: etoile.h:1507
Cmp pow(const Cmp &, int)
Power .
Definition: cmp_math.C:351
void inc2_dzpuis()
Increases by 2 the value of dzpuis and changes accordingly the values of the Cmp in the external comp...
Definition: cmp_r_manip.C:195
Tenseur uuu
Norm of u_euler.
Definition: etoile.h:1521
double * p_mass_g
Gravitational mass.
Definition: etoile.h:551
double omega
Rotation angular velocity ([f_unit] )
Definition: etoile.h:1504
void std_base_scal()
Sets the spectral bases of the Valeur va to the standard ones for a scalar.
Definition: cmp.C:647
Tenseur a_car
Total conformal factor .
Definition: etoile.h:518
Cmp j_t
t-component of the current 4-vector
Definition: et_rot_mag.h:158
bool relativistic
Indicator of relativity: true for a relativistic star, false for a Newtonian one. ...
Definition: etoile.h:440
Tbl & set(int l)
Read/write of the value in a given domain.
Definition: cmp.h:724
Tenseur ener
Total energy density in the fluid frame.
Definition: etoile.h:463
virtual double tsw() const
Ratio T/W.
int get_dzpuis() const
Returns dzpuis.
Definition: cmp.h:903
double Q_int() const
Computed charge from the integration of charge density over the star (i.e.
Tenseur Elec() const
Computes the electric field spherical components in Lorene&#39;s units.
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:718
Valeur ** asymptot(int n, const int flag=0) const
Asymptotic expansion at r = infinity.
Definition: cmp_asymptot.C:74
const Valeur & mult_ct() const
Returns applied to *this.
Cmp A_t
t-component of the elecctromagnetic potential 1-form, divided by .
Definition: et_rot_mag.h:150
virtual void MHD_comput()
Computes the electromagnetic part of the stress-energy tensor.
Tenseur & logn
Metric potential = logn_auto.
Definition: etoile.h:1524
void set_dzpuis(int)
Set a value to dzpuis.
Definition: cmp.C:657
int get_nt(int l) const
Returns the number of points in the co-latitude direction ( ) in domain no. l.
Definition: grilles.h:474
double * p_grv2
Error on the virial identity GRV2.
Definition: etoile.h:1636
void set_etat_qcq()
Sets the logical state to ETATQCQ (ordinary state).
Definition: tenseur.C:652
double Q_comput() const
Computed charge deduced from the asymptotic behaviour of At [SI units].
double MagMom() const
Magnetic Momentum in SI units.
Tenseur ener_euler
Total energy density in the Eulerian frame.
Definition: etoile.h:468
Tenseur & dzeta
Metric potential = beta_auto.
Definition: etoile.h:1537
Cmp B_phi
-component of the magnetic field
Definition: et_rot_mag.h:157
Valeur va
The numerical value of the Cmp.
Definition: cmp.h:464
virtual double mom_quad_old() const
Part of the quadrupole moment.
Standard electro-magnetic units.
Tensor handling *** DEPRECATED : use class Tensor instead ***.
Definition: tenseur.h:304
Tenseur Jp_em
component of the electromagnetic momentum density 3-vector, as measured in the Eulerian frame...
Definition: et_rot_mag.h:167
Tenseur Spp_em
component of the electromagnetic stress 3-tensor, as measured in the Eulerian frame.
Definition: et_rot_mag.h:173
double * p_angu_mom
Angular momentum.
Definition: etoile.h:1634