thermofluids 2.0.0__py3-none-any.whl

thermofluids/ProcessEquipment/Compressor.py

@@ -0,0 +1,167 @@
+from thermofluids import Statepoint, Quantity
+from CoolProp.CoolProp import PropsSI
+import math
+import warnings
+
+
+class Compressor():
+    """
+    Models a Compressor or Pump
+    :param inlet: [Statepoint] compressor inlet statepoint
+    :param eta: [Quantity] or [float] icentropic efficiency of turbo equipment
+    :param Pout: [Quantity] or [float] pressure at outlet of compressor or pump
+    :return: [Statepoint] compressor outlet statepoint
+    """
+    def __init__(self, inlet=None, inject=None, eta=None, Pout=None, output_name=None, work=None):
+        self.inject = inject
+        self.inlet = inlet
+        self.eta = eta
+        self.Pout = Pout
+        self.output_name = output_name
+        self._work = work
+        self._outlet = None
+
+    def set_inlet(self, inlet):
+        self.inlet = inlet
+
+    def set_eta(self, eta):
+        self.eta = eta
+
+    def set_Pout(self, Pout):
+        self.Pout = Pout
+
+    def set_output(self, output_name):
+        self.output_name = output_name
+
+    def get_Ns_Ds(self,rpm,D_rotor,n_comps,n_stages):
+        omega = rpm*2.0*math.pi/60.0
+        self.V_dot_CFS = (self.inlet.m/n_comps/self.inlet.rho).to('ft^3*s^-1')
+        gamma = self.inlet.cp / self.inlet.cv
+        ZRTMW = self.inlet.Z*Quantity(8.3144598,'J*K^-1*mol^-1')*self.inlet.t.to('K') / self.inlet.MW
+        adiabatic_head = (gamma*ZRTMW/(gamma-1.0)*(((self.Pout.to('Pa')/self.inlet.p.to('Pa'))/n_stages)**((gamma-1.0)/gamma)-1.0)).to('ft*lbf*lbm^-1')
+
+        self.Ns = rpm * self.V_dot_CFS**0.5 / (adiabatic_head**0.75)
+        self.Ds = D_rotor.to('ft')*adiabatic_head**0.25/(self.V_dot_CFS**0.5)
+        self.omega_tip = omega*D_rotor/2.0
+        self.machN = self.omega_tip/self.inlet.ss
+
+    @property
+    def work(self):
+        if self._work is None:
+            self.get_outlet()
+        return self._work
+
+    def get_outlet(self):
+        if self._outlet is not None:
+            return self._outlet
+
+        assert isinstance(self.inlet, Statepoint), '\'inlet\' must be set to a Statepoint'
+        self._outlet = Statepoint(name=self.output_name, fluid=self.inlet.fluid)
+        self._outlet.set_source(self.inlet)
+        self._outlet.set_m(self.inlet.m)
+        self._outlet.set_p(self.Pout)
+        if "HEOS" in self.inlet.fluid:
+            # mixtures don't have H(P,S) or T(P,S) available, so you have to manually solve for the temperature then enthalpy
+            res = 1.
+            s_target = inlet.s.magnitude
+            t_guess = Statepoint(fluid=inlet.fluid, p=self.Pout, x=1.).t
+            n = 0
+            while res > 0.001:
+                s_check = Statepoint(fluid=inlet.fluid, p=self.Pout, t=t_guess).s
+                res = abs(s_target - s_check.magnitude) / s_target
+                t_guess = (t_guess.to('K') * s_target / s_check.magnitude).to('degC')
+                h_out_s = Statepoint(fluid=inlet.fluid, p=self.Pout, t=t_guess).h
+                n += 1
+                if n > 100:
+                    ValueError('Mixture solver timed out')
+        elif hasattr(self.inlet,'c'):
+            self._outlet.set_c(self.inlet.c)
+            h_out_s = Statepoint(fluid=self.inlet.fluid, c=self.inlet.c, p=self.Pout, s=self.inlet.s).h
+        else:
+            h_out_s = Statepoint(fluid=self.inlet.fluid, p=self.Pout.to_base_units(), s=self.inlet.s).h
+        h_out = ((h_out_s - self.inlet.h)/self.eta + self.inlet.h)
+        self._work = self._outlet.m*(h_out - self.inlet.h)
+        self._outlet.set_h(h_out)
+        self.m_cool = 0. #this line is not used in this code, but make this code compatible with calls to isocompressor
+
+        self.CFM = (self.inlet.m/self.inlet.rho).to('ft^3/min')
+
+        return self._outlet
+
+    def get_isothermal_outlet(self):
+        assert isinstance(self.inlet, Statepoint), '\'inlet\' must be set to a Statepoint'
+        assert isinstance(self.inject, Statepoint), '\'inject\' must be set to a Statepoint'
+
+        #guess inlet flow rate
+        self.inject.set_m(self.inlet.m/4.)
+        res=1000.
+        count = 0
+        self._outlet = Statepoint(name=self.output_name, fluid=self.inlet.fluid)
+        inject_vap = Statepoint(name='inject_vap', fluid=self.inject.fluid)
+        outlet_isen = Statepoint(name='outlet_isen', fluid=self.inlet.fluid)
+        outlet_adia = Statepoint(name='outlet_adia', fluid=self.inlet.fluid)
+
+        while res>0.01:
+            c_mix = (self.inlet.c*self.inlet.m + self.inject.c*self.inject.m)/(self.inlet.m+self.inject.m)
+
+            inject_vap.set_x(1.)
+            inject_vap.set_m(self.inject.m)
+            inject_vap.set_p(self.inject.p)
+            inject_vap.set_c(self.inject.c)
+
+            h_vap = inject_vap.h - self.inject.h
+            outlet_isen.set_m(self.inlet.m + self.inject.m)
+            outlet_isen.set_p(self.Pout)
+
+            outlet_isen.set_c(c_mix)
+            outlet_isen.set_s(self.inlet.s)
+
+            outlet_adia.set_c(c_mix)
+            outlet_adia.set_p(self.Pout)
+            outlet_adia.set_m(self.inlet.m + self.inject.m)
+            outlet_adia.set_h((outlet_isen.h - self.inlet.h)/self.eta + self.inlet.h)
+
+            W_isen = self.inlet.m*(outlet_adia.h - self.inlet.h) + self.inject.m*(outlet_isen.h - self.inject.h)
+            #print self.inlet.m, outlet_isen.h, self.inlet.h, self.inject.m, self.inject.h
+
+            self._outlet.set_m(self.inlet.m + self.inject.m)
+            self._outlet.set_p(self.Pout)
+            outlet_isen.set_c(c_mix)
+            self._outlet.set_c(c_mix)
+            self._outlet.set_x(1.) #assume the outlet is saturated
+            W_iso = self.inlet.m*(self._outlet.h - self.inlet.h) + self.inject.m*(self._outlet.h - self.inject.h)
+            Q_cooling = W_isen - W_iso
+            self.m_cool = Q_cooling/h_vap
+            res = abs((self.inject.m - self.m_cool)/self.inject.m)
+            self.inject.set_m(self.m_cool)
+            if count>500:
+                warnings.warn('isothermal compressor injection flow rate did not converge after 500 iterations')
+                raise Exception()
+
+        self._work = W_iso
+        self.CFM = (self.inlet.m/self.inlet.rho).to('ft^3/min')
+        return self._outlet
+
+
+if __name__=='__main__':
+    FPS = 'REFPROP-MIX:AMMONIA&WATER'
+    inlet = Statepoint(name='inlet', fluid=FPS)
+    inlet.set_m(Quantity(0.001,'kg*s^-1'))
+    inlet.set_x(Quantity(1.,''))
+    inlet.set_c(Quantity(1.,''))
+    inlet.set_p(Quantity(1,'bar'))
+
+    eta_comp = .8
+    P_comp = Quantity(2.5,'bar')
+
+    comp = Compressor(inlet=inlet, eta=eta_comp, Pout=P_comp)
+    comp.get_outlet()
+    W_comp = comp.work
+    print(comp.outlet.h, comp.outlet.p, comp.outlet.c, comp.outlet.m, W_comp)
+
+    # fluid = "HEOS::R32[0.689]&R1234yf[0.311]"
+    # inlet = Statepoint(fluid=fluid, p=7., t=20., m=0.4)
+    # comp = Compressor(inlet=inlet, eta=0.8, Pout=19.)
+    # print(comp.get_outlet())
+    # print(comp.work)
+

