thermofluids 2.0.0__py3-none-any.whl

thermofluids/HeatTransfer/NTU.py

@@ -0,0 +1,45 @@
+from math import log
+
+from thermofluids.Base import Quantity
+
+
+def NTU(m_1, cp_1, m_2, cp_2,T_1_in,T__1_out,T_2_in,flow='counter', type='tube'):
+    C_1=m_1*cp_1
+    C_2=m_2*cp_2
+    C_max=max(C_1,C_2)
+    C_min=min(C_1,C_2)
+    c=C_min/C_max
+    Q_max=C_min*abs(T_1_in-T_2_in)
+    Q_1=C_1*abs(T_1_in-T__1_out)
+
+    epsilon=Q_1/Q_max
+
+    if type=='tube' and flow=='counter':
+            NTU=(1/(c-1))*(log((epsilon-1)/(epsilon*c-1)))
+    elif type=='tube' and flow =='parallel':
+            NTU=-(log(1-epsilon*(1+c)))/(1+c)
+    elif type=='tube' and flow=='counter'and c==1:
+            NTU=epsilon/(1-epsilon)
+    else:
+        raise Exception("No NTU correlations available for type '%s'. Please provide a HX type as an input" % type)
+
+    return NTU,C_min.magnitude
+
+
+#######test#####
+if __name__ == "__main__":
+    mdot_h=Quantity(2,'kg/s')
+    mdot_c=Quantity(1.2,'kg/s')
+    cp_h=Quantity(4.31,'kJ/kg*C')
+    cp_c=Quantity(4.18,'kJ/kg*C')
+    T_in_h=Quantity(160,'C')
+    T_in_c=Quantity(20,'C')
+    T_out_c=Quantity(80,'C')
+
+    print(NTU(mdot_c,cp_c,mdot_h,cp_h,T_in_c,T_out_c,T_in_h))
+
+
+
+
+
+

thermofluids/HeatTransfer/Nusselt.py

@@ -0,0 +1,59 @@
+from warnings import warn
+
+
+def Nu(Re, Pr, f=None, mode=None):
+    """
+    Nusselt number for forced convection
+    :param Re: Reynolds number
+    :param Pr: Prandtl number
+    :param f: Darcy friction factor
+    :param mode: 'heating' or 'cooling'
+    :return: Nusselt number
+    """
+    if f != None and Re >= 3000. and Re <= 5.e5 and Pr >= 0.5 and Pr <= 2000.:
+        return _Gnielinski(Re, Pr, f)
+    elif Re >= 10000. and Pr > 0.6 and Pr < 160:
+        return _Dittus_Boelter(Re, Pr, mode)
+    elif Re <= 2300.:
+        return _laminar()
+    else:
+        warn("No Nusselt number correlation available for Re=%s, Pr=%s. Using Gnielinski correlation as best guess" % (Re, Pr))
+        return _Gnielinski(Re, Pr, f)
+
+def _Gnielinski(Re, Pr, f):
+    "https://en.wikipedia.org/wiki/Nusselt_number#Gnielinski_correlation"
+    return (f/8.) * (Re - 1000.) * Pr / (1. + 12.7*(f/8.)**0.5 * (Pr**0.6667-1.))
+
+def _Dittus_Boelter(Re, Pr, mode):
+    "https://en.wikipedia.org/wiki/Nusselt_number#Dittus-Boelter_equation"
+    if mode.lower() == 'heating':
+        n = 0.4
+    elif mode.lower() == 'cooling':
+        n = 0.3
+    else:
+        raise Exception('Unknown mode %s. Should be either "heating" or "cooling"' % mode)
+
+    return 0.023 * Re**0.8 * Pr**n
+
+def _laminar():
+    "https://en.wikipedia.org/wiki/Nusselt_number#Forced_convection_in_fully_developed_laminar_pipe_flow"
+    return 4.   # average between const. heat flux and const. temp solutions
+
+def Nu_natural(Ra, Pr, shape):
+    """
+    Nusselt number for natural convection
+    References:
+    [1] Cengel Heat and Mass Transfer 3rd Ed p511
+    :param Ra: Rayleigh number
+    :param Pr: Prandtl number
+    :param shape: can be 'vertical plate', 'inclined plate', 'horizontal plate', 'vertical cylinder', 'horizontal cylinder', 'sphere'
+    :return: Nusselt number <Quantity, ->
+    """
+    shapes = ('vertical plate', 'inclined plate', 'horizontal plate', 'vertical cylinder', 'horizontal cylinder', 'sphere')
+    if shape not in shapes:
+        raise ValueError('Natural convection Nusselt correlation not found for %s. Please use one of: \n%s' % (shape, shapes))
+    if shape == 'vertical plate':
+        return (0.825 + (0.387 * Ra ** (1. / 6.)) / (1. + (0.492 / Pr) ** (9. / 16.)) ** (8. / 27.)) ** 2.  # ref [1]
+    else:
+        raise NotImplementedError("Natural convection Nusselt correlation for %s not yet implemented. \
+                                  Please see Cengel Heat and Mass Transfer p511 to add it.")

