eos_bifluid.h

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

/*
 *   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.17 2004/09/01 09:49:46 r_prix Exp $
 * $Log: eos_bifluid.h,v $
 * 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.17 2004/09/01 09:49:46 r_prix Exp $
 *
 */

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

// Headers C
#include <stdio.h>

// Lorene classes
#include "param.h"
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: 
    char *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 (char *fname ) ; 
    
    
    public:
    virtual ~Eos_bifluid() ;            

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


    // Name manipulation
    // -----------------
    public:
    const char* get_name() const ;  

    void set_name(const char* name_i) ; 

    // 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 ( char *fname ) ; 
    
    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:
    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 (char *fname) ; 
    
    friend Eos_bifluid* Eos_bifluid::eos_from_file(FILE* ) ; 
    friend Eos_bifluid* Eos_bifluid::eos_from_file(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(char *fname ) ; 
    
    friend Eos_bifluid* Eos_bifluid::eos_from_file(FILE* ) ; 
    friend Eos_bifluid* Eos_bifluid::eos_from_file(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 ;

};

        

#endif

---