blackhole.h

/*
 *  Definition of Lorene class Black_hole
 *
 */

/*
 *   Copyright (c) 2005-2007 Keisuke Taniguchi
 *
 *   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
 *
 */

#ifndef __BLACKHOLE_H_ 
#define __BLACKHOLE_H_ 

/*
 * $Id: blackhole.h,v 1.4 2014/10/13 08:52:32 j_novak Exp $
 * $Log: blackhole.h,v $
 * Revision 1.4  2014/10/13 08:52:32  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.3  2008/07/02 20:41:40  k_taniguchi
 * Addition of the routines to compute angular momentum
 *  and modification of the argument of equilibrium_spher.
 *
 * Revision 1.2  2008/05/15 18:53:37  k_taniguchi
 * Change of some parameters and introduction of some
 * computational routines.
 *
 * Revision 1.1  2007/06/22 01:02:57  k_taniguchi
 * *** empty log message ***
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/blackhole.h,v 1.4 2014/10/13 08:52:32 j_novak Exp $
 *
 */

// External classes which appear in the declaration of class Black_hole:
//class YYY ; 

// Headers Lorene
#include "metric.h"

                    //-------------------------------//
                    //     Base class Black_hole     //
                    //-------------------------------//

namespace Lorene {
class Black_hole {

    // Data : 
    // -----
    protected:
        Map& mp ;

    bool kerrschild ;

    double mass_bh ;

    // Metric quantities
    // -----------------

    Scalar lapconf ;  // lapconf = lapconf_rs + lapconf_bh

    Scalar lapconf_rs ;

    Scalar lapconf_bh ;

    Scalar lapse ;

    Vector shift ;  // shift = shift_rs + shift_bh

    Vector shift_rs ;

    Vector shift_bh ;

    Scalar confo ;

    //  Scalar trace_k ;

    Sym_tensor taij ;

    Sym_tensor taij_rs ;

    Scalar taij_quad ;

    Scalar taij_quad_rs ;

    Metric_flat flat ;

    //  Metric tgij ;

    // Derived data : 
    // ------------
    protected:
    mutable double* p_mass_irr ;  

    mutable double* p_mass_adm ;  

    mutable double* p_mass_kom ;  

    mutable double* p_rad_ah ; 

    mutable double* p_spin_am_bh ; 

    mutable Tbl* p_angu_mom_bh ;

    // Constructors - Destructor
    // -------------------------
    public:

    Black_hole(Map& mp_i, bool Kerr_schild, double massbh) ;

    Black_hole(const Black_hole& ) ;       

    Black_hole(Map& mp_i, FILE* fich) ;         

    virtual ~Black_hole() ;         
 

    // Memory management
    // -----------------
    protected:
    virtual void del_deriv() const ;

    void set_der_0x0() const ;


    // Mutators / assignment
    // ---------------------
    public:
    void operator=(const Black_hole&) ;

    Map& set_mp() {return mp; } ;

    double& set_mass_bh() {return mass_bh; } ;

    // Accessors
    // ---------
    public:
    const Map& get_mp() const {return mp; } ;

    bool is_kerrschild() const {return kerrschild; } ;

    double get_mass_bh() const {return mass_bh; } ;

    const Scalar& get_lapconf() const {return lapconf; } ;

    const Scalar& get_lapconf_rs() const {return lapconf_rs; } ;

    const Scalar& get_lapse() const {return lapse; } ;

    const Vector& get_shift() const {return shift; } ;

    const Vector& get_shift_rs() const {return shift_rs; } ;

    const Scalar& get_confo() const {return confo; } ;

    // Outputs
    // -------
    public:
    virtual void sauve(FILE *) const ;      
    
    friend ostream& operator<<(ostream& , const Black_hole& ) ; 

    protected:
    virtual ostream& operator>>(ostream& ) const ;

    // Global quantities
    // -----------------
    public:
    virtual double mass_irr() const ;

    virtual double mass_adm() const ;

    virtual double mass_kom() const ;

    virtual double rad_ah() const ;

    double spin_am_bh(bool bclapconf_nd, bool bclapconf_fs,
              const Tbl& xi_i, const double& phi_i,
              const double& theta_i, const int& nrk_phi,
              const int& nrk_theta) const ;

    const Tbl& angu_mom_bh() const ;

    // Computational routines
    // ----------------------
    public:
    const Valeur bc_lapconf(bool neumann, bool first) const ;

    const Valeur bc_shift_x(double omega_r) const ;

    const Valeur bc_shift_y(double omega_r) const ;

    const Valeur bc_shift_z() const ;

    const Valeur bc_confo() const ; 

    void extr_curv_bh() ;

    void equilibrium_spher(bool neumann, bool first, double spin_omega,
                   double precis = 1.e-14,
                   double precis_shift = 1.e-8) ;

    void static_bh(bool neumann, bool first) ;

    double rah_iso(bool neumann, bool first) const ;

    const Scalar r_coord(bool neumann, bool first) const ;

    Tbl runge_kutta_phi_bh(const Tbl& xi_i, const double& phi_i,
                   const int& nrk) const ;

    Tbl runge_kutta_theta_bh(const Tbl& xi_i, const double& theta_i,
                 const double& phi, const int& nrk) const ;

    Vector killing_vect_bh(const Tbl& xi_i, const double& phi_i,
                   const double& theta_i, const int& nrk_phi,
                   const int& nrk_theta) const ;

};
ostream& operator<<(ostream& , const Black_hole& ) ;

}
#endif