REFPROPMixtureBackend.h

Go to the documentation of this file.

/*
 * AbstractBackend.h
 *
 *  Created on: 20 Dec 2013
 *      Author: jowr
 */
 
#ifndef REFPROPMIXTUREBACKEND_H_
#define REFPROPMIXTUREBACKEND_H_
 
#include "AbstractState.h"
#include "DataStructures.h"
 
#include <vector>
 
namespace CoolProp {
 
class REFPROPMixtureBackend : public AbstractState
{
   private:
    std::string cached_component_string;
 
   protected:
    std::size_t Ncomp;
    bool _mole_fractions_set;
 
    static std::size_t instance_counter;
    static bool _REFPROP_supported;
    std::vector<CoolPropDbl> mole_fractions_long_double;  // read-only
    std::vector<double> mole_fractions, mass_fractions;
    std::vector<double> mole_fractions_liq, mole_fractions_vap;
    std::vector<std::string> fluid_names;
 
    CoolPropDbl call_phixdll(int itau, int idelta);
    CoolPropDbl call_phi0dll(int itau, int idelta);
 
   public:
    REFPROPMixtureBackend() : Ncomp(0), _mole_fractions_set(false) {
        instance_counter++;
    }
 
    REFPROPMixtureBackend(const std::vector<std::string>& fluid_names) {
        construct(fluid_names);
    };
 
    void construct(const std::vector<std::string>& fluid_names);
 
    std::string backend_name(void) {
        return get_backend_string(REFPROP_BACKEND_MIX);
    }
    virtual ~REFPROPMixtureBackend();
 
    static std::string version();
 
    std::vector<std::string> calc_fluid_names() {
        return fluid_names;
    };
    PhaseEnvelopeData PhaseEnvelope;
 
    void set_binary_interaction_double(const std::string& CAS1, const std::string& CAS2, const std::string& parameter, const double value);
    double get_binary_interaction_double(const std::string& CAS1, const std::string& CAS2, const std::string& parameter);
 
    std::string get_binary_interaction_string(const std::string& CAS1, const std::string& CAS2, const std::string& parameter);
    void set_binary_interaction_string(const std::size_t i, const std::size_t j, const std::string& parameter, const std::string& value);
 
    void set_binary_interaction_double(const std::size_t i, const std::size_t j, const std::string& parameter, const double value);
    double get_binary_interaction_double(const std::size_t i, const std::size_t j, const std::string& parameter);
 
    int match_CAS(const std::string& CAS);
 
    // REFPROP backend uses mole fractions
    bool using_mole_fractions() {
        return true;
    }
    bool using_mass_fractions() {
        return false;
    }
    bool using_volu_fractions() {
        return false;
    }
 
    std::string calc_name() {
        return fluid_param_string("name");
    }
 
    // Get _phase for pure fluids only
    phases calc_phase(void) {
        if (this->Ncomp > 1) {
            throw NotImplementedError("The REFPROP backend does not implement calc_phase function for mixtures.");
        } else {
            return _phase;
        }
    };
 
    // Utility function to determine the phase from quality value return from REFPROP
    phases GetRPphase();
 
    void calc_specify_phase(phases phase_index) {
        imposed_phase_index = phase_index;
        _phase = phase_index;
    }
    void calc_unspecify_phase() {
        imposed_phase_index = iphase_not_imposed;
    }
 
 
    void update(CoolProp::input_pairs, double value1, double value2);
 
    void update_with_guesses(CoolProp::input_pairs, double value1, double value2, const GuessesStructure& guesses);
 
    CoolPropDbl calc_molar_mass(void);
 
    void check_loaded_fluid(void);
 
    void calc_excess_properties();
 
    static bool REFPROP_supported(void);
 
    std::string fluid_param_string(const std::string& ParamName);
 
    CoolPropDbl calc_PIP(void);
 
    CoolPropDbl calc_cpmolar_idealgas(void);
 
 
    void set_REFPROP_fluids(const std::vector<std::string>& fluid_names);
 
 
    void set_mole_fractions(const std::vector<CoolPropDbl>& mole_fractions);
 
 
    void set_mass_fractions(const std::vector<CoolPropDbl>& mass_fractions);
 
    const std::vector<CoolPropDbl>& get_mole_fractions() {
        return mole_fractions_long_double;
    };
 
    const std::vector<CoolPropDbl> calc_mass_fractions();
 
    void calc_phase_envelope(const std::string& type);
 
    CoolPropDbl calc_compressibility_factor(void) {
        return _p / (_rhomolar * gas_constant() * _T);
    };
 
    const CoolProp::PhaseEnvelopeData& calc_phase_envelope_data() {
        return PhaseEnvelope;
    };
 
    std::vector<CoolPropDbl> calc_mole_fractions_liquid(void) {
        return std::vector<CoolPropDbl>(mole_fractions_liq.begin(), mole_fractions_liq.begin() + this->Ncomp);
    }
    std::vector<CoolPropDbl> calc_mole_fractions_vapor(void) {
        return std::vector<CoolPropDbl>(mole_fractions_vap.begin(), mole_fractions_vap.begin() + this->Ncomp);
    }
 
