thermofluids 2.0.0__py3-none-any.whl

thermofluids/Base/thermofluids_registry.txt

@@ -0,0 +1,5 @@
+tons_of_refrigeration =  3.51685 kW
+TR = tons_of_refrigeration
+GPM = 1 gal/min = gpm
+LPM = 1 L/min = lpm
+CFM = 1 ft^3/min = cfm

thermofluids/Fluids/Drag.py

@@ -0,0 +1,169 @@
+from warnings import warn
+from ..Base.Quantity import Quantity
+
+
+def c_d(shape):
+    """
+    https://en.wikipedia.org/wiki/Drag_coefficient
+    :param shape:
+    :return:
+    """
+    if shape == 'sphere':
+        cd = 0.47
+    elif shape == 'half sphere':
+        cd = 0.42
+    elif shape == 'cone':
+        cd = 0.5
+    elif shape == 'cube':
+        cd = 1.05
+    elif shape == 'angled cube':
+        cd = 0.8
+    elif shape == 'long cylinder':
+        cd = 0.82
+    elif shape == 'short cylinder':
+        cd = 1.15
+    elif shape == 'streamlined':
+        cd = 0.04
+    elif shape == 'half streamlined':
+        cd = 0.09
+    else:
+        raise ValueError(f'No drag coefficient available for {shape}. Please select from sphere, half sphere, cone, '
+                         f'cube, angled cube, long cylinder, short cylinder, streamlined, half streamlined.')
+    return cd
+
+
+def f_drag(shape, density, velocity, area=None):
+    """
+
+    :param shape: Shape of the object <str>
+    :param density: Density of the fluid <Quantity, kg/m^3>
+    :param velocity: Velocity of the fluid relative to the thing getting dragged <Quantity, m/s>
+    :param area: Optional, frontal area of the object <Quantity, m^2>
+    :return: Pressure on the object (without area specified) or force on the object (with area specified)
+    """
+    cd = c_d(shape.lower())
+
+    if area == None:
+        return 0.5 * cd * density * velocity**2.            # return as pressure
+    else:
+        return 0.5 * cd * density * velocity**2. * area     # return as force
+
+
+def _settling_vel_stokes(rho_solid, rho_liquid, visc_liquid, d_solid):
+    g = Quantity(9.81, 'm*s^-2')
+    if rho_solid > rho_liquid:
+        return 2. / 9. * (rho_solid - rho_liquid) / visc_liquid * g * (d_solid / 2.) ** 2.
+    else:
+        return 2. / 9. * (rho_liquid - rho_solid) / visc_liquid * g * (d_solid / 2.) ** 2.
+
+
+def _settling_vel_laminar(rho_solid, rho_liquid, d_solid, re):
+    from math import exp, log
+    g = Quantity(9.81, 'm*s^-2')
+    cd = exp(0.0453 * log(re)**2. - 0.8379 * log(re) + 2.8568)  # fit to 25 < Re < 4000 from https://en.wikipedia.org/wiki/Drag_coefficient#/media/File:Drag_coefficient_on_a_sphere_vs._Reynolds_number_-_main_trends.svg
+    if rho_solid > rho_liquid:
+        return (4. / (3. * cd) * d_solid * g * (rho_solid - rho_liquid) / rho_liquid) ** 0.5
+    else:
+        return (4. / (3. * cd) * d_solid * g * (rho_liquid - rho_solid) / rho_liquid) ** 0.5
+
+
+def _settling_vel_turbulent(rho_solid, rho_liquid, d_solid, re):
+    g = Quantity(9.81, 'm*s^-2')
+    cd = 0.47
+    if rho_solid > rho_liquid:
+        return (4. / (3. * cd) * d_solid * g * (rho_solid - rho_liquid) / rho_liquid) ** 0.5
+    else:
+        return (4. / (3. * cd) * d_solid * g * (rho_liquid - rho_solid) / rho_liquid) ** 0.5
+
+
+def settling_vel(statepoint, d_solid, rho_solid, d_h_ext, re='auto', detailed=False):
+    """
+    This function calculates the settling velocity for a solid particle in a flowing liquid. If the fluid is moving
+    slower than the settling velocity, the particle will tend to settle out. If its moving faster, it will tend to
+    remain entrained.
+    There are three regimes:
+
+        1. Stokes flow (Re<10: force balance is Stokes drag vs gravity
+        2. Laminar flow (10<Re<3000): force balance is hydrodynamic drag vs gravity
+        3. Turbulent flow (Re>3000): force balance is hydrodynamic drag vs gravity
+
+    :param statepoint: statepoint instance of the fluid containing the solids
+    :param d_solid: diameter of the solid particle
+    :param rho_solid: density of the solid particle
+    :param d_h_ext: hydraulic diameter of the flow area
+    :param re: Reynolds number, if known. If left default='auto', it will be calculated from the settling velocity
+    :return: settling velocity [m/s]
+    """
+    # assert rho_solid > statepoint.rho, "Not currently set up to handle solids less dense than fluid"
+
+    if re != 'auto':
+        if re < 10.:        # Stokes flow
+            v = _settling_vel_stokes(rho_solid=rho_solid, rho_liquid=statepoint.rho, visc_liquid=statepoint.visc, d_solid=d_solid)
+        elif re < 3000.:    # Laminar flow
+            v = _settling_vel_laminar(rho_solid=rho_solid, rho_liquid=statepoint.rho, d_solid=d_solid, re=re)
+        else:               # Turbulent flow
+            v = _settling_vel_turbulent(rho_solid=rho_solid, rho_liquid=statepoint.rho, d_solid=d_solid, re=re)
+    else:
+        v = Quantity(0.01, 'm*s^-1')
+        res = 1.
+        n_iter = 0.
+        while res > 0.01:
+            v_last = v
+            re = statepoint.rho * v * d_h_ext / statepoint.visc
+            # print(statepoint.rho, v, d_h_ext, statepoint.visc, re)
+            if re < 10.:        # Stokes flow
+                v = _settling_vel_stokes(rho_solid=rho_solid, rho_liquid=statepoint.rho, visc_liquid=statepoint.visc, d_solid=d_solid)
+            elif re < 3000.:    # Laminar flow
+                v = _settling_vel_laminar(rho_solid=rho_solid, rho_liquid=statepoint.rho, d_solid=d_solid, re=re)
+            else:               # Turbulent flow
+                v = _settling_vel_turbulent(rho_solid=rho_solid, rho_liquid=statepoint.rho, d_solid=d_solid, re=re)
+            res = abs((v - v_last) / v)
+            n_iter += 1
+            if n_iter > 1000:
+                warn(f'Settling velocity calculation did not converge. Last two iterations gave v={v} and v={v_last}')
+                break
+            # print 'Residual: ', res, v, re
+
+    if detailed:
+        if re < 10:
+            print('\tSettling velocity in Stokes flow regime')
+        elif re < 3000:
+            print('\tSettling velocity in laminar flow regime')
+        else:
+            print('\tSettling velocity in turbulent flow regime. Warning- this is not well characterized in this model')
+
+    return v
+
+
+
+
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    from ..Base.Statepoint import Statepoint
+
+    rho = Quantity(1000., 'kg*m^-3')
+    u = Quantity(5., 'm*s^-1')
+    A = Quantity(3.14 / 4. * 0.0254**2., 'm^2')
+    # print f_drag(shape='sphere', density=rho, velocity=u, area=A)
+
+    sp = Statepoint(fluid='INCOMP::TD12', t=0., p=1.)
+    fig1 = plt.figure()
+    ax1 = fig1.add_subplot(111)
+    ds = [0.01, 0.003, 0.001, 0.00033, 0.0001]
+    for d in ds:
+        vs = []
+        re_array = list(range(4000))
+        for re in re_array:
+            v = settling_vel(statepoint=sp,
+                           d_solid=Quantity(d, 'm'),
+                           rho_solid=Quantity(1000., 'kg*m^-3'),
+                           d_h_ext=Quantity(0.1, 'm'),
+                           re=re)
+            vs.append(v)
+
+        plt.plot(re_array, vs)
+    plt.legend(ds, title='Ice size', )
+    plt.xlabel('Re')
+    plt.ylabel('Settling velocity [m/s]')
+    plt.ylim(0, 0.5)
+    plt.show()