thermofluids/ProcessEquipment/Ejector.py

@@ -0,0 +1,145 @@
+"""
+Model of jet ejector based on http://ijlct.oxfordjournals.org/content/early/2009/01/01/ijlct.ctn001.full
+
+Fundamentally, an ejector converts thermal energy to kinetic energy by expanding a motive gas to high velocity and low pressure.
+The low pressure gas entrains a secondary fluid, transferring kinetic energy from the motive to the secondary gas.
+Then, the kinetic energy is converted back to thermal energy which increases the pressure and reduces the velocity.
+
+
+"""
+
+from math import sqrt
+from thermofluids import Statepoint
+from CoolProp.CoolProp import PropsSI
+
+# refrigerants = ['R23', 'R32', 'R41', 'R125', 'R134a', 'R143a', 'R152a', 'R161', 'R227ea', 'R236ea', 'R236fa', 'R245ca', 'R245fa', 'R365mfc', 'R1233zd(E)', 'R1234yf', 'R1234ze(E)',
+#                 'RE143a', 'RE245cb2', 'RE245fa2', 'RE347mcc',
+#                 'R21', 'R22', 'R123', 'R124', 'R141b', 'R142b',
+#                 'R11', 'R12', 'R13', 'R113', 'R114', 'R115',
+#                 'R14', 'R116', 'R218', 'R1216', 'C4F10', 'C5F12', 'RC318',
+#                 'Novec649']
+#
+# for fluid in refrigerants:
+#     try:
+#         # print fluid, '\t', PropsSI('T', 'Q', 0.5, 'P', 0.4e5, 'REFPROP::'+fluid)-273.15
+#         h_vap = PropsSI('H', 'Q', 1., 'T', 60.+273., 'REFPROP::'+fluid) - PropsSI('H', 'Q', 0., 'T', 60.+273., 'REFPROP::'+fluid)
+#         P_sat = PropsSI('P', 'Q', 0.5, 'T', 60.+273., 'REFPROP::'+fluid)/1.e5
+#         s_ref = PropsSI('S', 'Q', 1., 'P', P_sat*1.e5, 'REFPROP::'+fluid)
+#         T_exp = PropsSI('T', 'S', s_ref, 'P', 0.2e5, 'REFPROP::'+fluid) - 273.15
+#         print fluid, '\t', P_sat, '\t', h_vap/1000., T_exp
+#     except:
+#         print fluid, 'failed'
+#
+# print
+# print
+# print
+
+mot_fluid = 'REFPROP::Novec649'
+entr_fluid = 'Ammonia'
+
+eta_nozzle = 0.9
+entr_ratio = 0.3
+
+
+"Motive fluid from superheater to expansion nozzle"
+inlet = Statepoint(name='inlet', fluid=mot_fluid)
+inlet.set_p(1.45)
+inlet.set_t(PropsSI('T', 'Q', 0.5, 'P', inlet.p*1.e5, mot_fluid)-273.15 + 3.)   # 3C superheat
+inlet.set_m(0.27 / entr_ratio)
+print('Evaporator:', PropsSI('T', 'Q', 0.5, 'P', inlet.p*1.e5, mot_fluid)-273.15)
+
+"Motive fluid isentropic expansion"
+nozzle_s = Statepoint(name='nozzle_s')
+nozzle_s.set_source(inlet, ('fluid', 'm', 's'))           # isentropic expansion
+nozzle_s.set_p(0.2)
+
+"Motive fluid real expansion"
+nozzle = Statepoint(name='nozzle')
+nozzle.set_source(inlet, ('fluid', 'm'))
+nozzle.set_p(nozzle_s.p)
+nozzle.set_h(nozzle.source[0].h - eta_nozzle * (nozzle.source[0].h - nozzle_s.h))
+nozzle.vel = sqrt(2.*(nozzle.source[0].h - nozzle.h)*1000.)   # convert thermal energy to kinetic energy
+nozzle.Ma = nozzle.vel / nozzle.ss
+if PropsSI('T', 'Q', 0.5, 'P', nozzle.p*1.e5, mot_fluid)-273.15 >= nozzle.t:
+    raise Exception('Motive fluid condensing in primary nozzle')
+print('Motive Ma:', nozzle.vel / nozzle.ss)
+
+"Entrained fluid from boiler to entrainment"
+entr_inlet = Statepoint(name='entr_inlet', fluid=entr_fluid)
+entr_inlet.set_p(nozzle.p)
+entr_inlet.set_x(1.)                                    # saturated vapor inlet
+entr_inlet.set_m(inlet.m * entr_ratio)
+
+"Motive fluid after mixing"
+mix_mot = Statepoint(name='mix_mot')
+mix_mot.set_source(nozzle, ('fluid', 'm', 'p', 'h'))
+mix_mot.vel = mix_mot.source[0].m / (mix_mot.source[0].m + entr_inlet.m) * mix_mot.source[0].vel
+
+"Entrained fluid after mixing"
+mix_entr = Statepoint(name='mix_entr')
+mix_entr.set_source(entr_inlet, ('fluid', 'm', 'p', 'h'))
+mix_entr.vel = mix_mot.vel
+
+mix_ss = (1.-entr_ratio)*mix_mot.ss + entr_ratio*mix_entr.ss
+print('Mixture Ma:', mix_mot.vel / mix_ss)
+print('Mixture:', mix_mot.t, mix_entr.t)
+
+"Motive fluid through con-di nozzle"
+mot_recomp = Statepoint('mot_recomp')
+mot_recomp.set_source(mix_mot, ('fluid', 'm'))
+mot_recomp.set_h(mot_recomp.source[0].h + 0.5*mot_recomp.source[0].vel**2./1000.)
+mot_recomp.set_s(mot_recomp.source[0].s)
+
+"Entrained fluid through con-di nozzle"
+entr_recomp = Statepoint('entr_recomp')
+entr_recomp.set_source(mix_entr, ('fluid', 'm'))
+entr_recomp.set_h(entr_recomp.source[0].h + 0.5*entr_recomp.source[0].vel**2./1000.)
+entr_recomp.set_s(entr_recomp.source[0].s)
+W_comp = entr_recomp.m * (entr_recomp.h - entr_recomp.source[0].h)
+print('Compression work:', W_comp)
+
+"Motive fluid condensation"
+mot_cond = Statepoint('mot_cond')
+mot_cond.set_source(mot_recomp, ('fluid', 'm', 'p'))
+mot_cond.set_x(0.)
+print('Condenser:', mot_cond.t, mot_cond.p)
+
+"Entrained fluid condensation"
+entr_cond = Statepoint('entr_cond')
+entr_cond.set_source(entr_recomp, ('fluid', 'm', 'p'))
+entr_cond.set_t(mot_cond.t)
+
+Q_cond = mot_cond.m * (mot_cond.source[0].h - mot_cond.h) + entr_cond.m * (entr_cond.source[0].h - entr_cond.h)
+print('Condenser load:', Q_cond)
+
+"Pump motive fluid"
+mot_pump = Statepoint('mot_pump')
+mot_pump.set_source(mot_cond, ('fluid', 'm', 's'))
+mot_pump.set_p(inlet.p)
+
+"Pump entrained fluid"
+entr_pump = Statepoint('entr_pump')
+entr_pump.set_source(entr_cond, ('fluid', 'm', 's'))
+entr_pump.set_p(1.)
+
+W_pump = mot_pump.m * (mot_pump.h - mot_pump.source[0].h) + entr_pump.m * (entr_pump.h - entr_pump.source[0].h)
+print('Pump work:', W_pump)
+
+"Preheat motive fluid"
+mot_preheat = Statepoint('mot_preheat')
+mot_preheat.set_source(mot_pump, ('fluid', 'm', 'p'))
+mot_preheat.set_x(0.)
+Q_preheat = mot_preheat.m * (mot_preheat.h - mot_preheat.source[0].h)
+print('Preheat load:', Q_preheat)
+
+"Boil motive fluid"
+mot_boil = inlet
+mot_boil.set_source(mot_preheat)
+Q_boil = mot_boil.m * (mot_boil.h - mot_boil.source[0].h)
+print('Boiler load:', Q_boil)
+
+
+eta_carnot = 1. - (mot_cond.t+273.15) / (inlet.t+273.15)
+print('Actual efficiency:', W_comp / (Q_boil+Q_preheat))
+print('Carnot efficiency:', eta_carnot)
+print('Percent carnot:', (W_comp / (Q_boil+Q_preheat)) / eta_carnot)

