eos_bifluid.h

/*
 *  Definition of Lorene classes Eos_bifluid
 *               Eos_bf_poly
 *                               Eos_bf_tabul
 */

/*
 *   Copyright (c) 2001-2002 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 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 __EOS_BIFLUID_H_ 
#define __EOS_BIFLUID_H_ 

/*
 * $Id: eos_bifluid.h,v 1.24 2021/05/14 15:39:22 g_servignat Exp $
 * $Log: eos_bifluid.h,v $
 * Revision 1.24  2021/05/14 15:39:22  g_servignat
 * Added sound speed computation from enthalpy to Eos class and tabulated+polytropic derived classes
 *
 * Revision 1.23  2017/10/06 12:36:33  a_sourie
 * Cleaning of tabulated 2-fluid EoS class + superfluid rotating star model.
 *
 * Revision 1.22  2015/06/26 14:10:08  j_novak
 * Modified comments.
 *
 * Revision 1.21  2015/06/11 13:50:18  j_novak
 * Minor corrections
 *
 * Revision 1.20  2015/06/10 14:39:17  a_sourie
 * New class Eos_bf_tabul for tabulated 2-fluid EoSs and associated functions for the computation of rotating stars with such EoSs.
 *
 * Revision 1.19  2014/10/13 08:52:33  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.18  2014/04/25 10:43:50  j_novak
 * The member 'name' is of type string now. Correction of a few const-related issues.
 *
 * Revision 1.17  2004/09/01 09:49:46  r_prix
 * adapted to change in read_variable() for strings
 *
 * Revision 1.16  2004/03/22 13:12:41  j_novak
 * Modification of comments to use doxygen instead of doc++
 *
 * Revision 1.15  2004/01/30 13:21:29  r_prix
 * add documentation about 'special' 2-fluid typeos=5: == type0 + slow-rot style inversion
 *
 * Revision 1.14  2003/12/17 23:12:30  r_prix
 * replaced use of C++ <string> by standard ANSI char* to be backwards compatible
 * with broken compilers like MIPSpro Compiler 7.2 on SGI Origin200. ;-)
 *
 * Revision 1.13  2003/12/05 15:08:38  r_prix
 * - use read_variable() to read eos_bifluid from file
 * - changed 'contructor from file' to take filename as an argument instead of ifstream
 * - changed 'name' member of Eos_bifluid to C++-type string (for convenience&safety)
 *
 * Revision 1.12  2003/12/04 14:13:32  r_prix
 * added method get_typeos {return typeos}; and fixed some comments.
 *
 * Revision 1.11  2003/11/18 18:25:15  r_prix
 * moved particle-masses m_1, m_2 of the two fluids into class eos_bifluid (from eos_bf_poly)
 *
 * Revision 1.10  2002/10/16 14:36:29  j_novak
 * Reorganization of #include instructions of standard C++, in order to
 * use experimental version 3 of gcc.
 *
 * Revision 1.9  2002/09/13 09:17:31  j_novak
 * Modif. commentaires
 *
 * Revision 1.8  2002/06/17 14:05:16  j_novak
 * friend functions are now also declared outside the class definition
 *
 * Revision 1.7  2002/06/03 13:23:16  j_novak
 * The case when the mapping is not adapted is now treated
 *
 * Revision 1.6  2002/05/31 16:13:36  j_novak
 * better inversion for eos_bifluid
 *
 * Revision 1.5  2002/05/02 15:16:22  j_novak
 * Added functions for more general bi-fluid EOS
 *
 * Revision 1.4  2002/01/16 15:03:27  j_novak
 * *** empty log message ***
 *
 * Revision 1.3  2002/01/11 14:09:34  j_novak
 * Added newtonian version for 2-fluid stars
 *
 * Revision 1.2  2001/11/29 15:05:26  j_novak
 * The entrainment term in 2-fluid eos is modified
 *
 * Revision 1.1.1.1  2001/11/20 15:19:27  e_gourgoulhon
 * LORENE
 *
 * Revision 1.6  2001/08/31  15:47:35  novak
 * The flag tronc has been added to nbar_ent.. functions
 *
 * Revision 1.5  2001/08/27 12:21:11  novak
 * The delta2 Cmp argument put to const
 *
 * Revision 1.4  2001/08/27 09:50:15  novak
 * New formula for "polytrope"
 *
 * Revision 1.3  2001/06/22 15:36:11  novak
 * Modification de Eos_bifluid::trans2Eos
 *
 * Revision 1.2  2001/06/22 11:52:44  novak
 * *** empty log message ***
 *
 * Revision 1.1  2001/06/21 15:21:22  novak
 * Initial revision
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/eos_bifluid.h,v 1.24 2021/05/14 15:39:22 g_servignat Exp $
 *
 */

