dyneos.h

/*
 *  Definition of Lorene classes Dyn_eos
 *               Dyn_eos_poly
 *                               Dyn_eos_tab
 *                               Dyn_eos_cons
 *
 */

/*
 *   Copyright (c) 2019 Jerome Novak
 *             (c) 2000 Eric Gourgoulhon for Eos classes
 *
 *   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 __DYNEOS_H_ 
#define __DYNEOS_H_ 

/*
 * $Id: dyneos.h,v 1.3 2021/05/06 14:33:17 j_novak Exp $
 * $Log: dyneos.h,v $
 * Revision 1.3  2021/05/06 14:33:17  j_novak
 * New conversion function from Eos to Dyn_eos.
 *
 * Revision 1.2  2020/12/17 17:00:27  j_novak
 * Output of sound speed squared, instead of sound speed.
 *
 * Revision 1.1  2019/12/06 14:30:50  j_novak
 * New classes Dyn_eos... for cold Eos's with baryon density as input.
 *
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/dyneos.h,v 1.3 2021/05/06 14:33:17 j_novak Exp $
 *
 */

// Standard C++
#include "headcpp.h"

// Lorene classes
namespace Lorene {
  class Tbl ;
  class Param ;
  class Scalar ;
  class Eos ;

            //------------------------------------//
            //       base class Dyn_eos       //
            //------------------------------------//

class Dyn_eos {

    // Data :
    // -----

    protected: 
    string name ;       


    // Constructors - Destructor
    // -------------------------
    protected:
    Dyn_eos() ;         

    explicit Dyn_eos(const string&) ; 

    Dyn_eos(const Dyn_eos& ) ;  

    protected:
    Dyn_eos(FILE* ) ; 

    Dyn_eos(ifstream& ) ;

    public:
  static Dyn_eos* convert_from_Eos(const Eos&) ;
  
    public:
    virtual ~Dyn_eos() ;            


    // Name manipulation
    // -----------------
    public:
    const string& get_name() const ;    

    void set_name(const string&) ; 
    
    // Miscellaneous
    // -------------
    public:
    static Dyn_eos* eos_from_file(FILE* ) ; 
    
    static Dyn_eos* eos_from_file(ifstream& ) ; 
    
    virtual bool operator==(const Dyn_eos& ) const = 0 ; 

    virtual bool operator!=(const Dyn_eos& ) const = 0 ; 
    
    virtual int identify() const = 0 ; 

    // Outputs
    // -------

    public: 
    virtual void sauve(FILE* ) const ;  

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

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


    // Computational functions
    // -----------------------
    protected:
    void calcule(const Scalar& thermo, int nzet, int l_min,
             double (Dyn_eos::*fait)(double, const Param*) const,
             Param* par, Scalar& resu) const ;

    public:
        virtual double ent_nbar_p(double nbar, const Param* par=0x0) const = 0 ;

        Scalar ent_nbar(const Scalar& nbar, int nzet, int l_min = 0, Param* par=0x0) const  ;

        virtual double ener_nbar_p(double nbar, const Param* par=0x0) const = 0 ;

    Scalar ener_nbar(const Scalar& nbar, int nzet, int l_min = 0, Param* par=0x0) const ;

        virtual double press_nbar_p(double nbar, const Param* par=0x0) const = 0 ;


        Scalar press_nbar(const Scalar& nbar, int nzet, int l_min = 0, Param* par=0x0) const ;

        virtual double csound_square_nbar_p(double nbar, const Param* par=0x0) const = 0 ;

    Scalar csound_square_nbar(const Scalar& nbar, int nzet, int l_min = 0, Param* par=0x0) const ;


};
ostream& operator<<(ostream& , const Dyn_eos& ) ;   


            //------------------------------------//
            //         class Dyn_eos_poly         //
            //------------------------------------//


class Dyn_eos_poly : public Dyn_eos {

    // Data :
    // -----

    protected:
    double gam ;

    double kap ; 

    double m_0 ;

        double mu_0 ;



    double gam1 ;       
    double kapsgam1 ;    
    double gamkapsgam1 ; 
        double rel_mu_0 ;       

    // Constructors - Destructor
    // -------------------------
    public:

    Dyn_eos_poly(double gamma, double kappa) ;

    Dyn_eos_poly(double gamma, double kappa, double mass) ;

    Dyn_eos_poly(double gamma, double kappa, double mass, double mu_zero) ;

    Dyn_eos_poly(const Dyn_eos_poly& ) ;    
    
    protected:
    Dyn_eos_poly(FILE* ) ;

    Dyn_eos_poly(ifstream& ) ;