thermofluids/ProcessEquipment/HeatExchanger.py

@@ -0,0 +1,109 @@
+from thermofluids.Base import Statepoint
+from thermofluids.Base import Quantity
+import types
+from CoolProp.CoolProp import PropsSI
+
+class HX_Energy():
+    def __init__(self, cold_inlet=None, hot_inlet=None, cold_outlet=None, hot_outlet=None, pinch=None,
+                 cold_inlet_name='cold_inlet', cold_outlet_name='cold_outlet', hot_inlet_name='hot_inlet', hot_outlet_name='hot_outlet'):
+        """
+        Models a HX using an energy balance only. Any 3 of the following must be supplied:
+        hot inlet, hot outlet, cold inlet, cold outlet, or Pinch
+        :param cold_inlet: [Statepoint] HX cold inlet
+        :param hot_inlet: [Statepoint] HX hot inlet
+        :param cold_outlet: [Statepoint] HX cold outlet
+        :param hot_outlet: [Statepoint] HX hot outlet
+        :param pinch: [Quantity] or [float] Smallest pinch point at outlet of HX
+        :param cold_inlet_name: [string] name for cold inlet statepoint
+        :param cold_out_name: [string] name for cold outlet statepoint
+        :param hot_inlet_name: [string] name for hot inlet statepoint
+        :param hot_outlet_name: [string] name for hot outlet statepoint
+        """
+
+        self.cold_inlet = cold_inlet
+        self.hot_inlet = hot_inlet
+        self.cold_outlet = cold_outlet
+        self.hot_outlet = hot_outlet
+        self.pinch = pinch
+        self.cold_inlet_name = cold_inlet_name
+        self.cold_outlet_name = cold_outlet_name
+        self.hot_inlet_name = hot_inlet_name
+        self.hot_outlet_name = hot_outlet_name
+
+    def get_states(self):
+        flag_co = 0
+        flag_ci = 0
+        flag_ho = 0
+        flag_hi = 0
+        flag_p = 0
+
+        if self.cold_outlet is None:
+            flag_co=1
+            self.cold_outlet = Statepoint(name=self.cold_outlet_name, fluid=self.cold_inlet.fluid)
+            self.cold_outlet.set_t(max(self.cold_inlet.t, self.hot_inlet.t))
+            self.cold_outlet.set_m(self.cold_inlet.m)
+            self.cold_outlet.set_p(self.cold_inlet.p)
+            self.cold_outlet.set_c(self.cold_inlet.c)
+        if self.cold_inlet is None:
+            flag_ci=1
+            self.cold_inlet = Statepoint(name=self.cold_inlet_name, fluid=self.cold_outlet.fluid)
+            self.cold_inlet.set_t(min(self.hot_outlet.t, self.cold_outlet.t))
+            self.cold_inlet.set_m(self.cold_outlet.m)
+            self.cold_inlet.set_p(self.cold_outlet.p)
+            self.cold_inlet.set_c(self.cold_outlet.c)
+        if self.hot_outlet is None:
+            flag_ho=1
+            self.hot_outlet = Statepoint(name=self.hot_outlet_name, fluid=self.hot_inlet.fluid)
+            self.hot_outlet.set_t(min(self.cold_inlet.t, self.hot_inlet.t))
+            self.hot_outlet.set_m(self.hot_inlet.m)
+            self.hot_outlet.set_p(self.hot_inlet.p)
+            self.hot_outlet.set_c(self.hot_inlet.c)
+        if self.hot_inlet is None:
+            flag_hi=1
+            self.hot_inlet = Statepoint(name=self.hot_inlet_name, fluid=self.hot_outlet.fluid)
+            self.hot_inlet.set_t(max(self.cold_outlet.t, self.hot_outlet.t))
+            self.hot_inlet.set_m(self.hot_outlet.m)
+            self.hot_inlet.set_p(self.hot_outlet.p)
+            self.hot_inlet.set_c(self.hot_outlet.c)
+        if self.pinch is None:
+            flag_p=1
+
+        C_cold = self.cold_inlet.m * self.cold_inlet.cp
+        C_hot = self.hot_inlet.m * self.hot_inlet.cp
+
+
+        if (float(C_cold) > float(C_hot)) and (flag_ho > 0) and (flag_p == 0):
+            self.hot_outlet.update_prop(prop_val=self.cold_inlet.t + self.pinch, prop_name='T')
+        elif (float(C_cold) > float(C_hot)) and (flag_ci > 0) and (flag_p == 0):
+            self.cold_inlet.update_prop(prop_val=self.hot_outlet.t - self.pinch, prop_name='T')
+        elif (float(C_cold) <= float(C_hot)) and (flag_hi > 0) and (flag_p == 0):
+            self.hot_inlet.update_prop(prop_val=self.cold_outlet.t + self.pinch, prop_name='T')
+        elif (float(C_cold) <= float(C_hot)) and (flag_co > 0) and (flag_p == 0):
+            self.cold_outlet.update_prop(prop_val=self.hot_inlet.t - self.pinch, prop_name='T')
+
+        Q_HX_cold = self.cold_outlet.m*(self.cold_outlet.h-self.cold_inlet.h)
+        Q_HX_hot = self.hot_outlet.m*(self.hot_inlet.h-self.hot_outlet.h)
+        self.Q_HX = max(Q_HX_cold, Q_HX_hot)
+
+        if (flag_ho > 0) and (float(C_cold) <= float(C_hot)):
+            self.hot_outlet.update_prop(prop_val=self.hot_inlet.t - Q_HX_cold/(self.hot_inlet.m * self.hot_inlet.cp), prop_name='T')
+        if (flag_hi > 0) and (float(C_cold) > float(C_hot)):
+            self.hot_inlet.update_prop(prop_val=self.hot_outlet.t + Q_HX_cold/(self.hot_outlet.m * self.hot_outlet.cp), prop_name='T')
+        if (flag_ci > 0) and (float(C_cold) <= float(C_hot)):
+            self.cold_inlet.update_prop(prop_val=self.cold_outlet.t - Q_HX_hot/(self.cold_outlet.m * self.cold_outlet.cp), prop_name='T')
+        if(flag_co > 0) and (float(C_cold) > float(C_hot)):
+            self.cold_outlet.update_prop(prop_val=self.cold_inlet.t + Q_HX_hot/(self.cold_inlet.m * self.cold_inlet.cp), prop_name='T')
+
+        if (flag_p > 0):
+            if (float(C_cold) > float(C_hot)):
+                self.pinch = self.hot_outlet.t - self.cold_inlet.t
+            else:
+                self.pinch = self.hot_inlet.t - self.cold_outlet.t
+            if (flag_ho > 0):
+                self.hot_outlet.update_prop(prop_val=self.hot_inlet.t - Q_HX_cold/(self.hot_inlet.m * self.hot_inlet.cp), prop_name='T')
+            if (flag_hi > 0):
+                self.hot_inlet.update_prop(prop_val=self.hot_outlet.t + Q_HX_cold/(self.hot_outlet.m * self.hot_outlet.cp), prop_name='T')
+            if (flag_ci > 0):
+                self.cold_inlet.update_prop(prop_val=self.cold_outlet.t - Q_HX_hot/(self.cold_outlet.m * self.cold_outlet.cp), prop_name='T')
+            if(flag_co > 0):
+                self.cold_outlet.update_prop(prop_val=self.cold_inlet.t + Q_HX_hot/(self.cold_inlet.m * self.cold_inlet.cp), prop_name='T')

