compobj.h

/*
 *  Definition of Lorene class Compobj, Compobj_QI, Star_QI, Kerr_QI, AltBH_QI, HiggsMonopole, ScalarBH
 *
 */

/*
 *   Copyright (c) 2012, 2013 Claire Some, Eric Gourgoulhon
 *
 *   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 __COMPOBJ_H_ 
#define __COMPOBJ_H_ 

/*
 * $Id: compobj.h,v 1.21 2018/11/16 14:34:34 j_novak Exp $
 * $Log: compobj.h,v $
 * Revision 1.21  2018/11/16 14:34:34  j_novak
 * Changed minor points to avoid some compilation warnings.
 *
 * Revision 1.20  2015/11/05 17:31:21  f_vincent
 * Updated class scalarBH.
 *
 * Revision 1.19  2015/10/22 09:18:35  f_vincent
 * New class ScalarBH
 *
 * Revision 1.18  2014/10/13 08:52:33  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.17  2014/05/16 11:55:19  o_straub
 * fixed: GYOTO output from compobj & compobj_QI
 *
 * Revision 1.16  2014/01/31 15:34:54  e_gourgoulhon
 * Added members to class HiggsMonopole
 *
 * Revision 1.15  2014/01/29 16:29:16  e_gourgoulhon
 * Added new class HiggsMonopole
 *
 * Revision 1.14  2014/01/14 20:53:39  e_gourgoulhon
 * Updated documentation of r_isco
 *
 * Revision 1.13  2013/07/25 19:44:45  o_straub
 * calculation of the marginally bound radius
 *
 * Revision 1.12  2013/04/17 13:01:50  e_gourgoulhon
 * Some modifications in the class AltBH_QI
 *
 * Revision 1.11  2013/04/16 15:26:45  e_gourgoulhon
 * Added class AltBH_QI
 *
 * Revision 1.10  2013/04/04 15:31:34  e_gourgoulhon
 * r_isco returns now the coordinate r, not the areal r
 *
 * Revision 1.9  2013/04/03 12:08:57  e_gourgoulhon
 * Added member kk to Compobj; suppressed tkij
 *
 * Revision 1.8  2013/04/02 23:17:18  e_gourgoulhon
 * New class Kerr_QI
 *
 * Revision 1.7  2012/12/03 15:26:14  c_some
 * Added data member m2
 *
 * Revision 1.6  2012/11/22 16:02:18  c_some
 * *** empty log message ***
 *
 * Revision 1.5  2012/11/21 14:52:13  c_some
 * Documentation corrected
 *
 * Revision 1.4  2012/11/20 16:21:16  c_some
 * Added new class Star_QI
 *
 * Revision 1.3  2012/11/16 16:13:12  c_some
 * Added new class Compobj_QI
 *
 * Revision 1.2  2012/11/15 20:50:41  e_gourgoulhon
 * Corrected the documentation
 *
 * Revision 1.1  2012/11/15 16:20:51  c_some
 * New class Compobj
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/compobj.h,v 1.21 2018/11/16 14:34:34 j_novak Exp $
 *
 */


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


//---------------------------//
//    base class Compobj     //
//---------------------------//

namespace Lorene {
  class Compobj {

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

    Scalar nn ; 
    
    Vector beta ;
    
    Metric gamma ;

    Scalar ener_euler ; 

    Vector mom_euler ; 

    Sym_tensor stress_euler ;

    Sym_tensor kk ;

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

    // Constructors - Destructor
    // -------------------------
  public:
    Compobj(Map& map_i) ;

    Compobj(const Compobj& ) ;      

    Compobj(Map& map_i, FILE* ) ;           

    virtual ~Compobj() ;            
 

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


    // Mutators / assignment
    // ---------------------
  public:
    void operator=(const Compobj&) ;    
    
    Map& set_mp() {return mp; } ; 


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

    const Scalar& get_nn() const {return nn;} ;

    const Vector& get_beta() const {return beta;} ;
    
    const Metric& get_gamma() const {return gamma;} ;

    const Scalar& get_ener_euler() const {return ener_euler;}  ; 

    const Vector& get_mom_euler() const {return mom_euler;} ; 

    const Sym_tensor& get_stress_euler() const {return stress_euler;} ;

