bhole.h

/*
 *  Definition of Lorene classes Bhole
 *               Bhole_binaire
 *
 */

/*
 *   Copyright (c) 2000-2001 Philippe Grandclement
 *
 *   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
 *
 */


#ifndef __BHOLE_H_ 
#define __BHOLE_H_ 

/*
 * $Id: bhole.h,v 1.18 2014/10/13 08:52:32 j_novak Exp $
 * $Log: bhole.h,v $
 * Revision 1.18  2014/10/13 08:52:32  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.17  2007/05/15 12:44:18  p_grandclement
 * Scalar version of reevaluate
 *
 * Revision 1.16  2007/04/24 20:15:30  f_limousin
 * Implementation of Dirichlet and Neumann BC for the lapse
 *
 * Revision 1.15  2006/04/27 09:12:29  p_grandclement
 * First try at irrotational black holes
 *
 * Revision 1.14  2005/08/29 15:10:12  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.13  2004/12/02 09:33:04  p_grandclement
 * *** empty log message ***
 *
 * Revision 1.12  2004/03/25 12:35:34  j_novak
 * now using namespace Unites
 *
 * Revision 1.11  2004/03/25 09:14:06  j_novak
 * *** empty log message ***
 *
 * Revision 1.10  2004/03/25 08:53:33  j_novak
 * Error in the doc corrected.
 *
 * Revision 1.9  2004/03/24 17:14:04  j_novak
 * Translation of comments to doxygen
 *
 * Revision 1.8  2003/11/25 07:12:58  k_taniguchi
 * Change the argument of update_metric from the class Etoile_bin to Et_bin_nsbh.
 *
 * Revision 1.7  2003/11/13 13:43:53  p_grandclement
 * Addition of things needed for Bhole::update_metric (const Etoile_bin&, double, double)
 *
 * Revision 1.6  2003/10/24 13:05:48  p_grandclement
 * correction of the equations for Bin_ns_bh...
 *
 * Revision 1.5  2003/02/13 16:40:24  p_grandclement
 * Addition of various things for the Bin_ns_bh project, non of them being
 * completely tested
 *
 * Revision 1.4  2003/01/31 16:57:12  p_grandclement
 * addition of the member Cmp decouple used to compute the K_ij auto, once
 * the K_ij total is known
 *
 * Revision 1.3  2002/12/18 10:28:49  e_gourgoulhon
 *
 * Added the set_mp function.
 *
 * Revision 1.2  2002/09/13 09:17:31  j_novak
 * Modif. commentaires
 *
 * Revision 1.1.1.1  2001/11/20 15:19:27  e_gourgoulhon
 * LORENE
 *
 * Revision 2.45  2001/06/28  15:08:16  eric
 * Ajout de la fonction area().
 *
 * Revision 2.44  2001/05/16  11:32:45  phil
 * ajout de init_bhole_seul
 *
 * Revision 2.43  2001/05/07  12:35:28  phil
 * mmodifi commentaires
 *
 * Revision 2.42  2001/05/07  11:43:43  phil
 * *** empty log message ***
 *
 * Revision 2.41  2001/05/07  11:40:50  phil
 * mise a jour des commentaires
 *
 * Revision 2.40  2001/05/07  09:30:37  phil
 * *** empty log message ***
 *
 * Revision 2.39  2001/05/07  09:28:37  phil
 * *** empty log message ***
 *
 * Revision 2.38  2001/05/07  09:11:31  phil
 * *** empty log message ***
 *
 * Revision 2.37  2001/04/27  09:25:11  phil
 * fait_decouple est devenu public
 *
 * Revision 2.36  2001/04/26  12:04:11  phil
 * *** empty log message ***
 *
 * Revision 2.35  2001/04/05  13:42:40  phil
 * *** empty log message ***
 *
 * Revision 2.34  2001/04/05  13:34:29  phil
 * ajout resolution en utilisant phi
 *
 * Revision 2.33  2001/03/22  10:49:34  phil
 * *** empty log message ***
 *
 * Revision 2.32  2001/03/22  10:41:25  phil
 * pleins de modif
 *
 * Revision 2.31  2001/02/28  13:22:31  phil
 * modif vire kk_auto
 *
 * Revision 2.30  2001/02/12  15:37:42  phil
 * ajout calcul de J a linfini
 *
 * Revision 2.29  2001/01/29  14:29:56  phil
 * ajout type rotation
 *
 * Revision 2.28  2001/01/24  10:57:08  phil
 * ajout de set_rayonm
 *
 * Revision 2.27  2001/01/22  09:29:08  phil
 * vire les procedures qui servent pas
 *
 * Revision 2.26  2001/01/10  09:31:05  phil
 * modification de fait_kk_auto (membre de binaire maintenant)
 *
 * Revision 2.25  2001/01/09  13:38:15  phil
 * ajout memebre kk_auto
 *
 * Revision 2.24  2000/12/21  10:47:07  phil
 * retour eventuel a 2.21
 *
 * Revision 2.21  2000/12/20  09:07:56  phil
 * ajout set_statiques
 *
 * Revision 2.20  2000/12/18  16:40:39  phil
 * *** empty log message ***
 *
 * Revision 2.19  2000/12/18  16:38:04  phil
 * ajout convergence vers une masse donnee
 *
 * Revision 2.18  2000/12/15  16:41:28  phil
 * ajout calcul de la separation
 *
 * Revision 2.17  2000/12/14  10:44:28  phil
 * ATTENTION : PASSAGE DE PHI A PSI
 *
 * Revision 2.16  2000/12/13  15:35:18  phil
 * ajout calcul bare_masse
 *
 * Revision 2.15  2000/12/04  14:29:37  phil
 * ajout de grad_n_tot
 *
 * Revision 2.14  2000/12/01  16:12:52  phil
 * *** empty log message ***
 *
 * Revision 2.13  2000/12/01  14:16:20  phil
 * *** empty log message ***
 *
 * Revision 2.12  2000/11/24  15:14:44  phil
 * ajout de find_horizon
 *
 * Revision 2.11  2000/11/24  09:57:18  phil
 * ajout calcul masse et moment pour systeme
 *
 * Revision 2.10  2000/11/17  10:03:13  phil
 * ajout de coal
 *
 * Revision 2.9  2000/11/15  18:26:29  phil
 * simplifaction resolution du shift : on bosse a omega bloque
 *
 * Revision 2.8  2000/11/15  12:59:50  phil
 * changement solve_shift_omega
 *
 * Revision 2.7  2000/11/15  09:41:03  phil
 * *** empty log message ***
 *
 * Revision 2.6  2000/11/15  09:39:26  phil
 * ajout viriel
 *
 * Revision 2.5  2000/11/03  12:56:41  phil
 * ajout de const
 *
 * Revision 2.4  2000/10/26  08:20:45  phil
 * ajout verifie_shift
 *
 * Revision 2.3  2000/10/23  09:15:12  phil
 * modif commentaires
 *
 * Revision 2.2  2000/10/20  10:51:13  phil
 * Modif commentaires (minimale !)
 *
 * Revision 2.1  2000/10/20  09:27:28  phil
 * *** empty log message ***
 *
 * Revision 2.0  2000/10/20  09:22:04  phil
 * *** empty log message ***
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/bhole.h,v 1.18 2014/10/13 08:52:32 j_novak Exp $
 *
 */

