hole_bhns.h

/*
 *  Definition of Lorene class Hole_bhns
 *
 */

/*
 *   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 __HOLE_BHNS_H_ 
#define __HOLE_BHNS_H_ 

/*
 * $Id: hole_bhns.h,v 1.3 2014/10/13 08:52:35 j_novak Exp $
 * $Log: hole_bhns.h,v $
 * Revision 1.3  2014/10/13 08:52:35  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.2  2008/05/15 18:55:04  k_taniguchi
 * Change of some parameters and introduction of some
 * computational routines.
 *
 * Revision 1.1  2007/06/22 01:04:14  k_taniguchi
 * *** empty log message ***
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/hole_bhns.h,v 1.3 2014/10/13 08:52:35 j_novak Exp $
 *
 */

// Headers Lorene
#include "blackhole.h"
#include "metric.h"

namespace Lorene {

// External classes which appear in the declaration of class Hole_bhns:
class Star_bhns ; 

                    //-------------------------//
                    //     Class Hole_bhns     //
                    //-------------------------//

class Hole_bhns : public Black_hole {

    // Data :
    // -----
    protected:
        bool bc_lapconf_nd ;

        bool bc_lapconf_fs ;

    bool irrotational ;

    double omega_spin ;

    Scalar lapconf_auto_rs ;

    Scalar lapconf_auto_bh ;

        Scalar lapconf_auto ;  // = lapconf_auto_rs + lapconf_auto_bh

    Scalar lapconf_comp ;

    Scalar lapconf_tot ;  // = lapconf_auto + lapconf_comp

    Scalar lapse_auto ;  // = lapconf_auto / confo_tot

    Scalar lapse_tot ;  // = lapconf_tot / confo_tot

    Vector d_lapconf_auto_rs ;

    Vector d_lapconf_auto_bh ;

    Vector d_lapconf_auto ;

    Vector d_lapconf_comp ;

    Vector shift_auto_rs ;

    Vector shift_auto_bh ;

    Vector shift_auto ;

    Vector shift_comp ;

    Vector shift_tot ;

    Tensor d_shift_auto_rs ;

    Tensor d_shift_auto_bh ;

    Tensor d_shift_auto ;

    Tensor d_shift_comp ;

    Scalar confo_auto_rs ;

    Scalar confo_auto_bh ;

    Scalar confo_auto ;

    Scalar confo_comp ;

    Scalar confo_tot ;

    Vector d_confo_auto_rs ;

    Vector d_confo_auto_bh ;

    Vector d_confo_auto ;

    Vector d_confo_comp ;

    Sym_tensor taij_tot_rs ;

    Sym_tensor taij_tot_rot ;

    Sym_tensor taij_tot_bh ;

    Sym_tensor taij_tot ;

    Sym_tensor taij_auto_rs ;

    Sym_tensor taij_auto ;

    Sym_tensor taij_comp ;

    Scalar taij_quad_tot_rs ;

    Scalar taij_quad_tot_rot ;

    Scalar taij_quad_tot_bh ;

    Scalar taij_quad_tot ;

    Scalar taij_quad_auto ;

    Scalar taij_quad_comp ;

    // Derived data : 
    // ------------
    protected:
    mutable double* p_mass_irr_bhns ; 
    mutable double* p_spin_am_bhns ;

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

    Hole_bhns(Map& mp_i, bool kerrschild_i, bool bc_lapconf_nd,
          bool bc_lapconf_fs, bool irrotational, double massbh) ;

    Hole_bhns(const Hole_bhns& ) ;       

    Hole_bhns(Map& mp_i, FILE* fich) ;          

    virtual ~Hole_bhns() ;          

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

    void set_der_0x0() const ;


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

    double& set_omega_spin() { return omega_spin ; } ;

    Scalar& set_lapconf_auto_rs() ;

    Scalar& set_lapconf_auto_bh() ;

    Scalar& set_lapconf_auto() ;

    Scalar& set_lapconf_comp() ;

    Scalar& set_lapconf_tot() ;

    Scalar& set_lapse_auto() ;

    Scalar& set_lapse_tot() ;

    Vector& set_shift_auto_rs() ;

    Vector& set_shift_auto_bh() ;

    Vector& set_shift_auto() ;

    Vector& set_shift_comp() ;

    Vector& set_shift_tot() ;

    Scalar& set_confo_auto_rs() ;

    Scalar& set_confo_auto_bh() ;

    Scalar& set_confo_auto() ;