    const Sym_tensor& get_kk() const {return kk;} ;




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

    friend ostream& operator<<(ostream& , const Compobj& ) ;    

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

    // Computational methods
    // ---------------------
  public:
    virtual void extrinsic_curvature() ; 
    
    
    // Global quantities
    // -----------------
  public:
    virtual double adm_mass() const ;
  };


  //---------------------------//
  //    base class Compobj_QI  //
  //---------------------------//

  class Compobj_QI : public Compobj {

    // Data : 
    // -----
  protected:

    Scalar a_car ; 

    Scalar bbb ; 

    Scalar b_car ; 

    Scalar nphi ; 

    Scalar ak_car ; 


    // Derived data : 
    // ------------
  protected:
    mutable double* p_angu_mom ;    
    mutable double* p_r_isco ;  
    mutable double* p_f_isco ;  
    mutable double* p_espec_isco ;  
    mutable double* p_lspec_isco ;  
    mutable double* p_r_mb ;    

    // Constructors - Destructor
    // -------------------------
  public:
    Compobj_QI(Map& map_i) ;

    Compobj_QI(const Compobj_QI& ) ;        

    Compobj_QI(Map& map_i, FILE* ) ;            

    virtual ~Compobj_QI() ;         
 

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


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

    // Accessors
    // ---------
  public:

    const Scalar& get_bbb() const {return bbb;} ; 

    const Scalar& get_a_car() const {return a_car;} ; 

    const Scalar& get_b_car() const {return b_car;} ; 

    const Scalar& get_nphi() const {return nphi;} ; 


    const Scalar& get_ak_car() const {return ak_car;} ; 






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

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

    virtual double r_isco(int lmin, ostream* ost = 0x0) const ; 
    
    virtual double f_isco(int lmin) const ; 

    virtual double espec_isco(int lmin) const ; 
    
    virtual double lspec_isco(int lmin) const ; 

    virtual double r_mb(int lmin, ostream* ost = 0x0) const ;


    // Computational routines
    // ----------------------

    virtual void update_metric() ; 
        
    virtual void extrinsic_curvature() ;
    
  };


  //--------------------------//
  //   base class Star_QI     //
  //--------------------------//

  class Star_QI : public Compobj_QI {

    // Data : 
    // -----
  protected:

    Scalar logn ;

    Scalar tnphi ; 

    Scalar nuf ;    

    Scalar nuq ;    

    Scalar dzeta ;  

    Scalar tggg ; 

    Vector w_shift ; 
    
    Scalar khi_shift ; 

    Scalar ssjm1_nuf ; 

    Scalar ssjm1_nuq ; 

    Scalar ssjm1_dzeta ; 

    Scalar ssjm1_tggg ; 

    Scalar ssjm1_khi ; 
     
    Vector ssjm1_wshift ; 
     

    // Derived data : 
    // ------------
  protected:
    
    mutable double* p_grv2 ;    
    mutable double* p_grv3 ;    
    mutable double* p_mom_quad ;    
    mutable double* p_mass_g ;  
     

    // Constructors - Destructor
    // -------------------------
  public:
    Star_QI(Map& mp_i) ;            
    
    
    Star_QI(const Star_QI& ) ;      

    Star_QI(Map& mp_i, FILE* fich) ;            

    virtual ~Star_QI() ;            


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

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

    const Scalar& get_logn() const {return logn;} ;


    const Scalar& get_tnphi() const {return tnphi;} ; 
    
    const Scalar& get_nuf() const {return nuf;} ;   

    const Scalar& get_nuq() const {return nuq;} ;   

    const Scalar& get_dzeta() const {return dzeta;} ;   

    const Scalar& get_tggg() const {return tggg;} ; 

    const Vector& get_w_shift() const {return w_shift;} ; 
    
    const Scalar& get_khi_shift() const {return khi_shift;} ; 


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

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

    virtual double grv2() const ;   

    virtual double grv3(ostream* ost = 0x0) const ; 
    
    virtual double mom_quad() const ;   
    

    // Computational routines
    // ----------------------
  public: 
    
    void update_metric() ; 
        
    void fait_shift() ; 
    
    void fait_nphi() ; 
            
    static double lambda_grv2(const Scalar& sou_m, const Scalar& sou_q) ;
        
  };


