processpi 0.2.0.4__tar.gz → 0.2.2__tar.gz

{processpi-0.2.0.4 → processpi-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processpi
-Version: 0.2.0.4
+Version: 0.2.2
 Summary: Python toolkit for chemical engineering simulations, equipment design, and unit conversions
 Home-page: https://processpi.org
 Author: Raviteja Varma Nadimpalli
@@ -182,8 +182,8 @@ from processpi.components import Water, Ethanol
 water = Water()
 ethanol = Ethanol()
 
-print(f"Water density: {water.density()} kg/m3")
-print(f"Ethanol viscosity: {ethanol.viscosity()} Pa·s")
+print(f"Water density: {water.density()}")
+print(f"Ethanol viscosity: {ethanol.viscosity()}")
 ```
 
 ⚠ **Note**: Component data is for educational/demo purposes only. Extended property support is in progress.
@@ -200,6 +200,7 @@ from processpi.units import VolumetricFlowRate, Diameter, Length
 
 # Define pipe and fluid
 pipe = Pipe(
+    name="Main Pipe",
     internal_diameter=Diameter(50, "mm"),
     length=Length(10, "m")
 )

{processpi-0.2.0.4 → processpi-0.2.2}/README.md

@@ -135,8 +135,8 @@ from processpi.components import Water, Ethanol
 water = Water()
 ethanol = Ethanol()
 
-print(f"Water density: {water.density()} kg/m3")
-print(f"Ethanol viscosity: {ethanol.viscosity()} Pa·s")
+print(f"Water density: {water.density()}")
+print(f"Ethanol viscosity: {ethanol.viscosity()}")
 ```
 
 ⚠ **Note**: Component data is for educational/demo purposes only. Extended property support is in progress.
@@ -153,6 +153,7 @@ from processpi.units import VolumetricFlowRate, Diameter, Length
 
 # Define pipe and fluid
 pipe = Pipe(
+    name="Main Pipe",
     internal_diameter=Diameter(50, "mm"),
     length=Length(10, "m")
 )

processpi-0.2.2/processpi/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

{processpi-0.2.0.4 → processpi-0.2.2}/processpi/calculations/engine.py

@@ -12,10 +12,12 @@ from processpi.units import * # Import all unit classes
 # Import all calculation classes for the registry. This makes them available to the engine.
 from processpi.calculations.fluids.velocity import FluidVelocity
 from processpi.calculations.fluids.reynolds_number import ReynoldsNumber
+from processpi.calculations.fluids.flow_type import TypeOfFlow
 from processpi.calculations.fluids.friction_factor_colebrookwhite import ColebrookWhite
 from processpi.calculations.fluids.pressure_drop_darcy import PressureDropDarcy
 from processpi.calculations.fluids.pressure_drop_fanning import PressureDropFanning
 from processpi.calculations.fluids.pressure_drop_hazen_williams import PressureDropHazenWilliams
+from processpi.equipment.pressure_vessel import PressureVessel
 # Add more imports here as you implement new calculations
 # from processpi.calculations.fluids.pressure_drop import PressureDrop
 # from processpi.calculations.heat_transfer import HeatTransfer
@@ -59,6 +61,9 @@ class CalculationEngine:
             "reynolds_number": ReynoldsNumber,
             "re": ReynoldsNumber,
             "reynoldsnumber": ReynoldsNumber,
+            "type_of_flow": TypeOfFlow,
+            "flow_type": TypeOfFlow,
+            "flow_regime": TypeOfFlow,
             "colebrook_white": ColebrookWhite,
             "friction_factor_colebrookwhite": ColebrookWhite,
             "friction_factor": ColebrookWhite,
@@ -68,6 +73,8 @@ class CalculationEngine:
             "pressure_drop": PressureDropDarcy,
             "pressure_drop_fanning": PressureDropFanning,
             "pressure_drop_hazen_williams": PressureDropHazenWilliams,
+            "pressure_vessel": PressureVessel,
+            "vessel_design": PressureVessel,
 
             # Add more mappings as new calculations are added
             # "pressure_drop": PressureDrop,

processpi-0.2.2/processpi/calculations/heat_transfer/__init__.py

@@ -0,0 +1,92 @@
+from .biot import BiotNumber
+from .combined_modes import ConductionConvectionCombined
+from .condensation import CondensingVapourFilm
+from .condensation_dropwise import DropwiseCondensation
+from .condensation_nusselt import NusseltCondensation
+from .conduction_heat_loss import ConductionHeatLoss
+from .convection_heat_loss import ConvectionHeatLoss
+from .crossflow_tube import CrossFlowSingleTube
+from .fourier import FourierNumber
+from .fourierlaw import FourierLaw
+from .heat_exchanger import (
+    ConvectiveCoefficient,
+    DarcyPressureDrop,
+    KernNusselt,
+    LatentHeatDuty,
+    ReynoldsFromProperties,
+    SensibleHeatDuty,
+)
+from .heat_exchanger_area import HeatExchangerArea
+from .hx_kern import (
+    ConvectiveH,
+    DarcyDrop,
+    DittusBoelter,
+    KernShellNu,
+    LatentDuty,
+    Reynolds,
+    SensibleDuty,
+    ShellDiameterEstimate,
+    TubeCountFromArea,
+)
+from .lmtd import LMTD
+from .newton_cooling import NewtonCooling
+from .ntu import NTUHeatExchanger
+from .nusselt import NusseltNumber
+from .overall_u import OverallHeatTransferCoefficient
+from .peclet import PecletNumber
+from .prandtl import PrandtlNumber
+from .radial_cylinder import RadialHeatFlowCylinder
+from .radiation_blackbody import BlackbodyRadiation
+from .radiation_exchange import RadiationExchange
+from .radiation_greybody import GreybodyRadiation
+from .radiation_viewfactor import RadiationWithViewFactor
+from .resistance import ThermalResistanceParallel, ThermalResistanceSeries
+from .reyleigh import RayleighNumber
+from .rohsenow_boiling import RohsenowBoiling
+from .stefan_boltzmann import StefanBoltzmann
+
+__all__ = [
+    "BiotNumber",
+    "ConductionConvectionCombined",
+    "CondensingVapourFilm",
+    "DropwiseCondensation",
+    "NusseltCondensation",
+    "ConductionHeatLoss",
+    "ConvectionHeatLoss",
+    "CrossFlowSingleTube",
+    "FourierNumber",
+    "FourierLaw",
+    "HeatExchangerArea",
+    "LMTD",
+    "NewtonCooling",
+    "NTUHeatExchanger",
+    "NusseltNumber",
+    "OverallHeatTransferCoefficient",
+    "PecletNumber",
+    "PrandtlNumber",
+    "RadialHeatFlowCylinder",
+    "BlackbodyRadiation",
+    "RadiationExchange",
+    "GreybodyRadiation",
+    "RadiationWithViewFactor",
+    "ThermalResistanceSeries",
+    "ThermalResistanceParallel",
+    "RayleighNumber",
+    "RohsenowBoiling",
+    "StefanBoltzmann",
+    "SensibleHeatDuty",
+    "LatentHeatDuty",
+    "KernNusselt",
+    "ConvectiveCoefficient",
+    "DarcyPressureDrop",
+    "ReynoldsFromProperties",
+    "SensibleDuty",
+    "LatentDuty",
+    "Reynolds",
+    "DittusBoelter",
+    "KernShellNu",
+    "ConvectiveH",
+    "TubeCountFromArea",
+    "ShellDiameterEstimate",
+    "DarcyDrop",
+]

{processpi-0.2.0.4 → processpi-0.2.2}/processpi/calculations/heat_transfer/conduction_heat_loss.py

@@ -23,4 +23,4 @@ class ConductionHeatLoss(CalculationBase):
         L = self._get_value(self.inputs["thickness"], "thickness")                        # m
 
         Q = k * A * ΔT / L
-        return HeatFlux(Q, "W")
+        return HeatFlow(Q, "W")

{processpi-0.2.0.4 → processpi-0.2.2}/processpi/calculations/heat_transfer/convection_heat_loss.py

@@ -20,4 +20,4 @@ class ConvectionHeatLoss(CalculationBase):
         ΔT = self._get_value(self.inputs["temp_difference"], "temp_difference")         # K
 
         Q = h * A * ΔT
-        return HeatFlux(Q, "W")
+        return HeatFlow(Q, "W")

{processpi-0.2.0.4 → processpi-0.2.2}/processpi/calculations/heat_transfer/crossflow_tube.py

@@ -1,3 +1,5 @@
+import math
+
 from ..base import CalculationBase
 from ...units import *
 

processpi-0.2.2/processpi/calculations/heat_transfer/heat_exchanger.py

@@ -0,0 +1,167 @@
+"""Deprecated names for the heat exchanger calculations in ``hx_kern``.
+
+These six classes used to be a second copy of calculations that ``hx_kern``
+also implements, under other names and keywords. Only the ``hx_kern`` set is
+used by the exchangers, so it is now the single implementation. Each class
+here keeps its old keywords, its old error messages, its ``inputs`` and its
+return type, maps the keywords onto the ``hx_kern`` class and warns with a
+``DeprecationWarning``. The formulas were identical, so the numbers are too.
+
+========================  ==================  ==================================
+old name                  use instead         keywords renamed
+========================  ==================  ==================================
+SensibleHeatDuty          SensibleDuty        mass_flow_rate -> m_dot,
+                                              specific_heat -> cp
+LatentHeatDuty            LatentDuty          mass_flow_rate -> m_dot
+KernNusselt               DittusBoelter       none (0.023 Re^0.8 Pr^n is the
+                                              Dittus-Boelter form, not Kern's
+                                              shell-side ``KernShellNu``)
+ConvectiveCoefficient     ConvectiveH         thermal_conductivity -> k,
+                                              characteristic_diameter ->
+                                              diameter
+DarcyPressureDrop         DarcyDrop           friction_factor -> f
+ReynoldsFromProperties    Reynolds            none
+========================  ==================  ==================================
+"""
+
+from __future__ import annotations
+
+import warnings
+from typing import Dict, Tuple, Type
+
+from ..base import CalculationBase
+from .hx_kern import (
+    ConvectiveH,
+    DarcyDrop,
+    DittusBoelter,
+    LatentDuty,
+    Reynolds,
+    SensibleDuty,
+)
+
+
+class _DeprecatedHXCalculation(CalculationBase):
+    """Old keyword interface over one ``hx_kern`` calculation.
+
+    ``_keyword_map`` lists the required old keywords, in the order the old
+    class checked them, with the ``hx_kern`` keyword each one becomes.
+    ``_optional`` lists keywords passed through unchanged when given.
+    """
+
+    _canonical: Type[CalculationBase]
+    _keyword_map: Tuple[Tuple[str, str], ...]
+    _optional: Tuple[str, ...] = ()
+
+    def __init__(self, **kwargs):
+        warnings.warn(
+            f"{type(self).__name__} is deprecated; use "
+            f"processpi.calculations.heat_transfer.{self._canonical.__name__} "
+            f"({self._rename_note()}).",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(**kwargs)
+
+    @classmethod
+    def _rename_note(cls) -> str:
+        renamed = [f"{old} -> {new}" for old, new in cls._keyword_map if old != new]
+        return "keywords " + ", ".join(renamed) if renamed else "same keywords"
+
+    def validate_inputs(self):
+        for old, _new in self._keyword_map:
+            if old not in self.inputs:
+                raise ValueError(f"Missing required input: {old}")
+
+    def _canonical_inputs(self) -> Dict[str, object]:
+        mapped = {}
+        for old, new in self._keyword_map:
+            # Same check and message as the old class, under the old name.
+            self._get_value(self.inputs[old], old)
+            mapped[new] = self.inputs[old]
+        for key in self._optional:
+            if key in self.inputs:
+                mapped[key] = self.inputs[key]
+        return mapped
+
+    def calculate(self):
+        return self._canonical(**self._canonical_inputs()).calculate()
+
+
+class SensibleHeatDuty(_DeprecatedHXCalculation):
+    """Q = m * Cp * (Tin - Tout). Deprecated: use ``SensibleDuty``."""
+
+    _canonical = SensibleDuty
+    _keyword_map = (
+        ("mass_flow_rate", "m_dot"),
+        ("specific_heat", "cp"),
+        ("t_in", "t_in"),
+        ("t_out", "t_out"),
+    )
+
+
+class LatentHeatDuty(_DeprecatedHXCalculation):
+    """Q = m * lambda. Deprecated: use ``LatentDuty``."""
+
+    _canonical = LatentDuty
+    _keyword_map = (
+        ("mass_flow_rate", "m_dot"),
+        ("latent_heat", "latent_heat"),
+    )
+
+
+class KernNusselt(_DeprecatedHXCalculation):
+    """Nu = 0.023 * Re^0.8 * Pr^n. Deprecated: use ``DittusBoelter``.
+
+    Despite the name this is the Dittus-Boelter tube-side correlation, the
+    same formula and default n = 0.4 as ``DittusBoelter``. Kern's shell-side
+    correlation is ``KernShellNu``.
+    """
+
+    _canonical = DittusBoelter
+    _keyword_map = (
+        ("reynolds", "reynolds"),
+        ("prandtl", "prandtl"),
+    )
+    _optional = ("n",)
+
+
+class ConvectiveCoefficient(_DeprecatedHXCalculation):
+    """h = Nu * k / D. Deprecated: use ``ConvectiveH``."""
+
+    _canonical = ConvectiveH
+    _keyword_map = (
+        ("nusselt", "nusselt"),
+        ("thermal_conductivity", "k"),
+        ("characteristic_diameter", "diameter"),
+    )
+
+
+class DarcyPressureDrop(_DeprecatedHXCalculation):
+    """dP = f * (L / D) * (rho * v^2 / 2), f the Darcy factor. Deprecated: use ``DarcyDrop``.
+
+    The old body grouped ``rho * v * v / 2`` before multiplying and
+    ``DarcyDrop`` multiplies left to right, so a result can differ from the
+    old one in the last bit or two of the float (at most 4e-16 relative over
+    2700 random cases); the formula is the same.
+    """
+
+    _canonical = DarcyDrop
+    _keyword_map = (
+        ("friction_factor", "f"),
+        ("length", "length"),
+        ("diameter", "diameter"),
+        ("density", "density"),
+        ("velocity", "velocity"),
+    )
+
+
+class ReynoldsFromProperties(_DeprecatedHXCalculation):
+    """Re = rho * v * D / mu. Deprecated: use ``Reynolds``."""
+
+    _canonical = Reynolds
+    _keyword_map = (
+        ("density", "density"),
+        ("velocity", "velocity"),
+        ("diameter", "diameter"),
+        ("viscosity", "viscosity"),
+    )

{processpi-0.2.0.4 → processpi-0.2.2}/processpi/calculations/heat_transfer/heat_exchanger_area.py

@@ -14,7 +14,9 @@ class HeatExchangerArea(CalculationBase):
         for key in required:
             if key not in self.inputs:
                 raise ValueError(f"Missing required input: {key}")
-        if self.inputs["log_mean_temp_diff"].value <= 0:
+        dtlm = self.inputs["log_mean_temp_diff"]
+        dtlm_val = dtlm.value if hasattr(dtlm, "value") else float(dtlm)
+        if dtlm_val <= 0:
             raise ValueError("Log mean temperature difference must be positive")
 
     def calculate(self):

processpi-0.2.2/processpi/calculations/heat_transfer/hx_kern.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import math
+
+from ..base import CalculationBase
+from ...units import HeatFlow, HeatTransferCoefficient, Pressure
+
+
+class SensibleDuty(CalculationBase):
+    """Q = m * Cp * |Tin - Tout|. Replaces the deprecated ``SensibleHeatDuty``."""
+
+    def validate_inputs(self):
+        for key in ("m_dot", "cp", "t_in", "t_out"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        m = self._get_value(self.inputs["m_dot"], "m_dot")
+        cp = self._get_value(self.inputs["cp"], "cp")
+        t_in = self._get_value(self.inputs["t_in"], "t_in")
+        t_out = self._get_value(self.inputs["t_out"], "t_out")
+        return HeatFlow(abs(m * cp * (t_in - t_out)), "W")
+
+
+class LatentDuty(CalculationBase):
+    """Q = m * lambda. Replaces the deprecated ``LatentHeatDuty``."""
+
+    def validate_inputs(self):
+        for key in ("m_dot", "latent_heat"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        m = self._get_value(self.inputs["m_dot"], "m_dot")
+        latent = self._get_value(self.inputs["latent_heat"], "latent_heat")
+        return HeatFlow(abs(m * latent), "W")
+
+
+class Reynolds(CalculationBase):
+    """Re = rho * v * D / mu. Replaces the deprecated ``ReynoldsFromProperties``."""
+
+    def validate_inputs(self):
+        for key in ("density", "velocity", "diameter", "viscosity"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        rho = self._get_value(self.inputs["density"], "density")
+        v = self._get_value(self.inputs["velocity"], "velocity")
+        d = self._get_value(self.inputs["diameter"], "diameter")
+        mu = self._get_value(self.inputs["viscosity"], "viscosity")
+        return (rho * v * d) / mu
+
+
+class DittusBoelter(CalculationBase):
+    """Dittus-Boelter: Nu = 0.023 * Re^0.8 * Pr^n, n = 0.4 heating (default), 0.3 cooling.
+
+    Replaces the deprecated ``KernNusselt``, which was this same formula.
+    """
+
+    def validate_inputs(self):
+        for key in ("reynolds", "prandtl"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        re = self._get_value(self.inputs["reynolds"], "reynolds")
+        pr = self._get_value(self.inputs["prandtl"], "prandtl")
+        n = self.inputs.get("n", 0.4)
+        return 0.023 * re**0.8 * pr**n
+
+class KernShellNu(CalculationBase):
+    def validate_inputs(self):
+        for key in ("reynolds", "prandtl"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        re = self._get_value(self.inputs["reynolds"], "reynolds")
+        pr = self._get_value(self.inputs["prandtl"], "prandtl")
+        return 0.36 * re**0.55 * pr**(1 / 3)
+
+
+class ConvectiveH(CalculationBase):
+    """h = Nu * k / D. Replaces the deprecated ``ConvectiveCoefficient``."""
+
+    def validate_inputs(self):
+        for key in ("nusselt", "k", "diameter"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        nu = self._get_value(self.inputs["nusselt"], "nusselt")
+        k = self._get_value(self.inputs["k"], "k")
+        d = self._get_value(self.inputs["diameter"], "diameter")
+        return HeatTransferCoefficient((nu * k) / d, "W/m2K")
+
+
+class TubeCountFromArea(CalculationBase):
+    def validate_inputs(self):
+        for key in ("area", "tube_od", "tube_length"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        area = self._get_value(self.inputs["area"], "area")
+        d_o = self._get_value(self.inputs["tube_od"], "tube_od")
+        l_t = self._get_value(self.inputs["tube_length"], "tube_length")
+        return max(1, math.ceil(area / (math.pi * d_o * l_t)))
+
+
+class ShellDiameterEstimate(CalculationBase):
+    def validate_inputs(self):
+        for key in ("tube_count", "tube_pitch"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        n_t = self._get_value(self.inputs["tube_count"], "tube_count")
+        p_t = self._get_value(self.inputs["tube_pitch"], "tube_pitch")
+        return 0.637 * p_t * (n_t ** 0.5)
+
+
+class DarcyDrop(CalculationBase):
+    """Darcy-Weisbach: dP = f * (L / D) * rho * v^2 / 2.
+
+    ``f`` is the Darcy friction factor (4 times the Fanning factor).
+    Replaces the deprecated ``DarcyPressureDrop``.
+    """
+
+    def validate_inputs(self):
+        for key in ("f", "length", "diameter", "density", "velocity"):
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        f = self._get_value(self.inputs["f"], "f")
+        l = self._get_value(self.inputs["length"], "length")
+        d = self._get_value(self.inputs["diameter"], "diameter")
+        rho = self._get_value(self.inputs["density"], "density")
+        v = self._get_value(self.inputs["velocity"], "velocity")
+        return Pressure(f * (l / d) * rho * v * v / 2.0, "Pa")
+
+
+class CondensationHTC(CalculationBase):
+    """
+    Nusselt film condensation correlation
+    for vertical tube condensation.
+
+    Preliminary engineering approximation.
+    """
+
+    def validate_inputs(self):
+
+        required = (
+            "rho_l",
+            "rho_v",
+            "mu_l",
+            "k_l",
+            "h_fg",
+            "delta_t",
+            "length",
+        )
+
+        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"],
+            "rho_l",
+        )
+
+        rho_v = self._get_value(
+            self.inputs["rho_v"],
+            "rho_v",
+        )
+
+        mu_l = self._get_value(
+            self.inputs["mu_l"],
+            "mu_l",
+        )
+
+        k_l = self._get_value(
+            self.inputs["k_l"],
+            "k_l",
+        )
+
+        h_fg = self._get_value(
+            self.inputs["h_fg"],
+            "h_fg",
+        )
+
+        delta_t = self._get_value(
+            self.inputs["delta_t"],
+            "delta_t",
+        )
+
+        length = self._get_value(
+            self.inputs["length"],
+            "length",
+        )
+
+        g = 9.81
+
+        h = 0.943 * (
+            (
+                rho_l
+                * (rho_l - rho_v)
+                * g
+                * h_fg
+                * (k_l ** 3)
+            )
+            / (
+                mu_l
+                * length
+                * delta_t
+            )
+        ) ** 0.25
+
+        return HeatTransferCoefficient(
+            h,
+            "W/m2K",
+        )
+
+class BoilingHTC(CalculationBase):
+    """
+    Simplified boiling heat-transfer coefficient.
+
+    Preliminary engineering approximation.
+    """
+
+    def validate_inputs(self):
+
+        required = (
+            "heat_flux",
+            "pressure",
+        )
+
+        for key in required:
+
+            if key not in self.inputs:
+
+                raise ValueError(
+                    f"Missing required input: {key}"
+                )
+
+    def calculate(self):
+
+        q_flux = self._get_value(
+            self.inputs["heat_flux"],
+            "heat_flux",
+        )
+
+        pressure = self._get_value(
+            self.inputs["pressure"],
+            "pressure",
+        )
+
+        # ======================================================
+        # SIMPLE ENGINEERING APPROXIMATION
+        # ======================================================
+
+        h = (
+            55.0
+            * (q_flux ** 0.67)
+            * (pressure ** 0.12)
+        )
+
+        # prevent unrealistic values
+        h = max(
+            1500.0,
+            min(h, 15000.0),
+        )
+
+        return HeatTransferCoefficient(
+            h,
+            "W/m2K",
+        )

{processpi-0.2.0.4 → processpi-0.2.2}/processpi/calculations/heat_transfer/lmtd.py

@@ -14,9 +14,22 @@ class LMTD(CalculationBase):
                 raise ValueError(f"Missing required input: {key}")
 
     def calculate(self):
+        eps = 1e-6
 
         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 dTlm
+        if dT1 <= 0 or dT2 <= 0:
+            raise ValueError("Invalid temperature approach in LMTD calculation.")
+
+        dT1 = max(dT1, eps)
+        dT2 = max(dT2, eps)
+
+        if abs(dT1 - dT2) < eps:
+            return dT1
+
+        ratio = dT1 / dT2
+        if ratio <= 0:
+            raise ValueError("Invalid temperature approach in LMTD calculation.")
+
+        return (dT1 - dT2) / math.log(ratio)