isol_hole.h

/*
 *  Definition of Lorene class Isol_hole
 *               
 */

/*
 *   Copyright (c) 2009 Nicolas Vasset
 */


#ifndef __ISOLHOLE_H_ 
#define __ISOLHOLE_H_ 


// Headers Lorene
#include "tensor.h"
#include "metric.h"
#include "spheroid.h"
#include "excision_surf.h"
#include "excision_hor.h"

 class Eos ;

            //---------------------------//
            //    Class Isol_hole        //
            //---------------------------//

namespace Lorene {
class Isol_hole {

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

        double Omega ;     
        bool NorKappa ;    
        Scalar boundNoK ; 
    bool isCF ;       

    
    // Metric data
    // -----------------

    Scalar lapse ; 
    
    // Conformal factor
    Scalar conf_fact;

    Vector shift ;
    
        Sym_tensor hij ;

    Sym_tensor hatA ; 

   // Derived data : 
    // ------------
    protected:

    

    mutable Spheroid* p_hor ;
    mutable double* p_adm_mass ; 

    mutable double* p_komar_angmom ;

    mutable double* p_virial_residue ;
    

    


    // Constructors - Destructor
    // -------------------------
    public:
    
    Isol_hole(const Map& mp_i, double Omega_i, bool NorKappa_i, Scalar NoK_i, bool isCF_i = false) ;            
    
    
    Isol_hole(const Isol_hole& ) ;      

    Isol_hole(const Map& mp_i, double Omega_i, bool NorKappa_i, Scalar NoK_i, bool isCF_i, FILE* fich) ;            

    virtual ~Isol_hole() ;          

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


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

    void compute_stat_metric(double precis, double relax, int mer_max, int mer_max2, bool isvoid = true) ; 

    void secmembre_kerr(Sym_tensor& source_hh);
 
 

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

    double get_Omega() const {return Omega ;} ;

    const Scalar& get_boundN() const{
    if (NorKappa == false){
      return boundNoK;
    }
    else cout << "The boundary condition is imposed on the surface gravity!" << endl;
    }
    
    const Scalar& get_Kappa() const{
      if(NorKappa == true){
      return boundNoK;
    }
    else cout << "The boundary condition is imposed on the lapse!" <<endl;
    }


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

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

    const Sym_tensor& get_hij() const {return hij;} ;

    const Sym_tensor& get_hatA() const {return hatA;} ;




    // Outputs
    // -------
    public:
    virtual void sauve(FILE* ) const ;      

        void Einstein_errors();                     

 
    // Global quantities
    // -----------------
    public:

      
    Spheroid hor() ;
 
    double adm_mass() ; 

    double komar_angmom() ;

    double virial_residue() ;

    

};

}
#endif