  //---------------------//
  //   class Kerr_QI     //
  //---------------------//

  class Kerr_QI : public Compobj_QI {

    // Data : 
    // -----
  protected:

    double mm ;

    double aa ; 


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

    // Constructors - Destructor
    // -------------------------
  public:
    Kerr_QI(Map& mp_i, double mass, double a_over_m) ;          
    
    
    Kerr_QI(const Kerr_QI& ) ;      

    Kerr_QI(Map& mp_i, FILE* fich) ;            

    virtual ~Kerr_QI() ;            

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

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

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

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

    // Computational routines
    // ----------------------
  public: 
    

  };

  //-------------------//
  //   class AltBH_QI  //
  //-------------------//

  class AltBH_QI : public Compobj_QI {

    // Data : 
    // -----
  protected:

    char description1[256] ;  
    char description2[256] ;  
    double a_spin ;     
    
    Scalar krphi ; 
    
    // Derived data : 
    // ------------
  protected:
         

    // Constructors - Destructor
    // -------------------------
  public:
    AltBH_QI(Map& mp_i, const char* file_name, double a_spin_i) ;          
    
    
    AltBH_QI(const AltBH_QI& ) ;      

    AltBH_QI(Map& mp_i, FILE* fich) ;            

    virtual ~AltBH_QI() ;            

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

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

    const Scalar& get_krphi() const {return krphi;} ;
    
    // Outputs
    // -------
  public:
    virtual void sauve(FILE* ) const ;      
    
  protected:
    virtual ostream& operator>>(ostream& ) const ;    

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

    // Computational routines
    // ----------------------
  public: 
    
    virtual void extrinsic_curvature() ; 
 
  };

  //-------------------//
  //   class ScalarBH  //
  //-------------------//

  class ScalarBH : public Compobj {

    // Data : 
    // -----
  protected:

    //char description1[256] ;  ///< String describing the model
    // char description2[256] ;  ///< String describing the model    
    Scalar ff0 ; 
    Scalar ff1 ; 
    Scalar ff2 ; 
    Scalar ww ; 
    Scalar sfield ; 
    double rHor ; 

    // Constructors - Destructor
    // -------------------------
  public:
    ScalarBH(Map& mp_i, const char* file_name) ;          
    
    ScalarBH(const ScalarBH& ) ;      

    ScalarBH(Map& mp_i, FILE* fich) ;            

    virtual ~ScalarBH() ;            

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

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

    // Accessors
    // ---------
  public:
    const Scalar& get_ff0() const {return ff0; } ; 
    const Scalar& get_ff1() const {return ff1; } ; 
    const Scalar& get_ff2() const {return ff2; } ; 
    const Scalar& get_ww() const {return ww; } ; 
    const Scalar& get_sfield() const {return sfield; } ; 
    double get_rHor() const {return rHor; } ; 
    
    // Outputs
    // -------
  public:
    virtual void sauve(FILE* ) const ;      
    
  protected:
    virtual ostream& operator>>(ostream& ) const ;    

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

    // Computational routines
    // ----------------------
  public: 
    virtual void update_metric();
  };


  //------------------------//
  //   class HiggsMonopole  //
  //------------------------//

  class HiggsMonopole : public Compobj {

    // Data : 
    // -----
  protected:

    char description1[256] ;  
    char description2[256] ;  

    Scalar hh ; 
    
    Scalar grr ; 

    Scalar press ; 

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

    // Constructors - Destructor
    // -------------------------
  public:
    HiggsMonopole(Map& mp_i, const char* file_name) ;          
    
    HiggsMonopole(const HiggsMonopole& ) ;      

    virtual ~HiggsMonopole() ;            

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

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

    const Scalar& get_higgs() const {return hh;} ;
    
    const Scalar& get_grr() const {return grr;} ;
    
    const Scalar& get_press() const {return press;} ;
    
    // Outputs
    // -------
  public:
    // virtual void sauve(FILE* ) const ;      ///< Save in a file
    
  protected:
    virtual ostream& operator>>(ostream& ) const ;    

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

    // Computational routines
    // ----------------------
  public: 
    
    // virtual void extrinsic_curvature() ; 
 
  };




}
#endif