thermofluids/ProcessEquipment/IsoCompressor.py

@@ -0,0 +1,124 @@
+import warnings
+
+from thermofluids.Base import Quantity
+from thermofluids.Base import Statepoint
+import math
+
+
+class IsoCompressor():
+    def __init__(self, inlet=None, inject=None, Pout=None, output_name=None, work=None, eta=None):
+        """
+        Models an Isothermal Compressor or Pump
+        :param inlet: [Statepoint] compressor inlet statepoint
+        :param injeciton: [Statepoint] cooling injection stream
+        :param eta: [Quantity] or [float] icentropic efficiency of turbo equipment
+        :param Pout: [Quantity] or [float] pressure at outlet of compressor or pump
+        :return: [Statepoint] compressor outlet statepoint
+        """
+        self.inject = inject
+        self.inlet = inlet
+        self.Pout = Pout
+        self.output_name = output_name
+        self.work = work
+        self.eta = eta
+        print(self.inlet)
+
+    def set_inlet(self, inlet):
+        self.inlet = inlet
+
+    def set_eta(self, eta):
+        self.eta = eta
+
+    def set_Pout(self, Pout):
+        self.Pout = Pout
+
+    def set_output_name(self, output_name):
+        self.output_name = output_name
+
+    def get_Ns_Ds(self, rpm, D_rotor, n_comps, n_stages):
+        omega = rpm * 2.0 * math.pi / 60.0
+        self.V_dot_CFS = (self.inlet.m / n_comps / self.inlet.rho).to('ft^3*s^-1')
+        gamma = self.inlet.cp / self.inlet.cv
+        ZRTMW = self.inlet.Z * Quantity(8.3144598, 'J*K^-1*mol^-1') * self.inlet.t.to('K') / self.inlet.MW
+        adiabatic_head = (gamma * ZRTMW / (gamma - 1.0) * (
+                ((self.Pout.to('Pa') / self.inlet.p.to('Pa')) / n_stages) ** (
+                (gamma - 1.0) / gamma) - 1.0)).to('ft*lbf*lbm^-1')
+
+        self.Ns = rpm * self.V_dot_CFS ** 0.5 / (adiabatic_head ** 0.75)
+        self.Ds = D_rotor.to('ft') * adiabatic_head ** 0.25 / (self.V_dot_CFS ** 0.5)
+        self.omega_tip = omega * D_rotor / 2.0
+        self.machN = self.omega_tip / self.inlet.ss
+
+    def get_outlet(self):
+
+        assert isinstance(self.inlet, Statepoint), '\'inlet\' must be set to a Statepoint'
+        assert isinstance(self.inject, Statepoint), '\'inject\' must be set to a Statepoint'
+
+        #guess inlet flow rate
+        self.inject.set_m(self.inlet.m/4.)
+        res=1000.
+        count = 0
+        self.outlet = Statepoint(name=self.output_name, fluid=self.inlet.fluid)
+        inject_vap = Statepoint(name='inject_vap', fluid=self.inject.fluid)
+        outlet_isen = Statepoint(name='outlet_isen', fluid=self.inlet.fluid)
+        outlet_adia = Statepoint(name='outlet_adia', fluid=self.inlet.fluid)
+
+        while res>0.01:
+            c_mix = (self.inlet.c*self.inlet.m + self.inject.c*self.inject.m)/(self.inlet.m+self.inject.m)
+
+            inject_vap.set_x(1.)
+            inject_vap.set_m(self.inject.m)
+            inject_vap.set_p(self.inject.p)
+            inject_vap.set_c(self.inject.c)
+
+            h_vap = inject_vap.h - self.inject.h
+            outlet_isen.set_m(self.inlet.m + self.inject.m)
+            outlet_isen.set_p(self.Pout)
+
+            outlet_isen.set_c(c_mix)
+            outlet_isen.set_s(self.inlet.s)
+
+            outlet_adia.set_c(c_mix)
+            outlet_adia.set_p(self.Pout)
+            outlet_adia.set_m(self.inlet.m + self.inject.m)
+            print(outlet_isen.h, self.inlet.h, self.eta, self.inlet.h)
+            outlet_adia.set_h((outlet_isen.h - self.inlet.h)/self.eta + self.inlet.h)
+
+            W_isen = self.inlet.m*(outlet_adia.h - self.inlet.h) + self.inject.m*(outlet_isen.h - self.inject.h)
+            #print self.inlet.m, outlet_isen.h, self.inlet.h, self.inject.m, self.inject.h
+
+            self.outlet.set_m(self.inlet.m + self.inject.m)
+            self.outlet.set_p(self.Pout)
+            outlet_isen.set_c(c_mix)
+            self.outlet.set_c(c_mix)
+            self.outlet.set_x(1.) #assume the outlet is saturated
+            W_iso = self.inlet.m*(self.outlet.h - self.inlet.h) + self.inject.m*(self.outlet.h - self.inject.h)
+            Q_cooling = W_isen - W_iso
+            self.m_cool = Q_cooling/h_vap
+            res = abs((self.inject.m - self.m_cool)/self.inject.m)
+            self.inject.set_m(self.m_cool)
+            if count>500:
+                warnings.warn('isothermal compressor injection flow rate did not converge after 500 iterations')
+                raise Exception()
+
+        self.work = W_iso
+        self.CFM = Quantity(float(self.inlet.m/self.inlet.rho)*2118.88,'ft^3/min')
+        return self.outlet
+
+if __name__=='__main__':
+    #inputs
+    R_HX = 1.
+    FPS = 'REFPROP-MIX:METHANOL&WATER'
+    inject = Statepoint(name='inject', fluid=FPS)
+    inlet = Statepoint(name='inlet', fluid=FPS)
+    inject.set_x(.0)
+    inject.set_c(.72)
+    inject.set_p(1.0)
+
+    inlet.set_x(1.)
+    inlet.set_c(0.72)
+    inlet.set_p(1.0)
+    inlet.set_m(0.035)
+    comp = IsoCompressor(inlet=inlet, inject=inject, Pout=2., eta=1)
+    comp.get_outlet()
+    print(comp.work)