// Standard C++
#include "headcpp.h"
#include <string>

// Headers C
#include <cstdio>

// Lorene classes
#include "param.h"
#include "utilitaires.h"
namespace Lorene {
class Tbl ;
class Param ;
class Cmp ;
class Eos ;
class Eos_poly ;

            //------------------------------------//
            //   base class Eos for two fluids    //
            //------------------------------------//
#define MAX_EOSNAME 100

class Eos_bifluid {

    // Data :
    // -----

    protected: 
    string name;        

    double m_1 ; 

    double m_2 ; 


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

    explicit Eos_bifluid(const char* name_i, double mass1, double mass2) ; 

    Eos_bifluid(const Eos_bifluid& ) ;  

    protected:
    Eos_bifluid(FILE* ) ; 
    
    Eos_bifluid (const char *fname ) ; 
    
    Eos_bifluid (ifstream& fich) ; 


    public:
    virtual ~Eos_bifluid() ;            

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


    // Name manipulation
    // -----------------
    public:
    string get_name() const {return name;} ; 

    // Miscellaneous
    // -------------
    public:

    double get_m1() const {return m_1 ;}; 

    double get_m2() const {return m_2 ;}; 

    static Eos_bifluid* eos_from_file (FILE* ) ; 
    
    static Eos_bifluid* eos_from_file ( const char *fname ) ; 
    
    static Eos_bifluid* eos_from_file(ifstream& ) ; 


    virtual bool operator==(const Eos_bifluid& ) const = 0 ; 

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

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

    public: 
    virtual void sauve(FILE* ) const ;  

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

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


    // Computational functions
    // -----------------------
    public:
    virtual void calcule_tout(const Cmp& ent1, const Cmp& ent2, const Cmp& delta2,
              Cmp& nbar1, Cmp& nbar2, Cmp& ener, Cmp& press,
              int nzet, int l_min = 0) const ; 

   virtual bool nbar_ent_p(const double ent1, const double ent2, 
                const double delta2, double& nbar1, 
                double& nbar2) const = 0 ;

    virtual double nbar_ent_p1(const double ent1) const = 0 ;

    virtual double nbar_ent_p2(const double ent2) const = 0 ;

        void nbar_ent(const Cmp& ent1, const Cmp& ent2, const Cmp& delta2, 
              Cmp& nbar1, Cmp& nbar2, int nzet, int l_min = 0) 
      const  ; 
    
        virtual double ener_nbar_p(const double nbar1, const double nbar2, 
                   const double delta2) const = 0 ; 
       
        Cmp ener_ent(const Cmp& ent1, const Cmp& ent2, const Cmp& delta2, 
              int nzet, int l_min = 0) const ; 
    
        virtual double press_nbar_p(const double nbar1, const double nbar2, 
                    const double delta2) const = 0 ; 
       
        Cmp press_ent(const Cmp& ent1, const Cmp& ent2, const Cmp& delta2, 
              int nzet, int l_min = 0) const ; 

