hot_star.h

/*
 *  Definition of Lorene class Hot_star
 *               
 */

/*
 *   Copyright (c) 2026 Santiago Jaraba
 *
 *   Copyright (c) 2010 Michal Bejger (for preceding class Star)
 *   Copyright (c) 2004 Francois Limousin (for preceding class Star)
 *
 *   Copyright (c) 2000-2001 Eric Gourgoulhon (for preceding class Etoile)
 *   Copyright (c) 2000-2001 Keisuke Taniguchi (for preceding class Etoile)
 *
 *   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 __HOT_STAR_H_ 
#define __HOT_STAR_H_ 

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

namespace Lorene {
class Hot_eos ;

            //---------------------------//
            //    base class Hot_star        //
            //---------------------------//

class Hot_star {

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

    int nzet ;
    
    const Hot_eos& heos ;   
    
    // Fluid quantities with respect to the fluid frame
    // ------------------------------------------------

    Scalar ent ;       
    
    Scalar nbar ;      
    Scalar ener ;      
    Scalar press ;     

    // Temperature and entropy
    Scalar temp ; 
    Scalar entropy ; 

    // Fluid quantities with respect to the Eulerian frame
    // ---------------------------------------------------
    Scalar ener_euler ; 

    Scalar s_euler ;   

    Scalar gam_euler ; 
    
    Vector u_euler ; 
 
    Sym_tensor stress_euler ;
    
    // Metric potentials
    // -----------------
    
    Scalar logn ;

    Scalar nn ; 
    
    Vector beta ;
    
    // Scalar field \f$\ln Q = \ln(\psi^2  N)\f$ 
    //## to be removed from base class Star
    Scalar lnq ;
    
    Metric gamma ;


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

    mutable double* p_ray_eq_pis2 ;

    mutable double* p_ray_eq_pi ;
    
    mutable double* p_ray_eq_3pis2 ;

    mutable double* p_ray_pole ;
    
    mutable Itbl* p_l_surf ; 
    
    mutable Tbl* p_xi_surf ; 
    
    mutable double* p_mass_b ;  
    mutable double* p_mass_g ;  


    // Constructors - Destructor
    // -------------------------
    public:
    
    Hot_star(Map& mp_i, int nzet_i, const Hot_eos& heos_i) ;            
    
    
    Hot_star(const Hot_star& ) ;        

    Hot_star(Map& mp_i, const Hot_eos& heos_i, FILE* fich) ;            

    virtual ~Hot_star() ;           

    
    // 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 Hot_star&) ;   
    
    Map& set_mp() {return mp; } ; 

    void set_enthalpy(const Scalar& ) ; 
    
    void equation_of_state() ; 
    
     virtual void hydro_euler() ; 
    
     virtual void equilibrium_spher(double ent_c, double precis = 1.e-14, 
             const Tbl* pent_limit = 0x0 ) ; 

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

    int get_nzet() const {return nzet; } ; 

    const Hot_eos& get_eos() const {return heos; } ; 

    const Scalar& get_ent() const {return ent;} ;

    const Scalar& get_entropy() const {return ent;} ;

    const Scalar& get_nbar() const {return nbar;} ;

    const Scalar& get_ener() const {return ener;} ;

    const Scalar& get_press() const {return press;} ;

    const Scalar& get_temp() const {return temp;} ;

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

    const Scalar& get_s_euler() const {return s_euler;} ;

    const Scalar& get_gam_euler() const {return gam_euler;} ;

    const Vector& get_u_euler() const {return u_euler;} ;

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

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

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

    const Vector& get_beta() const {return beta;} ;

    // Returns the scalar field \f$\ln Q\f$.
    //## to be removed from base class Star
    const Scalar& get_lnq() const {return lnq;} ;

    const Metric& get_gamma() const {return gamma;} ;

    // Outputs
    // -------
    public:
    virtual void sauve(FILE* ) const ;      
    
    friend ostream& operator<<(ostream& , const Hot_star& ) ;   

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

    // Global quantities
    // -----------------
    public:
    double ray_eq() const ; 
    
    double ray_eq_pis2() const ; 
    
    double ray_eq_pi() const ; 
    
    double ray_eq_3pis2() const ;

    double ray_pole() const ; 
    
    virtual const Itbl& l_surf() const ; 
    
    const Tbl& xi_surf() const ; 

        virtual double mass_b() const = 0  ;
    
        virtual double mass_g() const = 0  ;
    
};
ostream& operator<<(ostream& , const Hot_star& ) ;  


            //---------------------------//
            //    class Star_bin         //
            //---------------------------//

class Star_bin : public Hot_star {

    // Data : 
    // -----
    protected:
    bool irrotational ; 
    
    Scalar psi0 ; 

    Vector d_psi ; 
    
    Vector wit_w ; 
    
    Scalar loggam ; 

    Vector bsn ; 
    
    Scalar pot_centri ;     


    Scalar logn_auto ; 

    Scalar logn_comp ; 

    Vector dcov_logn ;

    Vector dcon_logn ;
    
    Scalar lnq_auto ;

    Scalar lnq_comp ;

    
    Scalar psi4 ;

    Vector dcov_phi ;
    Vector dcon_phi ;

    Metric_flat flat ;

    Metric gtilde ;

    Vector beta_auto ; 

    Vector beta_comp ; 


    Sym_tensor hij ; 


    Sym_tensor hij_auto ;

    Sym_tensor hij_comp ;

    Sym_tensor tkij_auto ;
    
    Sym_tensor tkij_comp ;
    
    Scalar kcar_auto ;
    
    Scalar kcar_comp ;

    Scalar ssjm1_logn ;

    Scalar ssjm1_lnq ;

    Scalar ssjm1_khi ;

    Vector ssjm1_wbeta ;
    
    Scalar ssjm1_h11 ;

    Scalar ssjm1_h21 ;

    Scalar ssjm1_h31 ;

    Scalar ssjm1_h22 ;

    Scalar ssjm1_h32 ;

    Scalar ssjm1_h33 ;

     Scalar decouple ;

     bool conf_flat ;
    
    // Derived data : 
    // ------------
    protected:
    mutable double* p_xa_barycenter ; 

}; 

}
#endif