AbstractState.h

Go to the documentation of this file.

/*
 * AbstractState.h
 *
 *  Created on: 21 Dec 2013
 *      Author: jowr
 */
 
#ifndef ABSTRACTSTATE_H_
#define ABSTRACTSTATE_H_
 
#include "CoolProp/detail/CachedElement.h"
#include "CoolProp/Exceptions.h"
#include "CoolProp/DataStructures.h"
#include "CoolProp/fluids/PhaseEnvelope.h"
#include <memory>
using std::shared_ptr;
 
namespace CoolProp {
 
class SpinodalData
{
   public:
    std::vector<double> tau,  
      delta,                  
      M1;                     
};
 
class GuessesStructure
{
   public:
    double T,               
      p,                    
      rhomolar,             
      hmolar,               
      smolar,               
      rhomolar_liq,         
      rhomolar_vap;         
    std::vector<double> x,  
      y;                    
    GuessesStructure() {
        clear();
    };
    void clear() {
        T = _HUGE;
        p = _HUGE;
        rhomolar = _HUGE;
        hmolar = _HUGE;
        smolar = _HUGE;
        rhomolar_liq = _HUGE;
        rhomolar_vap = _HUGE;
        x.clear(), y.clear();
    }
};
 
 
class AbstractState
{
   protected:
    long _fluid_type;
    phases _phase;               
    phases imposed_phase_index;  
 
    bool isSupercriticalPhase() {
        return (this->_phase == iphase_supercritical || this->_phase == iphase_supercritical_liquid || this->_phase == iphase_supercritical_gas);
    }
 
    bool isHomogeneousPhase() {
        return (this->_phase == iphase_liquid || this->_phase == iphase_gas || isSupercriticalPhase() || this->_phase == iphase_critical_point);
    }
 
    bool isTwoPhase() {
        return (this->_phase == iphase_twophase);
    }
 
    CacheArray<80> cache;
    using CAE = CacheArrayElement<double>;
 
    SimpleState _critical, _reducing;
 
    CAE _molar_mass = cache.next();
 
    CAE _gas_constant = cache.next();
 
    double _rhomolar, _T, _p, _Q;
 
    CAE _tau = cache.next(), _delta = cache.next();
 
    CAE _viscosity = cache.next(), _conductivity = cache.next(), _surface_tension = cache.next();
 
    CAE _hmolar = cache.next(), _smolar = cache.next(), _umolar = cache.next(), _logp = cache.next(), _logrhomolar = cache.next(),
        _cpmolar = cache.next(), _cp0molar = cache.next(), _cvmolar = cache.next(), _speed_sound = cache.next(), _gibbsmolar = cache.next(),
        _helmholtzmolar = cache.next();
 
    CAE _hmolar_residual = cache.next(), _smolar_residual = cache.next(), _gibbsmolar_residual = cache.next();
 
    CAE _hmolar_excess = cache.next(), _smolar_excess = cache.next(), _gibbsmolar_excess = cache.next(), _umolar_excess = cache.next(),
        _volumemolar_excess = cache.next(), _helmholtzmolar_excess = cache.next();
 
    CAE _rhoLanc = cache.next(), _rhoVanc = cache.next(), _pLanc = cache.next(), _pVanc = cache.next(), _TLanc = cache.next(), _TVanc = cache.next();
 
    CachedElement _fugacity_coefficient;
 
    CAE _rho_spline = cache.next(), _drho_spline_dh__constp = cache.next(), _drho_spline_dp__consth = cache.next();
 
    CAE _alpha0 = cache.next(), _dalpha0_dTau = cache.next(), _dalpha0_dDelta = cache.next(), _d2alpha0_dTau2 = cache.next(),
        _d2alpha0_dDelta_dTau = cache.next(), _d2alpha0_dDelta2 = cache.next(), _d3alpha0_dTau3 = cache.next(), _d3alpha0_dDelta_dTau2 = cache.next(),
        _d3alpha0_dDelta2_dTau = cache.next(), _d3alpha0_dDelta3 = cache.next(), _alphar = cache.next(), _dalphar_dTau = cache.next(),
        _dalphar_dDelta = cache.next(), _d2alphar_dTau2 = cache.next(), _d2alphar_dDelta_dTau = cache.next(), _d2alphar_dDelta2 = cache.next(),
        _d3alphar_dTau3 = cache.next(), _d3alphar_dDelta_dTau2 = cache.next(), _d3alphar_dDelta2_dTau = cache.next(),
        _d3alphar_dDelta3 = cache.next(), _d4alphar_dTau4 = cache.next(), _d4alphar_dDelta_dTau3 = cache.next(),
        _d4alphar_dDelta2_dTau2 = cache.next(), _d4alphar_dDelta3_dTau = cache.next(), _d4alphar_dDelta4 = cache.next();
 
    CAE _dalphar_dDelta_lim = cache.next(), _d2alphar_dDelta2_lim = cache.next(), _d2alphar_dDelta_dTau_lim = cache.next(),
        _d3alphar_dDelta2_dTau_lim = cache.next();
 
    CAE _rhoLmolar = cache.next(), _rhoVmolar = cache.next();
    CAE _Qmass = cache.next();
 