thermofluids/Fluids/Moody.py

@@ -0,0 +1,57 @@
+"""
+From http://nullege.com/codes/show/src@l@i@libtsl-HEAD@mr_darcy.py
+Edited by Luke Erickson to include transition region
+"""
+
+from warnings import warn
+from math import log10
+from ..Base.Quantity import Quantity
+
+
+def frictionfactor(Re,relrough):
+    """
+    Returns the Darcy friction factor based on reynolds # and relative roughness.
+    """
+    if type(Re) is Quantity:
+        assert Re.units == '', f'Re must be unitless but has units {Re.units}'
+    if type(relrough) is Quantity:
+        assert relrough.units == '', f'Relative roughness must be unitless but has units {relrough.units}'
+    if relrough > 0.05:
+        warn('Moody diagram only valid for relative roughness < 0.05. Received value %f' % relrough)
+
+    regime = _flowregime(Re,relrough)
+
+    if regime=='laminar':
+        return _laminar(Re)
+    elif regime=='turbulent':
+        return _turbulent(Re,relrough)
+    elif regime=='transition':
+        return _transition(Re, relrough)
+
+def _flowregime(Re,relrough):
+    if Re < 2300.:
+        return "laminar"
+    elif Re > 4000.:
+        return "turbulent"
+    else:
+        return "transition"
+
+def _laminar(Re):
+    return 64.0 / Re
+
+def _turbulent(Re,relrough):
+    # Uses Serghides's Solution to approximate the Colebrook eqn
+    a=-2*log10(relrough/3.7 + 12.0/Re)
+    b=-2*log10(relrough/3.7 + 2.51*a/Re)
+    c=-2*log10(relrough/3.7 + 2.51*b/Re)
+    return (a-(b-a)**2/(c-2*b+a))**-2.0 #returns f
+
+def _transition(Re, relrough):
+    """
+    Assume linear interpolation between laminar and turbulent regions
+    """
+    warn("Using interpolated friction factor in high uncertainly transition Re region")
+
+    turb = _turbulent(Re, relrough)
+    lam = _laminar(Re)
+    return lam + (Re.magnitude-2300.) / (4000.-2300.) * (turb - lam)

