star_rot_dirac.h

/*
 *  Definition of Lorene class Star_rot_Dirac
 *
 */

/*
 *   Copyright (c) 2005 Lap-Ming Lin & 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_DIRAC_H_ 
#define __STAR_ROT_DIRAC_H_ 

/*
 *
 * $Header: /cvsroot/Lorene/C++/Include/star_rot_dirac.h,v 1.9 2023/12/20 10:16:18 j_novak Exp $
 *
 */


// Headers Lorene
#include "star.h"


namespace Lorene {
  class Star_rot_Dirac : public Star {
    
    // Data : 
    // -----
  protected:
    int relat_type ;
  
    int spectral_filter ;
    
    double omega ;  
    
    // Quantities related to the conformal factor and lapse
    //----------------------------------
    
    Scalar psi4 ;   
    Scalar psi2 ;   
    Scalar qqq ;    
    Scalar ln_psi ; 
    
    
    // Fluid quantities
    //-----------------------------------------
    
    Vector j_euler ; 
    Scalar v2 ; 
    
    // Metric stuff 
    //-------------------------------------
    
    const Metric_flat& flat ; 
    
    Metric tgamma  ;  
    Sym_tensor aa ; 
    Sym_tensor taa ; 
    Scalar aa_quad ; 

    Sym_tensor_trans hh ; 
    
    
    // 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_Dirac(Map& mp_i, int nzet_i, const Eos& eos_i, int relat_i=1,
           int filter=0) ;  

    Star_rot_Dirac(const Star_rot_Dirac& ) ; 

    
    Star_rot_Dirac(Map& mp_i, const Eos& eos_i, FILE* fich) ;
    
    
    virtual ~Star_rot_Dirac() ;  
    
    
    // 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_Dirac& ) ;    
    
    // 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_qqq() const {return qqq;} ;
    
    const Scalar& get_ln_psi() const {return ln_psi;} ;
    
    
    // Fluid stuff
    //------------------
    
    const Vector& get_j_euler() const {return j_euler;} ;
    
    const Scalar& get_v2() const {return v2;} ;
    
    
    //Metric stuff
    //-------------------
    const Metric get_tgamma() const {return tgamma;} ;
    
    const Sym_tensor get_aa() const {return aa;} ;
    
    const Sym_tensor get_taa() const {return taa;} ;
    
    const Scalar get_aa_quad() const {return aa_quad;} ;
    
    const Sym_tensor_trans get_hh() const {return hh;} ;
    
    
    
    
    // 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_qqq(Scalar& q_new) const ;

    void solve_shift(Vector& shift_new) const ;

    void solve_hij(Sym_tensor_trans& hij_new) const ;
              
  };

}
#endif