    // ----------------------------------------
    // Property accessors to be optionally implemented by the backend
    // for properties that are not always calculated
    // ----------------------------------------
    virtual CoolPropDbl calc_hmolar() {
        throw NotImplementedError("calc_hmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_hmolar_residual() {
        throw NotImplementedError("calc_hmolar_residual is not implemented for this backend");
    };
    virtual CoolPropDbl calc_smolar() {
        throw NotImplementedError("calc_smolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_smolar_residual() {
        throw NotImplementedError("calc_smolar_residual is not implemented for this backend");
    };
    virtual CoolPropDbl calc_neff() {
        throw NotImplementedError("calc_neff is not implemented for this backend");
    };
    virtual CoolPropDbl calc_umolar() {
        throw NotImplementedError("calc_umolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_cpmolar() {
        throw NotImplementedError("calc_cpmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_cpmolar_idealgas() {
        throw NotImplementedError("calc_cpmolar_idealgas is not implemented for this backend");
    };
    virtual CoolPropDbl calc_cvmolar() {
        throw NotImplementedError("calc_cvmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_gibbsmolar() {
        throw NotImplementedError("calc_gibbsmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_gibbsmolar_residual() {
        throw NotImplementedError("calc_gibbsmolar_residual is not implemented for this backend");
    };
    virtual CoolPropDbl calc_helmholtzmolar() {
        throw NotImplementedError("calc_helmholtzmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_speed_sound() {
        throw NotImplementedError("calc_speed_sound is not implemented for this backend");
    };
    virtual CoolPropDbl calc_isothermal_compressibility() {
        throw NotImplementedError("calc_isothermal_compressibility is not implemented for this backend");
    };
    virtual CoolPropDbl calc_isobaric_expansion_coefficient() {
        throw NotImplementedError("calc_isobaric_expansion_coefficient is not implemented for this backend");
    };
    virtual CoolPropDbl calc_isentropic_expansion_coefficient() {
        throw NotImplementedError("calc_isentropic_expansion_coefficient is not implemented for this backend");
    };
    virtual CoolPropDbl calc_viscosity() {
        throw NotImplementedError("calc_viscosity is not implemented for this backend");
    };
    virtual CoolPropDbl calc_conductivity() {
        throw NotImplementedError("calc_conductivity is not implemented for this backend");
    };
    virtual CoolPropDbl calc_surface_tension() {
        throw NotImplementedError("calc_surface_tension is not implemented for this backend");
    };
    virtual CoolPropDbl calc_molar_mass() {
        throw NotImplementedError("calc_molar_mass is not implemented for this backend");
    };
    virtual CoolPropDbl calc_acentric_factor() {
        throw NotImplementedError("calc_acentric_factor is not implemented for this backend");
    };
    virtual CoolPropDbl calc_pressure() {
        throw NotImplementedError("calc_pressure is not implemented for this backend");
    };
    virtual CoolPropDbl calc_gas_constant() {
        throw NotImplementedError("calc_gas_constant is not implemented for this backend");
    };
    virtual CoolPropDbl calc_fugacity_coefficient(std::size_t i) {
        throw NotImplementedError("calc_fugacity_coefficient is not implemented for this backend");
    };
    virtual std::vector<CoolPropDbl> calc_fugacity_coefficients() {
        throw NotImplementedError("calc_fugacity_coefficients is not implemented for this backend");
    };
    virtual CoolPropDbl calc_fugacity(std::size_t i) {
        throw NotImplementedError("calc_fugacity is not implemented for this backend");
    };
    virtual CoolPropDbl calc_chemical_potential(std::size_t i) {
        throw NotImplementedError("calc_chemical_potential is not implemented for this backend");
    };
    virtual CoolPropDbl calc_PIP() {
        throw NotImplementedError("calc_PIP is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_Qmass();
 
    struct PhaseMolarMasses
    {
        double liquid;
        double vapor;
    };
 
    virtual PhaseMolarMasses calc_phase_molar_masses();
 
    virtual void update_Qmass_pair(CoolProp::input_pairs pair, double v1, double v2);
 
    // Excess properties
    virtual void calc_excess_properties() {
        throw NotImplementedError("calc_excess_properties is not implemented for this backend");
    };
 
    // Derivatives of residual helmholtz energy
    virtual CoolPropDbl calc_alphar() {
        throw NotImplementedError("calc_alphar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dalphar_dDelta() {
        throw NotImplementedError("calc_dalphar_dDelta is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dalphar_dTau() {
        throw NotImplementedError("calc_dalphar_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alphar_dDelta2() {
        throw NotImplementedError("calc_d2alphar_dDelta2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alphar_dDelta_dTau() {
        throw NotImplementedError("calc_d2alphar_dDelta_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alphar_dTau2() {
        throw NotImplementedError("calc_d2alphar_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alphar_dDelta3() {
        throw NotImplementedError("calc_d3alphar_dDelta3 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alphar_dDelta2_dTau() {
        throw NotImplementedError("calc_d3alphar_dDelta2_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alphar_dDelta_dTau2() {
        throw NotImplementedError("calc_d3alphar_dDelta_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alphar_dTau3() {
        throw NotImplementedError("calc_d3alphar_dTau3 is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_d4alphar_dDelta4() {
        throw NotImplementedError("calc_d4alphar_dDelta4 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d4alphar_dDelta3_dTau() {
        throw NotImplementedError("calc_d4alphar_dDelta3_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d4alphar_dDelta2_dTau2() {
        throw NotImplementedError("calc_d4alphar_dDelta2_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d4alphar_dDelta_dTau3() {
        throw NotImplementedError("calc_d4alphar_dDelta_dTau3 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d4alphar_dTau4() {
        throw NotImplementedError("calc_d4alphar_dTau4 is not implemented for this backend");
    };
 
    // Derivatives of ideal-gas helmholtz energy
    virtual CoolPropDbl calc_alpha0() {
        throw NotImplementedError("calc_alpha0 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dalpha0_dDelta() {
        throw NotImplementedError("calc_dalpha0_dDelta is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dalpha0_dTau() {
        throw NotImplementedError("calc_dalpha0_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alpha0_dDelta_dTau() {
        throw NotImplementedError("calc_d2alpha0_dDelta_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alpha0_dDelta2() {
        throw NotImplementedError("calc_d2alpha0_dDelta2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alpha0_dTau2() {
        throw NotImplementedError("calc_d2alpha0_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alpha0_dDelta3() {
        throw NotImplementedError("calc_d3alpha0_dDelta3 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alpha0_dDelta2_dTau() {
        throw NotImplementedError("calc_d3alpha0_dDelta2_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alpha0_dDelta_dTau2() {
        throw NotImplementedError("calc_d3alpha0_dDelta_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alpha0_dTau3() {
        throw NotImplementedError("calc_d3alpha0_dTau3 is not implemented for this backend");
    };
 
    virtual void calc_reducing_state() {
        throw NotImplementedError("calc_reducing_state is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_Tmax() {
        throw NotImplementedError("calc_Tmax is not implemented for this backend");
    };
    virtual CoolPropDbl calc_Tmin() {
        throw NotImplementedError("calc_Tmin is not implemented for this backend");
    };
    virtual CoolPropDbl calc_pmax() {
        throw NotImplementedError("calc_pmax is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_GWP20() {
        throw NotImplementedError("calc_GWP20 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_GWP100() {
        throw NotImplementedError("calc_GWP100 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_GWP500() {
        throw NotImplementedError("calc_GWP500 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_ODP() {
        throw NotImplementedError("calc_ODP is not implemented for this backend");
    };
    virtual CoolPropDbl calc_flame_hazard() {
        throw NotImplementedError("calc_flame_hazard is not implemented for this backend");
    };
    virtual CoolPropDbl calc_health_hazard() {
        throw NotImplementedError("calc_health_hazard is not implemented for this backend");
    };
    virtual CoolPropDbl calc_physical_hazard() {
        throw NotImplementedError("calc_physical_hazard is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dipole_moment() {
        throw NotImplementedError("calc_dipole_moment is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_first_partial_deriv(parameters Of, parameters Wrt, parameters Constant);
    virtual CoolPropDbl calc_second_partial_deriv(parameters Of1, parameters Wrt1, parameters Constant1, parameters Wrt2, parameters Constant2);
 
    virtual CoolPropDbl calc_reduced_density() {
        throw NotImplementedError("calc_reduced_density is not implemented for this backend");
    };
    virtual CoolPropDbl calc_reciprocal_reduced_temperature() {
        throw NotImplementedError("calc_reciprocal_reduced_temperature is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_Bvirial() {
        throw NotImplementedError("calc_Bvirial is not implemented for this backend");
    };
    virtual CoolPropDbl calc_Cvirial() {
        throw NotImplementedError("calc_Cvirial is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dBvirial_dT() {
        throw NotImplementedError("calc_dBvirial_dT is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dCvirial_dT() {
        throw NotImplementedError("calc_dCvirial_dT is not implemented for this backend");
    };
    virtual CoolPropDbl calc_compressibility_factor() {
        throw NotImplementedError("calc_compressibility_factor is not implemented for this backend");
    };
 
    virtual std::string calc_name() {
        throw NotImplementedError("calc_name is not implemented for this backend");
    };
    virtual std::string calc_description() {
        throw NotImplementedError("calc_description is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_Ttriple() {
        throw NotImplementedError("calc_Ttriple is not implemented for this backend");
    };
    virtual CoolPropDbl calc_p_triple() {
        throw NotImplementedError("calc_p_triple is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_T_critical() {
        throw NotImplementedError("calc_T_critical is not implemented for this backend");
    };
    virtual CoolPropDbl calc_T_reducing() {
        throw NotImplementedError("calc_T_reducing is not implemented for this backend");
    };
    virtual CoolPropDbl calc_p_critical() {
        throw NotImplementedError("calc_p_critical is not implemented for this backend");
    };
    virtual CoolPropDbl calc_p_reducing() {
        throw NotImplementedError("calc_p_reducing is not implemented for this backend");
    };
    virtual CoolPropDbl calc_rhomolar_critical() {
        throw NotImplementedError("calc_rhomolar_critical is not implemented for this backend");
    };
    virtual CoolPropDbl calc_rhomass_critical() {
        throw NotImplementedError("calc_rhomass_critical is not implemented for this backend");
    };
    virtual CoolPropDbl calc_rhomolar_reducing() {
        throw NotImplementedError("calc_rhomolar_reducing is not implemented for this backend");
    };
    virtual void calc_phase_envelope(const std::string& type) {
        throw NotImplementedError("calc_phase_envelope is not implemented for this backend");
    };
    virtual CoolPropDbl calc_rhomass() {
        return rhomolar() * molar_mass();
    }
    virtual CoolPropDbl calc_hmass() {
        return hmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_hmass_excess() {
        return hmolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_smass() {
        return smolar() / molar_mass();
    }
    virtual CoolPropDbl calc_smass_excess() {
        return smolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_cpmass() {
        return cpmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_cp0mass() {
        return cp0molar() / molar_mass();
    }
    virtual CoolPropDbl calc_cvmass() {
        return cvmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_umass() {
        return umolar() / molar_mass();
    }
    virtual CoolPropDbl calc_umass_excess() {
        return umolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_gibbsmass() {
        return gibbsmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_gibbsmass_excess() {
        return gibbsmolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_helmholtzmass() {
        return helmholtzmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_helmholtzmass_excess() {
        return helmholtzmolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_volumemass_excess() {
        return volumemolar_excess() / molar_mass();
    }
 
    virtual void update_states() {
        throw NotImplementedError("This backend does not implement update_states function");
    };
 
    virtual CoolPropDbl calc_melting_line(int param, int given, CoolPropDbl value) {
        throw NotImplementedError("This backend does not implement calc_melting_line function");
    };
 
    virtual CoolPropDbl calc_saturation_ancillary(parameters param, int Q, parameters given, double value) {
        throw NotImplementedError("This backend does not implement calc_saturation_ancillary");
    };
 
    virtual phases calc_phase() {
        throw NotImplementedError("This backend does not implement calc_phase function");
    };
    virtual void calc_specify_phase(phases phase) {
        throw NotImplementedError("This backend does not implement calc_specify_phase function");
    };
    virtual void calc_unspecify_phase() {
        throw NotImplementedError("This backend does not implement calc_unspecify_phase function");
    };
    virtual std::vector<std::string> calc_fluid_names() {
        throw NotImplementedError("This backend does not implement calc_fluid_names function");
    };
    virtual const CoolProp::SimpleState& calc_state(const std::string& state) {
        throw NotImplementedError("calc_state is not implemented for this backend");
    };
 
    virtual const CoolProp::PhaseEnvelopeData& calc_phase_envelope_data() {
        throw NotImplementedError("calc_phase_envelope_data is not implemented for this backend");
    };
 
    virtual std::vector<CoolPropDbl> calc_mole_fractions_liquid() {
        throw NotImplementedError("calc_mole_fractions_liquid is not implemented for this backend");
    };
    virtual std::vector<CoolPropDbl> calc_mole_fractions_vapor() {
        throw NotImplementedError("calc_mole_fractions_vapor is not implemented for this backend");
    };
    virtual const std::vector<CoolPropDbl> calc_mass_fractions() {
        throw NotImplementedError("calc_mass_fractions is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_fraction_min() {
        throw NotImplementedError("calc_fraction_min is not implemented for this backend");
    };
    virtual CoolPropDbl calc_fraction_max() {
        throw NotImplementedError("calc_fraction_max is not implemented for this backend");
    };
    virtual CoolPropDbl calc_T_freeze() {
        throw NotImplementedError("calc_T_freeze is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_first_saturation_deriv(parameters Of1, parameters Wrt1) {
        throw NotImplementedError("calc_first_saturation_deriv is not implemented for this backend");
    };
    virtual CoolPropDbl calc_second_saturation_deriv(parameters Of1, parameters Wrt1, parameters Wrt2) {
        throw NotImplementedError("calc_second_saturation_deriv is not implemented for this backend");
    };
    virtual CoolPropDbl calc_first_two_phase_deriv(parameters Of, parameters Wrt, parameters Constant) {
        throw NotImplementedError("calc_first_two_phase_deriv is not implemented for this backend");
    };
    virtual CoolPropDbl calc_second_two_phase_deriv(parameters Of, parameters Wrt, parameters Constant, parameters Wrt2, parameters Constant2) {
        throw NotImplementedError("calc_second_two_phase_deriv is not implemented for this backend");
    };
    virtual CoolPropDbl calc_first_two_phase_deriv_splined(parameters Of, parameters Wrt, parameters Constant, CoolPropDbl x_end) {
        throw NotImplementedError("calc_first_two_phase_deriv_splined is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_saturated_liquid_keyed_output(parameters key) {
        throw NotImplementedError("calc_saturated_liquid_keyed_output is not implemented for this backend");
    };
    virtual CoolPropDbl calc_saturated_vapor_keyed_output(parameters key) {
        throw NotImplementedError("calc_saturated_vapor_keyed_output is not implemented for this backend");
    };
    virtual void calc_ideal_curve(const std::string& type, std::vector<double>& T, std::vector<double>& p) {
        throw NotImplementedError("calc_ideal_curve is not implemented for this backend");
    };
 
    virtual CoolPropDbl calc_T() {
        return _T;
    }
    virtual CoolPropDbl calc_rhomolar() {
        return _rhomolar;
    }
 
    virtual double calc_tangent_plane_distance(const double T, const double p, const std::vector<double>& w, const double rhomolar_guess) {
        throw NotImplementedError("calc_tangent_plane_distance is not implemented for this backend");
    };
 
    virtual void calc_true_critical_point(double& T, double& rho) {
        throw NotImplementedError("calc_true_critical_point is not implemented for this backend");
    };
 
    virtual void calc_conformal_state(const std::string& reference_fluid, CoolPropDbl& T, CoolPropDbl& rhomolar) {
        throw NotImplementedError("calc_conformal_state is not implemented for this backend");
    };
 
    virtual void calc_viscosity_contributions(CoolPropDbl& dilute, CoolPropDbl& initial_density, CoolPropDbl& residual, CoolPropDbl& critical) {
        throw NotImplementedError("calc_viscosity_contributions is not implemented for this backend");
    };
    virtual void calc_conductivity_contributions(CoolPropDbl& dilute, CoolPropDbl& initial_density, CoolPropDbl& residual, CoolPropDbl& critical) {
        throw NotImplementedError("calc_conductivity_contributions is not implemented for this backend");
    };
    virtual std::vector<CriticalState> calc_all_critical_points() {
        throw NotImplementedError("calc_all_critical_points is not implemented for this backend");
    };
    virtual void calc_build_spinodal() {
        throw NotImplementedError("calc_build_spinodal is not implemented for this backend");
    };
    virtual SpinodalData calc_get_spinodal_data() {
        throw NotImplementedError("calc_get_spinodal_data is not implemented for this backend");
    };
    virtual void calc_criticality_contour_values(double& L1star, double& M1star) {
        throw NotImplementedError("calc_criticality_contour_values is not implemented for this backend");
    };
 
    virtual void mass_to_molar_inputs(CoolProp::input_pairs& input_pair, CoolPropDbl& value1, CoolPropDbl& value2);
 
    virtual void calc_change_EOS(const std::size_t i, const std::string& EOS_name) {
        throw NotImplementedError("calc_change_EOS is not implemented for this backend");
    };
 
   public:
    AbstractState() : _fluid_type(FLUID_TYPE_UNDEFINED), _phase(iphase_unknown) {
        // Explicit scope: a virtual `clear()` call from the base ctor
        // would dispatch to this class anyway (derived overrides aren't
        // active yet), so call it directly to make that intent visible
        // and silence clang-analyzer-optin.cplusplus.VirtualCall.
        AbstractState::clear();
    }
    virtual ~AbstractState() = default;
 
 
    static AbstractState* factory(const std::string& backend, const std::string& fluid_names) {
        return factory(backend, strsplit(fluid_names, '&'));
    };
 
    static AbstractState* factory(const std::string& backend, const std::vector<std::string>& fluid_names);
 
    void set_T(CoolPropDbl T) {
        _T = T;
    }
 
    virtual std::string backend_name() = 0;
 
    virtual std::string build_options_json() const {
        return "";
    }
 
    // The derived classes must implement this function to define whether they use mole fractions (true) or mass fractions (false)
    virtual bool using_mole_fractions() = 0;
    virtual bool using_mass_fractions() = 0;
    virtual bool using_volu_fractions() = 0;
 
    virtual void set_mole_fractions(const std::vector<CoolPropDbl>& mole_fractions) = 0;
    virtual void set_mass_fractions(const std::vector<CoolPropDbl>& mass_fractions) = 0;
    virtual void set_volu_fractions(const std::vector<CoolPropDbl>& mass_fractions) {
        throw NotImplementedError("Volume composition has not been implemented.");
    }
 
    virtual void set_reference_stateS(const std::string& reference_state) {
        throw NotImplementedError(
          "Setting reference state has not been implemented for this backend. Try using CoolProp::set_reference_stateD instead.");
    }
 
    virtual void set_reference_stateD(double T, double rhomolar, double hmolar0, double smolar0) {
        throw NotImplementedError(
          "Setting reference state has not been implemented for this backend. Try using CoolProp::set_reference_stateD instead.");
    }
 
#ifndef COOLPROPDBL_MAPS_TO_DOUBLE
    void set_mole_fractions(const std::vector<double>& mole_fractions) {
        set_mole_fractions(std::vector<CoolPropDbl>(mole_fractions.begin(), mole_fractions.end()));
    };
    void set_mass_fractions(const std::vector<double>& mass_fractions) {
        set_mass_fractions(std::vector<CoolPropDbl>(mass_fractions.begin(), mass_fractions.end()));
    };
    void set_volu_fractions(const std::vector<double>& volu_fractions) {
        set_volu_fractions(std::vector<CoolPropDbl>(volu_fractions.begin(), volu_fractions.end()));
    };
#endif
 
    std::vector<CoolPropDbl> mole_fractions_liquid() {
        return calc_mole_fractions_liquid();
    };
    std::vector<double> mole_fractions_liquid_double() {
        std::vector<CoolPropDbl> x = calc_mole_fractions_liquid();
        return {x.begin(), x.end()};
    };
 
    std::vector<CoolPropDbl> mole_fractions_vapor() {
        return calc_mole_fractions_vapor();
    };
    std::vector<double> mole_fractions_vapor_double() {
        std::vector<CoolPropDbl> y = calc_mole_fractions_vapor();
        return {y.begin(), y.end()};
    };
 
    virtual const std::vector<CoolPropDbl>& get_mole_fractions() = 0;
    virtual const std::vector<CoolPropDbl> get_mass_fractions() {
        return this->calc_mass_fractions();
    };
 
    virtual void update(CoolProp::input_pairs input_pair, double Value1, double Value2) = 0;
 
    virtual void update_QT_pure_superanc(double Q, double T) {
        throw NotImplementedError("update_QT_pure_superanc is not implemented for this backend");
    };
 
    virtual void update_with_guesses(CoolProp::input_pairs input_pair, double Value1, double Value2, const GuessesStructure& guesses) {
        throw NotImplementedError("update_with_guesses is not implemented for this backend");
    };
 
    virtual void fast_evaluate(CoolProp::input_pairs input_pair, const double* val1, const double* val2, std::size_t N_inputs,
                               const CoolProp::parameters* outputs, std::size_t N_outputs, double* out_buffer, std::size_t out_buffer_size,
                               int* status_flags, std::size_t status_flags_size, CoolProp::phases imposed_phase = CoolProp::iphase_not_imposed) {
        throw NotImplementedError("fast_evaluate is not implemented for this backend");
    };
 
    virtual bool available_in_high_level() {
        return true;
    }
 
    virtual std::string fluid_param_string(const std::string&) {
        throw NotImplementedError("fluid_param_string has not been implemented for this backend");
    }
 
    std::vector<std::string> fluid_names();
 
    virtual const double get_fluid_constant(std::size_t i, parameters param) const {
        throw NotImplementedError("get_fluid_constant is not implemented for this backend");
    };
 
    virtual void set_binary_interaction_double(const std::string& CAS1, const std::string& CAS2, const std::string& parameter, const double value) {
        throw NotImplementedError("set_binary_interaction_double is not implemented for this backend");
    };
    virtual void set_binary_interaction_double(const std::size_t i, const std::size_t j, const std::string& parameter, const double value) {
        throw NotImplementedError("set_binary_interaction_double is not implemented for this backend");
    };
    virtual void set_binary_interaction_string(const std::string& CAS1, const std::string& CAS2, const std::string& parameter,
                                               const std::string& value) {
        throw NotImplementedError("set_binary_interaction_string is not implemented for this backend");
    };
    virtual void set_binary_interaction_string(const std::size_t i, const std::size_t j, const std::string& parameter, const std::string& value) {
        throw NotImplementedError("set_binary_interaction_string is not implemented for this backend");
    };
    virtual double get_binary_interaction_double(const std::string& CAS1, const std::string& CAS2, const std::string& parameter) {
        throw NotImplementedError("get_binary_interaction_double is not implemented for this backend");
    };
    virtual double get_binary_interaction_double(const std::size_t i, const std::size_t j, const std::string& parameter) {
        throw NotImplementedError("get_binary_interaction_double is not implemented for this backend");
    };
    virtual std::string get_binary_interaction_string(const std::string& CAS1, const std::string& CAS2, const std::string& parameter) {
        throw NotImplementedError("get_binary_interaction_string is not implemented for this backend");
    };
    virtual void apply_simple_mixing_rule(std::size_t i, std::size_t j, const std::string& model) {
        throw NotImplementedError("apply_simple_mixing_rule is not implemented for this backend");
    };
    virtual void set_cubic_alpha_C(const size_t i, const std::string& parameter, const double c1, const double c2, const double c3) {
        throw ValueError("set_cubic_alpha_C only defined for cubic backends");
    };
    virtual void set_fluid_parameter_double(const size_t i, const std::string& parameter, const double value) {
        throw ValueError("set_fluid_parameter_double only defined for cubic backends");
    };
    virtual double get_fluid_parameter_double(const size_t i, const std::string& parameter) {
        throw ValueError("get_fluid_parameter_double only defined for cubic backends");
    };
 
    virtual bool clear();
    virtual bool clear_comp_change();
 
    virtual const CoolProp::SimpleState& get_reducing_state() {
        return _reducing;
    };
 
    const CoolProp::SimpleState& get_state(const std::string& state) {
        return calc_state(state);
    };
 
    double Tmin();
    double Tmax();
    double pmax();
    double Ttriple();
 
    phases phase() {
        return calc_phase();
    };
    void specify_phase(phases phase) {
        calc_specify_phase(phase);
    };
    void unspecify_phase() {
        calc_unspecify_phase();
    };
 
    double T_critical();
    double p_critical();
    double rhomolar_critical();
    double rhomass_critical();
 
    std::vector<CriticalState> all_critical_points() {
        return calc_all_critical_points();
    };
 
    void build_spinodal() {
        calc_build_spinodal();
    };
 
    SpinodalData get_spinodal_data() {
        return calc_get_spinodal_data();
    };
 
    void criticality_contour_values(double& L1star, double& M1star) {
        return calc_criticality_contour_values(L1star, M1star);
    }
 
    double tangent_plane_distance(const double T, const double p, const std::vector<double>& w, const double rhomolar_guess = -1) {
        return calc_tangent_plane_distance(T, p, w, rhomolar_guess);
    };
 
    double T_reducing();
    double rhomolar_reducing();
    double rhomass_reducing();
 
    double p_triple();
 
    std::string name() {
        return calc_name();
    };
    std::string description() {
        return calc_description();
    };
 
    double dipole_moment() {
        return calc_dipole_moment();
    }
 
    // ----------------------------------------
    // Bulk properties - temperature and density are directly calculated every time
    // All other parameters are calculated on an as-needed basis
    // ----------------------------------------
    double keyed_output(parameters key);
    double trivial_keyed_output(parameters key);
    double saturated_liquid_keyed_output(parameters key) {
        return calc_saturated_liquid_keyed_output(key);
    };
    double saturated_vapor_keyed_output(parameters key) {
        return calc_saturated_vapor_keyed_output(key);
    };
 
    double T() {
        return calc_T();
    };
    double rhomolar() {
        return calc_rhomolar();
    };
    double rhomass() {
        return calc_rhomass();
    };
    double p() {
        return _p;
    };
    double Q() {
        return _Q;
    };
    double Qmass();
    double tau();
    double delta();
    double molar_mass();
    double acentric_factor();
    double gas_constant();
    double Bvirial();
    double dBvirial_dT();
    double Cvirial();
    double dCvirial_dT();
    double compressibility_factor();
    double hmolar();
    double hmolar_residual();
    double hmolar_idealgas();
    double hmass_idealgas();
    double hmass() {
        return calc_hmass();
    };
    double hmolar_excess();
    double hmass_excess() {
        return calc_hmass_excess();
    };
    double smolar();
    double smolar_residual();
    double smolar_idealgas();
    double smass_idealgas();
    double neff();
    double smass() {
        return calc_smass();
    };
    double smolar_excess();
    double smass_excess() {
        return calc_smass_excess();
    };
    double umolar();
    double umass() {
        return calc_umass();
    };
    double umolar_excess();
    double umass_excess() {
        return calc_umass_excess();
    };
    double umolar_idealgas();
    double umass_idealgas();
    double cpmolar();
    double cpmass() {
        return calc_cpmass();
    };
    double cp0molar();
    double cp0mass() {
        return calc_cp0mass();
    };
    double cvmolar();
    double cvmass() {
        return calc_cvmass();
    };
    double gibbsmolar();
    double gibbsmolar_residual();
    double gibbsmass() {
        return calc_gibbsmass();
    };
    double gibbsmolar_excess();
    double gibbsmass_excess() {
        return calc_gibbsmass_excess();
    };
    double helmholtzmolar();
    double helmholtzmass() {
        return calc_helmholtzmass();
    };
    double helmholtzmolar_excess();
    double helmholtzmass_excess() {
        return calc_helmholtzmass_excess();
    };
    double volumemolar_excess();
    double volumemass_excess() {
        return calc_volumemass_excess();
    };
    double speed_sound();
    double isothermal_compressibility();
    double isobaric_expansion_coefficient();
    double isentropic_expansion_coefficient();
    double fugacity_coefficient(std::size_t i);
    std::vector<double> fugacity_coefficients();
    double fugacity(std::size_t i);
    double chemical_potential(std::size_t i);
    double fundamental_derivative_of_gas_dynamics();
    double PIP() {
        return calc_PIP();
    };
 
    void true_critical_point(double& T, double& rho) {
        calc_true_critical_point(T, rho);
    }
 
    void ideal_curve(const std::string& type, std::vector<double>& T, std::vector<double>& p) {
        calc_ideal_curve(type, T, p);
    };
 
    // ----------------------------------------
    //    Partial derivatives
    // ----------------------------------------
 
    CoolPropDbl first_partial_deriv(parameters Of, parameters Wrt, parameters Constant) {
        return calc_first_partial_deriv(Of, Wrt, Constant);
    };
 
    CoolPropDbl second_partial_deriv(parameters Of1, parameters Wrt1, parameters Constant1, parameters Wrt2, parameters Constant2) {
        return calc_second_partial_deriv(Of1, Wrt1, Constant1, Wrt2, Constant2);
    };
 
    CoolPropDbl first_saturation_deriv(parameters Of1, parameters Wrt1) {
        return calc_first_saturation_deriv(Of1, Wrt1);
    };
 
    CoolPropDbl second_saturation_deriv(parameters Of1, parameters Wrt1, parameters Wrt2) {
        return calc_second_saturation_deriv(Of1, Wrt1, Wrt2);
    };
 
    double first_two_phase_deriv(parameters Of, parameters Wrt, parameters Constant) {
        return calc_first_two_phase_deriv(Of, Wrt, Constant);
    };
 
    double second_two_phase_deriv(parameters Of, parameters Wrt1, parameters Constant1, parameters Wrt2, parameters Constant2) {
        return calc_second_two_phase_deriv(Of, Wrt1, Constant1, Wrt2, Constant2);
    };
 
    double first_two_phase_deriv_splined(parameters Of, parameters Wrt, parameters Constant, double x_end) {
        return calc_first_two_phase_deriv_splined(Of, Wrt, Constant, x_end);
    };
 
    // ----------------------------------------
    //    Phase envelope for mixtures
    // ----------------------------------------
 
    void build_phase_envelope(const std::string& type = "");
    const CoolProp::PhaseEnvelopeData& get_phase_envelope_data() {
        return calc_phase_envelope_data();
    };
 
    // ----------------------------------------
    //    Ancillary equations
    // ----------------------------------------
 
    virtual bool has_melting_line() {
        return false;
    };
    double melting_line(int param, int given, double value);
    double saturation_ancillary(parameters param, int Q, parameters given, double value);
 
    // ----------------------------------------
    // Transport properties
    // ----------------------------------------
    double viscosity();
    void viscosity_contributions(CoolPropDbl& dilute, CoolPropDbl& initial_density, CoolPropDbl& residual, CoolPropDbl& critical) {
        calc_viscosity_contributions(dilute, initial_density, residual, critical);
    };
    double conductivity();
    void conductivity_contributions(CoolPropDbl& dilute, CoolPropDbl& initial_density, CoolPropDbl& residual, CoolPropDbl& critical) {
        calc_conductivity_contributions(dilute, initial_density, residual, critical);
    };
    double surface_tension();
    double Prandtl() {
        return cpmass() * viscosity() / conductivity();
    };
    void conformal_state(const std::string& reference_fluid, CoolPropDbl& T, CoolPropDbl& rhomolar) {
        return calc_conformal_state(reference_fluid, T, rhomolar);
    };
 
    void change_EOS(const std::size_t i, const std::string& EOS_name) {
        calc_change_EOS(i, EOS_name);
    }
 
    // ----------------------------------------
    // Helmholtz energy and derivatives
    // ----------------------------------------
    CoolPropDbl alpha0() {
        if (!_alpha0) _alpha0 = calc_alpha0();
        return _alpha0;
    };
    CoolPropDbl dalpha0_dDelta() {
        if (!_dalpha0_dDelta) _dalpha0_dDelta = calc_dalpha0_dDelta();
        return _dalpha0_dDelta;
    };
    CoolPropDbl dalpha0_dTau() {
        if (!_dalpha0_dTau) _dalpha0_dTau = calc_dalpha0_dTau();
        return _dalpha0_dTau;
    };
    CoolPropDbl d2alpha0_dDelta2() {
        if (!_d2alpha0_dDelta2) _d2alpha0_dDelta2 = calc_d2alpha0_dDelta2();
        return _d2alpha0_dDelta2;
    };
    CoolPropDbl d2alpha0_dDelta_dTau() {
        if (!_d2alpha0_dDelta_dTau) _d2alpha0_dDelta_dTau = calc_d2alpha0_dDelta_dTau();
        return _d2alpha0_dDelta_dTau;
    };
    CoolPropDbl d2alpha0_dTau2() {
        if (!_d2alpha0_dTau2) _d2alpha0_dTau2 = calc_d2alpha0_dTau2();
        return _d2alpha0_dTau2;
    };
    CoolPropDbl d3alpha0_dTau3() {
        if (!_d3alpha0_dTau3) _d3alpha0_dTau3 = calc_d3alpha0_dTau3();
        return _d3alpha0_dTau3;
    };
    CoolPropDbl d3alpha0_dDelta_dTau2() {
        if (!_d3alpha0_dDelta_dTau2) _d3alpha0_dDelta_dTau2 = calc_d3alpha0_dDelta_dTau2();
        return _d3alpha0_dDelta_dTau2;
    };
    CoolPropDbl d3alpha0_dDelta2_dTau() {
        if (!_d3alpha0_dDelta2_dTau) _d3alpha0_dDelta2_dTau = calc_d3alpha0_dDelta2_dTau();
        return _d3alpha0_dDelta2_dTau;
    };
    CoolPropDbl d3alpha0_dDelta3() {
        if (!_d3alpha0_dDelta3) _d3alpha0_dDelta3 = calc_d3alpha0_dDelta3();
        return _d3alpha0_dDelta3;
    };
 
    CoolPropDbl alphar() {
        if (!_alphar) _alphar = calc_alphar();
        return _alphar;
    };
    CoolPropDbl dalphar_dDelta() {
        if (!_dalphar_dDelta) _dalphar_dDelta = calc_dalphar_dDelta();
        return _dalphar_dDelta;
    };
    CoolPropDbl dalphar_dTau() {
        if (!_dalphar_dTau) _dalphar_dTau = calc_dalphar_dTau();
        return _dalphar_dTau;
    };
    CoolPropDbl d2alphar_dDelta2() {
        if (!_d2alphar_dDelta2) _d2alphar_dDelta2 = calc_d2alphar_dDelta2();
        return _d2alphar_dDelta2;
    };
    CoolPropDbl d2alphar_dDelta_dTau() {
        if (!_d2alphar_dDelta_dTau) _d2alphar_dDelta_dTau = calc_d2alphar_dDelta_dTau();
        return _d2alphar_dDelta_dTau;
    };
    CoolPropDbl d2alphar_dTau2() {
        if (!_d2alphar_dTau2) _d2alphar_dTau2 = calc_d2alphar_dTau2();
        return _d2alphar_dTau2;
    };
    CoolPropDbl d3alphar_dDelta3() {
        if (!_d3alphar_dDelta3) _d3alphar_dDelta3 = calc_d3alphar_dDelta3();
        return _d3alphar_dDelta3;
    };
    CoolPropDbl d3alphar_dDelta2_dTau() {
        if (!_d3alphar_dDelta2_dTau) _d3alphar_dDelta2_dTau = calc_d3alphar_dDelta2_dTau();
        return _d3alphar_dDelta2_dTau;
    };
    CoolPropDbl d3alphar_dDelta_dTau2() {
        if (!_d3alphar_dDelta_dTau2) _d3alphar_dDelta_dTau2 = calc_d3alphar_dDelta_dTau2();
        return _d3alphar_dDelta_dTau2;
    };
    CoolPropDbl d3alphar_dTau3() {
        if (!_d3alphar_dTau3) _d3alphar_dTau3 = calc_d3alphar_dTau3();
        return _d3alphar_dTau3;
    };
    CoolPropDbl d4alphar_dDelta4() {
        if (!_d4alphar_dDelta4) _d4alphar_dDelta4 = calc_d4alphar_dDelta4();
        return _d4alphar_dDelta4;
    };
    CoolPropDbl d4alphar_dDelta3_dTau() {
        if (!_d4alphar_dDelta3_dTau) _d4alphar_dDelta3_dTau = calc_d4alphar_dDelta3_dTau();
        return _d4alphar_dDelta3_dTau;
    };
    CoolPropDbl d4alphar_dDelta2_dTau2() {
        if (!_d4alphar_dDelta2_dTau2) _d4alphar_dDelta2_dTau2 = calc_d4alphar_dDelta2_dTau2();
        return _d4alphar_dDelta2_dTau2;
    };
    CoolPropDbl d4alphar_dDelta_dTau3() {
        if (!_d4alphar_dDelta_dTau3) _d4alphar_dDelta_dTau3 = calc_d4alphar_dDelta_dTau3();
        return _d4alphar_dDelta_dTau3;
    };
    CoolPropDbl d4alphar_dTau4() {
        if (!_d4alphar_dTau4) _d4alphar_dTau4 = calc_d4alphar_dTau4();
        return _d4alphar_dTau4;
    };
};
 
class AbstractStateGenerator
{
   public:
    virtual AbstractState* get_AbstractState(const std::vector<std::string>& fluid_names) = 0;
 
    virtual AbstractState* get_AbstractState(const std::vector<std::string>& fluid_names, const std::string& options_json);
 
    virtual ~AbstractStateGenerator() = default;
};
 
void register_backend(const backend_families& bf, const shared_ptr<AbstractStateGenerator>& gen);
 
template <class T>
class GeneratorInitializer
{
   public:
    GeneratorInitializer(backend_families bf) {
        register_backend(bf, std::make_shared<T>());
    };
};
 
} /* namespace CoolProp */
#endif /* ABSTRACTSTATE_H_ */