FluidClass.h

Go to the documentation of this file.

#ifndef FLUIDCLASS_H
#define FLUIDCLASS_H

#include <map>
#include <string>
#include <exception>
#include <vector>

#include "CPExceptions.h"
#include "CoolPropTools.h"
#include "Helmholtz.h"
#include "TTSE.h"
#include "Units.h"
#include "AllFluids.h"

// On PowerPC, we are going to use the stdint.h integer types and not let rapidjson use its own
#if defined(__powerpc__)
#include <stdint.h>
#define RAPIDJSON_NO_INT64DEFINE
#endif

#include "rapidjson/rapidjson.h"
#include "rapidjson/document.h"
#include "rapidjson/filestream.h"       // wrapper of C stream for prettywriter as output
#include "rapidjson/prettywriter.h"     // for stringify JSON

class Fluid;

void rebuild_CriticalSplineConstants_T();

struct HSContainer
{
        double hmax,T_hmax,rho_hmax,s_hmax, sV_Tmin, sL_Tmin, hV_Tmin, hL_Tmin;
        std::vector<double> a_hs_satL;
        std::vector<int> n_hs_satL;
};
struct OtherParameters
{
        double molemass, Ttriple, ptriple, accentricfactor, R_u, rhoVtriple, rhoLtriple;
        std::string CAS;
        std::string HSReferenceState;
};
struct CriticalStruct
{
        double rho, T, v, h, s, rhobar;
        PressureUnit p;
};
struct FluidLimits
{
        double Tmin, Tmax, pmax, rhomax;        
};

class AncillaryCurveClass
{
public:
        // Default Constructor
        AncillaryCurveClass(){built = false;};
        // Constructor with values
        AncillaryCurveClass(Fluid *pFluid, std::string Output){built = false; update(pFluid,Output);};
        void update(Fluid *pFluid, std::string Output);
        std::vector<double> xL,yL,xV,yV;
        int build(int N);
        long iOutput;
        Fluid * pFluid;
        double interpolateL(double T);
        double interpolateV(double T);
        double reverseinterpolateL(double y);
        double reverseinterpolateV(double y);
        bool built;
};

struct OnePhaseLUTStruct
{
        std::vector< std::vector<double> > hmat,rhomat,cpmat,cp0mat, smat,cvmat,umat,viscmat,kmat,pmat,dpdTmat;
        std::vector<double> Tvec,pvec;
        double Tmin,Tmax,pmin,pmax;
        int nT,np;
        bool built,forcebuild;
};




class CriticalSplineStruct_T
{
public:
        CriticalSplineStruct_T(){};
        CriticalSplineStruct_T(double Tend, double rhoendL, double rhoendV, double drhoLdT_sat, double drhoVdT_sat){
                this->Tend = Tend;
                this->rhoendL = rhoendL;
                this->rhoendV = rhoendV;
                this->drhoLdT_sat = drhoLdT_sat;
                this->drhoVdT_sat = drhoVdT_sat;
        };
        double interpolate_rho(Fluid* pFluid, int phase, double T);

        double Tend;
        double rhoendL;
        double rhoendV;
        double drhoLdT_sat;
        double drhoVdT_sat;
};


struct BibTeXKeysStruct
{
        std::string EOS;
        std::string CP0;
        std::string VISCOSITY;
        std::string CONDUCTIVITY;
        std::string ECS_LENNARD_JONES;
        std::string ECS_FITS;
        std::string SURFACE_TENSION;
        
};

struct EnvironmentalFactorsStruct
{
        double GWP20, GWP100, GWP500, ODP, HH, PH, FH;
        std::string ASHRAE34;
};

struct FluidCacheElement
{
        double tau, delta, cached_val;
};

struct FluidCache
{
        FluidCacheElement phir,dphir_dDelta,dphir_dTau,d2phir_dDelta2,d2phir_dTau2,d2phir_dDelta_dTau;
};

class Fluid
{
        protected:
                FluidCache cache; 
                std::string name; 
                std::string REFPROPname; 
                std::vector <std::string> aliases; 
                std::string ECSReferenceFluid; 
                