    void check_status();
 
    CoolPropDbl calc_viscosity(void);
    CoolPropDbl calc_conductivity(void);
    CoolPropDbl calc_surface_tension(void);
    CoolPropDbl calc_Bvirial(void);
    CoolPropDbl calc_dBvirial_dT(void);
    CoolPropDbl calc_Cvirial(void);
 
    CoolPropDbl calc_fugacity_coefficient(std::size_t i);
    CoolPropDbl calc_fugacity(std::size_t i);
    CoolPropDbl calc_chemical_potential(std::size_t i);
    CoolPropDbl calc_melting_line(int param, int given, CoolPropDbl value);
    bool has_melting_line();
    double calc_melt_Tmax();
    CoolPropDbl calc_T_critical(void);
    CoolPropDbl calc_T_reducing(void);
    void calc_reducing_state(void);
    CoolPropDbl calc_p_critical(void);
    CoolPropDbl calc_p_triple(void);
    CoolPropDbl calc_p_min(void) {
        return calc_p_triple();
    };
    CoolPropDbl calc_rhomolar_critical(void);
    CoolPropDbl calc_rhomolar_reducing(void);
    CoolPropDbl calc_Ttriple(void);
    CoolPropDbl calc_acentric_factor(void);
    CoolPropDbl calc_gas_constant(void);
    CoolPropDbl calc_dipole_moment(void);
 
    void calc_true_critical_point(double& T, double& rho);
 
    CoolPropDbl calc_saturated_liquid_keyed_output(parameters key);
    CoolPropDbl calc_saturated_vapor_keyed_output(parameters key);
 
    void calc_ideal_curve(const std::string& type, std::vector<double>& T, std::vector<double>& p);
 
    void limits(double& Tmin, double& Tmax, double& rhomolarmax, double& pmax);
    CoolPropDbl calc_pmax(void);
    CoolPropDbl calc_Tmax(void);
    CoolPropDbl calc_Tmin(void);
 
    CoolPropDbl calc_smolar_residual(void) {
        return (tau() * calc_dalphar_dTau() - calc_alphar()) * gas_constant();
    }
 
    CoolPropDbl calc_alphar(void) {
        return call_phixdll(0, 0);
    };
    CoolPropDbl calc_dalphar_dDelta(void) {
        return call_phixdll(0, 1);
    };
    CoolPropDbl calc_dalphar_dTau(void) {
        return call_phixdll(1, 0);
    };
    CoolPropDbl calc_d2alphar_dDelta2(void) {
        return call_phixdll(0, 2);
    };
    CoolPropDbl calc_d2alphar_dDelta_dTau(void) {
        return call_phixdll(1, 1);
    };
    CoolPropDbl calc_d2alphar_dTau2(void) {
        return call_phixdll(2, 0);
    };
    CoolPropDbl calc_d3alphar_dDelta3(void) {
        return call_phixdll(0, 3);
    };
    CoolPropDbl calc_d3alphar_dDelta2_dTau(void) {
        return call_phixdll(1, 2);
    };
    CoolPropDbl calc_d3alphar_dDelta_dTau2(void) {
        return call_phixdll(2, 1);
    };
    CoolPropDbl calc_d3alphar_dTau3(void) {
        return call_phixdll(3, 0);
    };
 
    CoolPropDbl calc_alpha0(void) {
        return call_phi0dll(0, 0);
    };
    CoolPropDbl calc_dalpha0_dDelta(void) {
        return call_phi0dll(0, 1);
    };
    CoolPropDbl calc_dalpha0_dTau(void) {
        return call_phi0dll(1, 0);
    };
    CoolPropDbl calc_d2alpha0_dDelta2(void) {
        return call_phi0dll(0, 2);
    };
    CoolPropDbl calc_d2alpha0_dDelta_dTau(void) {
        return call_phi0dll(1, 1);
    };
    CoolPropDbl calc_d2alpha0_dTau2(void) {
        return call_phi0dll(2, 0);
    };
    CoolPropDbl calc_d3alpha0_dDelta3(void) {
        return call_phi0dll(0, 3);
    };
    CoolPropDbl calc_d3alpha0_dDelta2_dTau(void) {
        return call_phi0dll(1, 2);
    };
    CoolPropDbl calc_d3alpha0_dDelta_dTau2(void) {
        return call_phi0dll(2, 1);
    };
    CoolPropDbl calc_d3alpha0_dTau3(void) {
        return call_phi0dll(3, 0);
    };
};
 
bool force_load_REFPROP();
bool force_unload_REFPROP();
void REFPROP_SETREF(char hrf[3], int ixflag, double x0[1], double& h0, double& s0, double& T0, double& p0, int& ierr, char herr[255], int l1, int l2);
 
} /* namespace CoolProp */
#endif /* REFPROPMIXTUREBACKEND_H_ */