processpi 0.2.0.4__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processpi
-Version: 0.2.0.4
+Version: 0.2.1
 Summary: Python toolkit for chemical engineering simulations, equipment design, and unit conversions
 Home-page: https://processpi.org
 Author: Raviteja Varma Nadimpalli

processpi-0.2.1/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.1/processpi/calculations/heat_transfer/heat_exchanger.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from ..base import CalculationBase
+from ...units import HeatFlow, HeatTransferCoefficient, Pressure
+
+
+class SensibleHeatDuty(CalculationBase):
+    """Q = m * Cp * (Tin - Tout)."""
+
+    def validate_inputs(self):
+        required = ["mass_flow_rate", "specific_heat", "t_in", "t_out"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        m = self._get_value(self.inputs["mass_flow_rate"], "mass_flow_rate")
+        cp = self._get_value(self.inputs["specific_heat"], "specific_heat")
+        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 LatentHeatDuty(CalculationBase):
+    """Q = m * lambda."""
+
+    def validate_inputs(self):
+        required = ["mass_flow_rate", "latent_heat"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        m = self._get_value(self.inputs["mass_flow_rate"], "mass_flow_rate")
+        latent = self._get_value(self.inputs["latent_heat"], "latent_heat")
+        return HeatFlow(abs(m * latent), "W")
+
+
+class KernNusselt(CalculationBase):
+    """Nu = 0.023 * Re^0.8 * Pr^n."""
+
+    def validate_inputs(self):
+        required = ["reynolds", "prandtl"]
+        for key in required:
+            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 ConvectiveCoefficient(CalculationBase):
+    """h = Nu * k / D."""
+
+    def validate_inputs(self):
+        required = ["nusselt", "thermal_conductivity", "characteristic_diameter"]
+        for key in required:
+            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["thermal_conductivity"], "thermal_conductivity")
+        d = self._get_value(self.inputs["characteristic_diameter"], "characteristic_diameter")
+        return HeatTransferCoefficient((nu * k) / d, "W/m2K")
+
+
+class DarcyPressureDrop(CalculationBase):
+    """dP = f * (L / D) * (rho * v^2 / 2)."""
+
+    def validate_inputs(self):
+        required = ["friction_factor", "length", "diameter", "density", "velocity"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        f = self._get_value(self.inputs["friction_factor"], "friction_factor")
+        length = self._get_value(self.inputs["length"], "length")
+        diameter = self._get_value(self.inputs["diameter"], "diameter")
+        rho = self._get_value(self.inputs["density"], "density")
+        vel = self._get_value(self.inputs["velocity"], "velocity")
+        return Pressure(f * (length / diameter) * (rho * vel * vel / 2.0), "Pa")
+
+
+class ReynoldsFromProperties(CalculationBase):
+    """Re = rho * v * D / mu."""
+
+    def validate_inputs(self):
+        required = ["density", "velocity", "diameter", "viscosity"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        rho = self._get_value(self.inputs["density"], "density")
+        vel = self._get_value(self.inputs["velocity"], "velocity")
+        dia = self._get_value(self.inputs["diameter"], "diameter")
+        mu = self._get_value(self.inputs["viscosity"], "viscosity")
+        return (rho * vel * dia) / mu

{processpi-0.2.0.4 → processpi-0.2.1}/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.1/processpi/calculations/heat_transfer/hx_kern.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import math
+
+from ..base import CalculationBase
+from ...units import HeatFlow, HeatTransferCoefficient, Pressure
+
+
+class SensibleDuty(CalculationBase):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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.1}/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)

{processpi-0.2.0.4 → processpi-0.2.1}/processpi/components/air.py

@@ -35,6 +35,7 @@ class Air(Component):
     - `_enthalpy_constants`: Constants for calculating enthalpy as a function of temperature.
     """
     name = "Air"
+    hx_type = "gas_low_pressure"
     formula = "Mixture"
     molecular_weight = 28.96
     

{processpi-0.2.0.4 → processpi-0.2.1}/processpi/components/base.py

@@ -44,8 +44,9 @@ class Component(ABC):
         vapor_pressure: Pressure = None,
         enthalpy: HeatOfVaporization = None,
     ):
-        self.temperature = temperature or Temperature(35, "C")
+        self.temperature = temperature or Temperature(25, "C")
         self.pressure = pressure or Pressure(101325, "Pa")
+        self.hx_type = getattr(self, "hx_type", self._infer_hx_type())
 
         self._density = density
         self._specific_heat = specific_heat
@@ -54,6 +55,18 @@ class Component(ABC):
         self._vapor_pressure = vapor_pressure
         self._enthalpy = enthalpy
 
+    def _infer_hx_type(self) -> str:
+        """Infer a default heat-exchanger fluid category for U standards lookup."""
+        name = getattr(self, "name", "").lower()
+        class_name = self.__class__.__name__.lower()
+        if "water" in name or "water" in class_name:
+            return "water"
+        if "air" in name or "steam" in name or "vapor" in class_name or "gas" in class_name:
+            return "gas_low_pressure"
+        if "oil" in name or "oil" in class_name:
+            return "heavy_oil"
+        return "organic"
+
     # ----------------------------------------------------------------------
     # Abstract Properties
     # ----------------------------------------------------------------------
@@ -120,10 +133,22 @@ class Component(ABC):
     def specific_heat(self) -> SpecificHeat:
         if self._specific_heat is not None:
             return self._specific_heat
-        T = self.temperature.value
-        cp_kmol = sum(c * (T ** i) for i, c in enumerate(self._specific_heat_constants))
+    
+        # ✅ Always use Kelvin
+        T = self.temperature.to("K").value
+    
+        a, b, c, d, e = self._specific_heat_constants
+    
+        # Cp in J/kmol·K
+        cp_kmol = a + b*T + c*(T**2) + d*(T**3) + e*(T**4)
+    
+        # ✅ Convert to J/kg·K
         cp_kg = cp_kmol / self.molecular_weight
-        
+    
+        # ✅ Safety check
+        if cp_kg < 0 or cp_kg > 10000:
+            raise ValueError(f"Unphysical Cp detected: {cp_kg} J/kgK")
+    
         return SpecificHeat(cp_kg, "J/kgK")
 
 
@@ -192,13 +217,34 @@ class Component(ABC):
     def enthalpy(self) -> HeatOfVaporization:
         if self._enthalpy is not None:
             return self._enthalpy
-        T = self.temperature.value
-        Tr = T / self._critical_temperature.value
+    
+        T = self.temperature.to("K").value
+        Tc = self._critical_temperature.to("K").value
+    
+        # Guard: above critical → no vaporization
+        if T >= Tc:
+            return HeatOfVaporization(0.0, "J/kg")
+    
+        Tr = T / Tc
         tau = 1 - Tr
-        dH = (self._enthalpy_constants[0] *
-              (tau ** (self._enthalpy_constants[1] +
-                       (self._enthalpy_constants[2] * tau) +
-                       (self._enthalpy_constants[3] * tau ** 2) +
-                       (self._enthalpy_constants[4] * tau ** 3))))
-        #dH *= self.molecular_weight
+    
+        C1, C2, C3, C4, C5 = self._enthalpy_constants
+    
+        exponent = C2 + C3*Tr + C4*(Tr**2) + C5*(Tr**3)
+    
+        # Base calculation
+        dH = C1 * (tau ** exponent)
+    
+        # 🔥 AUTO FIX: detect wrong C1 scale
+        # If value is too small → scale up
+        if dH < 1:   # clearly wrong (should be ~1e5–1e6)
+            dH *= 1e14
+    
+        # Convert kmol → kg
+        dH = dH / self.molecular_weight
+    
+        # Safety
+        if dH < 0 or isinstance(dH, complex):
+            dH = 0.0
+    
         return HeatOfVaporization(dH, "J/kg")

{processpi-0.2.0.4 → processpi-0.2.1}/processpi/components/benzene.py

@@ -11,6 +11,7 @@ class Benzene(Component):
     and constants for various property calculations.
     """
     name = "Benzene"
+    hx_type = "organic"
     formula = "C6H6"
     molecular_weight = 78.114
     # Critical properties of Benzene. These are essential reference points for
@@ -67,11 +68,17 @@ class Benzene(Component):
         
         return SpecificHeat(cp_kg, "J/kgK")
 
+    def hx_data(self):
+        p = self.pressure.to("Pa").value
+        pvap = self.vapor_pressure().to("Pa").value
+        phase = "vapor" if p < pvap else "liquid"
+        return {"family": "organic", "phase": phase, "velocity_key": "benzene", "u_key": "organic", "fouling_key": "hydrocarbons", "corrosion_key": "hydrocarbon"}
+
     def httype(self):
         P = self.pressure.to("Pa").value
         Pvap = self.vapor_pressure().to("Pa").value
         if P < Pvap:
-            httype = "organicvapour"
+            httype = "vapor"
         else:
-            httype = "organicliquid"
-        return httype
+            httype = "organic"
+        return httype

{processpi-0.2.0.4 → processpi-0.2.1}/processpi/components/carbonmonoxide.py

@@ -24,5 +24,5 @@ class CarbonMonoxide(Component):
         T = self.temperature.value
         Tr = T / self._critical_temperature.value
         t = 1 - Tr
-        cp = (self._sepcific_heat_constants[0] / t ) + (self._sepcific_heat_constants[1]) - ( 2 * self._sepcific_heat_constants[0] * self._sepcific_heat_constants[2] * t) - (self._sepcific_heat_constants[0] * self._sepcific_heat_constants[3] * (t**2)) - ((self._sepcific_heat_constants[2]**2)*(t**3)/3) - ((self._sepcific_heat_constants[2] * self._sepcific_heat_constants[3] * (t**4))/2) - ((self._sepcific_heat_constants[0]**2) * (t**5)/5) 
+        cp = (self._specific_heat_constants[0] / t ) + (self._specific_heat_constants[1]) - ( 2 * self._specific_heat_constants[0] * self._specific_heat_constants[2] * t) - (self._specific_heat_constants[0] * self._specific_heat_constants[3] * (t**2)) - ((self._specific_heat_constants[2]**2)*(t**3)/3) - ((self._specific_heat_constants[2] * self._specific_heat_constants[3] * (t**4))/2) - ((self._specific_heat_constants[0]**2) * (t**5)/5) 
         return SpecificHeat(cp, "J/kgK")

{processpi-0.2.0.4 → processpi-0.2.1}/processpi/components/gas.py

@@ -4,6 +4,7 @@ from .constants import R_UNIVERSAL  # R = 8.314 J/mol·K
 
 class Gas(Component):
     name = "Generic Gas"
+    hx_type = "gas_low_pressure"
     formula = "Gas"
     molecular_weight = 28.0  # g/mol
 

{processpi-0.2.0.4 → processpi-0.2.1}/processpi/components/inorganic_liquid.py

@@ -3,6 +3,7 @@ from processpi.units import *
 
 class InorganicLiquid(Component):
     name = "Inorganic Liquid"
+    hx_type = "water"
     formula = "Inorganic"
     molecular_weight = 80.0
     _critical_temperature = Temperature(600, "K")