thermofluids 2.0.0__py3-none-any.whl

thermofluids/Base/Statepoint.py

@@ -0,0 +1,1191 @@
+"""
+Written by Luke Erickson for Rebound Technology Jan 27 2015
+"""
+
+from .Quantity import Quantity
+from .ThermoExceptions import StatepointError
+from CoolProp.CoolProp import PropsSI, HAPropsSI
+import warnings
+import numpy as np
+from scipy.optimize import curve_fit
+
+
+class Statepoint():
+    """
+    A statepoint instance represents a thermofluid statepoint. It fully characterizes a fluid at a point.
+    Specify and two independent intensive properties and the rest will be automatically calculated.
+    Some extensive properties are also logged, such as mass flow rate.
+    This class uses CoolProp for the backend property lookups.
+
+    Do not change the properties of a statepoint once it has been fully defined- create a new instance instead.
+
+    :param name: Name of the statepoint for your own reference. Any string
+    :param fluid: Any CoolProp fluid. Can be a simple option like "water" or "R404A", an incompressible fluid like "INCOMP::MMA", or a Refprop fluid, if you have access to that library, like "REFPROP-MIX:METHANOL&WATER"
+    :param t: Temperature in Celcius
+    :param p: Pressure in bar
+    :param x: Quality in fraction 0-1. All liquid is 0, all vapor is 1.
+    :param h: Enthalpy in kJ/kg. Reference points are those from CoolProp/Refprop
+    :param s: Entropy kJ/kg-C
+    :param c: Concentration (used for INCOMP and REFPROP-MIX mixtures) kg/kg
+    :param m: Mass flow rate kg/s
+    :param twb: Wet bulb temperature C
+    :param tdp: Dew point temperature C
+    :param rh: Relative humidity -
+    :param omega: Humidity ratio kg water/kg dry air
+    :param source: Another statepoint instance to import properties from
+    :param source_vars: A tuple of strings of the properties you'd like to import from source
+
+    All the inputs are also available as attributes. Additional dependent attributes include:
+        * cp: heat capacity at constant pressure kJ/kg-C
+        * cv: heat capacity at constant volume kJ/kg-C
+        * rho: density kg/m^3
+        * u: internal energy kJ/kg
+        * gamma: heat capacity ratio
+        * k: thermal conductivity kW/m-C
+        * tlsat: saturation temperature of liquid aka bubble point C (Refprop only)
+        * tvsat: saturation temperature of vapor aka dew point C (Refprop only)
+        * cvap: equilibrium concentration of vapor for a liquid kg/kg (Refprop only)
+        * ss: speed of sound m/s
+        * visc: Dynamic viscosity (mu) kg/m-s^2
+        * pr: Prandtl number -
+        * sigma: surface tension N/m
+        * beta: coefficient of thermal expansion C^-1
+        * t_freeze: freezing temperature C
+
+    Statepoints can be added or divided (see methods below).
+
+    Examples:
+        * ``sp = Statepoint(fluid='water', t=25., p=1.)     # water at room conditions``
+        * ``sp = Statepoint(fluid='INCOMP::MMA', t=-20., p=20., c=0.25, m=0.2)  # flow of methanol and water``
+        * ``sp = Statepoint(fluid='REFPROP-MIX:METHANOL&WATER', x=0.8, p=0.25, c=0.95, m=1.5)``
+        * ``sp = Statepoint(source=sp, source_vars=('fluid', 'm', 't'), x=0)    # import everything but quality from another statepoint``
+
+    Warnings:
+        You can set `Statepoint.allow_warnings = False` to suppress warnings
+    """
+    out_of_bounds_flag = False
+    allow_warnings = True
+
+    def __init__(self, name=None, fluid=None, t=None, p=None, x=None, h=None, s=None, c=None, m=None,
+                 twb=None, tdp=None, rh=None, omega=None, source=None, source_vars=()):
+        # type: (object, object) -> object
+        self.name = name
+        self.IVs = {}
+        self.IVs_formatted = False
+        self.fluid = fluid
+        self.coolprop_fluid = None
+
+        self.sink = []
+        self.source = []
+
+        self.nameisset = False
+
+        self.prints = ()
+
+        if t is not None:
+            self.set_t(t)
+        if p is not None:
+            self.set_p(p)
+        if x is not None:
+            self.set_x(x)
+        if h is not None:
+            self.set_h(h)
+        if s is not None:
+            self.set_s(s)
+        if c is not None:
+            if c < 0.000001:
+                self.set_c(0.000001)
+            else:
+                self.set_c(c)
+        if m is not None:
+            self.set_m(m)
+        if twb is not None:
+            self.set_twb(twb)
+        if tdp is not None:
+            self.set_tdp(tdp)
+        if rh is not None:
+            self.set_rh(rh)
+        if omega is not None:
+            self.set_omega(omega)
+        if source is not None:
+            self.set_source(source, source_vars)
+
+    def __add__(self, other):
+        """
+        Adding two statepoints mixes them isenthalpically, conserving mass and energy. It assumes the higher pressure fluid is expanded to the lower pressure
+        The function returns another statepoint instance with fluid, mass, enthalpy, and pressure (and optionally concentration) set
+        """
+        if other.__class__ is not Statepoint:
+            print((other.__class__))
+            raise TypeError('Can\'t add a Statepoint to anything other than a Statepoint')
+
+        #if other.fluid is not self.fluid:   #This statement causes problems because the fluid name changes based on concentration and must be updated to remove that text before comparing
+            #raise StatepointError('Can\'t add statepoints of different fluids')
+
+        new = Statepoint(name=None)
+        new.set_fluid(self.fluid)
+        new.set_m(self.m + other.m)
+        new.set_h((self.m * self.h + other.m * other.h) / (self.m + other.m))
+        new.set_p(min(self.p, other.p))
+        if hasattr(self, 'c'):
+            new.set_c((self.c*self.m + other.c*other.m)/new.m)
+
+        return new
+
+    def __div__(self, other):
+        """
+        Diving a statepoint by an integer divides the mass flow rate by the integer leaving all other properties equal
+        :param other: an integer
+        :return: new statepoint
+        """
+        try:
+            return Statepoint(name=self.name, fluid=self.fluid, p=self.p, h=self.h, c=self.c, m=self.m/other)
+        except AttributeError:
+            return Statepoint(name=self.name, fluid=self.fluid, p=self.p, h=self.h, m=self.m/other)
+
+    def __truediv__(self, other):
+        """
+        Diving a statepoint by an integer divides the mass flow rate by the integer leaving all other properties equal
+        :param other: an integer
+        :return: new statepoint
+        """
+        try:
+            return Statepoint(name=self.name, fluid=self.fluid, p=self.p, h=self.h, c=self.c, m=self.m/other)
+        except AttributeError:
+            return Statepoint(name=self.name, fluid=self.fluid, p=self.p, h=self.h, m=self.m/other)
+
+    def _repr_default(self):
+        """Lists several useful properties of the statepoint"""
+        repr = ''
+        try:
+            repr += self.fluid + '\t'
+        except AttributeError:
+            pass
+
+        try:
+            repr += str(self.m) + '\t'
+        except AttributeError:
+            pass
+
+        try:
+            repr += str(self.t) + '\t'
+        except AttributeError:
+            pass
+
+        try:
+            repr += f'{self.c*100.: .1f}%' + '\t'
+        except AttributeError:
+            pass
+
+        try:
+            repr += str(self.p) + '\t'
+        except AttributeError:
+            pass
+
+        return repr
+
+    def print_options(self, tuple_of_prints=()):
+        self.prints = tuple_of_prints
+
+    def __repr__(self):
+        """Statepoint_name\tfluid_name\tmdot\ttemp\tconc\tenthalpy"""
+        if len(self.prints) == 0:
+            return self._repr_default()
+        else:
+            repr = ""
+            for var in self.prints:
+                repr = repr+'\t'+str(getattr(self, var))
+            return repr
+
+    def warn_out_of_bounds(self):
+        if Statepoint.allow_warnings:
+            if not Statepoint.out_of_bounds_flag:
+                Statepoint.out_of_bounds_flag = True
+                warnings.warn('Using extrapolated property data. Accuracy may be diminished.')
+
+    def set_fluid(self, fluid):
+        self.fluid = fluid
+
+    def set_t(self, val, unit='degC'):
+        if hasattr(self, '_t'):
+            self.update_prop(prop_val=val, prop_name='t')
+        else:
+            if val.__class__ == Quantity:
+                self._t = val
+            else:
+                self._t = Quantity(val, unit)
+            self.IVs['T'] = self._t
+
+    def set_h(self, val, unit='kJ*kg^-1'):
+        if hasattr(self, '_h'):
+            self.update_prop(prop_val=val, prop_name='h')
+        else:
+            if val.__class__ == Quantity:
+                self._h = val
+            else:
+                self._h = Quantity(val, unit)
+            self.IVs['H'] = self._h
+
+    def set_s(self, val, unit='degC^-1*kJ*kg^-1'):
+        if hasattr(self, '_s'):
+            self.update_prop(prop_val=val, prop_name='s')
+        else:
+            if val.__class__ == Quantity:
+                self._s = val
+            else:
+                self._s = Quantity(val, unit)
+            self.IVs['S'] = self._s
+
+    def set_p(self, val, unit='bar'):
+        if hasattr(self, '_p'):
+            self.update_prop(prop_val=val, prop_name='p')
+        else:
+            if val.__class__ == Quantity:
+                self._p = val
+            else:
+                self._p = Quantity(val, unit)
+            self.IVs['P'] = self._p
+
+    def set_x(self, val, unit=''):
+        if hasattr(self, '_x'):
+            self.update_prop(prop_val=val, prop_name='x')
+        else:
+            if val.__class__ == Quantity:
+                self._x = val
+            else:
+                self._x = Quantity(val, unit)
+            self.IVs['Q'] = self._x
+
+    def set_c(self, val, unit=''):
+        if val < 0.000001:
+            val = 0.000001
+        if val.__class__ == Quantity:
+            self.c = val.to('').magnitude
+        else:
+            # self.c = Quantity(val, unit)
+            self.c = val
+
+    def set_m(self, val, unit='kg*s^-1'):
+        if val.__class__ == Quantity:
+            self.m = val
+        else:
+            self.m = Quantity(val, unit)
+
+    def set_twb(self, val, unit='degC'):
+        if hasattr(self, '_twb'):
+            self.update_prop(prop_val=val, prop_name='twb')
+        else:
+            if val.__class__ == Quantity:
+                self._twb = val
+            else:
+                self._twb = Quantity(val, unit)
+            self.IVs['Twb'] = self._twb
+
+    def set_tdp(self, val, unit='degC'):
+        if hasattr(self, '_tdp'):
+            self.update_prop(prop_val=val, prop_name='tdp')
+        else:
+            if val.__class__ == Quantity:
+                self._tdp = val
+            else:
+                self._tdp = Quantity(val, unit)
+            self.IVs['Tdp'] = self._tdp
+
+    def set_rh(self, val, unit=''):
+        if hasattr(self, '_rh'):
+            self.update_prop(prop_val=val, prop_name='rh')
+        else:
+            if val.__class__ == Quantity:
+                self._rh = val
+            else:
+                self._rh = Quantity(val, unit)
+            self.IVs['RH'] = self._rh
+
+    def set_omega(self, val, unit=''):
+        if hasattr(self, '_omega'):
+            self.update_prop(prop_val=val, prop_name='omega')
+        else:
+            if val.__class__ == Quantity:
+                self._omega = val
+            else:
+                self._omega = Quantity(val, unit)
+            self.IVs['Omega'] = self._omega
+
+    def _formatIVs(self):
+        if self.fluid == None:
+            raise StatepointError("Fluid must be set (statepoint.set_fluid(val)) before calling properties")
+        self.cpargs = []
+        for key in self.IVs:
+            self.cpargs.append(key)
+            self.cpargs.append(self.IVs[key].to_base_units().magnitude)
+        if len(self.cpargs) != 4 and self.fluid != 'humid air':
+            raise StatepointError('%s statepoint requires 2 independent properties to be set. Only %s is set'
+                                  % (self.name, list(self.IVs.keys())))
+        if len(self.cpargs) != 6 and self.fluid == 'humid air':
+            raise StatepointError('%s statepoint requires 3 independent properties to be set. Only %s is set'
+                                  % (self.name, list(self.IVs.keys())))
+
+        # if hasattr(self, 'c') and self.fluid[-1] != ']':
+        if hasattr(self, 'c'):
+            if 'REFPROP' in self.fluid:
+                mw1 = PropsSI('M', 'T', 273, 'P', 101325., self.fluid[self.fluid.find('&')+1:self.fluid.__len__()])
+                mw2 = PropsSI('M', 'T', 273, 'P', 101325, self.fluid[self.fluid.find(':')+1:self.fluid.find('&')])
+                if float(self.c) == 0.0:
+                    c_mol = 0.0
+                else:
+                    c_mol = (self.c / mw2) / (self.c / mw2 + (1.-self.c) / mw1)
+                self.coolprop_fluid = self.fluid.replace('&', '[%s]&'%str(c_mol).strip()) + '[%s]'%str(1.0-c_mol).strip()
+                self.nameisset = True
+            else:
+                self.coolprop_fluid = self.fluid + '[%s]' % str(self.c).strip()
+                self.nameisset = True
+        else:
+            self.coolprop_fluid = self.fluid
+            self.nameisset = True
+
+    @property
+    def tmax(self):     # Maximum t for dataset
+        if hasattr(self, '_tmax'):
+            return self._tmax
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if '[' in self.fluid:
+            local_fluid = self.fluid.split('[')[0]
+        else:
+            local_fluid = self.fluid
+        if self.fluid == 'humid air':
+            val = 187.     # not documented, just guess and tested
+        else:
+            val = PropsSI('Tmax', 'T', 298., 'P', 1.e5, local_fluid)-273.15
+        self._tmax = Quantity(val, 'degC')
+        return self._tmax
+
+    @property
+    def tmin(self):     # Minimum t for dataset
+        if hasattr(self, '_tmin'):
+            return self._tmin
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if '[' in self.fluid:
+            local_fluid = self.fluid.split('[')[0]
+        else:
+            local_fluid = self.fluid
+        if self.fluid == 'humid air':
+            val = -223.     # not documented, just guess and tested
+        else:
+            val = PropsSI('Tmin', 'T', 298., 'P', 1.e5, local_fluid)-273.15
+        self._tmin = Quantity(val, 'degC')
+        return self._tmin
+
+    @property
+    def pmax(self):     # Maximum p for dataset
+        if hasattr(self, '_pmax'):
+            return self._pmax
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            val = 1000.     # not documented, just guess and tested
+        else:
+            val = PropsSI('Pmax', 'T', 298., 'P', 1.e5, self.coolprop_fluid) / 1.e5
+        self._pmax = Quantity(val, 'bar')
+        return self._pmax
+
+    @property
+    def pmin(self):     # Minimum p for dataset
+        if hasattr(self, '_pmin'):
+            return self._pmin
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            val = 0.0001     # not documented, just guess and tested
+        else:
+            val = PropsSI('Pmin', 'T', 298., 'P', 1.e5, self.coolprop_fluid) / 1.e5
+        self._pmin = Quantity(val, 'bar')
+        return self._pmin
+
+    @property
+    def cmax(self):     # Maximum c for dataset
+        if hasattr(self, '_cmax'):
+            return self._cmax
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            val = None
+        else:
+            val = PropsSI('fraction_max', 'T', 298., 'P', 1.e5, self.coolprop_fluid)
+        self._cmax = Quantity(val, '')
+        return self._cmax
+
+    @property
+    def cmin(self):     # Minimum c for dataset
+        if hasattr(self, '_cmin'):
+            return self._cmin
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            val = None
+        else:
+            val = PropsSI('fraction_min', 'T', 298., 'P', 1.e5, self.coolprop_fluid)
+        self._cmin = Quantity(val, '')
+        return self._cmin
+
+    @property
+    def t(self):        # Temperature
+        if hasattr(self, '_t'):
+            return self._t
+        if not self.IVs_formatted:
+            self._formatIVs()
+        try:
+            if self.fluid == 'humid air':
+                val = HAPropsSI('T', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) - 273.15
+            else:
+                val = PropsSI('T', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)-273.15
+            self._t = Quantity(val, 'degC')
+            return self._t
+        except ValueError as e:
+            if not hasattr(self, 'c'):  # only use extrapolated data for salt brines
+                raise e
+            elif 'H' in self.cpargs and 'P' in self.cpargs:
+                cp_at_20C_below_max = PropsSI('C', 'T', self.tmax.to('degC').magnitude - 20. + 273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+                cp_at_max = PropsSI('C', 'T', self.tmax.to('degC').magnitude + 273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+                h_at_tmax = PropsSI('H', 'T', self.tmax.to('degC').magnitude + 273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+
+                # solve the extrapolation equations for enthalpy and cp for t
+                val = (40.**0.5 * (10. * cp_at_max**2. + cp_at_max * (self.h.magnitude - h_at_tmax) + cp_at_20C_below_max * (h_at_tmax - self.h.magnitude))**0.5 +
+                        cp_at_max * (self.tmax.magnitude - 20.) - cp_at_20C_below_max * self.tmax.magnitude) / (cp_at_max - cp_at_20C_below_max)
+                self._t = Quantity(val, 'degC')
+                return self._t
+            else:
+                raise ValueError(f'No temperature extrapolation data for incompressible fluids unless using P and H inputs. Got {self.cpargs} instead')
+
+    @property
+    def p(self):        # Pressure
+        if hasattr(self, '_p'):
+            return self._p
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            val = HAPropsSI('P', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) / 100000.
+        else:
+            val = PropsSI('P', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid) / 100000.
+        self._p = Quantity(val, 'bar')
+        return self._p
+
+    @property
+    def h(self):        # Enthalpy
+        if hasattr(self, '_h'):
+            return self._h
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.tmin <= self.t <= self.tmax:
+            if self.fluid == 'humid air':
+                # print(self.cpargs)
+                val = HAPropsSI('Hha', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) / 1000.
+            else:
+                val = PropsSI('H', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid) / 1000.
+            self._h = Quantity(val, 'kJ*kg^-1')
+            return self._h
+        elif hasattr(self, 'c') and self.t > self.tmax:
+            """
+            Integrate extrapolated cp over t. See cp function for more info about extrapolation of cp.
+            Assumes cp extrapolation is linear.
+            """
+            self.warn_out_of_bounds()
+            cp_at_t = self.cp.magnitude
+            cp_at_tmax = PropsSI('C', 'T', self.tmax.to('degC').magnitude+273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+            h_at_tmax = PropsSI('H', 'T', self.tmax.to('degC').magnitude+273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+            val = h_at_tmax + (cp_at_t + cp_at_tmax) * (self.t - self.tmax).magnitude / 2.
+            self._h = Quantity(val, 'kJ*kg^-1')
+            return self._h
+        else:
+            raise ValueError(f'Temperature {self.t} is not within data range {self.tmin}-{self.tmax} and no extrapolation has been created')
+
+    @property
+    def s(self):        # Entropy
+        if hasattr(self, '_s'):
+            return self._s
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.tmin <= self.t <= self.tmax:
+            if self.fluid == 'humid air':
+                val = HAPropsSI('Sha', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) / 1000.
+            else:
+                val = PropsSI('S', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid) / 1000.
+        elif hasattr(self, 'c') and self.t > self.tmax:     # extrapolate for high temp salt mixes
+            s_at_tmax = PropsSI('S', 'T', self.tmax.to('degC').magnitude+273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+            s_at_tmax_minus_10 = PropsSI('S', 'T', self.tmax.to('degC').magnitude+263.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+            val = s_at_tmax + (s_at_tmax - s_at_tmax_minus_10) / 10. * (self.t - self.tmax).magnitude
+        else:
+            raise ValueError('No entropy data available at these conditions, and no extrapolation has been created')
+        self._s = Quantity(val, 'delta_degC^-1*kJ*kg^-1')
+        return self._s
+
+    @property
+    def cp(self):       # Heat capacity at const pressure
+        if hasattr(self, '_cp'):
+            return self._cp
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.tmin <= self.t <= self.tmax:
+            if self.fluid == 'humid air':
+                val = HAPropsSI('Cha', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) / 1000.
+            else:
+                val = PropsSI('C', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid) / 1000.
+            self._cp = Quantity(val, 'delta_degC^-1*kJ*kg^-1')
+            return self._cp
+        elif hasattr(self, 'c') and self.t > self.tmax:        # extrapolate for salt mixtures above the data range
+            """
+            linearly extrapolate cp as a function of temperature, holding p and c constant
+            based on my (Luke's) testing, this seems to be within a few percent up to the boiling pointish
+            if you change this extrapolation, you also need to change the enthalpy and temperature function because they assumes linear extrapolation
+            """
+            self.warn_out_of_bounds()
+            cp_at_20C_below_max = PropsSI('C', 'T', self.tmax.to('degC').magnitude-20.+273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+            cp_at_max = PropsSI('C', 'T', self.tmax.to('degC').magnitude+273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+            val = cp_at_max + (cp_at_max - cp_at_20C_below_max) / 20. * (self.t - self.tmax).magnitude
+            self._cp = Quantity(val, 'delta_degC^-1*kJ*kg^-1')
+            return self._cp
+        else:
+            raise ValueError('Temperature %0.1f is not within data range %0.1f-%0.1f and no extrapolation has been created' % (self.t, self.tmin, self.tmax))
+
+    @property
+    def rho(self):       # density
+        if hasattr(self, '_rho'):
+            return self._rho
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.tmin <= self.t <= self.tmax:
+            if self.fluid == 'humid air':
+                val = 1. / HAPropsSI('Vha', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5])
+            else:
+                val = PropsSI('D', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)
+            self._rho = Quantity(val, 'kg*m^-3')
+            return self._rho
+        elif hasattr(self, 'c') and self.t > self.tmax:        # extrapolate for salt mixtures above the data range
+            """
+            Assume density decreases at the same rate as pure water
+            """
+            rho_water_at_tmax = PropsSI('D', 'T', self.tmax.to('degC').magnitude+273.15, 'P', 1.e5, 'water')
+            if self.t < Quantity(99.6, 'degC'):
+                rho_water_at_t = PropsSI('D', 'T', self.t+273.15, 'P', 1.e5, 'water')
+            else:
+                rho_water_at_t = PropsSI('D', 'T', self.t+273.15, 'Q', 0., 'water')
+            rho_at_tmax = PropsSI('D', 'T', self.tmax.to('degC').magnitude+273.15, 'P', 1.e5, self.coolprop_fluid)
+            val = rho_at_tmax + rho_water_at_t - rho_water_at_tmax
+            self._rho = Quantity(val, 'kg*m^-3')
+            return self._rho
+        else:
+            raise ValueError('Temperature %0.1f is not within data range %0.1f-%0.1f and no extrapolation has been created' % (self.t, self.tmin, self.tmax))
+
+    @property
+    def u(self):        # internal energy
+        if hasattr(self, '_u'):
+            return self._u
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            val = HAPropsSI('U', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) / 1000.
+        else:
+            val = PropsSI('U', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid) / 1000.
+        self._u = Quantity(val, 'kJ*kg^-1')
+        return self._u
+
+    @property
+    def cv(self):       # Heat capacity at const volume
+        if hasattr(self, '_cv'):
+            return self._cv
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            val = HAPropsSI('CVMASS', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) / 1000.
+        else:
+            val = PropsSI('CVMASS', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid) / 1000.
+        self._cv = Quantity(val, 'delta_degC^-1*kJ*kg^-1')
+        return self._cv
+
+    @property
+    def gamma(self):       # Heat capacity ratio
+        if hasattr(self, '_gamma'):
+            return self._gamma
+        self._gamma = self.cp / self.cv
+        return self._gamma
+
+    @property
+    def k(self):        # Thermal conductivity
+        if hasattr(self, '_k'):
+            return self._k
+        if not self.IVs_formatted:
+            self._formatIVs()
+        try:
+            if self.fluid == 'humid air':
+                val = HAPropsSI('L', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) / 1000.
+            else:
+                val = PropsSI('L', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid) / 1000.
+        except ValueError as e:
+            if 'METHANOL' in self.fluid and self.x < 0:
+                local_fluid = 'INCOMP::MMA[%f]' % self.c
+                val = PropsSI('L', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], local_fluid) / 1000.
+            elif hasattr(self, 'c') and self.fluid[:4] == 'REFP':
+                newFluid = self.coolprop_fluid.split(':')[1].split('&')[1].split('[')[0]
+                if Statepoint.allow_warnings:
+                    warnings.warn('Using %s to get thermal conductivity because no properties available for %s' % (newFluid, self.coolprop_fluid))
+                if 0. <= self.x <= 1.:
+                    # if the fluid is saturated, use the same pressure and quality with just the first fluid, not a mixture
+                    newSP = Statepoint(fluid=newFluid, p=self.p, x=self.x)
+                    val = newSP.k.magnitude
+                else:
+                    # if the fluid is not saturated, set it to the same pressure and the same delta from the saturation temp
+                    tSatOld = Statepoint(fluid=self.coolprop_fluid, p=self.p, x=0.).t
+                    tSatNew = Statepoint(fluid=newFluid, p=self.p, x=0.).t
+                    newSP = Statepoint(fluid=newFluid, p=self.p, t=tSatNew + self.t - tSatOld)
+                    val = newSP.k.magnitude
+            elif hasattr(self, 'c') and self.t > self.tmax:        # extrapolate for salt mixtures above the data range
+                """
+                Assume density decreases at the same rate as pure water
+                """
+                k_water_at_tmax = PropsSI('L', 'T', self.tmax.to('degC').magnitude+273.15, 'P', 1.e5, 'water') / 1000.
+                if self.t < 99.6:
+                    k_water_at_t = PropsSI('L', 'T', self.t+273.15, 'P', 1.e5, 'water') / 1000.
+                else:
+                    k_water_at_t = PropsSI('L', 'T', self.t+273.15, 'Q', 0., 'water') / 1000.
+                k_at_tmax = PropsSI('L', 'T', self.tmax.to('degC').magnitude+273.15, 'P', 1.e5, self.coolprop_fluid) / 1000.
+                val = k_at_tmax + k_water_at_t - k_water_at_tmax
+            else:
+                raise ValueError('Conductivity inputs are out of range and there are no extrapolations available')
+        self._k = Quantity(val, 'delta_degC^-1*kJ*s^-1*m^-1')
+        return self._k
+
+    @property
+    def x(self):        # Quality (vapor fraction by mass)
+        if hasattr(self, '_x'):
+            return self._x
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            raise Exception('Quality not defined for humid air')
+        val = PropsSI('Q', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)
+        self._x = Quantity(val, '')
+        return self._x
+
+    @property
+    def tlsat(self):    #
+        if hasattr(self, '_tlsat'):
+            return self._tlsat
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if 'REFPROP' not in self.fluid:
+            raise Exception('saturation properties only availible for REFPROP fluids')
+        val = PropsSI('T', 'Q', 0.0, 'P', self.p.to_base_units(), self.coolprop_fluid)-273.15
+        self._tlsat = Quantity(val, 'degC')
+        return self._tlsat
+
+    @property
+    def tvsat(self):    #
+        if hasattr(self, '_tvsat'):
+            return self._tvsat
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if 'REFPROP' not in self.fluid:
+            raise Exception('saturation properties only availible for REFPROP fluids')
+        val = PropsSI('T', 'Q', 1.0, 'P', self.p.to_base_units(), self.coolprop_fluid)-273.15
+        self._tvsat = Quantity(val, 'degC')
+        return self._tvsat
+
+    @property
+    def cvap(self):     #
+        if hasattr(self, '_cvap'):
+            return self._cvap
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if 'REFPROP' not in self.fluid:
+            raise Exception('saturation properties only availible for REFPROP fluids')
+
+        tlsat = PropsSI('T', 'Q', 0.0, 'P', self.p.to_base_units(), self.coolprop_fluid)-273.15
+        res = 1.
+        c_int = self.c
+        count = 0
+        fluid = self.coolprop_fluid
+        while res>0.001:
+            count = count + 1
+            fluid = fluid[0:fluid.find('[')] + fluid[fluid.find('&'):fluid.rfind('[')]
+
+            mw1 = PropsSI('M', 'T', 273, 'P', 101325., self.coolprop_fluid[self.coolprop_fluid.find('&')+1:self.coolprop_fluid.__len__()])
+            mw2 = PropsSI('M', 'T', 273, 'P', 101325, self.coolprop_fluid[self.coolprop_fluid.find(':')+1:self.coolprop_fluid.find('&')])
+            c_mol = (c_int / mw2) / (c_int / mw2 + (1.-c_int) / mw1)
+
+            fluid = fluid.replace('&', '[%s]&'%str(c_mol).strip()) + '[%s]'%str(1.-c_mol).strip()
+            tvsat = PropsSI('T', 'Q', 1.0, 'P', self.p.to_base_units(), fluid)-273.15
+            c_last = c_int
+            c_int = c_last+(tvsat-tlsat)/500.
+            res = abs((c_int-c_last)/c_int)
+            if count > 500:
+                raise Exception('vapor composition did not converge after 500 iterations')
+
+        try:
+            self._cvap = Quantity(c_int, '')
+        except:
+            self._cvap = c_int
+        return self._cvap
+
+    @property
+    def ss(self):        # Speed of sound
+        if hasattr(self, '_ss'):
+            return self._ss
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            raise Exception('CoolProp doesn\'t provide data for humid air speed of sound')
+        val = PropsSI('speed_of_sound', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)
+        self._ss = Quantity(val, 'm*s^-1')
+        return self._ss
+
+    @property
+    def visc(self):     # Dyanmic viscosity
+        def exp_func(t, mu0, E):
+            return mu0 * np.exp(E / (8.314 * (t + 273.15)))
+
+        if (hasattr(self, '_visc')):
+            return self._visc
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.tmin <= self.t <= self.tmax:
+            if self.fluid == 'humid air':
+                val = HAPropsSI('Visc', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5])
+            else:
+                val = PropsSI('viscosity', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)
+            self._visc = Quantity(val, 'kg*m^-1*s^-1')
+            return self._visc
+        elif hasattr(self, 'c') and self.t > self.tmax:
+            """Exponential curve fit to data from t=0 to tmax extrapolated out to t.
+            https://en.wikipedia.org/wiki/Temperature_dependence_of_liquid_viscosity#Arrhenius_model"""
+            ts = np.linspace(1., self.tmax.magnitude)
+            mu_act = np.array([Statepoint(fluid=self.fluid, t=t, p=1., c=self.c).visc.magnitude for t in ts])
+            m, garbage = curve_fit(exp_func, ts, mu_act)
+            val = exp_func(self.t.magnitude, m[0], m[1])
+            self._visc = Quantity(val, 'kg*m^-1*s^-1')
+            return self._visc
+        else:
+            raise ValueError('Temperature %0.1f is not within data range %0.1f-%0.1f and no extrapolation has been created' % (self.t, self.tmin, self.tmax))
+
+    @property
+    def pr(self):       # Prandtl number
+        if (hasattr(self, '_pr')):
+            return self._pr
+        if not self.IVs_formatted:
+            self._formatIVs()
+        try:                # handle viscosity being undefined for refprop mixtures with alcohols
+            mu = self.visc
+        except ValueError as e:
+            newFluid = self.fluid.split(':')[1].split('&')[0].split('[')[0]
+            if Statepoint.allow_warnings:
+                warnings.warn('Using %s instead because ' % newFluid + e.message)
+            if 0. <= self.x <= 1.:
+                # if the fluid is saturated, use the same pressure and quality with just the first fluid, not a mixture
+                newSP = Statepoint(fluid=newFluid, p=self.p, x=self.x)
+                mu = newSP.visc
+            else:
+                # if the fluid is not saturated, set it to the same pressure and the same delta from the saturation temp
+                tSatOld = Statepoint(fluid=self.fluid, p=self.p, x=0.).t
+                tSatNew = Statepoint(fluid=newFluid, p=self.p, x=0.).t
+                newSP = Statepoint(fluid=newFluid, p=self.p, t=tSatNew + self.t - tSatOld)
+                mu = newSP.visc
+        self._pr = self.cp * mu / self.k
+        return self._pr
+
+    @property
+    def sigma(self):    # surface tension
+        if (hasattr(self, '_sigma')):
+            return self._sigma
+        if not self.IVs_formatted:
+            self._formatIVs()
+        val = PropsSI('I', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)
+        self._sigma = Quantity(val, 'kg*s^-2')
+        return self._sigma
+
+    @property
+    def beta(self):     # coefficient of thermal expansion
+        if hasattr(self, '_beta'):
+            return self._beta
+        if not self.IVs_formatted:
+            self._formatIVs()
+        try:
+            val = PropsSI('ISOBARIC_EXPANSION_COEFFICIENT', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)
+        except ValueError:
+            rho1 = PropsSI('D', 'T', self.t+273.15, 'P', self.p*1.e5, self.coolprop_fluid)
+            rho2 = PropsSI('D', 'T', self.t+0.1+273.15, 'P', self.p*1.e5, self.coolprop_fluid)
+            rho3 = PropsSI('D', 'T', self.t-0.1+273.15, 'P', self.p*1.e5, self.coolprop_fluid)
+            val1 = (rho1 - rho2) / rho1
+            val2 = (rho3 - rho1) / rho1
+            if abs((val1 - val2) / val1) < 0.01:    # check both higher and lower temps to make sure we're not at a discontinuity
+                val = (val1 + val2) / 2.
+            else:
+                raise ValueError('Thermal expansion coefficient calc failed- discontinuity detected. Vals: %f %f' % (val1, val2))
+        self._beta = Quantity(val, 'delta_degC^-1')
+        return self._beta
+
+    @property
+    def t_freeze(self):     # freezing point
+        if hasattr(self, '_t_freeze'):
+            return self._t_freeze
+        if not self.IVs_formatted:
+            self._formatIVs()
+        val = PropsSI('T_FREEZE', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid) - 273.15
+        self._t_freeze = Quantity(val, 'degC')
+        return self._t_freeze
+
+    @property
+    def Z(self):  # compressibility
+        if hasattr(self, '_Z'):
+            return self._Z
+        if not self.IVs_formatted:
+            self._formatIVs()
+        if self.fluid == 'humid air':
+            val = HAPropsSI('Z', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5])
+        else:
+            val = PropsSI('Z', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)
+        self._Z = Quantity(val, '')
+        return self._Z
+
+    @property
+    def MW(self):  # molecular weight
+        if hasattr(self, '_MW'):
+            return self._MW
+        if not self.IVs_formatted:
+            self._formatIVs()
+        val = PropsSI('M', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.coolprop_fluid)
+        self._MW = Quantity(val, 'kg*mol^-1')
+        return self._MW
+
+    @property
+    def vdot(self):     # volumetric flow rate
+        if hasattr(self, '_vdot'):
+            return self._vdot
+        if not self.IVs_formatted:
+            self._formatIVs()
+        self._vdot = self.m / self.rho
+        return self._vdot
+
+    @property
+    def twb(self):
+        """ Wet bulb temperature """
+        if self.fluid != 'humid air':
+            raise Exception(f'Wet bulb temperature not defined for {self.fluid}')
+        if hasattr(self, '_twb'):
+            return self._twb
+        if not self.IVs_formatted:
+            self._formatIVs()
+        val = HAPropsSI('Twb', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) - 273.15
+        self._twb = Quantity(val, 'degC')
+        return self._twb
+
+    @property
+    def tdp(self):
+        """ Dew point temperature """
+        if self.fluid != 'humid air':
+            raise Exception(f'Dew point temperature not defined for {self.fluid}')
+        if hasattr(self, '_tdp'):
+            return self._tdp
+        if not self.IVs_formatted:
+            self._formatIVs()
+        val = HAPropsSI('Tdp', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5]) - 273.15
+        self._tdp = Quantity(val, 'degC')
+        return self._tdp
+
+    @property
+    def rh(self):
+        """ Relative humidity """
+        if self.fluid != 'humid air':
+            raise Exception(f'Relative humidity not defined for {self.fluid}')
+        if hasattr(self, '_rh'):
+            return self._rh
+        if not self.IVs_formatted:
+            self._formatIVs()
+        val = HAPropsSI('RH', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5])
+        self._rh = Quantity(val, '')
+        return self._rh
+
+    @property
+    def omega(self):
+        """ Humidity ratio, kg water / kg dry air """
+        if self.fluid != 'humid air':
+            raise Exception(f'Humidity ratio not defined for {self.fluid}')
+        if hasattr(self, '_omega'):
+            return self._omega
+        if not self.IVs_formatted:
+            self._formatIVs()
+        val = HAPropsSI('Omega', self.cpargs[0], self.cpargs[1], self.cpargs[2], self.cpargs[3], self.cpargs[4], self.cpargs[5])
+        self._omega = Quantity(val, '')
+        return self._omega
+
+    def set_source(self, source, setprops=()):
+        """
+        This method allows the user to create a map of statepoints and update the sink from the source properties
+        :param source: [Statepoint]
+        :param setprops: [Tuple of strings] A list of the properties that should be constant from source to sink
+        :return: None
+        """
+        self.source.append(source)
+        source.sink.append(self)
+        propToMethod = {'fluid': self.set_fluid, 'h': self.set_h, 't': self.set_t, 'p': self.set_p, 'x': self.set_x,
+                        'm': self.set_m, 'c': self.set_c, 's': self.set_s}
+        for prop in setprops:
+            if getattr(source, prop) == None:
+                raise StatepointError('Source does not have \'%s\' set' % prop)
+            else:
+                propToMethod[prop](getattr(source, prop))    # sets the props
+        return True
+
+    def set_sink(self, sink):
+        self.sink.append(sink)
+        sink.source.append(self)
+        return True
+
+    def update_prop(self, prop_val, prop_name):
+        """
+        This method allows the user to update a property value and have the statepoint clear its dependent variables
+        :param prop_val: [Float or Quantity] The updated value of the property
+        :param prop_name: [string] The name of the property to be updated
+        :return: None
+        """
+        if prop_name in ('t','T','temp','Temp','temperature','Temperature'):
+            if 'T' in list(self.IVs.keys()):
+                del self._t
+                if hasattr(self, '_p') and 'P' not in list(self.IVs.keys()):
+                    del self._p
+                if hasattr(self, '_h') and 'H' not in list(self.IVs.keys()):
+                    del self._h
+                if hasattr(self, '_k'):
+                    del self._k
+                if hasattr(self, '_s') and 'S' not in list(self.IVs.keys()):
+                    del self._s
+                if hasattr(self, '_x') and 'Q' not in list(self.IVs.keys()):
+                    del self._x
+                if hasattr(self, '_twb') and 'Twb' not in list(self.IVs.keys()):
+                    del self._twb
+                if hasattr(self, '_tdp') and 'Tdp' not in list(self.IVs.keys()):
+                    del self._tdp
+                if hasattr(self, '_rh') and 'RH' not in list(self.IVs.keys()):
+                    del self._rh
+                if hasattr(self, '_omega') and 'Omega' not in list(self.IVs.keys()):
+                    del self._omega
+                if isinstance(prop_val, Quantity):
+                    self._t = prop_val
+                else:
+                    self._t = Quantity(prop_val, 'degC')
+                self.IVs['T'] = self._t
+                self._formatIVs()
+            else:
+                raise StatepointError('T was not an initial property input for [%s]' %self.name)
+
+        if prop_name in ('p','P','pressure','Pressure'):
+            if 'P' in list(self.IVs.keys()):
+                del self._p
+                if hasattr(self, '_t') and 'T' not in list(self.IVs.keys()):
+                    del self._t
+                if hasattr(self, '_h') and 'H' not in list(self.IVs.keys()):
+                    del self._h
+                if hasattr(self, '_k'):
+                    del self._k
+                if hasattr(self, '_s') and 'S' not in list(self.IVs.keys()):
+                    del self._s
+                if hasattr(self, '_x') and 'Q' not in list(self.IVs.keys()):
+                    del self._x
+                if hasattr(self, '_twb') and 'Twb' not in list(self.IVs.keys()):
+                    del self._twb
+                if hasattr(self, '_tdp') and 'Tdp' not in list(self.IVs.keys()):
+                    del self._tdp
+                if hasattr(self, '_rh') and 'RH' not in list(self.IVs.keys()):
+                    del self._rh
+                if hasattr(self, '_omega') and 'Omega' not in list(self.IVs.keys()):
+                    del self._omega
+                if isinstance(prop_val, Quantity):
+                    self._p = prop_val
+                else:
+                    self._p = Quantity(prop_val, 'bar')
+                self.IVs['P'] = self._p
+                self._formatIVs()
+            else:
+                raise StatepointError('P was not an initial property input for [%s]' %self.name)
+
+        if prop_name in ('h','H','enthalpy','Enthalpy'):
+            if 'H' in list(self.IVs.keys()):
+                del self._h
+                if hasattr(self, '_t') and 'T' not in list(self.IVs.keys()):
+                    del self._t
+                if hasattr(self, '_p') and 'P' not in list(self.IVs.keys()):
+                    del self._p
+                if hasattr(self, '_k'):
+                    del self._k
+                if hasattr(self, '_s') and 'S' not in list(self.IVs.keys()):
+                    del self._s
+                if hasattr(self, '_x') and 'Q' not in list(self.IVs.keys()):
+                    del self._x
+                if hasattr(self, '_twb') and 'Twb' not in list(self.IVs.keys()):
+                    del self._twb
+                if hasattr(self, '_tdp') and 'Tdp' not in list(self.IVs.keys()):
+                    del self._tdp
+                if hasattr(self, '_rh') and 'RH' not in list(self.IVs.keys()):
+                    del self._rh
+                if hasattr(self, '_omega') and 'Omega' not in list(self.IVs.keys()):
+                    del self._omega
+                if isinstance(prop_val, Quantity):
+                    self._h = prop_val
+                else:
+                    self._h = Quantity(prop_val, 'kJ*kg^-1')
+                self.IVs['H'] = self._h
+                self._formatIVs()
+            else:
+                raise StatepointError('H was not an initial property input for [%s]' %self.name)
+
+        if prop_name in ('s','S','entropy','Entropy'):
+            if 'S' in list(self.IVs.keys()):
+                del self._s
+                if hasattr(self, '_t') and 'T' not in list(self.IVs.keys()):
+                    del self._t
+                if hasattr(self, '_p') and 'P' not in list(self.IVs.keys()):
+                    del self._p
+                if hasattr(self, '_k'):
+                    del self._k
+                if hasattr(self, '_h') and 'H' not in list(self.IVs.keys()):
+                    del self._h
+                if hasattr(self, '_x') and 'Q' not in list(self.IVs.keys()):
+                    del self._x
+                if hasattr(self, '_twb') and 'Twb' not in list(self.IVs.keys()):
+                    del self._twb
+                if hasattr(self, '_tdp') and 'Tdp' not in list(self.IVs.keys()):
+                    del self._tdp
+                if hasattr(self, '_rh') and 'RH' not in list(self.IVs.keys()):
+                    del self._rh
+                if hasattr(self, '_omega') and 'Omega' not in list(self.IVs.keys()):
+                    del self._omega
+                if isinstance(prop_val, Quantity):
+                    self._s = prop_val
+                else:
+                    self._s = Quantity(prop_val, 'degC^-1*kJ*kg^-1')
+                self.IVs['S'] = self._s
+                self._formatIVs()
+            else:
+                raise StatepointError('S was not an initial property input for [%s]' %self.name)
+
+        if prop_name in ('X','x','quality','Quality'):
+            if 'Q' in list(self.IVs.keys()):
+                del self._x
+                if hasattr(self, '_t') and 'T' not in list(self.IVs.keys()):
+                    del self._t
+                if hasattr(self, '_p') and 'P' not in list(self.IVs.keys()):
+                    del self._p
+                if hasattr(self, '_k'):
+                    del self._k
+                if hasattr(self, '_h') and 'H' not in list(self.IVs.keys()):
+                    del self._h
+                if hasattr(self, '_s') and 'S' not in list(self.IVs.keys()):
+                    del self._x
+                if hasattr(self, '_twb') and 'Twb' not in list(self.IVs.keys()):
+                    del self._twb
+                if hasattr(self, '_tdp') and 'Tdp' not in list(self.IVs.keys()):
+                    del self._tdp
+                if hasattr(self, '_rh') and 'RH' not in list(self.IVs.keys()):
+                    del self._rh
+                if hasattr(self, '_omega') and 'Omega' not in list(self.IVs.keys()):
+                    del self._omega
+                if isinstance(prop_val, Quantity):
+                    self._x = prop_val
+                else:
+                    self._x = Quantity(prop_val, '')
+                self.IVs['Q'] = self._x
+                self._formatIVs()
+            else:
+                raise StatepointError('X was not an initial property input for [%s]' % self.name)
+
+
+
+
+
+if __name__=='__main__':
+    s = Statepoint(fluid='REFPROP-MIX:METHANOL&WATER', p=1., t=10., c=0.5)
+    print((s.rho))
+
+    s = Statepoint(fluid='REFPROP-MIX:METHANOL&WATER', p=0.11, t=10., c=0.3)
+    print((s.cvap))
+
+
+    """ Luke wrote this script to validate the salt water property extrapolations"""
+    # from thermofluids import Statepoint
+    # import matplotlib.pyplot as plt
+    # import numpy as np
+    #
+    #
+    # fluid = 'INCOMP::MCA'
+    # t = np.arange(0., 40., step=1.)
+    # c = np.arange(0., 0.3, 0.03)
+    # rhos = np.zeros_like(t)
+    # cps = np.zeros_like(t)
+    # viscs = np.zeros_like(t)
+    # hs = np.zeros_like(t)
+    # ks = np.zeros_like(t)
+    #
+    # plt.style.use('seaborn')
+    # fig, ax = plt.subplots(nrows=1, sharex=True)
+    # # ax[0].set_ylabel('rho')
+    # # ax[1].set_ylabel('cp')
+    # # ax[2].set_ylabel('visc')
+    # # ax[3].set_ylabel('h')
+    # ax.set_ylabel('k')
+    # ax.set_xlabel('t')
+    #
+    # for cx in c:
+    #     for i, tx in enumerate(t):
+    #         sp = Statepoint(fluid=fluid, t=tx, p=1., c=cx)
+    #         rhos[i] = sp.rho
+    #         cps[i] = sp.cp
+    #         viscs[i] = sp.visc
+    #         hs[i] = sp.h
+    #         ks[i] = sp.k
+    #
+    #     # ax[0].plot(t, rhos, label=cx)
+    #     # ax[1].plot(t, cps, label=cx)
+    #     # ax[2].plot(t, viscs, label=cx)
+    #     # ax[3].plot(t, hs, label=cx)
+    #     ax.plot(ks, label=cx)
+    #
+    # t = np.arange(1., 100., 1.)
+    # rhos = np.zeros_like(t)
+    # cps = np.zeros_like(t)
+    # viscs = np.zeros_like(t)
+    # hs = np.zeros_like(t)
+    # ks = np.zeros_like(t)
+    # for i, tx in enumerate(t):
+    #     sp = Statepoint(fluid='water', t=tx, p=1.)
+    #     rhos[i] = sp.rho
+    #     cps[i] = sp.cp
+    #     viscs[i] = sp.visc
+    #     hs[i] = sp.h
+    #     ks[i] = sp.k
+    # # ax[0].plot(t, rhos, label='Water', c='black')
+    # # ax[1].plot(t, cps, label='Water', c='black')
+    # # ax[2].plot(t, viscs, label='Water', c='black')
+    # # ax[3].plot(t, hs, label='Water', c='black')
+    # ax.plot(t, ks, label='Water', c='black')
+    #
+    # t = np.arange(41., 100., 1.)
+    # cps = np.zeros_like(t)
+    # hs = np.zeros_like(t)
+    # rhos = np.zeros_like(t)
+    # viscs = np.zeros_like(t)
+    # ks = np.zeros_like(t)
+    # for cx in c:
+    #     for i, tx in enumerate(t):
+    #         sp = Statepoint(fluid='INCOMP::MCA', t=tx, p=1., c=cx)
+    #         cps[i] = sp.cp
+    #         hs[i] = sp.h
+    #         rhos[i] = sp.rho
+    #         viscs[i] = sp.visc
+    #         ks[i] = sp.k
+    #     # ax[0].plot(t, rhos, linestyle='dashed')
+    #     # ax[1].plot(t, cps, linestyle='dashed')
+    #     # ax[2].plot(t, viscs, linestyle='dashed')
+    #     # ax[3].plot(t, hs, linestyle='dashed')
+    #     ax.plot(t, ks, linestyle='dashed')
+    #
+    # # plt.legend()
+    # plt.show()