                double ECS_qd; 
                std::string EOSReference; 
                std::string TransportReference; 
                bool isPure; 

                // The structures that hold onto ancillary data for the fluid
                AncillaryCurveClass *h_ancillary;
                AncillaryCurveClass *s_ancillary;

                double _get_rho_guess(double T, double p); 

                // The boundaries for the TTSE
                double hmin_TTSE, hmax_TTSE, pmin_TTSE, pmax_TTSE;
                unsigned int Nsat_TTSE, Nh_TTSE, Np_TTSE;
    public:

                BibTeXKeysStruct BibTeXKeys;
                EnvironmentalFactorsStruct environment;

                std::vector <phi_BC*> phirlist; 
                std::vector <phi_BC*> phi0list; 

                Fluid(){
                        params.R_u=8.314472; 
                        isPure=true;  

                        enabled_EXTTP = false;
                        // Default parameters for TTSE - others are set in post-load() function
                        built_TTSE_LUT = false;
                        enabled_TTSE_LUT = false;
                        Nsat_TTSE = 400;
                        Nh_TTSE = 200;
                        Np_TTSE = 200;
                        hmin_TTSE = _HUGE;
                        hmax_TTSE = _HUGE;
                        pmin_TTSE = _HUGE;
                        pmax_TTSE = _HUGE;
                        enable_writing_tables_to_files = true;
                        CriticalSpline_T.Tend = _HUGE;
                                
                        preduce = &crit; 
                        h_ancillary = NULL;
                        s_ancillary = NULL;

                        ECSReferenceFluid = "R134a";
                        ECS_qd = 1/(0.5e-9);
                };
                virtual ~Fluid();

                // Some post-loading things happen here
                void post_load(rapidjson::Document &JSON, rapidjson::Document &JSON_CAS);

                void add_alias(std::string alias){ aliases.push_back(alias);};

                // Fluid-specific parameters
                struct CriticalStruct crit;
                struct FluidLimits limits;
                struct OtherParameters params;
                struct CriticalStruct * preduce; 
                struct CriticalStruct reduce; 
                struct HSContainer HS; 

                TTSETwoPhaseTableClass TTSESatL;
                TTSETwoPhaseTableClass TTSESatV;
                TTSESinglePhaseTableClass TTSESinglePhase;

                // The class that holds the information on the critical spline parameters
                CriticalSplineStruct_T CriticalSpline_T;

                // Member Access functions
                std::string get_name(){return name;};
                char * get_namec(){return (char *)name.c_str();};
                std::string get_REFPROPname(){return REFPROPname;};
                std::string get_EOSReference(){return EOSReference;};
                std::string get_TransportReference(){return TransportReference;};
                std::vector<std::string> get_aliases(){return aliases;};
                bool pure(){return isPure;};
                double R();

                // These MUST be implemented by derived class
        virtual double conductivity_Trho(double T, double rho);
                virtual double viscosity_Trho(double T, double rho);
                
                // These Helmholtz energy terms are provided by the base class
                virtual double phir(double tau, double delta);
                // First derivative
                virtual double dphir_dDelta(double tau, double delta);
                virtual double dphir_dTau(double tau, double delta);
                // Second derivative
                virtual double d2phir_dDelta2(double tau, double delta);
                virtual double d2phir_dDelta_dTau(double tau, double delta);
                virtual double d2phir_dTau2(double tau, double delta);
                // Third derivative
                virtual double d3phir_dDelta3(double tau, double delta);
                virtual double d3phir_dDelta2_dTau(double tau, double delta);
                virtual double d3phir_dDelta_dTau2(double tau, double delta);
                virtual double d3phir_dTau3(double tau, double delta);
                
                virtual double phi0(double tau, double delta);
                virtual double dphi0_dDelta(double tau, double delta);
                virtual double dphi0_dTau(double tau, double delta);

                virtual double d2phi0_dDelta2(double tau, double delta);
                virtual double d2phi0_dDelta_dTau(double tau, double delta);
                virtual double d2phi0_dTau2(double tau, double delta);