    Scalar& set_confo_comp() ;

    Scalar& set_confo_tot() ;

    // Accessors
    // ---------
    public:
    bool has_bc_lapconf_nd() const {return bc_lapconf_nd; } ;

    bool has_bc_lapconf_fs() const {return bc_lapconf_fs; } ;

    bool is_irrotational() const {return irrotational; } ;

    double get_omega_spin() const {return omega_spin; } ;

    const Scalar& get_lapconf_auto_rs() const {return lapconf_auto_rs; } ;

    const Scalar& get_lapconf_auto() const {return lapconf_auto; } ;

    const Scalar& get_lapconf_comp() const {return lapconf_comp; } ;

    const Scalar& get_lapconf_tot() const {return lapconf_tot; } ;

    const Scalar& get_lapse_auto() const {return lapse_auto; } ;

    const Scalar& get_lapse_tot() const {return lapse_tot; } ;

    const Vector& get_d_lapconf_auto_rs() const
      {return d_lapconf_auto_rs; } ;

    const Vector& get_d_lapconf_auto() const {return d_lapconf_auto; } ;

    const Vector& get_d_lapconf_comp() const {return d_lapconf_comp; } ;

    const Vector& get_shift_auto_rs() const {return shift_auto_rs; } ;

    const Vector& get_shift_auto() const {return shift_auto; } ;

    const Vector& get_shift_comp() const {return shift_comp; } ;

    const Vector& get_shift_tot() const {return shift_tot; } ;

    const Tensor& get_d_shift_auto_rs() const {return d_shift_auto_rs; } ;

    const Tensor& get_d_shift_auto() const {return d_shift_auto; } ;

    const Tensor& get_d_shift_comp() const {return d_shift_comp; } ;

    const Scalar& get_confo_auto_rs() const {return confo_auto_rs; } ;

    const Scalar& get_confo_auto() const {return confo_auto; } ;

    const Scalar& get_confo_comp() const {return confo_comp; } ;

    const Scalar& get_confo_tot() const {return confo_tot; } ;

    const Vector& get_d_confo_auto_rs() const {return d_confo_auto_rs; } ;

    const Vector& get_d_confo_auto() const {return d_confo_auto; } ;

    const Vector& get_d_confo_comp() const {return d_confo_comp; } ;

    const Sym_tensor& get_taij_tot_rs() const {return taij_tot_rs; } ;

    const Sym_tensor& get_taij_tot() const {return taij_tot; } ;

    const Sym_tensor& get_taij_auto_rs() const {return taij_auto_rs; } ;

    const Sym_tensor& get_taij_auto() const {return taij_auto; } ;

    const Sym_tensor& get_taij_comp() const {return taij_comp; } ;

    const Scalar& get_taij_quad_tot_rs() const {return taij_quad_tot_rs; } ;
    const Scalar& get_taij_quad_tot_rot() const {return taij_quad_tot_rot; } ;

    const Scalar& get_taij_quad_tot() const {return taij_quad_tot; } ;

    const Scalar& get_taij_quad_auto() const {return taij_quad_auto; } ;

    const Scalar& get_taij_quad_comp() const {return taij_quad_comp; } ;

    // Outputs
    // -------
    public:
    virtual void sauve(FILE *) const ;      
    
    protected:
    virtual ostream& operator>>(ostream& ) const ;

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

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

    // Computational routines
    // ----------------------
    public:
    const Valeur bc_lapconf() const ;

    const Valeur bc_shift_x(double ome_orb, double y_rot) const ;

    const Valeur bc_shift_y(double ome_orb, double x_rot) const ;

    const Valeur bc_shift_z() const ;

    const Valeur bc_confo(double ome_orb, double x_rot,
                  double y_rot) const ;

    void update_metric_bhns(const Star_bhns& star,
                const Hole_bhns& hole_prev,
                double relax) ;

    void update_met_der_comp_bhns(const Star_bhns& star) ;

    void extr_curv_bhns(double omega_orb, double x_rot, double y_rot) ;

    void equilibrium_bhns(int mer, int mermax_bh,
                  int filter_r, int filter_r_s, int filter_p_s,
                  double x_rot, double y_rot, double precis,
                  double omega_orb, double resize_bh,
                  const Tbl& fact_resize, Tbl& diff) ;

    void relax_bhns(const Hole_bhns& hole_prev,
            double relax_met, int mer, int fmer_met) ;

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

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

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

    friend class Bin_bhns ;

};

}
#endif