IncompressibleBackend.h

Go to the documentation of this file.

 
#ifndef INCOMPRESSIBLEBACKEND_H_
#define INCOMPRESSIBLEBACKEND_H_
 
#include "CoolProp/DataStructures.h"
#include "CoolProp/fluids/IncompressibleFluid.h"
#include "CoolProp/AbstractState.h"
#include "CoolProp/Exceptions.h"
 
#include <vector>
 
namespace CoolProp {
 
class IncompressibleBackend : public AbstractState
{
 
   protected:
    //double _T, _p; // From AbstractState
    std::vector<CoolPropDbl> _fractions;
 
    CachedElement _T_ref, _p_ref, _x_ref, _h_ref, _s_ref;
    CachedElement _hmass_ref, _smass_ref;
 
    CachedElement _cmass, _hmass, _rhomass, _smass, _umass;
    CachedElement _drhodTatPx, _dsdTatPx, _dhdTatPx, _dsdTatPxdT, _dhdTatPxdT, _dsdpatTx, _dhdpatTx;
 
    IncompressibleFluid* fluid;
 
 
    void set_fractions(const std::vector<CoolPropDbl>& fractions);
 
   public:
    IncompressibleBackend();
    virtual ~IncompressibleBackend() = default;
    std::string backend_name() override {
        return get_backend_string(INCOMP_BACKEND);
    }
 
    IncompressibleBackend(IncompressibleFluid* fluid);
    IncompressibleBackend(const std::string& fluid_name);
    IncompressibleBackend(const std::vector<std::string>& component_names);
 
    // Incompressible backend uses different compositions
    bool using_mole_fractions() override {
        return this->fluid->getxid() == IFRAC_MOLE;
    };
    bool using_mass_fractions() override {
        return (this->fluid->getxid() == IFRAC_MASS || this->fluid->getxid() == IFRAC_PURE);
    };
    bool using_volu_fractions() override {
        return this->fluid->getxid() == IFRAC_VOLUME;
    };
 
 
    void update(CoolProp::input_pairs input_pair, double value1, double value2) override;
 
    std::string fluid_param_string(const std::string& ParamName) override {
        if (!ParamName.compare("long_name")) {
            return calc_name();
        } else {
            throw ValueError(format("Input value [%s] is invalid.", ParamName.c_str()));
        }
    }
 
    bool clear() override;
 
    void set_reference_state(double T0 = 20 + 273.15, double p0 = 101325, double x0 = 0.0, double h0 = 0.0, double s0 = 0.0);
 
 
    void set_mole_fractions(const std::vector<CoolPropDbl>& mole_fractions) override;
    const std::vector<CoolPropDbl>& get_mole_fractions() override {
        throw NotImplementedError("get_mole_fractions not implemented for this backend");
    };
 
 
    void set_mass_fractions(const std::vector<CoolPropDbl>& mass_fractions) override;
 
 
    void set_volu_fractions(const std::vector<CoolPropDbl>& volu_fractions) override;
 
    void check_status();
 
    double rhomass();
    double hmass();
    double smass();
    double umass();
    double cmass();
 
    double drhodTatPx();
    double dsdTatPx();
    double dhdTatPx();
    double dsdTatPxdT();
    double dhdTatPxdT();
    double dsdpatTx();
    double dhdpatTx();
 
    double T_ref();
    double p_ref();
    double x_ref();
    double h_ref();
    double s_ref();
 
    double hmass_ref();
    double smass_ref();
 
 
    CoolPropDbl DmassP_flash(CoolPropDbl rhomass, CoolPropDbl p);
 
    CoolPropDbl HmassP_flash(CoolPropDbl hmass, CoolPropDbl p);
 
    CoolPropDbl PSmass_flash(CoolPropDbl p, CoolPropDbl smass);
 
    // CoolPropDbl PUmass_flash(CoolPropDbl p, CoolPropDbl umass);  // not implemented
 
