AbstractState.h

/*
 * AbstractState.h
 *
 *  Created on: 21 Dec 2013
 *      Author: jowr
 */

#ifndef ABSTRACTSTATE_H_
#define ABSTRACTSTATE_H_

#include "CachedElement.h"
#include "Exceptions.h"
#include "DataStructures.h"
#include "PhaseEnvelope.h"
#include "crossplatform_shared_ptr.h"

#include <numeric>

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(void) {
        return (this->_phase == iphase_supercritical || this->_phase == iphase_supercritical_liquid || this->_phase == iphase_supercritical_gas);
    }

    bool isHomogeneousPhase(void) {
        return (this->_phase == iphase_liquid || this->_phase == iphase_gas || isSupercriticalPhase() || this->_phase == iphase_critical_point);
    }

    bool isTwoPhase(void) {
        return (this->_phase == iphase_twophase);
    }

    SimpleState _critical, _reducing;

    CachedElement _molar_mass;

    CachedElement _gas_constant;

    double _rhomolar, _T, _p, _Q, _R;

    CachedElement _tau, _delta;

    CachedElement _viscosity, _conductivity, _surface_tension;

    CachedElement _hmolar, _smolar, _umolar, _logp, _logrhomolar, _cpmolar, _cp0molar, _cvmolar, _speed_sound, _gibbsmolar, _helmholtzmolar;

    CachedElement _hmolar_residual, _smolar_residual, _gibbsmolar_residual;

    CachedElement _hmolar_excess, _smolar_excess, _gibbsmolar_excess, _umolar_excess, _volumemolar_excess, _helmholtzmolar_excess;

    CachedElement _rhoLanc, _rhoVanc, _pLanc, _pVanc, _TLanc, _TVanc;

    CachedElement _fugacity_coefficient;

    CachedElement _rho_spline, _drho_spline_dh__constp, _drho_spline_dp__consth;

    CachedElement _alpha0, _dalpha0_dTau, _dalpha0_dDelta, _d2alpha0_dTau2, _d2alpha0_dDelta_dTau, _d2alpha0_dDelta2, _d3alpha0_dTau3,
      _d3alpha0_dDelta_dTau2, _d3alpha0_dDelta2_dTau, _d3alpha0_dDelta3, _alphar, _dalphar_dTau, _dalphar_dDelta, _d2alphar_dTau2,
      _d2alphar_dDelta_dTau, _d2alphar_dDelta2, _d3alphar_dTau3, _d3alphar_dDelta_dTau2, _d3alphar_dDelta2_dTau, _d3alphar_dDelta3, _d4alphar_dTau4,
      _d4alphar_dDelta_dTau3, _d4alphar_dDelta2_dTau2, _d4alphar_dDelta3_dTau, _d4alphar_dDelta4;

    CachedElement _dalphar_dDelta_lim, _d2alphar_dDelta2_lim, _d2alphar_dDelta_dTau_lim, _d3alphar_dDelta2_dTau_lim;

    CachedElement _rhoLmolar, _rhoVmolar;

    // ----------------------------------------
    // Property accessors to be optionally implemented by the backend
    // for properties that are not always calculated
    // ----------------------------------------
    virtual CoolPropDbl calc_hmolar(void) {
        throw NotImplementedError("calc_hmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_hmolar_residual(void) {
        throw NotImplementedError("calc_hmolar_residual is not implemented for this backend");
    };
    virtual CoolPropDbl calc_smolar(void) {
        throw NotImplementedError("calc_smolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_smolar_residual(void) {
        throw NotImplementedError("calc_smolar_residual is not implemented for this backend");
    };
    virtual CoolPropDbl calc_umolar(void) {
        throw NotImplementedError("calc_umolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_cpmolar(void) {
        throw NotImplementedError("calc_cpmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_cpmolar_idealgas(void) {
        throw NotImplementedError("calc_cpmolar_idealgas is not implemented for this backend");
    };
    virtual CoolPropDbl calc_cvmolar(void) {
        throw NotImplementedError("calc_cvmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_gibbsmolar(void) {
        throw NotImplementedError("calc_gibbsmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_gibbsmolar_residual(void) {
        throw NotImplementedError("calc_gibbsmolar_residual is not implemented for this backend");
    };
    virtual CoolPropDbl calc_helmholtzmolar(void) {
        throw NotImplementedError("calc_helmholtzmolar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_speed_sound(void) {
        throw NotImplementedError("calc_speed_sound is not implemented for this backend");
    };
    virtual CoolPropDbl calc_isothermal_compressibility(void) {
        throw NotImplementedError("calc_isothermal_compressibility is not implemented for this backend");
    };
    virtual CoolPropDbl calc_isobaric_expansion_coefficient(void) {
        throw NotImplementedError("calc_isobaric_expansion_coefficient is not implemented for this backend");
    };
    virtual CoolPropDbl calc_isentropic_expansion_coefficient(void) {
        throw NotImplementedError("calc_isentropic_expansion_coefficient is not implemented for this backend");
    };
    virtual CoolPropDbl calc_viscosity(void) {
        throw NotImplementedError("calc_viscosity is not implemented for this backend");
    };
    virtual CoolPropDbl calc_conductivity(void) {
        throw NotImplementedError("calc_conductivity is not implemented for this backend");
    };
    virtual CoolPropDbl calc_surface_tension(void) {
        throw NotImplementedError("calc_surface_tension is not implemented for this backend");
    };
    virtual CoolPropDbl calc_molar_mass(void) {
        throw NotImplementedError("calc_molar_mass is not implemented for this backend");
    };
    virtual CoolPropDbl calc_acentric_factor(void) {
        throw NotImplementedError("calc_acentric_factor is not implemented for this backend");
    };
    virtual CoolPropDbl calc_pressure(void) {
        throw NotImplementedError("calc_pressure is not implemented for this backend");
    };
    virtual CoolPropDbl calc_gas_constant(void) {
        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(void) {
        throw NotImplementedError("calc_PIP is not implemented for this backend");
    };

    // Excess properties
    virtual void calc_excess_properties(void) {
        throw NotImplementedError("calc_excess_properties is not implemented for this backend");
    };

    // Derivatives of residual helmholtz energy
    virtual CoolPropDbl calc_alphar(void) {
        throw NotImplementedError("calc_alphar is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dalphar_dDelta(void) {
        throw NotImplementedError("calc_dalphar_dDelta is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dalphar_dTau(void) {
        throw NotImplementedError("calc_dalphar_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alphar_dDelta2(void) {
        throw NotImplementedError("calc_d2alphar_dDelta2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alphar_dDelta_dTau(void) {
        throw NotImplementedError("calc_d2alphar_dDelta_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alphar_dTau2(void) {
        throw NotImplementedError("calc_d2alphar_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alphar_dDelta3(void) {
        throw NotImplementedError("calc_d3alphar_dDelta3 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alphar_dDelta2_dTau(void) {
        throw NotImplementedError("calc_d3alphar_dDelta2_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alphar_dDelta_dTau2(void) {
        throw NotImplementedError("calc_d3alphar_dDelta_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alphar_dTau3(void) {
        throw NotImplementedError("calc_d3alphar_dTau3 is not implemented for this backend");
    };

    virtual CoolPropDbl calc_d4alphar_dDelta4(void) {
        throw NotImplementedError("calc_d4alphar_dDelta4 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d4alphar_dDelta3_dTau(void) {
        throw NotImplementedError("calc_d4alphar_dDelta3_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d4alphar_dDelta2_dTau2(void) {
        throw NotImplementedError("calc_d4alphar_dDelta2_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d4alphar_dDelta_dTau3(void) {
        throw NotImplementedError("calc_d4alphar_dDelta_dTau3 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d4alphar_dTau4(void) {
        throw NotImplementedError("calc_d4alphar_dTau4 is not implemented for this backend");
    };

    // Derivatives of ideal-gas helmholtz energy
    virtual CoolPropDbl calc_alpha0(void) {
        throw NotImplementedError("calc_alpha0 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dalpha0_dDelta(void) {
        throw NotImplementedError("calc_dalpha0_dDelta is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dalpha0_dTau(void) {
        throw NotImplementedError("calc_dalpha0_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alpha0_dDelta_dTau(void) {
        throw NotImplementedError("calc_d2alpha0_dDelta_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alpha0_dDelta2(void) {
        throw NotImplementedError("calc_d2alpha0_dDelta2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d2alpha0_dTau2(void) {
        throw NotImplementedError("calc_d2alpha0_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alpha0_dDelta3(void) {
        throw NotImplementedError("calc_d3alpha0_dDelta3 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alpha0_dDelta2_dTau(void) {
        throw NotImplementedError("calc_d3alpha0_dDelta2_dTau is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alpha0_dDelta_dTau2(void) {
        throw NotImplementedError("calc_d3alpha0_dDelta_dTau2 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_d3alpha0_dTau3(void) {
        throw NotImplementedError("calc_d3alpha0_dTau3 is not implemented for this backend");
    };

    virtual void calc_reducing_state(void) {
        throw NotImplementedError("calc_reducing_state is not implemented for this backend");
    };

    virtual CoolPropDbl calc_Tmax(void) {
        throw NotImplementedError("calc_Tmax is not implemented for this backend");
    };
    virtual CoolPropDbl calc_Tmin(void) {
        throw NotImplementedError("calc_Tmin is not implemented for this backend");
    };
    virtual CoolPropDbl calc_pmax(void) {
        throw NotImplementedError("calc_pmax is not implemented for this backend");
    };

    virtual CoolPropDbl calc_GWP20(void) {
        throw NotImplementedError("calc_GWP20 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_GWP100(void) {
        throw NotImplementedError("calc_GWP100 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_GWP500(void) {
        throw NotImplementedError("calc_GWP500 is not implemented for this backend");
    };
    virtual CoolPropDbl calc_ODP(void) {
        throw NotImplementedError("calc_ODP is not implemented for this backend");
    };
    virtual CoolPropDbl calc_flame_hazard(void) {
        throw NotImplementedError("calc_flame_hazard is not implemented for this backend");
    };
    virtual CoolPropDbl calc_health_hazard(void) {
        throw NotImplementedError("calc_health_hazard is not implemented for this backend");
    };
    virtual CoolPropDbl calc_physical_hazard(void) {
        throw NotImplementedError("calc_physical_hazard is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dipole_moment(void) {
        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(void) {
        throw NotImplementedError("calc_reduced_density is not implemented for this backend");
    };
    virtual CoolPropDbl calc_reciprocal_reduced_temperature(void) {
        throw NotImplementedError("calc_reciprocal_reduced_temperature is not implemented for this backend");
    };

    virtual CoolPropDbl calc_Bvirial(void) {
        throw NotImplementedError("calc_Bvirial is not implemented for this backend");
    };
    virtual CoolPropDbl calc_Cvirial(void) {
        throw NotImplementedError("calc_Cvirial is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dBvirial_dT(void) {
        throw NotImplementedError("calc_dBvirial_dT is not implemented for this backend");
    };
    virtual CoolPropDbl calc_dCvirial_dT(void) {
        throw NotImplementedError("calc_dCvirial_dT is not implemented for this backend");
    };
    virtual CoolPropDbl calc_compressibility_factor(void) {
        throw NotImplementedError("calc_compressibility_factor is not implemented for this backend");
    };

    virtual std::string calc_name(void) {
        throw NotImplementedError("calc_name is not implemented for this backend");
    };
    virtual std::string calc_description(void) {
        throw NotImplementedError("calc_description is not implemented for this backend");
    };

    virtual CoolPropDbl calc_Ttriple(void) {
        throw NotImplementedError("calc_Ttriple is not implemented for this backend");
    };
    virtual CoolPropDbl calc_p_triple(void) {
        throw NotImplementedError("calc_p_triple is not implemented for this backend");
    };

    virtual CoolPropDbl calc_T_critical(void) {
        throw NotImplementedError("calc_T_critical is not implemented for this backend");
    };
    virtual CoolPropDbl calc_T_reducing(void) {
        throw NotImplementedError("calc_T_reducing is not implemented for this backend");
    };
    virtual CoolPropDbl calc_p_critical(void) {
        throw NotImplementedError("calc_p_critical is not implemented for this backend");
    };
    virtual CoolPropDbl calc_p_reducing(void) {
        throw NotImplementedError("calc_p_reducing is not implemented for this backend");
    };
    virtual CoolPropDbl calc_rhomolar_critical(void) {
        throw NotImplementedError("calc_rhomolar_critical is not implemented for this backend");
    };
    virtual CoolPropDbl calc_rhomass_critical(void) {
        throw NotImplementedError("calc_rhomass_critical is not implemented for this backend");
    };
    virtual CoolPropDbl calc_rhomolar_reducing(void) {
        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(void) {
        return rhomolar() * molar_mass();
    }
    virtual CoolPropDbl calc_hmass(void) {
        return hmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_hmass_excess(void) {
        return hmolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_smass(void) {
        return smolar() / molar_mass();
    }
    virtual CoolPropDbl calc_smass_excess(void) {
        return smolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_cpmass(void) {
        return cpmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_cp0mass(void) {
        return cp0molar() / molar_mass();
    }
    virtual CoolPropDbl calc_cvmass(void) {
        return cvmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_umass(void) {
        return umolar() / molar_mass();
    }
    virtual CoolPropDbl calc_umass_excess(void) {
        return umolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_gibbsmass(void) {
        return gibbsmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_gibbsmass_excess(void) {
        return gibbsmolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_helmholtzmass(void) {
        return helmholtzmolar() / molar_mass();
    }
    virtual CoolPropDbl calc_helmholtzmass_excess(void) {
        return helmholtzmolar_excess() / molar_mass();
    }
    virtual CoolPropDbl calc_volumemass_excess(void) {
        return volumemolar_excess() / molar_mass();
    }

    virtual void update_states(void) {
        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(void) {
        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(void) {
        throw NotImplementedError("This backend does not implement calc_unspecify_phase function");
    };
    virtual std::vector<std::string> calc_fluid_names(void) {
        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(void) {
        throw NotImplementedError("calc_phase_envelope_data is not implemented for this backend");
    };

    virtual std::vector<CoolPropDbl> calc_mole_fractions_liquid(void) {
        throw NotImplementedError("calc_mole_fractions_liquid is not implemented for this backend");
    };
    virtual std::vector<CoolPropDbl> calc_mole_fractions_vapor(void) {
        throw NotImplementedError("calc_mole_fractions_vapor is not implemented for this backend");
    };
    virtual const std::vector<CoolPropDbl> calc_mass_fractions(void) {
        throw NotImplementedError("calc_mass_fractions is not implemented for this backend");
    };

    virtual CoolPropDbl calc_fraction_min(void) {
        throw NotImplementedError("calc_fraction_min is not implemented for this backend");
    };
    virtual CoolPropDbl calc_fraction_max(void) {
        throw NotImplementedError("calc_fraction_max is not implemented for this backend");
    };
    virtual CoolPropDbl calc_T_freeze(void) {
        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(void) {
        return _T;
    }
    virtual CoolPropDbl calc_rhomolar(void) {
        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(void) {
        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) {
        clear();
    }
    virtual ~AbstractState(){};


    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(void) = 0;

    // The derived classes must implement this function to define whether they use mole fractions (true) or mass fractions (false)
    virtual bool using_mole_fractions(void) = 0;
    virtual bool using_mass_fractions(void) = 0;
    virtual bool using_volu_fractions(void) = 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

#ifdef EMSCRIPTEN
    void set_mole_fractions_double(const std::vector<double>& mole_fractions) {
        set_mole_fractions(std::vector<CoolPropDbl>(mole_fractions.begin(), mole_fractions.end()));
    };
#endif

    std::vector<CoolPropDbl> mole_fractions_liquid(void) {
        return calc_mole_fractions_liquid();
    };
    std::vector<double> mole_fractions_liquid_double(void) {
        std::vector<CoolPropDbl> x = calc_mole_fractions_liquid();
        return std::vector<double>(x.begin(), x.end());
    };

    std::vector<CoolPropDbl> mole_fractions_vapor(void) {
        return calc_mole_fractions_vapor();
    };
    std::vector<double> mole_fractions_vapor_double(void) {
        std::vector<CoolPropDbl> y = calc_mole_fractions_vapor();
        return std::vector<double>(y.begin(), y.end());
    };

    virtual const std::vector<CoolPropDbl>& get_mole_fractions(void) = 0;
    virtual const std::vector<CoolPropDbl> get_mass_fractions(void) {
        return this->calc_mass_fractions();
    };

    virtual void update(CoolProp::input_pairs input_pair, double Value1, double Value2) = 0;

    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 bool available_in_high_level(void) {
        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(void);

    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(void);
    double Tmax(void);
    double pmax(void);
    double Ttriple(void);

    phases phase(void) {
        return calc_phase();
    };
    void specify_phase(phases phase) {
        calc_specify_phase(phase);
    };
    void unspecify_phase(void) {
        calc_unspecify_phase();
    };

    double T_critical(void);
    double p_critical(void);
    double rhomolar_critical(void);
    double rhomass_critical(void);

    std::vector<CriticalState> all_critical_points(void) {
        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(void);
    double rhomolar_reducing(void);
    double rhomass_reducing(void);

    double p_triple(void);

    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(void) {
        return calc_T();
    };
    double rhomolar(void) {
        return calc_rhomolar();
    };
    double rhomass(void) {
        return calc_rhomass();
    };
    double p(void) {
        return _p;
    };
    double Q(void) {
        return _Q;
    };
    double tau(void);
    double delta(void);
    double molar_mass(void);
    double acentric_factor(void);
    double gas_constant(void);
    double Bvirial(void);
    double dBvirial_dT(void);
    double Cvirial(void);
    double dCvirial_dT(void);
    double compressibility_factor(void);
    double hmolar(void);
    double hmolar_residual(void);
    double hmass(void) {
        return calc_hmass();
    };
    double hmolar_excess(void);
    double hmass_excess(void) {
        return calc_hmass_excess();
    };
    double smolar(void);
    double smolar_residual(void);
    double smass(void) {
        return calc_smass();
    };
    double smolar_excess(void);
    double smass_excess(void) {
        return calc_smass_excess();
    };
    double umolar(void);
    double umass(void) {
        return calc_umass();
    };
    double umolar_excess(void);
    double umass_excess(void) {
        return calc_umass_excess();
    };
    double cpmolar(void);
    double cpmass(void) {
        return calc_cpmass();
    };
    double cp0molar(void);
    double cp0mass(void) {
        return calc_cp0mass();
    };
    double cvmolar(void);
    double cvmass(void) {
        return calc_cvmass();
    };
    double gibbsmolar(void);
    double gibbsmolar_residual(void);
    double gibbsmass(void) {
        return calc_gibbsmass();
    };
    double gibbsmolar_excess(void);
    double gibbsmass_excess(void) {
        return calc_gibbsmass_excess();
    };
    double helmholtzmolar(void);
    double helmholtzmass(void) {
        return calc_helmholtzmass();
    };
    double helmholtzmolar_excess(void);
    double helmholtzmass_excess(void) {
        return calc_helmholtzmass_excess();
    };
    double volumemolar_excess(void);
    double volumemass_excess(void) {
        return calc_volumemass_excess();
    };
    double speed_sound(void);
    double isothermal_compressibility(void);
    double isobaric_expansion_coefficient(void);
    double isentropic_expansion_coefficient(void);
    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(void);
    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(void) {
        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);
    void viscosity_contributions(CoolPropDbl& dilute, CoolPropDbl& initial_density, CoolPropDbl& residual, CoolPropDbl& critical) {
        calc_viscosity_contributions(dilute, initial_density, residual, critical);
    };
    double conductivity(void);
    void conductivity_contributions(CoolPropDbl& dilute, CoolPropDbl& initial_density, CoolPropDbl& residual, CoolPropDbl& critical) {
        calc_conductivity_contributions(dilute, initial_density, residual, critical);
    };
    double surface_tension(void);
    double Prandtl(void) {
        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(void) {
        if (!_alpha0) _alpha0 = calc_alpha0();
        return _alpha0;
    };
    CoolPropDbl dalpha0_dDelta(void) {
        if (!_dalpha0_dDelta) _dalpha0_dDelta = calc_dalpha0_dDelta();
        return _dalpha0_dDelta;
    };
    CoolPropDbl dalpha0_dTau(void) {
        if (!_dalpha0_dTau) _dalpha0_dTau = calc_dalpha0_dTau();
        return _dalpha0_dTau;
    };
    CoolPropDbl d2alpha0_dDelta2(void) {
        if (!_d2alpha0_dDelta2) _d2alpha0_dDelta2 = calc_d2alpha0_dDelta2();
        return _d2alpha0_dDelta2;
    };
    CoolPropDbl d2alpha0_dDelta_dTau(void) {
        if (!_d2alpha0_dDelta_dTau) _d2alpha0_dDelta_dTau = calc_d2alpha0_dDelta_dTau();
        return _d2alpha0_dDelta_dTau;
    };
    CoolPropDbl d2alpha0_dTau2(void) {
        if (!_d2alpha0_dTau2) _d2alpha0_dTau2 = calc_d2alpha0_dTau2();
        return _d2alpha0_dTau2;
    };
    CoolPropDbl d3alpha0_dTau3(void) {
        if (!_d3alpha0_dTau3) _d3alpha0_dTau3 = calc_d3alpha0_dTau3();
        return _d3alpha0_dTau3;
    };
    CoolPropDbl d3alpha0_dDelta_dTau2(void) {
        if (!_d3alpha0_dDelta_dTau2) _d3alpha0_dDelta_dTau2 = calc_d3alpha0_dDelta_dTau2();
        return _d3alpha0_dDelta_dTau2;
    };
    CoolPropDbl d3alpha0_dDelta2_dTau(void) {
        if (!_d3alpha0_dDelta2_dTau) _d3alpha0_dDelta2_dTau = calc_d3alpha0_dDelta2_dTau();
        return _d3alpha0_dDelta2_dTau;
    };
    CoolPropDbl d3alpha0_dDelta3(void) {
        if (!_d3alpha0_dDelta3) _d3alpha0_dDelta3 = calc_d3alpha0_dDelta3();
        return _d3alpha0_dDelta3;
    };

    CoolPropDbl alphar(void) {
        if (!_alphar) _alphar = calc_alphar();
        return _alphar;
    };
    CoolPropDbl dalphar_dDelta(void) {
        if (!_dalphar_dDelta) _dalphar_dDelta = calc_dalphar_dDelta();
        return _dalphar_dDelta;
    };
    CoolPropDbl dalphar_dTau(void) {
        if (!_dalphar_dTau) _dalphar_dTau = calc_dalphar_dTau();
        return _dalphar_dTau;
    };
    CoolPropDbl d2alphar_dDelta2(void) {
        if (!_d2alphar_dDelta2) _d2alphar_dDelta2 = calc_d2alphar_dDelta2();
        return _d2alphar_dDelta2;
    };
    CoolPropDbl d2alphar_dDelta_dTau(void) {
        if (!_d2alphar_dDelta_dTau) _d2alphar_dDelta_dTau = calc_d2alphar_dDelta_dTau();
        return _d2alphar_dDelta_dTau;
    };
    CoolPropDbl d2alphar_dTau2(void) {
        if (!_d2alphar_dTau2) _d2alphar_dTau2 = calc_d2alphar_dTau2();
        return _d2alphar_dTau2;
    };
    CoolPropDbl d3alphar_dDelta3(void) {
        if (!_d3alphar_dDelta3) _d3alphar_dDelta3 = calc_d3alphar_dDelta3();
        return _d3alphar_dDelta3;
    };
    CoolPropDbl d3alphar_dDelta2_dTau(void) {
        if (!_d3alphar_dDelta2_dTau) _d3alphar_dDelta2_dTau = calc_d3alphar_dDelta2_dTau();
        return _d3alphar_dDelta2_dTau;
    };
    CoolPropDbl d3alphar_dDelta_dTau2(void) {
        if (!_d3alphar_dDelta_dTau2) _d3alphar_dDelta_dTau2 = calc_d3alphar_dDelta_dTau2();
        return _d3alphar_dDelta_dTau2;
    };
    CoolPropDbl d3alphar_dTau3(void) {
        if (!_d3alphar_dTau3) _d3alphar_dTau3 = calc_d3alphar_dTau3();
        return _d3alphar_dTau3;
    };
    CoolPropDbl d4alphar_dDelta4(void) {
        if (!_d4alphar_dDelta4) _d4alphar_dDelta4 = calc_d4alphar_dDelta4();
        return _d4alphar_dDelta4;
    };
    CoolPropDbl d4alphar_dDelta3_dTau(void) {
        if (!_d4alphar_dDelta3_dTau) _d4alphar_dDelta3_dTau = calc_d4alphar_dDelta3_dTau();
        return _d4alphar_dDelta3_dTau;
    };
    CoolPropDbl d4alphar_dDelta2_dTau2(void) {
        if (!_d4alphar_dDelta2_dTau2) _d4alphar_dDelta2_dTau2 = calc_d4alphar_dDelta2_dTau2();
        return _d4alphar_dDelta2_dTau2;
    };
    CoolPropDbl d4alphar_dDelta_dTau3(void) {
        if (!_d4alphar_dDelta_dTau3) _d4alphar_dDelta_dTau3 = calc_d4alphar_dDelta_dTau3();
        return _d4alphar_dDelta_dTau3;
    };
    CoolPropDbl d4alphar_dTau4(void) {
        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 ~AbstractStateGenerator(){};
};

void register_backend(const backend_families& bf, shared_ptr<AbstractStateGenerator> gen);

template <class T>
class GeneratorInitializer
{
   public:
    GeneratorInitializer(backend_families bf) {
        register_backend(bf, shared_ptr<AbstractStateGenerator>(new T()));
    };
};

} /* namespace CoolProp */
#endif /* ABSTRACTSTATE_H_ */