thermofluids/HeatTransfer/Ra.py

@@ -0,0 +1,22 @@
+from thermofluids.Base import Quantity
+from thermofluids.Base import Statepoint
+from .Gr import Gr
+
+
+def Ra(statepoint, gr=None, L=None, t_wall=None):
+    """
+    Rayleigh number for natural convection
+    Please specify either the Grashof number or the characteristic length and wall temperature
+    :param statepoint: A statepoint instance of the fluid being heated/cooled
+    :param gr: Grashof number <Quantity [-]>
+    :param L: Characteristic length <Quantity [m]>
+    :param t_wall: Wall temperature <Quantity [C]>
+    :return:
+    """
+    assert ((Gr is not None) or (L is not None and t_wall is not None))
+
+    if gr is None:
+        g = Quantity(9.81, 'm*s^-2')
+        gr = statepoint.rho ** 2. * g * statepoint.beta * L ** 3. * (t_wall - statepoint.t) / statepoint.visc ** 2.
+
+    return gr * statepoint.pr

thermofluids/HeatTransfer/TwoPhase.py

@@ -0,0 +1,249 @@
+"""
+This file contains functions to calculate the heat transfer for convective boiling flow in a tube. It is based on the
+Shah correlation as described in Carey 'Liquid-Vapor Phase-Change Phenomena' p616.
+"""
+
+import warnings
+from math import exp, log10,pi
+
+from thermofluids.Fluids.Moody import frictionfactor
+from thermofluids.HeatTransfer.Nusselt import Nu
+from thermofluids import Statepoint, Quantity
+
+
+def warning_on_one_line(message, category, filename, lineno, file=None, line=None):
+    return ' %s:%s %s\n' % (filename, lineno, message)
+warnings.formatwarning = warning_on_one_line
+
+
+def Co(x, rho_v, rho_l):
+    """
+    Convection number - Some representation of volumetric liquid/gas ratio (higher is more liquid)
+    :param x: quality [kg/kg]
+    :param rho_v: vapor density [kg/m^3]
+    :param rho_l: liquid density [kg/m^3]
+    :return: Convenction number [-]
+    """
+
+    return pow((1. - x)/x, 0.8) * pow(rho_v / rho_l, 0.5)
+
+
+def Bo(q_flux, G, h_v):
+    """
+    Boiling number - the ratio of flow rate due to boiling vs flow rate through pipe
+    :param q_flux: heat flux [kW/m^2]
+    :param G: mass flux [kg/m^2-s]
+    :param h_v: enthalpy of vaporization [kJ/kg]
+    :return: boiling number [-]
+    """
+
+    return q_flux / (G * h_v)
+
+
+def Fr_le(G, rho_l, d):
+    """
+    Froude number - the ratio of flow inertia to gravity field
+    :param G: mass flux [kg/m^2-s]
+    :param rho_l: liquid density [kg/m^3]
+    :param d: hydraulic diameter [m]
+    :return: Froude number [-]
+    """
+
+    g = Quantity(9.807, 'm*s^-2')
+    return G * G / (rho_l * rho_l * g * d)
+
+def crit_heat_flux(h_v, rho_l, rho_v, sigma):
+    """
+    Critical heat flux for boiling heat transfer according to:
+    https://en.wikipedia.org/wiki/Critical_heat_flux#Correlations_for_critical_heat_flux
+    :param h_v: enthalpy of vaporization [kJ/kg]
+    :param rho_l: liquid density [kg/m^3]
+    :param rho_v: vapor density [kg/m^3]
+    :param sigma: interfacial tension [N/m]
+    :return: critical heat transfer [kW/m^2]
+    """
+    C = 0.149                           # supposed to be for 'large horizontal plates'
+    g = Quantity(9.806, 'm*s^-2')
+
+    return C * h_v * rho_v * (sigma * g * (rho_l - rho_v) / rho_v**2.)**0.25
+
+def heat_flux_nucleate_boiling(mu_l, h_v, rho_l, rho_v, sigma, cp_l, T_s, T_sat, Csf, n, Pr_l):
+    """
+    heat flux for nucleate boiling based on Rohsenow correlation
+    https://en.wikipedia.org/wiki/Nucleate_boiling#Boiling_Heat_transfer_correlations
+    :param mu_l: Liquid viscosity [kg/m-s]
+    :param h_v: enthalpy of vaporization [kJ/kg]
+    :param rho_l: liquid density [kg/m^3]
+    :param rho_v: vapor density [kg/m^3]
+    :param sigma: interfacial tension [m^2/s]
+    :param cp_l: liquid specific heat capacity [kJ/kg-C]
+    :param T_s: surface temperature [C]
+    :param T_sat: saturation temperature [C]
+    :param Csf: surface fluid combination
+    :param Pr_l: liquid prandtl number
+    :param n: parameter depending on surface fluid combo, typically 1.0 or 1.7
+    :return: heat flux [kW/m^2]
+    """
+    g = Quantity(9.807, 'm*s^-2')
+    q = mu_l * h_v * pow(g * (rho_l - rho_v) / sigma, 0.5) *  pow(cp_l * (T_s - T_sat) / (Csf * h_v * pow(Pr_l, n)), 3.)
+    q_max = crit_heat_flux(h_v, rho_l, rho_v, sigma)
+    if q > q_max:
+        raise Exception('Departure from nucleate boiling exceeded')
+    return q
+
+def htc_conv_boil(x, rho_l, rho_v, G, h_v, d, q_flux, mu_l, k_l, pr_l):
+    """
+    Heat transfer coefficient of boiling flow through a tube based on Shah correlation as described in
+    Carey 'Liquid-Vapor Phase-Change Phenomena' p616.
+    :param x: quality [-]
+    :param rho_l: liquid density [kg/m^3]
+    :param rho_v: vapor density [kg/m^3]
+    :param G: mass flux [kg/m^2-s]
+    :param h_v: enthalpy of vaporization [kJ/kg]
+    :param d: hydraulic diameter [m]
+    :param q_flux: Boiling heat flux [kW/m^2]
+    :param mu_l: liquid kinematic viscosity [kg/m-s]
+    :param k_l: liquid thermal conductivity [kW/m-C]
+    :param pr_l: liquid Prandtl number [-]
+    :return: Heat transfer coefficient [kW/m^2-C]
+    """
+
+    co = Co(x, rho_v, rho_l)
+    bo = Bo(q_flux, G, h_v)
+    fr = Fr_le(G, rho_l, d)
+
+    if fr >= 0.04:
+        Ns = co
+    else:
+        Ns = 0.38*pow(fr, -0.3) * co
+    if bo >= 11.e-4:
+        Fs = 14.7
+    else:
+        Fs = 15.4
+    psi_cb = 1.8 * pow(Ns, -0.8)
+
+    if Ns > 1.:
+        if bo > 0.3e-4:
+            psi_nb = 230 * pow(bo, 0.5)
+        else:
+            psi_nb = 1 + 46 * pow(bo, 0.5)
+        psi_s = max(psi_nb, psi_cb)
+    else:
+        if Ns > 0.1:
+            psi_bs = Fs * pow(bo, 0.5) * exp(2.74 * pow(Ns, -0.1))
+        else:
+            psi_bs = Fs * pow(bo, 0.5) * exp(2.74 * pow(Ns, -0.15))
+        psi_s = max(psi_bs, psi_cb)
+    if psi_s < 1.:
+        warnings.warn('Shah correlation predicts lower heat transfer than liquid convection. Seems dubious, eh?')
+
+    # find liquid phase heat transfer coefficient
+    re_l = G * (1. - x) * d / mu_l
+    ff_l = frictionfactor(Re=re_l, relrough=1.5e-5/d)   #TODO: update this for other materials
+    htc_l = k_l / d * Nu(Re=re_l, Pr=pr_l, f=ff_l, mode='cooling')
+    htc = htc_l * psi_s
+
+    return htc
+
+
+def superficial_flow_regime(state, d, orientation, detailed=False):
+    liquid_only = Statepoint(fluid=state.fluid,m=(1.-state.x)*state.m,p=state.p, x=0.0)
+    gas_only = Statepoint(fluid=state.fluid, m=(state.x) * state.m, p=state.p, x=1.0)
+    A = d**2/4.*pi
+    G = state.m/A
+    x = state.x
+    mu_l = liquid_only.visc     #/liquid_only.rho
+    mu_v = gas_only.visc        #/gas_only.rho
+    rho_l = liquid_only.rho
+    rho_v = gas_only.rho
+    # based on Carey p484-486
+    Re_l = G * (1. - x) * d / mu_l
+    Re_v = G * x * d / mu_v
+    # print 'Re #s: ', Re_l, Re_v
+    laminar_warning = False
+    if float(Re_l) > 2000:
+        f_l = 0.079 * Re_l**0.25
+    else:
+        laminar_warning = True
+        f_l = 16 * Re_l
+    if float(Re_v) > 2000:
+        f_v = 0.079 * Re_v**0.25
+    else:
+        laminar_warning = True
+        f_v = 16 * Re_v
+    if laminar_warning:
+        warnings.warn('Non-boiling flow is laminar, results may be inaccurate')
+    dPdz_l = -2. * f_l * G**2. * (1.-x)**2. / (rho_l * d)
+    dPdz_v = - 2 * f_v * G**2. * x**2. / (rho_v * d)
+    X = (dPdz_l / dPdz_v) ** 0.5
+    if X < 10e-3 or X > 10e4:
+        raise ValueError('Martinelli parameter is outside of the range of the correlation')
+
+    if orientation.lower() == 'horizontal':
+        j_v = G * x / rho_v         # superficial vapor flux
+        j_l = G * (1. - x) / rho_l  # superficial liquid flux
+        g = Quantity(9.807, 'm*s^-2')
+        nu_l = mu_l / rho_l
+        K_td = (rho_v * j_v**2. * j_l / (nu_l * (rho_l - rho_v) * g))**0.5
+        if (K_td <  0.8):
+            warnings.warn('Flow regime K_td parameter is outside of the range of the correlation. Value is %f, min is 1' % K_td)
+        F_td = (rho_v * j_v**2. / ((rho_l - rho_v) * d * g))**0.5
+        if (F_td < 0.001 or F_td > 10.):
+            warnings.warn('Flow regime F_td parameter is outside of the range of the correlation')
+        T_td = (-dPdz_l / ((rho_l - rho_v) * g))**0.5
+        if (T_td < 0.001 or T_td > 10.):
+            warnings.warn('Flow regime parameter is outside of the range of the correlation')
+        # print()
+
+        if detailed:
+            print(X, T_td,F_td, 1.3027 - 0.3826*log10(X) + 0.0161 * log10(X)**2.)
+        if K_td < 10.**(0.7757 - 0.112*log10(X) - 0.2097 * log10(X)**2.):
+            return 'Stratified smooth'
+        elif F_td < 10.**(-0.6644 - 0.8985*log10(X) - 0.2362 * log10(X)**2.):
+            return 'Stratified wavy'
+        elif X < 1.6:
+            return 'Annular dispersed'
+        elif T_td < 1.3027 - 0.3826*log10(X) + 0.0161 * log10(X)**2.:
+            return 'Intermittent'
+        else:
+            return 'Dispersed bubble'
+    elif orientation.lower() == 'vertical':
+        j_v = G * x / rho_v  # superficial vapor flux
+        j_l = G * (1. - x) / rho_l  # superficial liquid flux
+        return_str = 'Vertical orientation map not currently implemented. \nRefer to page 482 of Liquid-Vapor Phase-Change Phenomena \npvjv2 = '
+        return_str = return_str + str(j_v**2*rho_v) + '\npljl2 = ' + str(j_l**2*rho_l)
+        return return_str
+
+    else:
+        raise ValueError('Only horizontal or vertical orientation supported at this time')
+
+
+if __name__ == '__main__':
+    from thermofluids.Base import Statepoint
+    from thermofluids.Base import Quantity
+
+    t = Quantity(-14., 'C')
+    t_wall = Quantity(-13., 'C')
+    Q = Quantity(20., 'kJ*s^-1')
+    h = Quantity(0.208 * 0.0254, 'm')
+    w = Quantity((39.375 - 1.5) * 0.0254, 'm')
+    Csf = 0.0133                    # used value for water/chemically etched stainless (https://en.wikipedia.org/wiki/Nucleate_boiling#Boiling_Heat_transfer_correlations)
+    n = 1.
+    x = 0.5
+
+    refrigerant = 'ammonia'
+    v = Statepoint(fluid=refrigerant, t=t, x=1)
+    l = Statepoint(fluid=refrigerant, t=t, x=0)
+    mdot = Q / (v.h - l.h)
+    G = mdot / (h * w / 2.)
+
+    for t_wall in range(-14, 1, 1):
+        t_wall = Quantity(t_wall, 'degC')
+        q_flux = heat_flux_nucleate_boiling(l.visc, v.h - l.h, l.rho, v.rho, l.sigma, l.cp, t_wall, t, Csf, n, l.pr)
+        print(t_wall, q_flux)
+
+    q_flux = heat_flux_nucleate_boiling(l.visc, v.h-l.h, l.rho, v.rho, l.sigma, l.cp, t_wall, t, Csf, n, l.pr)
+    print('Flow regime: ', superficial_flow_regime(G, x, h, l.visc, v.visc, l.rho, v.rho, 'horizontal'))
+    print('q_flux: ', q_flux)
+
+    htc_conv_boil(x, v.rho, l.rho, G, v.h - l.h, h*2., q_flux, l.mu, l.k, l.pr)

