vector_etamu.C
/*
* Methods of class Vector related to eta and mu
*
* (see file vector.h for documentation)
*
*/
/*
* Copyright (c) 2005 Eric Gourgoulhon & Jerome Novak
*
* 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 vector_etamu_C[] = "$Header: /cvsroot/Lorene/C++/Source/Tensor/vector_etamu.C,v 1.4 2014/10/13 08:53:45 j_novak Exp $" ;
/*
* $Id: vector_etamu.C,v 1.4 2014/10/13 08:53:45 j_novak Exp $
* $Log: vector_etamu.C,v $
* Revision 1.4 2014/10/13 08:53:45 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.3 2014/10/06 15:13:21 j_novak
* Modified #include directives to use c++ syntax.
*
* Revision 1.2 2008/08/27 08:52:23 jl_cornou
* Added fonctions for angular potential A
*
* Revision 1.1 2005/02/14 13:01:50 j_novak
* p_eta and p_mu are members of the class Vector. Most of associated functions
* have been moved from the class Vector_divfree to the class Vector.
*
*
* $Header: /cvsroot/Lorene/C++/Source/Tensor/vector_etamu.C,v 1.4 2014/10/13 08:53:45 j_novak Exp $
*
*/
// Headers C
#include <cstdlib>
#include <cassert>
// Headers Lorene
#include "tensor.h"
//--------------//
// eta //
//--------------//
namespace Lorene {
const Scalar& Vector::eta() const {
if (p_eta == 0x0) { // a new computation is necessary
// All this has a meaning only for spherical components:
#ifndef NDEBUG
const Base_vect_spher* bvs = dynamic_cast<const Base_vect_spher*>(triad) ;
assert(bvs != 0x0) ;
#endif
// eta is computed from its definition:
Scalar sou_eta = *cmp[1] ; //V^th
sou_eta.div_tant() ;
sou_eta += cmp[1]->dsdt() + cmp[2]->stdsdp();
// Resolution of the angular Poisson equation for eta
// --------------------------------------------------
p_eta = new Scalar( sou_eta.poisson_angu() ) ;
}
return *p_eta ;
}
//--------------//
// mu //
//--------------//
const Scalar& Vector::mu() const {
if (p_mu == 0x0) { // a new computation is necessary
// All this has a meaning only for spherical components:
#ifndef NDEBUG
const Base_vect_spher* bvs = dynamic_cast<const Base_vect_spher*>(triad) ;
assert(bvs != 0x0) ;
#endif
Scalar tmp = *cmp[2] ; // V^ph
tmp.div_tant() ; // V^ph / tan(th)
// dV^ph/dth + V^ph/tan(th) - 1/sin(th) dV^th/dphi
tmp += cmp[2]->dsdt() - cmp[1]->stdsdp() ;
// Resolution of the angular Poisson equation for mu
// --------------------------------------------------
p_mu = new Scalar( tmp.poisson_angu() ) ;
}
return *p_mu ;
}
//-----------//
// A //
//-----------//
const Scalar& Vector::A() const {
if (p_A == 0x0) { // A new computation is necessary
// All this has a meaning only for spherical components :
#ifndef NDEBUG
const Base_vect_spher* bvs = dynamic_cast<const Base_vect_spher*>(triad) ;
assert(bvs != 0x0) ;
#endif
// p_eta doit être calculé
if (p_eta == 0x0) { Scalar etatmp = this->eta(); }
Scalar tmp = -*cmp[0] ; // -V^r
tmp.div_r_dzpuis(2); // -V^r/r
Scalar eta_tilde = *p_eta ;
Scalar etad = eta_tilde.dsdr() ;
eta_tilde.div_r_dzpuis(2);
etad.set_dzpuis(2);
tmp += etad + eta_tilde ; // d eta / dr + eta/r
p_A = new Scalar (tmp) ;
}
return *p_A ;
}
//----------------//
// update_vtvp //
//----------------//
void Vector::update_vtvp() {
assert( (p_eta != 0x0) && (p_mu != 0x0) ) ;
// V^theta :
*cmp[1] = p_eta->dsdt() - p_mu->stdsdp() ;
// V^phi :
*cmp[2] = p_eta->stdsdp() + p_mu->dsdt() ;
Scalar* p_eta_tmp = p_eta ; //## in order not to delete p_eta and p_mu
p_eta = 0x0 ;
Scalar* p_mu_tmp = p_mu ;
p_mu = 0x0 ;
Vector::del_deriv() ;
p_eta = p_eta_tmp ;
p_mu = p_mu_tmp ;
}
void Vector::set_vr_eta_mu(const Scalar& vr_i, const Scalar& eta_i,
const Scalar& mu_i) {
// All this has a meaning only for spherical components:
assert( dynamic_cast<const Base_vect_spher*>(triad) != 0x0 ) ;
assert(&vr_i.get_mp() == &eta_i.get_mp()) ;
del_deriv() ;
// V^r
*cmp[0] = vr_i ;
p_eta = new Scalar( eta_i ) ; // eta
p_mu = new Scalar( mu_i ) ; // mu
update_vtvp() ;
return ;
}
}
Lorene::Base_vect_spher
Spherical orthonormal vectorial bases (triads).
Definition base_vect.h:308
Lorene::Scalar::div_r_dzpuis
void div_r_dzpuis(int ced_mult_r)
Division by r everywhere but with the output flag dzpuis set to ced_mult_r .
Definition scalar_r_manip.C:147
Lorene::Scalar::poisson_angu
Scalar poisson_angu(double lambda=0) const
Solves the (generalized) angular Poisson equation with *this as source.
Definition scalar_pde.C:200
Lorene::Scalar::div_tant
void div_tant()
Division by .
Definition scalar_th_manip.C:111
Lorene::Scalar::dsdr
const Scalar & dsdr() const
Returns of *this .
Definition scalar_deriv.C:113
Lorene::Scalar::set_dzpuis
void set_dzpuis(int)
Modifies the dzpuis flag.
Definition scalar.C:808
Lorene::Vector::del_deriv
virtual void del_deriv() const
Deletes the derived quantities.
Definition vector.C:219
Lorene::Vector::mu
virtual const Scalar & mu() const
Gives the field such that the angular components of the vector are written:
Definition vector_etamu.C:98
Lorene::Vector::update_vtvp
void update_vtvp()
Computes the components and from the potential and , according to:
Definition vector_etamu.C:167
Lorene::Vector::p_A
Scalar * p_A
Field defined by.
Definition vector.h:241
Lorene::Vector::eta
virtual const Scalar & eta() const
Gives the field such that the angular components of the vector are written:
Definition vector_etamu.C:66
Lorene::Vector::p_mu
Scalar * p_mu
Field such that the angular components of the vector are written:
Definition vector.h:233
Lorene::Vector::p_eta
Scalar * p_eta
Field such that the angular components of the vector are written:
Definition vector.h:219
Lorene::Vector::A
virtual const Scalar & A() const
Gives the field defined by.
Definition vector_etamu.C:129
Lorene::Vector::set_vr_eta_mu
void set_vr_eta_mu(const Scalar &vr_i, const Scalar &eta_i, const Scalar &mu_i)
Defines the components through potentials and (see members p_eta and p_mu ), as well as the compon...
Definition vector_etamu.C:189
Lorene::Tensor::get_mp
const Map & get_mp() const
Returns the mapping.
Definition tensor.h:861
Lorene::Tensor::cmp
Scalar ** cmp
Array of size n_comp of pointers onto the components.
Definition tensor.h:315
Lorene::Tensor::triad
const Base_vect * triad
Vectorial basis (triad) with respect to which the tensor components are defined.
Definition tensor.h:303
Lorene
Lorene prototypes.
Definition app_hor.h:64