star_rot_cfc.h

/*
 *  Definition of Lorene class Star_rot_CFC
 *
 */

/*
 *   Copyright (c) 2024 Jerome Novak
 *
 *   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 __STAR_ROT_CFC_H_ 
#define __STAR_ROT_CFC_H_ 

// Headers Lorene
#include "star.h"


namespace Lorene {
  class Star_rot_CFC : public Star {
    
    // Data : 
    // -----
  protected:
    int relat_type ;
  
    int spectral_filter ;
    
    double omega ;  
    
    // Quantities related to the conformal factor
    //--------------------------------------------
    
    Scalar psi ; 

    
    // Fluid quantities
    //-----------------------------------------
    
    Vector j_euler ; 
    Scalar v2 ; 
    
    // Metric stuff 
    //-------------------------------------
    
    Scalar psi4 ;   
    Scalar psi2 ;   
    
    const Metric_flat& flat ; 
    
    Sym_tensor hatA ; 
    Scalar hatA_quad ; 

    // Derived data : 
    // ------------
  protected:
    
    // More to come later.....
    //----------------------------
    
    mutable double* p_angu_mom ; 
    mutable double* p_grv2 ; 
    mutable double* p_grv3 ; 
    mutable double* p_tsw ; 
    mutable double* p_r_circ ; 
    mutable double* p_rp_circ ; 
    

    // Constructors - Destructor
    // -------------------------
  public:
    
    Star_rot_CFC(Map& mp_i, int nzet_i, const Eos& eos_i, int relat_i=3,
           int filter=0) ;  

    Star_rot_CFC(const Star_rot_CFC& ) ; 

    
    Star_rot_CFC(Map& mp_i, const Eos& eos_i, FILE* fich) ;
    
    
    virtual ~Star_rot_CFC() ;    
    
    
    // Memory management
    // -----------------
  protected:
    
    virtual void del_deriv() const ; 
    
    void set_der_0x0() const ; 
    
    virtual void del_hydro_euler() ;
    
    
    // Mutators / assignment
    // ---------------------
  public:
    
    void operator=(const Star_rot_CFC& ) ;  
    
    // Accessors
    // ---------
  public:

    int get_relat() const {return relat_type;};

    bool is_relativistic() const {return (relat_type > 0) ;}; 
    
    int spectral_filter_order() const {return spectral_filter;};
    
    double get_omega() const {return omega;} ;
    
    
    const Scalar& get_psi4() const {return psi4;} ;
    
    const Scalar& get_psi2() const {return psi2;} ;
    
    const Scalar& get_psi() const {return psi;} ;
    
    // Fluid stuff
    //------------------
    
    const Vector& get_j_euler() const {return j_euler;} ;
    
    const Scalar& get_v2() const {return v2;} ;
    
    
    //Metric stuff
    //-------------------
    const Sym_tensor get_hatA() const {return hatA;} ;
    
    const Scalar get_hatA_quad() const {return hatA_quad;} ;
    
    
    // Outputs
    // -------
  public:
    
    virtual void sauve(FILE* ) const ;      
    
  protected:
    
    virtual ostream& operator>>(ostream& ) const ;
    
   
    // Global quantities
    //-------------------------
  public:
    
    virtual double mass_b() const ; 
    virtual double mass_g() const ; 
    virtual double angu_mom() const ; 
    virtual double grv2() const ;  
    virtual double grv3() const ; 
    virtual double tsw() const ; 
    virtual double aplat() const ; 
    virtual double r_circ() const ; 
    virtual double rp_circ() const ; 

    virtual double ellipt() const ;




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

    virtual void hydro_euler() ; 

       
    void update_metric() ;


    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)  ;

    void solve_logn_f(Scalar& ln_f_new) const ;

    void solve_logn_q(Scalar& ln_q_new) const ;

    void solve_psi(Scalar& psi_new) ;

    void solve_shift(Vector& shift_new) const ;

  };

}
#endif