    // Molar quantities are not meaningful for incompressible solutions,
    // which are formulated entirely on a mass basis with no fixed
    // composition / molecular weight (#1908). Throw a controlled
    // exception with a helpful pointer at the mass-basis equivalents
    // instead of silently returning the AbstractState default
    // (-_HUGE) which surfaced as "PropsSI failed ungracefully".
    CoolPropDbl calc_molar_mass() override {
        throw NotImplementedError("Molar mass is not defined for the INCOMP (incompressible) backend; INCOMP fluids are mass-based.");
    }
    CoolPropDbl calc_rhomolar() override {
        throw NotImplementedError("Dmolar / rhomolar is not defined for the INCOMP backend; use Dmass / rhomass instead.");
    }
    CoolPropDbl calc_hmolar() override {
        throw NotImplementedError("Hmolar / hmolar is not defined for the INCOMP backend; use Hmass / hmass instead.");
    }
    CoolPropDbl calc_smolar() override {
        throw NotImplementedError("Smolar / smolar is not defined for the INCOMP backend; use Smass / smass instead.");
    }
    CoolPropDbl calc_umolar() override {
        throw NotImplementedError("Umolar / umolar is not defined for the INCOMP backend; use Umass / umass instead.");
    }
    CoolPropDbl calc_cpmolar() override {
        throw NotImplementedError("Cpmolar / cpmolar is not defined for the INCOMP backend; use Cpmass / cpmass instead.");
    }
    CoolPropDbl calc_cvmolar() override {
        throw NotImplementedError("Cvmolar / cvmolar is not defined for the INCOMP backend; use Cvmass / cvmass instead.");
    }
 
    CoolPropDbl calc_rhomass() override {
        return fluid->rho(_T, _p, _fractions[0]);
    };
    CoolPropDbl calc_cmass() {
        return fluid->c(_T, _p, _fractions[0]);
    };
    CoolPropDbl calc_cpmass() override {
        return cmass();
    };
    CoolPropDbl calc_cvmass() override {
        return cmass();
    };
    CoolPropDbl calc_viscosity() override {
        return fluid->visc(_T, _p, _fractions[0]);
    };
    CoolPropDbl calc_conductivity() override {
        return fluid->cond(_T, _p, _fractions[0]);
    };
    CoolPropDbl calc_T_freeze() override {
        // No update is called - T_freeze is a trivial output
        fluid->checkX(_fractions[0]);
        return fluid->Tfreeze(_p, _fractions[0]);
    };
    CoolPropDbl calc_melting_line(int param, int given, CoolPropDbl value) override;
    CoolPropDbl calc_umass() override;
 
    CoolPropDbl calc_hmass() override;
    CoolPropDbl calc_smass() override;
 
   public:
    CoolPropDbl raw_calc_hmass(double T, double p, double x);
    CoolPropDbl raw_calc_smass(double T, double p, double x);
 
   protected:
    CoolPropDbl calc_first_partial_deriv(parameters Of, parameters Wrt, parameters Constant) override;
 
    /* Below are direct calculations of the derivatives. Nothing
     * special is going on, we simply use the polynomial class to
     * derive the different functions with respect to temperature.
     */
    double calc_drhodTatPx(double T, double p, double x) {
        return fluid->drhodTatPx(T, p, x);
    };
    double calc_dsdTatPx(double T, double p, double x) {
        return fluid->c(T, p, x) / T;
    };
    double calc_dhdTatPx(double T, double p, double x) {
        return fluid->c(T, p, x);
    };
    double calc_dsdTatPxdT(double T, double p, double x) {
        return fluid->dsdTatPxdT(T, p, x);
    };
    double calc_dhdTatPxdT(double T, double p, double x) {
        return fluid->dhdTatPxdT(T, p, x);
    };
 
    /* Other useful derivatives
     */
    double calc_dsdpatTx(double rho, double drhodTatPx);
    double calc_dhdpatTx(double T, double rho, double drhodTatPx);
 
   public:
    CoolPropDbl calc_Tmax() override {
        return fluid->getTmax();
    };
    CoolPropDbl calc_Tmin() override {
        return fluid->getTmin();
    };
    CoolPropDbl calc_fraction_min() override {
        return fluid->getxmin();
    };
    CoolPropDbl calc_fraction_max() override {
        return fluid->getxmax();
    };
    std::string calc_name() override {
        return fluid->getName();
    };
    std::string calc_description() override {
        return fluid->getDescription();
    };
};
 
} /* namespace CoolProp */
#endif /* INCOMPRESSIBLEBACKEND_H_ */