star_rot.h

/*
 *  Definition of Lorene class Star_rot
 *               
 */

/*
 *   Copyright (c) 2010 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 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 __STAR_ROT_H_ 
#define __STAR_ROT_H_ 

/*
 * $Id: star_rot.h,v 1.12 2026/02/05 14:23:25 j_novak Exp $
 * $Log: star_rot.h,v $
 * Revision 1.12  2026/02/05 14:23:25  j_novak
 * New method surf_grav_euler().
 *
 * Revision 1.11  2026/01/20 08:35:28  j_novak
 * New method radius_Morsink() to compute the physical radius along the definition of Morsink et al. (2007) in the oblate Schwarschild approximation.
 *
 * Revision 1.10  2023/07/04 09:01:09  j_novak
 * Changed the name r_pol_circ -> r_circ_merid to explicitly show the radius is a circumferential one, along a meridian.
 *
 * Revision 1.9  2023/07/04 07:28:34  j_novak
 * Added method "r_pol_circ()", to compute polar circumferential radius, with a circumference along a meridian.
 *
 * Revision 1.8  2017/10/20 13:55:41  j_novak
 * Calss Star_rot is now friend of class Star.
 *
 * Revision 1.7  2017/04/11 10:46:55  m_bejger
 * Star_rot::surf_grav() - surface gravity values along the theta direction
 *
 * Revision 1.6  2015/05/19 09:30:55  j_novak
 * New methods for computing the area of the star and its mean radius.
 *
 * Revision 1.5  2014/10/13 08:52:36  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.4  2010/02/08 10:56:30  j_novak
 * Added a few things missing for the reading from resulting file.
 *
 * Revision 1.3  2010/02/02 13:35:00  e_gourgoulhon
 * Remove the "under construction" mark.
 *
 * Revision 1.2  2010/01/25 18:14:05  e_gourgoulhon
 * Added member unsurc2
 * Added method is_relativistic()
 * Suppressed method f_eccentric
 *
 * Revision 1.1  2010/01/24 16:07:45  e_gourgoulhon
 * New class Star_rot.
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/star_rot.h,v 1.12 2026/02/05 14:23:25 j_novak Exp $
 *
 */

// Headers Lorene
#include "star.h"

namespace Lorene {
class Eos ;

            //--------------------------//
            //    class Star_rot        //
            //--------------------------//

  class Star_rot : public Star {

    // Data : 
    // -----
  protected:
    bool relativistic ;
    
    double unsurc2 ;         

    double omega ;      

    Scalar a_car ; 

    Scalar bbb ; 

    Scalar b_car ; 

    Scalar nphi ; 

    Scalar tnphi ; 

    Scalar uuu ;        
    
    Scalar nuf ;    

    Scalar nuq ;    

    Scalar dzeta ;  

    Scalar tggg ; 

    Vector w_shift ; 
    
    Scalar khi_shift ; 

    Sym_tensor tkij ; 

    Scalar ak_car ; 

    Scalar ssjm1_nuf ; 

    Scalar ssjm1_nuq ; 

    Scalar ssjm1_dzeta ; 

    Scalar ssjm1_tggg ; 

    Scalar ssjm1_khi ; 
     
    Vector ssjm1_wshift ; 
     

    // Derived data : 
    // ------------
  protected:
    
    mutable double* p_angu_mom ;    
    mutable double* p_tsw ;     
    mutable double* p_grv2 ;    
    mutable double* p_grv3 ;    
    mutable double* p_r_circ ;  
    mutable double* p_r_circ_merid ;    
    mutable double* p_aplat ;   
    mutable double* p_area ;        
    mutable double* p_z_eqf ;   
    mutable double* p_z_eqb ;   
    mutable double* p_z_pole ;  
    mutable double* p_mom_quad ;    
    mutable double* p_r_isco ;  
    mutable double* p_f_isco ;  
    mutable double* p_espec_isco ;  
    mutable double* p_lspec_isco ;  
    mutable double* p_f_eq ;        
    mutable Tbl*    p_surf_grav ;
    mutable Tbl*    p_surf_grav_euler ;
    mutable Tbl*    p_radius_Morsink ; 
     

    // Constructors - Destructor
    // -------------------------
  public:
    Star_rot(Map& mp_i, int nzet_i, bool relat, const Eos& eos_i) ;         
    
    
    Star_rot(const Star_rot& ) ;        

    Star_rot(Map& mp_i, const Eos& eos_i, FILE* fich) ;         

    virtual ~Star_rot() ;           


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

    virtual void del_hydro_euler() ; 
    

    // Mutators / assignment
    // ---------------------
  public:
    void operator=(const Star_rot& ) ;  
    
    // Accessors
    // ---------
  public:
    bool is_relativistic() const {return relativistic; } ;  

    virtual double get_omega_c() const ;        

    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_tnphi() const {return tnphi;} ; 

    const Scalar& get_uuu() const {return uuu;} ;       
    
    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;} ; 

    const Sym_tensor& get_tkij() const {return tkij;} ; 

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

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

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

    virtual void partial_display(ostream& ) const ;    

    // Global quantities
    // -----------------
  public:
    
    virtual const Itbl& l_surf() const ; 
    
    virtual double mass_b() const ;     
    virtual double mass_g() const ;     
    virtual double angu_mom() const ;   
    virtual double tsw() const ;        

    virtual double grv2() const ;   

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

    virtual double r_circ() const ; 
    virtual double r_circ_merid() const ; 
      
    virtual double aplat() const ;  
    virtual double area() const ;   
    virtual double mean_radius() const ; 
    virtual double z_eqf() const ;  
    virtual double z_eqb() const ;  
    virtual double z_pole() const ; 
    
    virtual double mom_quad() const ;   

    virtual const Tbl& surf_grav() const ; 

    virtual const Tbl& surf_grav_euler() const ; 

    virtual const Tbl& radius_Morsink() const ; 

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

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

    virtual double f_eq() const ;
    

    // Computational routines
    // ----------------------
  public: 
    virtual void hydro_euler() ; 
    
    void update_metric() ; 
        
    void fait_shift() ; 
    
    void fait_nphi() ; 
        
    void extrinsic_curvature() ;
    
    static double lambda_grv2(const Scalar& sou_m, const Scalar& sou_q) ;
        
    virtual void equilibrium(double ent_c, double omega0, double fact_omega, 
                 int nzadapt, const Tbl& ent_limit,
                 const Itbl& icontrol, const Tbl& control,
                 double mbar_wanted, double aexp_mass, 
                 Tbl& diff, Param* = 0x0) ;
    

    friend class Star ;
  };

}
#endif