thermofluids/ProcessEquipment/Pipe.py

@@ -0,0 +1,21 @@
+from thermofluids.Base import Statepoint
+
+class Pipe():
+    def __init__(self, inlet=None):
+        self.inlet = inlet
+
+    def get_outlet(self):
+        outlet = Statepoint()
+        outlet.set_source(self.inlet, ('fluid', 'm', 'h', 'p'))
+
+        return outlet
+
+if __name__ == "__main__":
+    inlet = Statepoint()
+    inlet.set_fluid("water")
+    inlet.set_p(1.)
+    inlet.set_m(1.)
+    inlet.set_t(25.)
+
+    pipe = Pipe(inlet)
+    print(pipe.get_outlet())

thermofluids/ProcessEquipment/Pump.py

@@ -0,0 +1,109 @@
+from thermofluids.Base import Statepoint
+from thermofluids.Base import Quantity
+from CoolProp.CoolProp import PropsSI
+from thermofluids.Properties.BrineProps import get_c_freeze, get_h_f, get_T_liq_sat, get_T_vap_sat, get_h_mix, get_C_vap_sat, get_C_liq_sat, get_c_satliq_at_t, get_c_satvap_at_t
+import warnings
+
+# these values are taken from the manufacterers speck. Flow must be in m^3/s and pressure in bara.
+PUMP_CURVE_DIC = {"IWAKI_M251": {"NPSHr": {
+    "flow": [0.000145517,0.00024495,0.00037565,0.000571933,0.001,0.0009168,0.001111983,0.0012997,0.001454833,0.001599733,0.001789267,0.001951767,0.00213965,0.002287983,0.0024091,0.00254205],
+    "pressure": [0.424, 0.348, 0.295, 0.231, 0.203, 0.205, 0.225, 0.268, 0.306, 0.356, 0.421, 0.481, 0.547, 0.600,0.639, 0.654]},
+                                 "pump_curve": {
+    "flow": [0.000166667,0.0005,0.000824567,0.001087717,0.001324567,0.001526317,0.001745617,0.001956133,0.00214035,0.002324567,0.002535083],
+    "pressure": [3.052436053,3.032940359,2.994046941,2.942025769,2.883636658,2.825149578,2.747166805,2.662718123,2.57836741,2.487354852,2.376944569]}}
+                  }
+
+class Pump():
+
+    def __init__(self, inlet=None, outlet_P=None, name=None):
+        self.name = name
+        self.inlet = inlet
+        self.outlet_P = outlet_P
+        self.max_flow = 0
+        self.max_P = 0
+        self.NPSHr=0
+
+    def set_outlet_P(self,outlet_P):
+        self.outlet_P = outlet_P
+
+    def set_inlet(self,inlet):
+        self.inlet = inlet
+
+    def set_name(self, name):
+            self.name = name
+
+    def flow_at_outlet_P(self):
+        x = 0
+        if(self.name=="M251" or self.name=="iwaki-M251" or self.name=="IWAKI-M251" or self.name=="Iwaki-M251" or self.name=="m251"):
+            pump_key = "IWAKI_M251"
+        if PUMP_CURVE_DIC[pump_key]["pump_curve"]["pressure"][0]<self.outlet_P:
+            warnings.warn('specified pump can reach max head of '+str(PUMP_CURVE_DIC[pump_key]["pump_curve"]["pressure"][0])+'bar and cannot meet the required head of '+str(self.outlet_P))
+        else:
+            while x < len(PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"]):
+                print(PUMP_CURVE_DIC[pump_key]["pump_curve"]["pressure"][x], self.outlet_P)
+                if(PUMP_CURVE_DIC[pump_key]["pump_curve"]["pressure"][x]<self.outlet_P):
+                    P_right = PUMP_CURVE_DIC[pump_key]["pump_curve"]["pressure"][x]
+                    P_left = PUMP_CURVE_DIC[pump_key]["pump_curve"]["pressure"][x-1]
+                    flow_right = PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"][x]
+                    flow_left = PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"][x-1]
+                    self.maxFlow = Quantity(flow_left + (self.outlet_P.magnitude - P_left) / (P_right - P_left) * (flow_right - flow_left),'m^3/s')
+                    x = 100000
+                if(x==len(PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"])):
+                    self.maxFlow = flow_right = PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"][x-1]
+                    x = 100000
+                x = x + 1
+
+            x = 0
+            while x < len(PUMP_CURVE_DIC[pump_key]["NPSHr"]["flow"]):
+                if (PUMP_CURVE_DIC[pump_key]["NPSHr"]["flow"][x] > self.maxFlow):
+                    P_right = PUMP_CURVE_DIC[pump_key]["NPSHr"]["pressure"][x]
+                    P_left = PUMP_CURVE_DIC[pump_key]["NPSHr"]["pressure"][x - 1]
+                    flow_right = PUMP_CURVE_DIC[pump_key]["NPSHr"]["flow"][x]
+                    flow_left = PUMP_CURVE_DIC[pump_key]["NPSHr"]["flow"][x - 1]
+                    self.NPSHr = Quantity(
+                        0.0597216 + P_left + (inlet_flow.magnitude - flow_left) / (flow_right - flow_left) * (P_right - P_left), 'bar')
+                    x = 100000
+                x = x + 1
+
+    def P_at_inlet_flow(self):
+        inlet_flow = self.inlet.m/self.inlet.rho
+        x=0
+        if(self.name=="M251" or self.name=="iwaki-M251" or self.name=="IWAKI-M251" or self.name=="Iwaki-M251" or self.name=="m251"):
+            pump_key = "IWAKI_M251"
+        if PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"][len(PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"])-1]<inlet_flow:
+            warnings.warn('specified pump can reach max flow of '+PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"][len(PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"])-1]+'m^3/s and cannot meet the required head of '+intlet_flows)
+        else:
+            while x<len(PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"]):
+                if(PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"][x]>inlet_flow):
+                    P_right = PUMP_CURVE_DIC[pump_key]["pump_curve"]["pressure"][x]
+                    P_left = PUMP_CURVE_DIC[pump_key]["pump_curve"]["pressure"][x-1]
+                    flow_right = PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"][x]
+                    flow_left = PUMP_CURVE_DIC[pump_key]["pump_curve"]["flow"][x-1]
+                    self.max_P = Quantity(P_left + (inlet_flow.magnitude - flow_left)/(flow_right-flow_left)*(P_right-P_left),'bar')
+                    #print (self.max_P-1.0)*401.0/12.,P_left, P_right, flow_left, flow_right, inlet_flow.magnitude, x
+                    x = 100000
+                x=x+1
+
+            x=0
+            while x<len(PUMP_CURVE_DIC[pump_key]["NPSHr"]["flow"]):
+                if(PUMP_CURVE_DIC[pump_key]["NPSHr"]["flow"][x]>inlet_flow):
+                    P_right = PUMP_CURVE_DIC[pump_key]["NPSHr"]["pressure"][x]
+                    P_left = PUMP_CURVE_DIC[pump_key]["NPSHr"]["pressure"][x-1]
+                    flow_right = PUMP_CURVE_DIC[pump_key]["NPSHr"]["flow"][x]
+                    flow_left = PUMP_CURVE_DIC[pump_key]["NPSHr"]["flow"][x-1]
+                    self.NPSHr = Quantity(0.0597216 + P_left + (inlet_flow.magnitude - flow_left)/(flow_right-flow_left)*(P_right-P_left),'bar')
+                    x = 100000
+                x=x+1
+
+
+
+
+    def get_outlet_SP(self):
+        self.outlet = Statepoint()
+        self.outlet.set_fluid(self.inlet.fluid)
+        self.outlet.set_p(self.inlet.p)
+        self.outlet.set_t(self.inlet.t)
+        self.outlet.set_m(outlet.set_m)
+
+if __name__=='__main__':
+    print(test(2.))