thermofluids/Fluids/PressureDrop.py

@@ -0,0 +1,322 @@
+from math import sqrt, log, sin, cos, tan
+
+from thermofluids import Quantity
+from thermofluids.Fluids.Moody import frictionfactor
+from thermofluids.Fluids.Re import Re
+
+
+def pressure_drop(statepoint, roughness, L, d1, d2=None, v=None, shape='round', props='REFPROP', units='bar', detailed=False):
+    """
+
+    :param statepoint:
+    :param roughness:
+    :param L:
+    :param d1:
+    :param d2:
+    :param shape:
+    :param props:
+    :return:
+    """
+    # if not isinstance(L, Quantity):
+    #     L = Quantity(L, 'm')
+    # if not isinstance(d1, Quantity):
+    #     d1 = Quantity(d1, 'm')
+    # if not isinstance(d2, Quantity):
+    #     d2 = Quantity(d2, 'm')
+    # if not isinstance(roughness, Quantity):
+    #     roughness = Quantity(roughness, 'm')
+    # assert type(shape) in (str, None), 'shape needs to be a string, got %r' % shape
+
+    if props=='ideal':
+        if statepoint.fluid.lower()=='air':
+            rho = statepoint.p.to('bar').magnitude * 1.e5 / (287.058 * (statepoint.t.magnitude+273.15))
+        else:
+            raise Exception('No ideal density calcs available for this fluid')
+    else:
+        rho = statepoint.rho
+
+    m = statepoint.m
+
+    if type(shape) is str:
+        if shape.lower() in ('round', 'circle'):
+            d_h = d1
+            v = m / rho / (3.14/4.*d_h**2.)
+        elif shape.lower() == 'square':
+            d_h = d1
+            v = m / rho / d_h**2.
+        elif shape.lower() == 'rectangle':
+            if d2 == None:
+                raise Exception("d2 must be set for rectangular pressure drop calcs")
+            d_h = 4.*d1*d2 / (2. * d1 + 2. * d2)
+            v = m / rho / (d1 * d2)
+        elif shape.lower() == 'pillow':
+            #use this for a mueller plate, assumes d1 is pillow height and d2 is pillow width but they can acutally be put in any which way
+            if d2 == None:
+                raise Exception("d2 must be set for pillow pressure drop calcs")
+            A = d1*d2*2.
+            P = ((d1/2.)**2 + (d2/2.)**2)**(0.5)*4.
+            d_h = 4. * A / P
+            v = m / rho / A
+        elif shape.lower() == 'annulus':
+            if d2 == None:
+                raise Exception("d2 must be set for annular pressure drop calcs")
+            d_h = d1 - d2
+            v = m / rho / (3.14 / 4. * (d1**2. - d2**2.))
+        elif shape.lower() == 'shell-and-tube':
+            d_h = d1
+            v = v
+        else:
+            raise ValueError(f"No calculations available for shape type {shape}")
+    elif shape is None:
+        d_h = d1
+        assert v is not None, 'Must assign either shape and dimensions or velocity'
+    else:
+        raise TypeError("Shape parameter must be string or None")
+
+    if detailed:
+        print('\t\tHydraulic diameter: ', d_h)
+        print('\t\tVelocity: ', v)
+
+    re = Re(statepoint, d_h, shape='rectangle', v=v)
+    if detailed:
+        print('\t\tRe: ', re)
+
+    ff = frictionfactor(re, roughness/d_h)
+    if detailed:
+        print('\t\tff: ', ff)
+
+    dP = (ff * rho / 2. * v**2 / d_h * L)
+    if detailed:
+        print('\t\tdP: ', dP)
+
+    if units == 'bar':
+        return dP * Quantity(1.e-5, 'bar^1*m^1*s^2*kg^-1')
+    if units in ('Pa', 'kg/m*s^2', 'kg*m^-1*s^-2'):
+        return dP
+    if units == 'kPa':
+        return dP * Quantity(1.e-3, 'kPa*kg^-1*m*s^2')
+    if units == 'psi':
+        return dP * Quantity(0.000145, 'psi*kg^-1*m*s^2')
+    if units == 'm':
+        return dP / (Quantity(9.81, 'm*s^-2') * statepoint.rho)
+    if units == 'in':
+        return (dP / (Quantity(9.81, 'm*s^-2') * statepoint.rho)).to('in')
+    else:
+        raise ValueError('No conversion for units ' + str(units))
+
+def pressure_drop_sudden_expansion(statepoint, d1, d2,roughness, units='bar'):
+    """
+    Calculates the pressure drop through a sudden expansion
+    Based on https://neutrium.net/fluid_flow/pressure-loss-from-fittings-expansion-and-reduction-in-pipe-size/
+    :param Re: Reynolds number of the inlet flow [-]
+    :param d1: diameter of inlet flow [m]
+    :param d2: diameter of the outlet flow [m]
+    :param ff: Darcy friction factor [-]
+    :param units: return units
+    :return: pressure drop [return units]
+    """
+    v = statepoint.m / statepoint.rho / (3.14 / 4. * d1 ** 2.)
+    re = Re(statepoint, d1, shape='round', v=v)
+    ff = frictionfactor(re, roughness / d1)
+
+    # raise Exception('This model seems real dubious- value shouldn\'t get so big at high diameter ratios')
+    if re < 4000:
+        K = 2. * (1. - (d1 / d2)**4.)
+    else:
+        K = (1. + 0.8 * ff) * (1. - (d1 / d2)**2.)**2.
+
+    vel = statepoint.m / statepoint.rho / (3.14 / 4. * d1**2.)
+    dP = 0.5 * K * statepoint.rho * vel**2.
+    dP.to(units)
+    return dP
+
+def pressure_drop_sudden_contraction(statepoint, roughness, d1, d2, units='bar'):
+    """
+    Calculates the pressure drop through a sudden contraction
+    Based on https://neutrium.net/fluid_flow/pressure-loss-from-fittings-expansion-and-reduction-in-pipe-size/
+    :param Re: Reynolds number of the inlet flow [-]
+    :param d1: diameter of inlet flow [m]
+    :param d2: diameter of the outlet flow [m]
+    :param ff: Darcy friction factor [-]
+    :param units: return units
+    :return: pressure drop [return units]
+    """
+    v = statepoint.m / statepoint.rho / (3.14 / 4. * d1 ** 2.)
+    re = Re(statepoint, d1, shape='round', v=v)
+    ff = frictionfactor(re, roughness / d1)
+    #raise Exception('This model seems real dubious- value shouldn\'t get so big at high diameter ratios')
+    if re < 2500:
+        K = (1.2 + 160. / re) * ((d1 / d2)**4. - 1.)
+    else:
+        K = (0.6 + 0.48 * ff) * (d1 / d2)**2. * ((d1 / d2)**2. - 1.)
+
+    dP = 0.5 * K * statepoint.rho * v**2.
+    dP.to(units)
+    print('Kc: ', K, 'Re: ', Re, 'ff: ', ff)
+    return dP
+
+def pressure_drop_tapered_contraction(statepoint, Re, d1, d2, ff, angle, units='bar'):
+    """
+    Calculates the pressure drop through a sudden contraction
+    Based on https://neutrium.net/fluid_flow/pressure-loss-from-fittings-expansion-and-reduction-in-pipe-size/
+    :param Re: Reynolds number of the inlet flow [-]
+    :param d1: diameter of inlet flow [m]
+    :param d2: diameter of the outlet flow [m]
+    :param ff: Darcy friction factor [-]
+    :param units: return units
+    :param angle: angle between the axis of the pipe and the wall of the taper [degrees]
+                    ----\
+                       ( \
+                angle (   \\_____
+        flow---->   ------ _____
+                          /
+                         /
+                    ____/
+    :return: pressure drop [return units]
+    """
+    raise Exception('This model seems real dubious- value shouldn\'t get so big at high diameter ratios')
+    dP_base = pressure_drop_sudden_contraction(statepoint=statepoint, Re=Re, d1=d1, d2=d2, ff=ff, units=units)
+    if angle < 22.5:
+        dP = dP_base * 1.6 * sin(angle * 3.14 / 180.)
+    else:
+        dP = dP_base * sqrt(sin(angle * 3.14 / 180.))
+    return dP
+
+def pressure_drop_tapered_expansion(statepoint, Re, d1, d2, ff, angle, units='bar'):
+    """
+    Calculates the pressure drop through a sudden contraction
+    Based on https://neutrium.net/fluid_flow/pressure-loss-from-fittings-expansion-and-reduction-in-pipe-size/
+    :param Re: Reynolds number of the inlet flow [-]
+    :param d1: diameter of inlet flow [m]
+    :param d2: diameter of the outlet flow [m]
+    :param ff: Darcy friction factor [-]
+    :param units: return units
+    :param angle: angle between the axis of the pipe and the wall of the taper [degrees]
+                    ----\
+                       ( \
+                angle (   \\_____
+                    ------ _____ <--- flow
+                          /
+                         /
+                    ____/
+    :return: pressure drop [return units]
+    """
+    raise Exception('This model seems real dubious- value shouldn\'t get so big at high diameter ratios')
+    dP_base = pressure_drop_sudden_expansion(statepoint=statepoint, Re=Re, d1=d1, d2=d2, ff=ff, units=units)
+    if angle < 22.5:
+        dP = dP_base * 2.6 * sin(angle * 3.14 / 180.)
+    else:
+        dP = dP_base
+    return dP
+
+def pressure_drop_fitting(statepoint, fitting_type, d1, roughness, units='bar'):
+    """
+    Calculates the pressure drop through an elbow
+    Based on https://neutrium.net/fluid_flow/pressure-loss-from-fittings-equivalent-length-method/
+    Secondary source for L/d values: http://www.metropumps.com/ResourcesFrictionLossData.pdf
+    :param statepoint: statepoint instance of fluid flowing through pipe
+    :param fitting_type: 'elbow', 'long elbow', '45 elbow'
+    :param d1: Hydraulic diameter [m]
+    :param roughness: pipe roughness [m]
+    :param units: return units [str]
+    :return: pressure drop [return units]
+    """
+    ks = {'elbow-threaded': 30.,
+          'elbow-welded': 20.,          # r/d = 1
+          'long elbow-threaded': 16.,
+          'long elbow-welded': 12.,     # r/d = 2
+          '45 elbow': 16.,
+          'tee-straight': 20.,
+          'tee-branch': 60.,
+          'ball valve': 3.,
+          'gate valve': 8.,
+          'butterfly valve': 45.,       # Source 2, derived from k ratio of butterfly valve to gate valve
+          'pipe entrance flush': 0.5,   # Source 2
+          'pipe exit': 1.               # Source 2
+          }
+    try:
+        Ldeq = ks[fitting_type]
+    except:
+        raise ValueError('No minor loss coefficient for %s. Please select from %s' % (fitting_type, list(ks.keys())))
+    dP = pressure_drop(statepoint=statepoint, roughness=roughness, L=d1 * Ldeq, d1=d1, units=units)
+
+    return dP.to(units)
+
+def pressure_drop_packed_bed(statepoint, L, d,A_cross,epsilon, units='bar'):
+    velocity = statepoint.m/(A_cross*statepoint.rho)
+    dP = L*(150.*statepoint.visc*velocity*(1-epsilon)**2/(d**2*epsilon**3) + 1.75*statepoint.rho*velocity**2*(1-epsilon)/(d*epsilon**3))
+
+    return dP.to(units)
+
+def pressure_drop_corrugated_plates(statepoint, length, width, spacing, chevron_angle, detailed=False, units='bar'):
+    """
+    Calcualtes the pressure drop through a channel of corrugated plates, such as in a brazed plate heat exchanger
+    Based on http://achp.sourceforge.net/ACHPComponents/PlateHeatExchanger.html#single-phase-flow
+    Seems to match Alfa Lavals pressure drop calculations pretty well
+    :param statepoint: a statepoint instance of the fluid flowing through the hx
+    :param length: plate length (in direction of flow)
+    :param width: plate width (perpendicular to direction of flow)
+    :param spacing: spacing between the plates [m]
+    :param chevron_angle: Angle between flow direction and chevron lines in radians. pi/2 is perpendicular to flow, 0 is parallel to flow
+    :return: pressure drop in specified units
+    """
+    assert chevron_angle < 3.14/2., 'Chevron angle must be in radians, not degrees, and between 0 and pi/2'
+
+    vel = statepoint.m / (statepoint.rho * spacing * width)
+    if detailed:
+        print('\tVelocity: ', vel)
+    d_h = 2. * width * spacing / (width + spacing)
+    re = statepoint.rho * vel * d_h / statepoint.visc
+    if detailed:
+        print('\tReynolds number: ', re)
+
+    zeta0 = 1. / (1.8 * log(re) - 1.5) ** 2.
+    zeta1 = 3.8 * 39. / re ** 0.289
+    ff = 1. / (cos(chevron_angle) / sqrt(0.18 * tan(chevron_angle) + 0.36 * sin(chevron_angle) + zeta0 / cos(chevron_angle)) +
+               (1. - cos(chevron_angle)) / sqrt(zeta1)) ** 2.
+    if detailed:
+        print('\tFriction factor: ', ff)
+    hg = ff * re ** 2. / 2.
+    if detailed:
+        print('\tHagen number: ', hg)
+    dP_hg = hg * statepoint.visc ** 2. * length / (statepoint.rho * d_h ** 3.)
+    if detailed:
+        print('\tPressure drop: ', dP_hg)
+    return dP_hg.to(units)
+
+
+def flow_at_dp(statepoint, dP, roughness, L, d1, d2=None, v=None, shape='round', props='REFPROP', detailed=False):
+    from thermofluids.Base import Statepoint
+    sp = Statepoint(fluid=statepoint.fluid, h=statepoint.h, p=statepoint.p, m=0.1)
+    res = 1.
+    while res > 0.001:
+        dP_check = pressure_drop(sp, roughness, L, d1, d2, v, shape, props, units=dP.units, detailed=detailed)
+        sp.set_m(sp.m * (dP / dP_check)**0.5)
+        res = abs(dP_check - dP) / dP.magnitude
+        if detailed:
+            print(sp.m, dP, dP_check, res)
+
+    return sp.m
+
+
+if __name__ == '__main__':
+    from thermofluids.Base import Statepoint
+    from thermofluids.Base import Quantity
+
+    s = Statepoint(fluid='air')
+    s.set_t(0.)
+    s.set_p(1.)
+    s.set_m(3.)
+
+    # print PressureDrop(statepoint=s, roughness=1.e-6, L=100., d1=0.1, d2=1., shape='rectangle')
+    d1 = Quantity(0.1, 'm')
+    d2 = Quantity(0.2, 'm')
+    # print pressure_drop_sudden_expansion(statepoint=s, Re=6000., d1=d1, d2=d2, ff=1.e-5)
+
+    s = Statepoint(fluid='water', t=10., p=1., m=0.116)
+    dP = Quantity(0.5, 'bar')
+    roughness = Quantity(1.e-4, 'm')
+    L = Quantity(1., 'm')
+    d = Quantity(0.25, 'in').to('m')
+    s.set_m(flow_at_dp(statepoint=s, dP=dP, roughness=roughness, L=L, d1=d, detailed=True))
+    print('Pressure drop check: ', pressure_drop(statepoint=s, roughness=roughness, L=L, d1=d))