    virtual double get_K11(const double n1, const double n2, const
                   double x)  const = 0 ;

    virtual double get_K12(const double n1, const double n2,const
                   double x) const = 0 ;

    virtual double get_K22(const double n1, const double n2, const
                   double x) const = 0 ;

        Cmp get_Knn(const Cmp& nbar1, const Cmp& nbar2, const Cmp& x2,
            int nzet, int l_min = 0) const  ; 

        Cmp get_Kpp(const Cmp& nbar1, const Cmp& nbar2, const Cmp&
            x2, int nzet, int l_min = 0) const ; 

        Cmp get_Knp(const Cmp& nbar1, const Cmp& nbar2, const Cmp& x2,
            int nzet, int l_min = 0) const ; 


    void calcule(const Cmp& nbar1, const Cmp& nbar2, const Cmp&
             x2, int nzet, int l_min, double
             (Eos_bifluid::*fait)(double, double, double) const, 
             Cmp& resu)
      const ; 
    
    // Conversion functions
    // ---------------------

    virtual Eos* trans2Eos() const = 0 ;
    
};
ostream& operator<<(ostream& , const Eos_bifluid& ) ;   


            //------------------------------------//
            //        class Eos_bf_poly       //
            //------------------------------------//

class Eos_bf_poly : public Eos_bifluid {

    // Data :
    // -----

    protected: 
    double gam1 ;

    double gam2 ;

    double gam3 ;
    
    double gam4 ;

    double gam5 ;

    double gam6 ;
    
    double kap1 ; 

    double kap2 ; 

    double kap3 ; 
    
    double beta ; 

    double gam1m1 ;     
    double gam2m1 ;     
    double gam34m1 ;    
    double gam56m1 ;    

 protected:
    int typeos ; 

    double relax ;

    double precis ; 
    
    double ecart ; 

    
    // Constructors - Destructor
    // -------------------------
    public:
    
    Eos_bf_poly(double kappa1, double kappa2, double kappa3, double beta) ;

    Eos_bf_poly(double gamma1, double gamma2, double gamma3,
            double gamma4, double gamma5, double gamma6,
            double kappa1, double kappa2, double kappa3,
            double beta, double mass1=1, double mass2=1, 
            double relax=0.5, double precis = 1.e-9,
            double ecart = 1.e-8) ; 

    Eos_bf_poly(const Eos_bf_poly& ) ;  
    
    protected:
    Eos_bf_poly(FILE* ) ; 
    
    Eos_bf_poly (const char *fname) ; 
    
    friend Eos_bifluid* Eos_bifluid::eos_from_file(FILE* ) ; 
    friend Eos_bifluid* Eos_bifluid::eos_from_file(const char *fname ) ; 

        public:
    virtual ~Eos_bf_poly() ;            

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


    // Miscellaneous
    // -------------
    public : 
    virtual bool operator==(const Eos_bifluid& ) const ; 

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

    double get_gam1() const {return gam1 ;};

    double get_gam2() const {return gam2 ;};

    double get_gam3() const {return gam3 ;};
    
    double get_gam4() const {return gam4 ;};
    
    double get_gam5() const {return gam5 ;};
    
    double get_gam6() const {return gam6 ;};
    
    double get_kap1() const {return kap1 ;}; 

    double get_kap2() const {return kap2 ;}; 

    double get_kap3() const {return kap3 ;}; 

    double get_beta() const {return beta ;}; 

    // Returns (sub)type of bifluid-eos (member \c typeos})
    int get_typeos() const {return typeos;};

    protected:
    void set_auxiliary() ; 
    
    void determine_type() ;

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

    public: 
    virtual void sauve(FILE* ) const ;  

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


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

    public: 

   virtual bool nbar_ent_p(const double ent1, const double ent2, 
                const double delta2, double& nbar1, 
                double& nbar2) const ; 
       
    virtual double nbar_ent_p1(const double ent1) const  ;

