IncompressibleBackend.h

#ifndef INCOMPRESSIBLEBACKEND_H_
#define INCOMPRESSIBLEBACKEND_H_

#include "DataStructures.h"
#include "IncompressibleFluid.h"
#include "AbstractState.h"
#include "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(){};
    std::string backend_name(void) {
        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(void) {
        return this->fluid->getxid() == IFRAC_MOLE;
    };
    bool using_mass_fractions(void) {
        return (this->fluid->getxid() == IFRAC_MASS || this->fluid->getxid() == IFRAC_PURE);
    };
    bool using_volu_fractions(void) {
        return this->fluid->getxid() == IFRAC_VOLUME;
    };


    void update(CoolProp::input_pairs input_pair, double value1, double value2);

    std::string fluid_param_string(const std::string& ParamName) {
        if (!ParamName.compare("long_name")) {
            return calc_name();
        } else {
            throw ValueError(format("Input value [%s] is invalid.", ParamName.c_str()));
        }
    }

    bool clear();

    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);
    const std::vector<CoolPropDbl>& get_mole_fractions(void) {
        throw NotImplementedError("get_mole_fractions not implemented for this backend");
    };


    void set_mass_fractions(const std::vector<CoolPropDbl>& mass_fractions);


    void set_volu_fractions(const std::vector<CoolPropDbl>& volu_fractions);

    void check_status();

    double rhomass(void);
    double hmass(void);
    double smass(void);
    double umass(void);
    double cmass(void);

    double drhodTatPx(void);
    double dsdTatPx(void);
    double dhdTatPx(void);
    double dsdTatPxdT(void);
    double dhdTatPxdT(void);
    double dsdpatTx(void);
    double dhdpatTx(void);

    double T_ref(void);
    double p_ref(void);
    double x_ref(void);
    double h_ref(void);
    double s_ref(void);

    double hmass_ref(void);
    double smass_ref(void);


    CoolPropDbl DmassP_flash(CoolPropDbl rhomass, CoolPropDbl p);

    CoolPropDbl HmassP_flash(CoolPropDbl hmass, CoolPropDbl p);

    CoolPropDbl PSmass_flash(CoolPropDbl p, CoolPropDbl smass);

    //    /// Calculate T given pressure and internal energy
    //    /**
    //    @param umass The mass internal energy in J/kg
    //    @param p The pressure in Pa
    //    @returns T The temperature in K
    //    */
    //    CoolPropDbl PUmass_flash(CoolPropDbl p, CoolPropDbl umass);

    CoolPropDbl calc_rhomass(void) {
        return fluid->rho(_T, _p, _fractions[0]);
    };
    CoolPropDbl calc_cmass(void) {
        return fluid->c(_T, _p, _fractions[0]);
    };
    CoolPropDbl calc_cpmass(void) {
        return cmass();
    };
    CoolPropDbl calc_cvmass(void) {
        return cmass();
    };
    CoolPropDbl calc_viscosity(void) {
        return fluid->visc(_T, _p, _fractions[0]);
    };
    CoolPropDbl calc_conductivity(void) {
        return fluid->cond(_T, _p, _fractions[0]);
    };
    CoolPropDbl calc_T_freeze(void) {
        // 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);
    CoolPropDbl calc_umass(void);

    CoolPropDbl calc_hmass(void);
    CoolPropDbl calc_smass(void);

   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);

    /* 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(void) {
        return fluid->getTmax();
    };
    CoolPropDbl calc_Tmin(void) {
        return fluid->getTmin();
    };
    CoolPropDbl calc_fraction_min(void) {
        return fluid->getxmin();
    };
    CoolPropDbl calc_fraction_max(void) {
        return fluid->getxmax();
    };
    std::string calc_name(void) {
        return fluid->getName();
    };
    std::string calc_description(void) {
        return fluid->getDescription();
    };
};

} /* namespace CoolProp */
#endif /* INCOMPRESSIBLEBACKEND_H_ */