processpi 0.1.2.11__tar.gz → 0.2.0__tar.gz

{processpi-0.1.2.11 → processpi-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processpi
-Version: 0.1.2.11
+Version: 0.2.0
 Summary: Python toolkit for chemical engineering simulations, equipment design, and unit conversions
 Home-page: https://github.com/varma666/ProcessPi
 Author: Raviteja Varma Nadimpalli
@@ -49,7 +49,11 @@ Dynamic: requires-python
 </p>
 
 <h1 align="center">Process PI</h1>
-
+<p align="center">
+  <a href="https://pepy.tech/projects/processpi">
+    <img src="https://static.pepy.tech/personalized-badge/processpi?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads"/>
+  </a>
+</p>
 <p align="center">
   <strong>Python toolkit for chemical engineering simulations, equipment design, and unit conversions</strong>
 </p>
@@ -77,6 +81,16 @@ Dynamic: requires-python
   </a>
 </p>
 
+<p align="center">
+  <a href="https://colab.research.google.com/github/varma666/ProcessPi/blob/main/notebooks/getting_started.ipynb">
+    <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open in Colab"/>
+  </a>
+  <a href="https://mybinder.org/v2/gh/varma666/ProcessPi/HEAD?filepath=notebooks/getting_started.ipynb">
+    <img src="https://mybinder.org/badge_logo.svg" alt="Launch Binder"/>
+  </a>
+</p>
+
+
 <p align="center">
   <em>Built with ❤️ for chemical engineers.</em>
 </p>

{processpi-0.1.2.11 → processpi-0.2.0}/README.md

@@ -3,7 +3,11 @@
 </p>
 
 <h1 align="center">Process PI</h1>
-
+<p align="center">
+  <a href="https://pepy.tech/projects/processpi">
+    <img src="https://static.pepy.tech/personalized-badge/processpi?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads"/>
+  </a>
+</p>
 <p align="center">
   <strong>Python toolkit for chemical engineering simulations, equipment design, and unit conversions</strong>
 </p>
@@ -31,6 +35,16 @@
   </a>
 </p>
 
+<p align="center">
+  <a href="https://colab.research.google.com/github/varma666/ProcessPi/blob/main/notebooks/getting_started.ipynb">
+    <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open in Colab"/>
+  </a>
+  <a href="https://mybinder.org/v2/gh/varma666/ProcessPi/HEAD?filepath=notebooks/getting_started.ipynb">
+    <img src="https://mybinder.org/badge_logo.svg" alt="Launch Binder"/>
+  </a>
+</p>
+
+
 <p align="center">
   <em>Built with ❤️ for chemical engineers.</em>
 </p>

{processpi-0.1.2.11 → processpi-0.2.0}/processpi/calculations/fluids/friction_factor_colebrookwhite.py

@@ -36,49 +36,41 @@ class ColebrookWhite(CalculationBase):
             if key not in self.inputs:
                 raise ValueError(f"Missing required input: {key}")
 
+        # In your `friction_factor_colebrookwhite.py` file
+
+    # In your `friction_factor_colebrookwhite.py` file
+
     def calculate(self):
         """
         Calculates the Darcy friction factor.
-
-        The method first checks if the flow is laminar (Re < 2000). If so, it
-        uses the simple and direct formula f = 64/Re. For turbulent flow (Re >= 2000),
-        it solves the implicit Colebrook-White equation iteratively.
-
-        Returns:
-            Dimensionless: The calculated Darcy friction factor.
         """
-        # Retrieve and validate input values.
+        # Retrieve Reynolds number and diameter using _get_value
         Re = self._get_value(self.inputs["reynolds_number"], "reynolds_number")
-        D = self._get_value(self.inputs["diameter"], "diameter")  # m
-        eps = self._get_value(self.inputs["roughness"], "roughness")  # mm
+        D = self._get_value(self.inputs["diameter"], "diameter")
+        #print(D)
+        eps_mm = self._get_value(self.inputs["roughness"], "roughness") 
+        #print(eps_mm)
+        eps_m = eps_mm / 1000  # Convert to mm
+        #print(eps_m)
 
-        # Handle the special case of laminar flow, where the friction factor
-        # is a simple, direct calculation and not an iterative one.
+
+        # Handle the special case of laminar flow.
         if Re < 2000:
             f = 64.0 / Re
             return Dimensionless(f)
 
         # For turbulent flow, solve the Colebrook-White equation iteratively.
-        # We start with a common initial guess for the friction factor.
         f = 0.02
-        tol = 1e-6  # Tolerance for convergence
-        max_iter = 100  # Maximum number of iterations to prevent an infinite loop
+        tol = 1e-6
+        max_iter = 100
 
         for _ in range(max_iter):
-            # Calculate both sides of the rearranged Colebrook-White equation.
-            lhs = 1.0 / math.sqrt(f)
-            rhs = -2.0 * math.log10((eps / (3.7 * D)) + (2.51 / (Re * math.sqrt(f))))
-
-            # Calculate the new value of f based on the rhs.
+            rhs = -2.0 * math.log10((eps_m / (3.7 * D)) + (2.51 / (Re * math.sqrt(f))))
             new_f = 1.0 / (rhs**2)
 
-            # Check for convergence. If the change in f is less than the tolerance,
-            # we have a stable solution and can return the result.
             if abs(new_f - f) < tol:
                 return Dimensionless(new_f)
-            
-            # Update f for the next iteration.
+
             f = new_f
 
-        # If the loop finishes without converging, return the last calculated value.
-        return Dimensionless(f)
+        return Dimensionless(f)

{processpi-0.1.2.11 → processpi-0.2.0}/processpi/calculations/fluids/pressure_drop_darcy.py

@@ -59,7 +59,7 @@ class PressureDropDarcy(CalculationBase):
         D = self._get_value(self.inputs["diameter"], "diameter")    # m
         rho = self._get_value(self.inputs["density"], "density")    # kg/m³
         v = self._get_value(self.inputs["velocity"], "velocity")    # m/s
-
+        #print(D)
         # Apply the Darcy-Weisbach formula to calculate the pressure drop.
         delta_P = f * (L / D) * (rho * v**2 / 2)
         

{processpi-0.1.2.11 → processpi-0.2.0}/processpi/calculations/fluids/reynolds_number.py

@@ -59,7 +59,7 @@ class ReynoldsNumber(CalculationBase):
         v = self._get_value(self.inputs["velocity"], "velocity")       # m/s
         D = self._get_value(self.inputs["diameter"], "diameter")       # m
         viscosity = self.inputs["viscosity"]
-
+        #print(D,v,rho,viscosity)
         # Check the type of viscosity provided (dynamic or kinematic) and apply
         # the corresponding formula to calculate the Reynolds number.
         if viscosity.viscosity_type == "dynamic":

processpi-0.2.0/processpi/calculations/heat_transfer/biot.py

@@ -0,0 +1,21 @@
+from ..base import CalculationBase
+from ...units import *
+
+class BiotNumber(CalculationBase):
+    """
+    Biot number.
+
+    **Formula:**
+        Bi = h * Lc / k
+    """
+    def validate_inputs(self):
+        required = ["h", "Lc", "k"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        h = self._get_value(self.inputs["h"], "heat_transfer_coefficient")
+        Lc = self._get_value(self.inputs["Lc"], "length")
+        k = self._get_value(self.inputs["k"], "thermal_conductivity")
+        return Dimensionless(h * Lc / k)

processpi-0.2.0/processpi/calculations/heat_transfer/boiling_chen.py

@@ -0,0 +1,41 @@
+from ..base import CalculationBase
+from ...units import *
+
+class ChenBoiling(CalculationBase):
+    """
+    Chen correlation for **flow boiling heat transfer**.
+
+    **Formula (simplified):**
+        h_total = S * h_pool + F * h_conv
+
+    **Where:**
+        * h_total = overall heat transfer coefficient [W/m²·K]
+        * h_pool = pool boiling coefficient (from Rohsenow or others)
+        * h_conv = forced convection coefficient (from Dittus-Boelter or similar)
+        * S = suppression factor (empirical, function of Re, Boiling number, etc.)
+        * F = enhancement factor (empirical, function of flow parameters)
+
+    **Inputs:**
+        * h_pool
+        * h_conv
+        * S
+        * F
+
+    **Output:**
+        * HeatTransferCoefficient [W/m²·K]
+    """
+
+    def validate_inputs(self):
+        required = ["h_pool", "h_conv", "S", "F"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        h_pool = self._get_value(self.inputs["h_pool"], "heat_transfer_coefficient")
+        h_conv = self._get_value(self.inputs["h_conv"], "heat_transfer_coefficient")
+        S      = self._get_value(self.inputs["S"], "dimensionless")
+        F      = self._get_value(self.inputs["F"], "dimensionless")
+
+        h_total = S * h_pool + F * h_conv
+        return HeatTransferCoefficient(h_total)

processpi-0.2.0/processpi/calculations/heat_transfer/combined_modes.py

@@ -0,0 +1,45 @@
+from ..base import CalculationBase
+from ...units import *
+
+class ConductionConvectionCombined(CalculationBase):
+    """
+    Heat transfer with conduction resistance + convection resistance.
+
+    **Formula:**
+        Q = (Ts - T∞) / (R_cond + R_conv)
+
+    Where:
+        R_cond = dx / (k * A)
+        R_conv = 1 / (h * A)
+
+    **Inputs:**
+        * `thickness`: Conduction thickness [m]
+        * `k`: Thermal conductivity [W/m·K]
+        * `h`: Convective coefficient [W/m²·K]
+        * `area`: Heat transfer area [m²]
+        * `T_surface`: Surface temperature [K]
+        * `T_fluid`: Bulk fluid temperature [K]
+
+    **Output:**
+        * HeatFlow [W]
+    """
+
+    def validate_inputs(self):
+        required = ["thickness", "k", "h", "area", "T_surface", "T_fluid"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        dx = self._get_value(self.inputs["thickness"], "length")
+        k = self._get_value(self.inputs["k"], "thermal_conductivity")
+        h = self._get_value(self.inputs["h"], "heat_transfer_coefficient")
+        A = self._get_value(self.inputs["area"], "area")
+        Ts = self._get_value(self.inputs["T_surface"], "temperature")
+        Tinf = self._get_value(self.inputs["T_fluid"], "temperature")
+
+        R_cond = dx / (k * A)
+        R_conv = 1 / (h * A)
+
+        Q = (Ts - Tinf) / (R_cond + R_conv)
+        return HeatFlow(Q)

processpi-0.2.0/processpi/calculations/heat_transfer/condensation.py

@@ -0,0 +1,46 @@
+import math
+from ..base import CalculationBase
+from ...units import *
+
+class CondensingVapourFilm(CalculationBase):
+    """
+    Heat transfer from condensing vapours on a vertical plate (Nusselt’s theory).
+
+    **Formula:**
+        h = 0.943 * [ (ρ_l * (ρ_l - ρ_v) * g * h_fg * k_l^3) / (μ_l * L * ΔT) ]^(1/4)
+
+    Then:
+        Q = h * A * ΔT
+
+    **Inputs:**
+        * `rho_l`: Liquid density [kg/m³]
+        * `rho_v`: Vapour density [kg/m³]
+        * `g`: Gravity [m/s²]
+        * `h_fg`: Latent heat [J/kg]
+        * `k_l`: Liquid thermal conductivity [W/m·K]
+        * `mu_l`: Liquid viscosity [Pa·s]
+        * `L`: Plate length [m]
+        * `A`: Area [m²]
+        * `deltaT`: Temperature difference [K]
+    """
+
+    def validate_inputs(self):
+        required = ["rho_l", "rho_v", "g", "h_fg", "k_l", "mu_l", "L", "A", "deltaT"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        rho_l = self._get_value(self.inputs["rho_l"], "density")
+        rho_v = self._get_value(self.inputs["rho_v"], "density")
+        g = self._get_value(self.inputs["g"], "acceleration")
+        h_fg = self._get_value(self.inputs["h_fg"], "specific_energy")
+        k_l = self._get_value(self.inputs["k_l"], "thermal_conductivity")
+        mu_l = self._get_value(self.inputs["mu_l"], "dynamic_viscosity")
+        L = self._get_value(self.inputs["L"], "length")
+        A = self._get_value(self.inputs["A"], "area")
+        dT = self._get_value(self.inputs["deltaT"], "temperature")
+
+        h = 0.943 * ((rho_l * (rho_l - rho_v) * g * h_fg * k_l**3) / (mu_l * L * dT))**0.25
+        Q = h * A * dT
+        return HeatFlow(Q)

processpi-0.2.0/processpi/calculations/heat_transfer/condensation_dropwise.py

@@ -0,0 +1,35 @@
+from ..base import CalculationBase
+from ...units import *
+
+class DropwiseCondensation(CalculationBase):
+    """
+    Empirical correlations for **dropwise condensation**.
+
+    Dropwise condensation has much higher heat transfer coefficients
+    than filmwise (often 5–10× larger).
+
+    **Simple empirical model:**
+        h_dw = C * h_fw
+
+    **Where:**
+        * h_dw = dropwise condensation heat transfer coefficient [W/m²·K]
+        * h_fw = filmwise condensation coefficient [W/m²·K] (from Nusselt theory)
+        * C = enhancement factor (typically 5–10, depending on surface treatment)
+
+    **Inputs:**
+        * h_fw   – filmwise coefficient [W/m²·K]
+        * C      – enhancement factor (default: 7)
+
+    **Output:**
+        * HeatTransferCoefficient [W/m²·K]
+    """
+
+    def validate_inputs(self):
+        if "h_fw" not in self.inputs:
+            raise ValueError("Missing required input: h_fw")
+
+    def calculate(self):
+        h_fw = self._get_value(self.inputs["h_fw"], "heat_transfer_coefficient")
+        C    = self.inputs.get("C", 7.0)
+        h_dw = C * h_fw
+        return HeatTransferCoefficient(h_dw)

processpi-0.2.0/processpi/calculations/heat_transfer/condensation_nusselt.py

@@ -0,0 +1,52 @@
+import math
+from ..base import CalculationBase
+from ...units import *
+
+class NusseltCondensation(CalculationBase):
+    """
+    Filmwise condensation heat transfer coefficient
+    based on **Nusselt’s theory** (laminar film condensation on vertical surface).
+
+    **Formula (vertical plate/tube):**
+        h = 0.943 * [ (k_l^3 * rho_l^2 * g * h_fg) / (mu_l * L * ΔT) ]^(1/4)
+
+    **Where:**
+        * h = average heat transfer coefficient [W/m²·K]
+        * k_l = liquid thermal conductivity [W/m·K]
+        * rho_l = liquid density [kg/m³]
+        * g = gravity [m/s²]
+        * h_fg = latent heat of vaporization [J/kg]
+        * mu_l = liquid viscosity [Pa·s]
+        * L = characteristic length (plate height or tube length) [m]
+        * ΔT = (T_wall – T_sat) [K]
+
+    **Inputs:**
+        * k_l
+        * rho_l
+        * g
+        * h_fg
+        * mu_l
+        * L
+        * dT
+
+    **Output:**
+        * HeatTransferCoefficient [W/m²·K]
+    """
+
+    def validate_inputs(self):
+        required = ["k_l", "rho_l", "g", "h_fg", "mu_l", "L", "dT"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        k_l   = self._get_value(self.inputs["k_l"], "thermal_conductivity")
+        rho_l = self._get_value(self.inputs["rho_l"], "density")
+        g     = self._get_value(self.inputs["g"], "acceleration")
+        h_fg  = self._get_value(self.inputs["h_fg"], "specific_energy")
+        mu_l  = self._get_value(self.inputs["mu_l"], "dynamic_viscosity")
+        L     = self._get_value(self.inputs["L"], "length")
+        dT    = self._get_value(self.inputs["dT"], "temperature")
+
+        h = 0.943 * ((k_l**3 * rho_l**2 * g * h_fg) / (mu_l * L * dT)) ** 0.25
+        return HeatTransferCoefficient(h)

processpi-0.2.0/processpi/calculations/heat_transfer/crossflow_tube.py

@@ -0,0 +1,34 @@
+from ..base import CalculationBase
+from ...units import *
+
+class CrossFlowSingleTube(CalculationBase):
+    """
+    Heat transfer to/from fluid flowing normal to a single tube.
+
+    **Formula:**
+        Q = h * A * (T_surface - T_fluid)
+
+    **Inputs:**
+        * `h`: Convective heat transfer coefficient [W/m²·K]
+        * `diameter`: Tube outer diameter [m]
+        * `length`: Tube length [m]
+        * `T_surface`: Tube surface temperature [K]
+        * `T_fluid`: Bulk fluid temperature [K]
+    """
+
+    def validate_inputs(self):
+        required = ["h", "diameter", "length", "T_surface", "T_fluid"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        h = self._get_value(self.inputs["h"], "heat_transfer_coefficient")
+        D = self._get_value(self.inputs["diameter"], "length")
+        L = self._get_value(self.inputs["length"], "length")
+        Ts = self._get_value(self.inputs["T_surface"], "temperature")
+        Tinf = self._get_value(self.inputs["T_fluid"], "temperature")
+
+        A = math.pi * D * L
+        Q = h * A * (Ts - Tinf)
+        return HeatFlow(Q)

processpi-0.2.0/processpi/calculations/heat_transfer/fourier.py

@@ -0,0 +1,22 @@
+from ..base import CalculationBase
+from ...units import *
+
+class FourierNumber(CalculationBase):
+    """
+    Fourier number (transient conduction).
+
+    **Formula:**
+        Fo = α * t / L²
+    """
+    def validate_inputs(self):
+        required = ["alpha", "time", "L"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        alpha = self._get_value(self.inputs["alpha"], "thermal_diffusivity")
+        t     = self._get_value(self.inputs["time"], "time")
+        L     = self._get_value(self.inputs["L"], "length")
+
+        return Dimensionless(alpha * t / (L**2))

processpi-0.2.0/processpi/calculations/heat_transfer/fourierlaw.py

@@ -0,0 +1,40 @@
+from ..base import CalculationBase
+from ...units import *
+
+class FourierLaw(CalculationBase):
+    """
+    Heat transfer rate by conduction (Fourier's Law).
+
+    **Formula:**
+        q = k * A * (ΔT / dx)
+
+    **Where:**
+        * k   = Thermal conductivity [W/m·K]
+        * A   = Cross-sectional area [m²]
+        * ΔT  = Temperature difference [K]
+        * dx  = Thickness of material [m]
+
+    **Inputs:**
+        * `conductivity`: Thermal conductivity (k).
+        * `area`: Heat transfer area (A).
+        * `deltaT`: Temperature difference (ΔT).
+        * `thickness`: Material thickness (dx).
+
+    **Output:**
+        * HeatFlow [W]
+    """
+
+    def validate_inputs(self):
+        required = ["conductivity", "area", "deltaT", "thickness"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        k = self._get_value(self.inputs["conductivity"], "conductivity")  # W/m·K
+        A = self._get_value(self.inputs["area"], "area")                  # m²
+        dT = self._get_value(self.inputs["deltaT"], "temperature")        # K
+        dx = self._get_value(self.inputs["thickness"], "length")          # m
+
+        q = k * A * (dT / dx)  # W
+        return HeatFlow(q)  # return in Watts

processpi-0.2.0/processpi/calculations/heat_transfer/grashof.py

@@ -0,0 +1,24 @@
+from ..base import CalculationBase
+from ...units import *
+
+class GrashofNumber(CalculationBase):
+    """
+    Grashof number (buoyancy vs. viscous forces in natural convection).
+
+    **Formula:**
+        Gr = g * β * ΔT * L³ / ν²
+    """
+    def validate_inputs(self):
+        required = ["g", "beta", "dT", "L", "nu"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        g   = self._get_value(self.inputs["g"], "acceleration")
+        beta = self._get_value(self.inputs["beta"], "thermal_expansion_coefficient")
+        dT  = self._get_value(self.inputs["dT"], "temperature")
+        L   = self._get_value(self.inputs["L"], "length")
+        nu  = self._get_value(self.inputs["nu"], "kinematic_viscosity")
+
+        return Dimensionless((g * beta * dT * (L**3)) / (nu**2))

processpi-0.2.0/processpi/calculations/heat_transfer/lmtd.py

@@ -0,0 +1,23 @@
+import math
+from ..base import CalculationBase
+from ...units import *
+
+class LMTDHeatExchanger(CalculationBase):
+    """
+    Heat Exchanger using LMTD method.
+    Q = U * A * ΔTlm
+    """
+    def validate_inputs(self):
+        required = ["U", "area", "dT1", "dT2"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        U = self._get_value(self.inputs["U"], "heat_transfer_coefficient")
+        A = self._get_value(self.inputs["area"], "area")
+        dT1 = self._get_value(self.inputs["dT1"], "temperature")
+        dT2 = self._get_value(self.inputs["dT2"], "temperature")
+
+        dTlm = dT1 if dT1 == dT2 else (dT1 - dT2) / math.log(dT1 / dT2)
+        return HeatFlow(U * A * dTlm)

processpi-0.2.0/processpi/calculations/heat_transfer/newton_cooling.py

@@ -0,0 +1,40 @@
+from ..base import CalculationBase
+from ...units import *
+
+class NewtonCooling(CalculationBase):
+    """
+    Convective heat transfer (Newton’s Law of Cooling).
+
+    **Formula:**
+        q = h * A * (Ts - T∞)
+
+    **Where:**
+        * h   = Heat transfer coefficient [W/m²·K]
+        * A   = Surface area [m²]
+        * Ts  = Surface temperature [K]
+        * T∞  = Bulk fluid temperature [K]
+
+    **Inputs:**
+        * `h`: Heat transfer coefficient.
+        * `area`: Surface area.
+        * `T_surface`: Surface temperature.
+        * `T_fluid`: Bulk fluid temperature.
+
+    **Output:**
+        * HeatFlow [W]
+    """
+
+    def validate_inputs(self):
+        required = ["h", "area", "T_surface", "T_fluid"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        h = self._get_value(self.inputs["h"], "heat_transfer_coefficient")  # W/m²·K
+        A = self._get_value(self.inputs["area"], "area")                    # m²
+        Ts = self._get_value(self.inputs["T_surface"], "temperature")       # K
+        Tinf = self._get_value(self.inputs["T_fluid"], "temperature")       # K
+
+        q = h * A * (Ts - Tinf)  # W
+        return HeatFlow(q)

processpi-0.2.0/processpi/calculations/heat_transfer/ntu.py

@@ -0,0 +1,21 @@
+from ..base import CalculationBase
+from ...units import *
+
+class NTUHeatExchanger(CalculationBase):
+    """
+    Heat Exchanger using Effectiveness-NTU method.
+    Q = ε * C_min * (T_hot,in - T_cold,in)
+    """
+    def validate_inputs(self):
+        required = ["effectiveness", "C_min", "T_hot_in", "T_cold_in"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        eps = self._get_value(self.inputs["effectiveness"], "dimensionless")
+        C_min = self._get_value(self.inputs["C_min"], "heat_capacity_rate")  # W/K
+        Th_in = self._get_value(self.inputs["T_hot_in"], "temperature")
+        Tc_in = self._get_value(self.inputs["T_cold_in"], "temperature")
+
+        return HeatFlow(eps * C_min * (Th_in - Tc_in))

processpi-0.2.0/processpi/calculations/heat_transfer/nusselt.py

@@ -0,0 +1,21 @@
+from ..base import CalculationBase
+from ...units import *
+
+class NusseltNumber(CalculationBase):
+    """
+    Nusselt number (dimensionless heat transfer coefficient).
+
+    **Formula:**
+        Nu = h * L / k
+    """
+    def validate_inputs(self):
+        required = ["h", "L", "k"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        h = self._get_value(self.inputs["h"], "heat_transfer_coefficient")
+        L = self._get_value(self.inputs["L"], "length")
+        k = self._get_value(self.inputs["k"], "thermal_conductivity")
+        return Dimensionless(h * L / k)

processpi-0.2.0/processpi/calculations/heat_transfer/overall_u.py

@@ -0,0 +1,16 @@
+from ..base import CalculationBase
+from ...units import *
+
+class OverallHeatTransferCoefficient(CalculationBase):
+    """
+    Overall heat transfer coefficient for a composite wall.
+    U = 1 / ΣR
+    """
+    def validate_inputs(self):
+        if "resistances" not in self.inputs:
+            raise ValueError("Missing required input: resistances")
+
+    def calculate(self):
+        Rs = [self._get_value(r, "thermal_resistance") for r in self.inputs["resistances"]]
+        R_total = sum(Rs)
+        return HeatTransferCoefficient(1 / R_total)