    virtual double nbar_ent_p2(const double ent2) const  ;

        virtual double ener_nbar_p(const double nbar1, const double nbar2, 
                   const double delta2) const  ; 
       
        virtual double press_nbar_p(const double nbar1, const double nbar2, 
                    const double delta2) const ; 
     // Conversion functions
     // ---------------------

    virtual Eos* trans2Eos() const ;
       
    virtual double get_K11(const double n1, const double n2, const
                   double delta2)  const  ;

    virtual double get_K12(const double n1, const double n2,const
                   double delta2) const ;

    virtual double get_K22(const double n1, const double n2, const
                   double delta2) const ;

};

            //------------------------------------//
            //        class Eos_bf_poly_newt      //
            //------------------------------------//

class Eos_bf_poly_newt : public Eos_bf_poly {

    // Data :
    // -----

    // no new data with respect to Eos_bf_poly  

    // Constructors - Destructor
    // -------------------------
    public:
    
    Eos_bf_poly_newt(double kappa1, double kappa2, double kappa3,
            double beta) ;

    Eos_bf_poly_newt(double gamma1, double gamma2, double gamma3,
             double gamma4, double gamma5, double gamma6,
             double kappa1, double kappa2, double kappa3,
             double beta, double mass1, double mass2, 
             double relax=0.5, double precis = 1.e-9,
             double ecart = 1.e-8) ;    


    Eos_bf_poly_newt(const Eos_bf_poly_newt& ) ;    
    
    protected:
    Eos_bf_poly_newt(FILE* ) ; 
    
    Eos_bf_poly_newt(const char *fname ) ; 
    
    friend Eos_bifluid* Eos_bifluid::eos_from_file(FILE* ) ; 
    friend Eos_bifluid* Eos_bifluid::eos_from_file(const char *fname) ; 

    public:
    virtual ~Eos_bf_poly_newt() ;           

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


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

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

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

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

    public: 
    virtual void sauve(FILE* ) const ;  

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


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

    public: 

        virtual bool nbar_ent_p(const double ent1, const double ent2, 
                const double delta2, double& nbar1, 
                double& nbar2) const ; 
       
    virtual double nbar_ent_p1(const double ent1) const  ;

    virtual double nbar_ent_p2(const double ent2) const  ;

   virtual double ener_nbar_p(const double nbar1, const double nbar2, 
                   const double delta2) const  ; 
       
        virtual double press_nbar_p(const double nbar1, const double nbar2, 
                    const double delta2) const ; 
     // Conversion functions
     // ---------------------

    virtual Eos* trans2Eos() const ;
       
    virtual double get_K11(const double n1, const double n2, const
                   double delta2)  const  ;

    virtual double get_K12(const double n1, const double n2,const
                   double delta2) const ;

    virtual double get_K22(const double n1, const double n2, const
                   double delta2) const ;

};


/* Declaration of the new class Eos_bf_tabul derived from Eos_bifluid */

            //------------------------------------//
            //        class Eos_bf_tabul          //
            //------------------------------------//

class Eos_bf_tabul : public Eos_bifluid {

    // Data :
    // -----

    protected: 
        string tablename ; 
    
        string authors ; 
    
        double delta_car_min ;
        
        double delta_car_max ;
        
        double mu1_min ;
        
        double mu1_max ;
        
        double mu2_min ;
        
        double mu2_max ;

        Tbl* mu1_tab ;

        Tbl* mu2_tab ;

        Tbl* delta_car_tab ; 
    
        Tbl* press_tab ;

        Tbl* n1_tab ;
        
        Tbl* n2_tab ;

        Tbl* d2psdmu1dmu2_tab ;

        Tbl* dpsddelta_car_tab ;

        Tbl* dn1sddelta_car_tab ;

        Tbl* dn2sddelta_car_tab ;