                virtual double d3phi0_dDelta3(double tau, double delta){throw NotImplementedError();};
                virtual double d3phi0_dDelta2_dTau(double tau, double delta){return 0;};
                virtual double d3phi0_dDelta_dTau2(double tau, double delta){return 0;};
                virtual double d3phi0_dTau3(double tau, double delta);

                // These thermodynamic properties as a function of temperature and density are
                // provided by the base class
                double pressure_Trho(double T, double rho);
                double enthalpy_Trho(double T, double rho);
                double entropy_Trho(double T, double rho);
                double internal_energy_Trho(double T, double rho);
                double speed_sound_Trho(double T, double rho);
                double specific_heat_p_Trho(double T, double rho);
                double specific_heat_p_ideal_Trho(double T);
                double specific_heat_v_Trho(double T, double rho);
                double gibbs_Trho(double T, double rho);
                double dpdT_Trho(double T,double rho);
                double dpdrho_Trho(double T,double rho);
                double drhodT_p_Trho(double T,double rho);

                // Get the density using the Soave EOS
                double density_Tp_Soave(double T, double p, int iValue = 0);

                virtual double density_Tp(double T, double p);
                virtual double density_Tp(double T, double p, double rho_guess);

                virtual void density_Ts(double T, double s, double &rhoout, double &pout, double &rhoLout, double &rhoVout, double &psatLout, double &psatVout);

                virtual void temperature_hs(double h, double s, double &Tout, double &rhoout, double &rhoL, double &rhoV, double &TsatLout, double &TsatVout);

                virtual void temperature_ps(double p, double s, double &Tout, double &rhoout, double &rhoL, double &rhoV, double &TsatLout, double &TsatVout);
                
                virtual void temperature_ph(double p, double h, double &Tout, double &rhoout, double &rhoL, double &rhoV, double &TsatLout, double &TsatVout, double T0 = -1, double rho0 = -1);
                
                double temperature_prho(double p, double rho, double T0);

                double temperature_prho_VanDerWaals(double p, double rho);
                double temperature_prho_PengRobinson(double p, double rho);

                std::string phase_Tp(double T, double p, double &pL, double &pV, double &rhoL, double &rhoV);
                
                long phase_Tp_indices(double T, double p, double &pL, double &pV, double &rhoL, double &rhoV);
                
                std::string phase_Trho(double T, double rho, double &pL, double &pV, double &rhoL, double &rhoV);

                long phase_Trho_indices(double T, double rho, double &pL, double &pV, double &rhoL, double &rhoV);

                long phase_prho_indices(double p, double rho, double &T, double &TL, double &TV, double &rhoL, double &rhoV);

                // Optional ancillary functions can be overloaded, will throw a NotImplementedError
                // to be caught by calling function if not implemented
                virtual double psat(double T){
                        throw NotImplementedError(std::string("psat not implemented for this fluid"));
                };
                virtual double psatL(double T){
                        throw NotImplementedError(std::string("psatL not implemented for this fluid"));
                };
                virtual double psatV(double T){
                        throw NotImplementedError(std::string("psatV not implemented for this fluid"));
                };
                virtual double rhosatL(double T){
                        throw NotImplementedError(std::string("rhosatL not implemented for this fluid"));
                };
                virtual double rhosatV(double T){
                        throw NotImplementedError(std::string("rhosatV not implemented for this fluid"));
                };
                double psatL_anc(double T){
                        if (isPure)
                                return psat(T);
                        else
                                return psatL(T);
                };
                double psatV_anc(double T){
                        if (isPure)
                                return psat(T);
                        else
                                return psatV(T);
                };
                // Ancillary equations composed by interpolating within 3-point 
                // curve that is calculated once
                double hsatV_anc(double T);
                double hsatL_anc(double T);
                double ssatV_anc(double T);
                double ssatL_anc(double T);
                double cpsatV_anc(double T);
                double cpsatL_anc(double T);
                double drhodT_pL_anc(double T);
                double drhodT_pV_anc(double T);
                double Tsat_anc(double p, double Q);