thermofluids/Fluids/Re.py

@@ -0,0 +1,88 @@
+from warnings import warn
+
+from thermofluids import Quantity, Statepoint
+
+
+def Re(statepoint, d_h, d_2=None, shape='round', v=None):
+    assert type(statepoint) is Statepoint, 'Statepoint must be a statepoint instance'
+    assert type(d_h) is Quantity, 'Hydraulic diameter must a Quantity instance'
+    assert d_h.check('[length]'), f'Hydraulic diameter must have units of length but has units {d_h.units}'
+    if v == None:
+        if shape=='round' or shape=='circle':
+            v = statepoint.m / statepoint.rho / (3.14/4.*d_h**2.)
+            d_h_x = d_h
+        elif shape=='square':
+            v = statepoint.m / statepoint.rho / d_h**2.
+            d_h_x = d_h
+        elif shape=='rectangle':
+            v = statepoint.m / statepoint.rho / (d_h * d_2)
+            d_h_x = 2. * d_h * d_2 / (d_h + d_2)
+        elif shape=='annulus':
+            assert d_2 is not None, 'd_2 must be set for annulus'
+            assert d_h > d_2, 'd_h must be greater than d_2 for an annulus'
+            v = statepoint.m / statepoint.rho / (3.14 / 4. * (d_h**2. - d_2**2.))
+            d_h_x = d_h - d_2
+        else:
+            raise Exception("No velocity calc available for shape '%s'. Please provide a velocity as an input" % shape)
+    else:
+        d_h_x = d_h
+
+    rho = statepoint.rho
+    try:
+        mu = statepoint.visc
+    except ValueError as e:
+        newFluid = statepoint.fluid.split(':')[1].split('&')[0].split('[')[0]
+        warn('Using %s instead because ' % newFluid + e.message)
+        rho = statepoint.rho
+        if 0. <= statepoint.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=statepoint.p, x=statepoint.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=statepoint.fluid, p=statepoint.p, x=0.).t
+            tSatNew = Statepoint(fluid=newFluid, p=statepoint.p, x=0.).t
+            newSP = Statepoint(fluid=newFluid, p=statepoint.p, t=tSatNew + statepoint.t - tSatOld)
+            mu = newSP.visc
+
+    return rho * v * d_h_x / mu
+
+def Re_ext(statepoint, vel, d1, d2=None, shape=None):
+    """
+    Reynolds number for external flow
+    :param statepoint: statepoint of fluid flowing over object
+    :param vel: velocty m/s
+    :param d1: dimension 1 [m]
+    :param d2: dimension 2 [m]
+    :param shape: not implemented
+    :return:
+    """
+    # TODO: expand to calculate d_h for different geometries    rho = statepoint.rho
+    try:
+        mu = statepoint.visc
+        rho = statepoint.rho
+    except ValueError as e:
+        newFluid = statepoint.fluid.split(':')[1].split('&')[0].split('[')[0]
+        warn('Using %s instead because ' % newFluid + e.message)
+        rho = statepoint.rho
+        if 0. <= statepoint.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=statepoint.p, x=statepoint.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=statepoint.fluid, p=statepoint.p, x=0.).t
+            tSatNew = Statepoint(fluid=newFluid, p=statepoint.p, x=0.).t
+            newSP = Statepoint(fluid=newFluid, p=statepoint.p, t=tSatNew + statepoint.t - tSatOld)
+            mu = newSP.visc
+
+    return rho * vel * d1 / mu
+
+
+if __name__ == "__main__":
+
+    s = Statepoint(fluid='water')
+    s.set_t(25.)
+    s.set_p(1.)
+    s.set_m(0.01)
+    print(Re(statepoint=s, d_h=Quantity(0.01, 'm')))

thermofluids/Fluids/__init__.py

@@ -0,0 +1,4 @@
+from thermofluids.Fluids.Drag import f_drag, settling_vel
+from thermofluids.Fluids.Moody import frictionfactor
+from thermofluids.Fluids.PressureDrop import pressure_drop, pressure_drop_fitting, pressure_drop_corrugated_plates, pressure_drop_packed_bed,pressure_drop_sudden_expansion,pressure_drop_sudden_contraction
+from thermofluids.Fluids.Re import Re, Re_ext

thermofluids/HeatTransfer/Gr.py

@@ -0,0 +1,12 @@
+from thermofluids.Base import Quantity, Statepoint
+
+
+def Gr(statepoint, L, t_wall):
+    assert isinstance(statepoint, Statepoint)
+    assert isinstance(L, Quantity)
+    assert isinstance(t_wall, Quantity)
+
+    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