    // To save the limit curve corresponding to n_n = 0
        Tbl* delta_car_n0 ;
        Tbl* mu1_n0 ;
        Tbl* mu2_n0 ;
    
    // To save the limit curve corresponding to n_p = 0
        Tbl* delta_car_p0 ;
        Tbl* mu1_p0 ;
        Tbl* mu2_p0 ;

    // To save the single-tab fluid
        Tbl* mu1_N ;
        Tbl* n_n_N ;
        Tbl* press_N ;
        Tbl* mu2_P ;
        Tbl* n_p_P ;
        Tbl* press_P ;


   // Constructors - Destructor     
   // -------------------------
     protected:

    Eos_bf_tabul(const char* name_i, const char* table, const char* path, double mass1, double mass2) ; 

    Eos_bf_tabul(const char* name_i, const char* file_name, double mass1, double mass2) ;

    private:
    Eos_bf_tabul(const Eos_bf_tabul& ) ;    
    
    protected:
    
    Eos_bf_tabul(FILE* ) ;
    
    Eos_bf_tabul(ifstream& ist, const char* table) ;
    
    Eos_bf_tabul(ifstream& ist) ;
    
    friend Eos_bifluid* Eos_bifluid::eos_from_file(FILE* ) ;
    friend Eos_bifluid* Eos_bifluid::eos_from_file(ifstream& ) ;

      public:
    virtual ~Eos_bf_tabul() ;           

   // Assignment
   // ----------
     private :
    void operator=(const Eos_bf_tabul& ) ;


    // Miscellaneous
   // -------------
    
     protected:     
   void read_table() ;

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

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

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

    public: 
    virtual void sauve(FILE* ) const ;  


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


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

    public: 
    void calcule_interpol(const Cmp& ent1, const Cmp& ent2, const Cmp& delta2,
                  Cmp& nbar1, Cmp& nbar2, Cmp& ener, Cmp& press, 
                  Cmp& K_nn, Cmp& K_np, Cmp& K_pp, Cmp& alpha_eos,
                  int nzet, int l_min = 0) const ; 

   virtual bool nbar_ent_p(const double ent1, const double ent2, 
                const double delta2, double& nbar1, 
                double& nbar2) const ; 
       
    virtual double nbar_ent_p1(const double ent1) const  ;

    virtual double nbar_ent_p2(const double ent2) const  ;

   virtual double ener_nbar_p(const double nbar1, const double nbar2, 
                   const double delta2) const  ; 
       
   virtual double press_nbar_p(const double nbar1, const double nbar2, 
                    const double delta2) const ; 
       
    virtual double get_K11(const double delta2, const double ent1, 
                const double ent2)  const  ;

    virtual double get_K12(const double delta2, const double ent1 , 
                const double ent2)  const  ;

    virtual double get_K22(const double delta2, const double ent1, 
                const double ent2)  const  ;
     
   virtual double ener_ent_p(const double ent1, const double ent2, 
                const double delta_car) const ;

   virtual double press_ent_p(const double ent1, const double ent2, 
                const double delta_car) const ;

    virtual double alpha_ent_p(const double ent1, const double ent2, 
                const double delta_car) const ;

    void interpol_3d_bifluid(const double delta2, const double mu1, 
            const double mu2, double& press, double& nbar1, double& nbar2, double& alpha) const ;   

    void interpol_2d_Tbl3d(const int i, const int j, const int k,  const Tbl& ytab, const Tbl& ztab,
                                                 const Tbl& ftab, const Tbl& dfdytab, const Tbl& dfdztab, const Tbl& d2fdydztab,
                                             const double y, const double z, double& f, double& dfdy, double& dfdz) const ;
    
    // Conversion function
    // ---------------------

    virtual Eos* trans2Eos() const ;
    
    virtual double csound_square_ent_p(double , const Param*) const {
        c_est_pas_fait(__FILE__) ;
        return 0;
    } ;
};


}
#endif