                double density_Tp_PengRobinson(double T, double p, int solution);

                std::vector<double> ConformalTemperature(Fluid *InterestFluid, Fluid *ReferenceFluid,double T, double rho, double T0, double rho0, std::string *errstring);
                // Extended corresponding states functions for fluids that do not have their own high-accuracy
                // transport property implementation
                virtual void ECSParams(double *e_k, double *sigma);

                virtual double ECS_psi_viscosity(double rhor){
                        return 1.0;
                };
                virtual double ECS_chi_conductivity(double rhor){
                        return 1.0;
                };
                virtual double ECS_f_int(double T){
                        return 1.32e-3;
                };
                double viscosity_ECS_Trho(double T, double rho, Fluid * ReferenceFluid);

                double conductivity_ECS_Trho(double T, double rho, Fluid * ReferenceFluid);

                virtual double conductivity_background(double T, double rho){
                        throw NotImplementedError(std::string("conductivity_background not implemented for this fluid"));
                };

                double conductivity_critical(double T, double rho, double qd = 2e9, double GAMMA = 0.0496, double zeta0 = 1.94e-10);

                virtual double viscosity_dilute(double T, double e_k, double sigma);

                virtual double viscosity_residual(double T, double rho){
                        throw NotImplementedError(std::string("viscosity_residual not implemented for this fluid"));
                };
                virtual double viscosity_background(double T, double rho){
                        throw NotImplementedError(std::string("viscosity_background not implemented for this fluid"));
                };

                virtual double surface_tension_T(double T);

                void saturation_VdW(double T, double &rhoL, double &rhoV, double &p, double s0=-1);

                virtual void saturation_T(double T, bool UseLUT, double &psatLout, double &psatVout, double &rhoLout, double &rhoVout);

                virtual void saturation_p(double p, bool UseLUT, double &TsatLout, double &TsatVout, double &rhoLout, double &rhoVout);

                virtual void saturation_h(double h, double Tmin, double Tmax, int Q, double &Tsatout, double &rhoout, double &TsatLout, double &TsatVout, double &rhoLout, double &rhoVout);

                virtual void saturation_s(double s, int Q, double &Tsatout, double &rhoout, double &TsatLout, double &TsatVout, double &rhoLout, double &rhoVout);
                
                void rhosatPure(double T, double &rhoLout, double &rhoVout, double &pout, double omega, bool use_guesses);

                void rhosatPure_Akasaka(double T, double &rhoLout, double &rhoVout, double &pout, double omega, bool use_guesses = false);

                void rhosatPure_Brent(double T, double &rhoLout, double &rhoVout, double &pout);

                void rhosatPure_BrentrhoV(double T, double &rhoLout, double &rhoVout, double &pout);
                
                double Tsat(double p, double Q, double T_guess);

                double Tsat(double p, double Q, double T_guess, bool UseLUT, double &rhoLout, double &rhoVout);
                
                bool isAlias(std::string name);

                bool enabled_TTSE_LUT, enabled_EXTTP, built_TTSE_LUT, enable_writing_tables_to_files;

                void enable_EXTTP(void);
                bool isenabled_EXTTP(void);
                void disable_EXTTP(void);

                void enable_TTSE_LUT(void);
                bool isenabled_TTSE_LUT(void);
                void disable_TTSE_LUT(void);
                void enable_TTSE_LUT_writing(void);
                bool isenabled_TTSE_LUT_writing(void);
                void disable_TTSE_LUT_writing(void);
                void set_TTSESat_LUT_size(int Nsat);
                void set_TTSESinglePhase_LUT_size(int Np, int Nh);
                void set_TTSESinglePhase_LUT_range(double hmin, double hmax, double pmin, double pmax);
                void get_TTSESinglePhase_LUT_range(double *hmin, double *hmax, double *pmin, double *pmax);
                bool build_TTSE_LUT(bool force = false);
                double interpolate_in_TTSE_LUT(long iParam, long iInput1, double Input1, long iInput2, double Input2);

        std::string to_json();
};

        

#endif