excised_slice.h

/*
 *  Definition of Lorene class Excised slice
 *               
 */

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


#ifndef __EXCISEDSLICE_H_ 
#define __EXCISEDSLICE_H_ 


// Headers Lorene
#include "spheroid.h"

//---------------------------//
//    Class Excised_slice    //
//---------------------------//

namespace Lorene {
class Excised_slice {

  // Data : 
  // -----
 protected:
   const Map& mp ;      
  
  // Metric data
  // -----------------
  
   int type_hor;

   int field_set;

  Scalar lapse ; 
    
  // Conformal factor
  Scalar conf_fact;

  Vector shift ;
    
  Sym_tensor hij ;

  Sym_tensor hatA ; 

  Vector Xx ;
 
      
  // 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:
    
  Excised_slice(const Map& mp_i, int hor_type, int scheme_type) ;           
    
    
  Excised_slice(const Excised_slice& ) ;    

  Excised_slice(const Map& mp_i, int hor_type, int scheme_type, FILE* fich) ;           

  virtual ~Excised_slice() ;            

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


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

  void compute_stat_metric(double precis, double Omega_i, bool NorKappa_i, Scalar NoK_i, bool isCF_i=true, double relax=0.2, int mer_max = 2000, int mer_max2=200, bool isvoid = true) ; 

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

  int get_type_hor() const {return type_hor; };
  

  int get_field_set() const {return field_set;};

  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;} ;
  
  const Vector& get_Xx() const {
    if (field_set==2) return Xx; 
    else if (field_set==1) cout <<"Error: the scheme used is the original FCF; this variable is irrelevant" << endl;
    else cout <<"error in the scheme definition; please check the class consistency" << endl;}

  int set_type_hor() {del_deriv() ; return type_hor ; } ;
  
  Scalar& set_lapse() {del_deriv() ; return lapse ; } ;
  
  Scalar& set_conf_fact() {del_deriv() ; return conf_fact ; } ;
  
  Vector& set_shift() {del_deriv() ; return shift ; } ;
  
  Sym_tensor& set_hij() {del_deriv() ; return hij ; } ;
  
  Sym_tensor& set_hatA() {del_deriv() ; return hatA ; } ;

  Vector& set_Xx() {del_deriv() ; return Xx ; } ; // Include an assert here!!!!


  // 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