#include "tenseur.h"

namespace Lorene {

class Tenseur ;
class Tenseur_sym ;
class Map_af ;
class Bhole_binaire ;
class Et_bin_nsbh ;

#define COROT 0
#define IRROT 1

class Bhole {

    // Data :
    protected:
    
    Map_af& mp ;  
    double rayon ; 
    double omega ; 
    double omega_local ; 
    int rot_state ; 
    double lapse_hori ; 
    
    double* boost ;
    double regul ; 
    
    Tenseur n_auto ; 
    Tenseur n_comp ; 
    Tenseur n_tot ; 
    
    Tenseur psi_auto ; 
    Tenseur psi_comp ; 
    Tenseur psi_tot ; 
    
    Tenseur grad_n_tot ; 
    Tenseur grad_psi_tot ; 
    
    Tenseur shift_auto ; 
    
    Tenseur_sym taij_auto ; 
    Tenseur_sym taij_comp ;

    Tenseur_sym taij_tot ;
    
    Tenseur_sym tkij_auto ; 
    Tenseur_sym tkij_tot ; 
    
    Cmp decouple ;
    
    //Constructors :
    public:
    Bhole (Map_af& mapping) ;
    Bhole (const Bhole&) ;  
    Bhole (Map_af&, FILE*, bool old=false) ; 
    ~Bhole() ; 
    
    public:
    //sauvegarde
    void sauve (FILE* fich) const ; 
    
    public:
    void operator= (const Bhole&) ; 
    
    const Map_af& get_mp() const {return mp;} ; 

    Map_af& set_mp() {return mp; } ;

    double get_rayon() const {return rayon;} ;
    
    void set_rayon(double ray) {rayon = ray ;} ;
    
    double get_omega() const {return omega;} ;
    void set_omega(double ome) {omega = ome ;} ;
    double get_omega_local() const {return omega_local;} ;
    void set_omega_local(double ome) {omega_local = ome ;} ;
    double get_rot_state() const {return rot_state;} ;
    void set_rot_state(int rotation) {rot_state = rotation;} ;
    double* get_boost () const {return boost;} ;
    void set_boost (double vx, double vy, double vz) {
        boost[0] = vx ; boost[1] = vy ; boost[2] = vz ;
    }
    
    double get_regul() const {return regul;} ;
    
    const Tenseur& get_n_auto() const {return n_auto ;} ;
    Cmp return_n_auto() const {return n_auto() ;} ;
    const Tenseur& get_n_comp() const {return n_comp ;} ;
    const Tenseur& get_n_tot() const {return n_tot ;} ;
    