thermofluids/HeatTransfer/__init__.py

@@ -0,0 +1,6 @@
+from thermofluids.HeatTransfer.Gr import Gr
+from thermofluids.HeatTransfer.Nusselt import Nu, Nu_natural
+from thermofluids.HeatTransfer.Ra import Ra
+from thermofluids.HeatTransfer.lmtd import lmtd
+from thermofluids.HeatTransfer.lmtd import lmtd
+from thermofluids.HeatTransfer.TwoPhase import superficial_flow_regime

thermofluids/HeatTransfer/lmtd.py

@@ -0,0 +1,32 @@
+from math import log
+
+def lmtd(t_hot_in, t_hot_out, t_cold_in, t_cold_out):
+    """
+    Log Mean Temperature Difference
+    :param t_hot_in: C
+    :param t_hot_out: C
+    :param t_cold_in: C
+    :param t_cold_out: C
+    :return: log mean temp difference C
+    """
+    assert t_hot_in > t_cold_out, '%f !> %f' % (t_hot_in, t_cold_out)
+    assert t_hot_in >= t_hot_out, '%f !> %f' % (t_hot_in, t_hot_out)
+    assert t_hot_out > t_cold_in, '%f !> %f' % (t_hot_out, t_cold_in)
+    # assert t_cold_out > t_cold_in, '%f !> %f' % (t_cold_out, t_cold_in)
+
+    dt_hot = t_hot_in - t_cold_out
+    dt_cold = t_hot_out - t_cold_in
+    if dt_cold == dt_hot:
+        return dt_cold
+    else:
+        return (dt_hot - dt_cold) / log(dt_hot / dt_cold)
+
+
+
+if __name__ == '__main__':
+    print(lmtd(10., 5., 4., 9.))
+    print(lmtd(10., 5., 0., 9.))
+    try:
+        print(lmtd(5., 5., 5., 5.))
+    except AssertionError:
+        print('that one produced an error as expected')