    friend Dyn_eos* Dyn_eos::eos_from_file(FILE* ) ;
    friend Dyn_eos* Dyn_eos::eos_from_file(ifstream& ) ; 

    public:
    virtual ~Dyn_eos_poly() ;           

    // Assignment
    // ----------
    void operator=(const Dyn_eos_poly& ) ;


    // Miscellaneous
    // -------------

    public :
    virtual bool operator==(const Dyn_eos& ) const ;

    virtual bool operator!=(const Dyn_eos& ) const ;

    virtual int identify() const ; 

    double get_gam() const ;

    double get_kap() const ;
    
    double get_m_0() const ;

    double get_mu_0() const ;

    protected:
    void set_auxiliary() ;


    // Outputs
    // -------

    public:
    virtual void sauve(FILE* ) const ;  

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


    // Computational functions
    // -----------------------

    public:
        virtual double ent_nbar_p(double nbar, const Param* par=0x0) const ;

        virtual double ener_nbar_p(double nbar, const Param* par=0x0) const ;

        virtual double press_nbar_p(double nbar, const Param* par=0x0) const ;

        virtual double csound_square_nbar_p(double nbar, const Param* par=0x0) const  ;
       
};

            //------------------------------------//
            //        class Dyn_eos_tab       //
            //------------------------------------//


 class Dyn_eos_tab : public Dyn_eos {
   
   // Data :
   // -----
   
 protected:
   string tablename ;
   
   string authors ; 
   
   bool compose_format ; 
   
   double nbmin ;
   
   double nbmax ;
   
   Tbl* lognb ;
   
   Tbl* loge ;
   
   Tbl* dlesdlnb ;
   
   Tbl* c_sound2 ;

   // Constructors - Destructor
   // -------------------------
 public:
   
   Dyn_eos_tab(const string& name_i, const string& table_name,
           bool compose = true) ;   
   
 protected:
   Dyn_eos_tab() ;
   
   Dyn_eos_tab(FILE* ) ;
   
   Dyn_eos_tab(ifstream& ist) ;
    
 private:
   Dyn_eos_tab(const Dyn_eos_tab& ) ;
   
   
   friend Dyn_eos* Dyn_eos::eos_from_file(FILE* ) ;
   friend Dyn_eos* Dyn_eos::eos_from_file(ifstream& ) ;

 public:
   virtual ~Dyn_eos_tab() ;         
   
   // Miscellaneous
   // -------------
   
 protected:     
   virtual void read_table_compose() ;
   
   virtual void read_table_lorene() ;

 public :
   virtual bool operator==(const Dyn_eos& ) const ;
   
   virtual bool operator!=(const Dyn_eos& ) const ;
   
   virtual int identify() const ;
   
   // Outputs
   // -------
   
 public:
   virtual void sauve(FILE* ) const ;   
   
 protected:  
   virtual ostream& operator>>(ostream &) const ;    
   
   // Computational functions
   // -----------------------

 public:
   virtual double ent_nbar_p(double nbar, const Param* par=0x0) const ;
   
   virtual double ener_nbar_p(double nbar, const Param* par=0x0) const ;
   
   virtual double press_nbar_p(double nbar, const Param* par=0x0) const ;
   
   virtual double csound_square_nbar_p(double nbar, const Param* par=0x0) const  ;
       
 };

            //------------------------------------//
            //       class Dyn_eos_cons           //
            //------------------------------------//


 class Dyn_eos_cons : public Dyn_eos_tab {

   // Constructors - Destructor
   // -------------------------
 public:

   Dyn_eos_cons(const string& name_i, const string& table_name,
           bool compose = true) ;
  
 protected:
   Dyn_eos_cons(FILE* ) ;
   
   Dyn_eos_cons(ifstream& ist) ;
    
 private:
   Dyn_eos_cons(const Dyn_eos_cons& ) ;
   
   friend Dyn_eos* Dyn_eos::eos_from_file(FILE* ) ;
   friend Dyn_eos* Dyn_eos::eos_from_file(ifstream& ) ;
  
 public:
  virtual ~Dyn_eos_cons() ;         
  
  // Miscellaneous
  // -------------
  
 protected:     
   virtual void read_table_compose() ;
   
   virtual void read_table_lorene() ;

 public :
  virtual bool operator==(const Dyn_eos& ) const ;
  
  virtual bool operator!=(const Dyn_eos& ) const ;
  
  virtual int identify() const ;
  
  // Outputs
  // -------
  
 protected:
  virtual ostream& operator>>(ostream &) const ;    
  
 };

 

}

#endif