    const Tenseur& get_psi_auto() const {return psi_auto ;} ;
    Cmp return_psi_auto() const {return psi_auto() ;} ;
    const Tenseur& get_psi_comp() const {return psi_comp ;} ;
    const Tenseur& get_psi_tot() const {return psi_tot ;} ;
    
    const Tenseur& get_grad_psi_tot() const {return grad_psi_tot ;} ;
    
    const Tenseur& get_grad_n_tot() const {return grad_n_tot ;} ;
    
    
    const Tenseur& get_shift_auto() const {return shift_auto ;} ;
    
    Cmp return_shift_auto(int i) const {return shift_auto(i) ;} ;
    
    const Tenseur& get_taij_auto() const {return taij_auto ;} ;
    const Tenseur& get_taij_comp() const {return taij_comp ;} ;
    const Tenseur& get_taij_tot() const {return taij_tot ;}
    
    const Tenseur& get_tkij_tot() const {return tkij_tot ;}
    const Tenseur& get_tkij_auto() const {return tkij_auto ;}
    const Cmp get_decouple() const {return decouple ;}
    
    Cmp& set_n_auto() {return n_auto.set() ;}
    Cmp& set_psi_auto() {return psi_auto.set() ;}
    
    void set_lapse_hori(double xx) {lapse_hori = xx;} 
    public:
    
    void fait_n_comp (const Bhole& comp) ;
    
    void fait_psi_comp (const Bhole& comp) ;
    void fait_n_comp (const Et_bin_nsbh& comp) ;
    
    void fait_psi_comp (const Et_bin_nsbh& comp) ;

    void fait_taij_auto () ;
    

    void regularise_shift (const Tenseur& comp) ;
    
     double viriel_seul () const ;
     
    void init_bhole () ;
    
    void init_kerr (double masse, double moment) ;
    
    void solve_lapse_seul (double relax) ;
    
    void solve_psi_seul (double relax) ;
    
    void solve_shift_seul (double precis, double relax) ;
    
    void regularise_seul () ;
    void solve_lapse_with_ns (double relax, int bound_nn, 
                  double lim_nn) ;
    
    void solve_psi_with_ns (double relax) ;
    
    void solve_shift_with_ns (const Et_bin_nsbh& ns, 
                  double precis, double relax,
                  int bound_nn, double lim_nn) ;
    
    void equilibrium (const Et_bin_nsbh& ns, double precis, double relax,
              int bound_nn, double lim_nn) ;
    void update_metric (const Et_bin_nsbh& ns) ;
        
    
    void fait_tkij() ;
    
    double area() const ; 
    
    double masse_adm_seul () const ;
    
    double masse_komar_seul() const ;
    
    double moment_seul_inf() const ;
    
    double moment_seul_hor() const ;
    
    /*
    * local angular momentum
    */
    double local_momentum() const ;
    
    void init_bhole_phi () ;
    
    void init_bhole_seul () ;
    
    friend class Bhole_binaire ; 
    friend class Bin_ns_bh ; 
} ;

class Bhole_binaire {
    
    // data :
    private:
    // les deux trous noirs.
    Bhole hole1 ;   
    Bhole hole2 ;   
    
    // Tableau sur les deux trous.
    Bhole* holes[2] ; 
    
    double pos_axe ; 
    double omega ;  
    
    public:
    // constructeurs & destructeur
    Bhole_binaire(Map_af& mp1, Map_af& mp2) ;   
    Bhole_binaire(const Bhole_binaire& ) ;  
    ~Bhole_binaire() ;  
    
    public:
    // trucs pour modifier
    void operator=(const Bhole_binaire&) ; 
    
    Bhole& set(int i) 
        { assert( (i==1) || (i==2) ); 
          return *holes[i-1] ;} ; 
    void set_omega(double ome) {omega = ome ; 
                 hole1.set_omega (ome) ;
                 hole2.set_omega (ome) ;} ;
    
    void set_pos_axe (double) ;
                 
    public:
    // trucs pour lire :
    const Bhole& operator()(int i) const 
        { assert( (i==1) || (i==2) ); 
          return *holes[i-1] ;} ;
          
    double get_omega() const {return omega; } ; 
    
    void init_bhole_binaire() ;
    
    double viriel() const ;
    void solve_lapse (double precis, double relax) ;
    
    void solve_psi (double precis, double relax) ;
   
    void solve_shift (double precis, double relax) ;
    
    void fait_tkij () ;
    
    void fait_decouple () ;
    
    public:
     void set_statiques (double precis, double relax) ;
     
      void coal (double precis, double relax, int nbre_ome, double search_ome, 
            double m1, double m2, const int sortie = 0) ;  

                
    double adm_systeme() const ;
    
    double komar_systeme() const ;
    
    double moment_systeme_inf() ;
    
    double moment_systeme_hor() const ;
    
     double distance_propre(const int nr = 65) const ;
     
    Tbl linear_momentum_systeme_inf() const ;
    
    void solve_phi (double precision, double relax) ;
    void init_phi() ;
} ;

}
#endif