processpi 0.2.1__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processpi
-Version: 0.2.1
+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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → processpi-0.2.2}/processpi/calculations/heat_transfer/hx_kern.py

@@ -7,6 +7,8 @@ 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:
@@ -21,6 +23,8 @@ class SensibleDuty(CalculationBase):
 
 
 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:
@@ -33,6 +37,8 @@ class LatentDuty(CalculationBase):
 
 
 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:
@@ -47,6 +53,11 @@ class Reynolds(CalculationBase):
 
 
 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:
@@ -71,6 +82,8 @@ class KernShellNu(CalculationBase):
 
 
 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:
@@ -109,6 +122,12 @@ class ShellDiameterEstimate(CalculationBase):
 
 
 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:

{processpi-0.2.1 → processpi-0.2.2}/processpi/calculations/mass_transfer/distillation_stage_count.py

@@ -178,13 +178,21 @@ class DistillationStageCount(CalculationBase):
         y_cur = xD if total_condenser else y_rect(xD)  # horizontal to equilibrium first if total condenser
 
         # Stage loop
+        reached_bottoms = False
         while stages < max_stages and x_cur - xB > tol:
             # 1) Horizontal to equilibrium curve (constant y)
             # Find x_eq such that y_eq(x_eq) = y_cur
-            x_eq = self._x_from_y_on_eq(y_cur, y_eq, x_min=xB, x_max=xD)
-            if x_eq is None:
-                # If it fails, try clipping
-                x_eq = max(min(x_cur, xD), xB)
+            # Search the whole composition range: the last step lands below xB,
+            # so a search confined to [xB, xD] finds no root there and the
+            # stepping stalled until max_stages.
+            x_eq = self._x_from_y_on_eq(y_cur, y_eq, x_min=0.0, x_max=1.0)
+            if x_eq is None or x_eq <= xB:
+                # This step reaches the bottoms composition: it is the last
+                # stage, the partial reboiler.
+                stages += 1
+                strip_stages += 1
+                reached_bottoms = True
+                break
 
             # 2) Vertical to operating line:
             # if x_eq >= xF_int -> rectifying, else stripping
@@ -204,10 +212,16 @@ class DistillationStageCount(CalculationBase):
             if abs(x_cur - xB) <= tol:
                 break
 
-        # Add reboiler stage if required
-        if partial_reboiler:
-            stages += 1
-            strip_stages += 1
+        if not reached_bottoms and x_cur - xB > tol:
+            raise ValueError(
+                f"McCabe-Thiele stepping did not reach xB within {max_stages} stages; "
+                "the reflux ratio is at or below the minimum (pinch)."
+            )
+
+        # The step that reaches xB is the partial reboiler, so it is already
+        # counted; adding another stage here counted the reboiler twice.
+        # Without a partial reboiler that last step is a tray, and the count
+        # stays the same as well.
 
         # Add condenser stage if total condenser and at least one rectifying stage
         if total_condenser and rect_stages > 0:

{processpi-0.2.1 → processpi-0.2.2}/processpi/calculations/reaction_engineering/catalyst_activity.py

@@ -87,7 +87,7 @@ class CatalystActivity(CalculationBase):
         # Common pieces for models producing activity a(t)
         t = float(self.inputs["t"])
         a0 = float(self.inputs.get("a0", 1.0))
-        k_d = float(self.inputs.get("k_d", self._arrhenius_kd()))
+        k_d = float(self.inputs["k_d"]) if "k_d" in self.inputs else self._arrhenius_kd()
         if t < 0 or a0 <= 0 or k_d < 0:
             raise ValueError("Require t >= 0, a0 > 0, k_d >= 0.")
 

{processpi-0.2.1 → processpi-0.2.2}/processpi/calculations/reaction_engineering/reaction_rate.py

@@ -98,7 +98,7 @@ class ReactionRate(CalculationBase):
         if model == "power_law":
             C: Mapping[str, float] = self.inputs["C"]
             exps: Mapping[str, float] = self.inputs["exponents"]
-            k = float(self.inputs.get("k", self._arrhenius_k()))
+            k = float(self.inputs["k"]) if "k" in self.inputs else self._arrhenius_k()
             rate = k
             for sp, a in exps.items():
                 c = float(C.get(sp, 0.0))
@@ -110,7 +110,7 @@ class ReactionRate(CalculationBase):
         if model == "langmuir_hinshelwood":
             C: Mapping[str, float] = self.inputs["C"]
             K: Mapping[str, float] = self.inputs["K"]
-            k = float(self.inputs.get("k", self._arrhenius_k()))
+            k = float(self.inputs["k"]) if "k" in self.inputs else self._arrhenius_k()
             numerator = self.inputs.get("numerator", {"A": 1.0})
             denom_power = float(self.inputs.get("denom_power", 1.0))
 

processpi-0.2.2/processpi/cli.py

@@ -0,0 +1,13 @@
+import time
+from tqdm import tqdm
+
+
+def main():
+    print("Launching ProcessPI...")
+    for i in tqdm(range(50), desc="Initializing package"):
+        time.sleep(0.05)  # simulate loading
+    print("ProcessPI ready!")
+
+
+if __name__ == "__main__":
+    main()

processpi-0.2.2/processpi/components/_112trichloroethane.py

@@ -0,0 +1,57 @@
+from .base import Component
+from processpi.units import *
+
+class _112Trichloroethane(Component):
+    """
+    Represents the properties and constants for 112Trichloroethane(C2H3Cl3).
+
+    This class provides a comprehensive set of physical and thermodynamic properties
+    for 112Trichloroethane, which are essential for various process engineering calculations.
+    These properties are stored as class attributes and are available for use by other
+    calculation modules within the ProcessPI library.
+
+    **Properties:**
+    - `name`: The common name of the compound.
+    - `formula`: The chemical formula.
+    - `molecular_weight`: The molar mass in g/mol.
+    - `_critical_temperature`: The critical temperature, above which a substance
+      cannot exist as a liquid, regardless of pressure.
+    - `_critical_pressure`: The critical pressure, the vapor pressure at the
+      critical temperature.
+    - `_critical_volume`: The critical volume per kmole.
+    - `_critical_zc`: The critical compressibility factor.
+    - `_critical_acentric_factor`: The acentric factor, a measure of the
+      non-sphericity of the molecule.
+    - `_density_constants`: Constants for calculating density as a function of temperature.
+    - `_specific_heat_constants`: Constants for calculating specific heat capacity as a
+      function of temperature.
+    - `_viscosity_constants`: Constants for calculating viscosity as a function of
+      temperature.
+    - `_thermal_conductivity_constants`: Constants for calculating thermal conductivity
+      as a function of temperature.
+    - `_vapor_pressure_constants`: Constants for calculating vapor pressure as a
+      function of temperature using the Antoine equation or similar models.
+    - `_enthalpy_constants`: Constants for calculating enthalpy as a function of temperature.
+    """
+    name = "112Trichloroethane"
+    formula = "C2H3Cl3"
+    molecular_weight = 133.404
+    # Heat exchanger data, read by Component.hx_data() and httype()
+    _hx_family = "organic"
+    _hx_liquid_type = "organic"
+    _hx_fouling_key = "hydrocarbons"
+    _hx_corrosion_key = "hydrocarbon"
+
+    # Critical properties
+    _critical_temperature = Temperature(602.0, "K")
+    _critical_pressure = Pressure(4.48, "MPa")
+    _critical_volume = Volume(0.281, "m3")
+    _critical_zc = 0.252
+    _critical_acentric_factor = 0.2591
+
+    _density_constants = [0.9062, 0.25475, 602.0, 0.31]
+    _specific_heat_constants = [103350, 159.3, 0.0, 0.0, 0.0]
+    _viscosity_constants = [0.388, 736.5, -1.7063,0,0]
+    _thermal_conductivity_constants = [0.20731, -0.00024997,0,0,0]
+    _vapor_pressure_constants = [54.153,-6041.80, -4.5383, 4.98e-18, 6.0]
+    _enthalpy_constants = [5.0929e-7, 0.38013,0,0,0]

processpi-0.2.2/processpi/components/_11dibromoethane.py

@@ -0,0 +1,57 @@
+from .base import Component
+from processpi.units import *
+
+class _11Dibromoethane(Component):
+    """
+    Represents the properties and constants for 11Dibromoethane(C2H4Br2).
+
+    This class provides a comprehensive set of physical and thermodynamic properties
+    for 11Dibromoethane, which are essential for various process engineering calculations.
+    These properties are stored as class attributes and are available for use by other
+    calculation modules within the ProcessPI library.
+
+    **Properties:**
+    - `name`: The common name of the compound.
+    - `formula`: The chemical formula.
+    - `molecular_weight`: The molar mass in g/mol.
+    - `_critical_temperature`: The critical temperature, above which a substance
+      cannot exist as a liquid, regardless of pressure.
+    - `_critical_pressure`: The critical pressure, the vapor pressure at the
+      critical temperature.
+    - `_critical_volume`: The critical volume per kmole.
+    - `_critical_zc`: The critical compressibility factor.
+    - `_critical_acentric_factor`: The acentric factor, a measure of the
+      non-sphericity of the molecule.
+    - `_density_constants`: Constants for calculating density as a function of temperature.
+    - `_specific_heat_constants`: Constants for calculating specific heat capacity as a
+      function of temperature.
+    - `_viscosity_constants`: Constants for calculating viscosity as a function of
+      temperature.
+    - `_thermal_conductivity_constants`: Constants for calculating thermal conductivity
+      as a function of temperature.
+    - `_vapor_pressure_constants`: Constants for calculating vapor pressure as a
+      function of temperature using the Antoine equation or similar models.
+    - `_enthalpy_constants`: Constants for calculating enthalpy as a function of temperature.
+    """
+    name = "11Dibromoethane"
+    formula = "C2H4Br2"
+    molecular_weight = 187.861
+    # Heat exchanger data, read by Component.hx_data() and httype()
+    _hx_family = "organic"
+    _hx_liquid_type = "organic"
+    _hx_fouling_key = "hydrocarbons"
+    _hx_corrosion_key = "hydrocarbon"
+
+    # Critical properties
+    _critical_temperature = Temperature(628.0, "K")
+    _critical_pressure = Pressure(6.03, "MPa")
+    _critical_volume = Volume(0.276, "m3")
+    _critical_zc = 0.319
+    _critical_acentric_factor = 0.125
+
+    _density_constants = [0.95523, 0.26364, 628.0, 0.29825]
+    _specific_heat_constants = [149400, -231.8, 0.5946, 0.0, 0.0]
+    _viscosity_constants = [-10.457, 1101.1, -0.0031354, 0.0, 0.0]
+    _thermal_conductivity_constants = [0.1426, -0.00016402, 0.0, 0.0, 0.0]
+    _vapor_pressure_constants = [62.711, -6503.50, -5.7669, 1.04e-06, 2.0]
+    _enthalpy_constants = [5.712e-7, 0.5255, 0.0, 0.0, 0.0]

processpi-0.2.2/processpi/components/_11dichloroethane.py

@@ -0,0 +1,57 @@
+from .base import Component
+from processpi.units import *
+
+class _11Dichloroethane(Component):
+    """
+    Represents the properties and constants for 11Dichloroethane(C2H4Cl2).
+
+    This class provides a comprehensive set of physical and thermodynamic properties
+    for 11Dichloroethane, which are essential for various process engineering calculations.
+    These properties are stored as class attributes and are available for use by other
+    calculation modules within the ProcessPI library.
+
+    **Properties:**
+    - `name`: The common name of the compound.
+    - `formula`: The chemical formula.
+    - `molecular_weight`: The molar mass in g/mol.
+    - `_critical_temperature`: The critical temperature, above which a substance
+      cannot exist as a liquid, regardless of pressure.
+    - `_critical_pressure`: The critical pressure, the vapor pressure at the
+      critical temperature.
+    - `_critical_volume`: The critical volume per kmole.
+    - `_critical_zc`: The critical compressibility factor.
+    - `_critical_acentric_factor`: The acentric factor, a measure of the
+      non-sphericity of the molecule.
+    - `_density_constants`: Constants for calculating density as a function of temperature.
+    - `_specific_heat_constants`: Constants for calculating specific heat capacity as a
+      function of temperature.
+    - `_viscosity_constants`: Constants for calculating viscosity as a function of
+      temperature.
+    - `_thermal_conductivity_constants`: Constants for calculating thermal conductivity
+      as a function of temperature.
+    - `_vapor_pressure_constants`: Constants for calculating vapor pressure as a
+      function of temperature using the Antoine equation or similar models.
+    - `_enthalpy_constants`: Constants for calculating enthalpy as a function of temperature.
+    """
+    name = "11Dichloroethane"
+    formula = "C2H4Cl2"
+    molecular_weight = 98.959
+    # Heat exchanger data, read by Component.hx_data() and httype()
+    _hx_family = "organic"
+    _hx_liquid_type = "organic"
+    _hx_fouling_key = "hydrocarbons"
+    _hx_corrosion_key = "hydrocarbon"
+
+    # Critical properties
+    _critical_temperature = Temperature(523.0, "K")
+    _critical_pressure = Pressure(5.07, "MPa")
+    _critical_volume = Volume(0.24, "m3")
+    _critical_zc = 0.28
+    _critical_acentric_factor = 0.2339
+
+    _density_constants = [1.1055, 0.26533, 523.0, 0.287]
+    _specific_heat_constants = [126340, -94.63, 0.32, 0.0, 0.0]
+    _viscosity_constants = [-8.991, 870.2, -0.2805, 0.0, 0.0]
+    _thermal_conductivity_constants = [0.18881, -0.00026083, 0.0, 0.0, 0.0]
+    _vapor_pressure_constants = [66.611, -5493.10, -6.7301, 5.36e-06, 2.0]
+    _enthalpy_constants = [4.2117e-7, 0.36927, 0.0, 0.0, 0.0]

processpi-0.2.2/processpi/components/_11dichloropropane.py

@@ -0,0 +1,57 @@
+from .base import Component
+from processpi.units import *
+
+class _11Dichloropropane(Component):
+    """
+    Represents the properties and constants for 11Dichloropropane(C3H6Cl2).
+
+    This class provides a comprehensive set of physical and thermodynamic properties
+    for 11Dichloropropane, which are essential for various process engineering calculations.
+    These properties are stored as class attributes and are available for use by other
+    calculation modules within the ProcessPI library.
+
+    **Properties:**
+    - `name`: The common name of the compound.
+    - `formula`: The chemical formula.
+    - `molecular_weight`: The molar mass in g/mol.
+    - `_critical_temperature`: The critical temperature, above which a substance
+      cannot exist as a liquid, regardless of pressure.
+    - `_critical_pressure`: The critical pressure, the vapor pressure at the
+      critical temperature.
+    - `_critical_volume`: The critical volume per kmole.
+    - `_critical_zc`: The critical compressibility factor.
+    - `_critical_acentric_factor`: The acentric factor, a measure of the
+      non-sphericity of the molecule.
+    - `_density_constants`: Constants for calculating density as a function of temperature.
+    - `_specific_heat_constants`: Constants for calculating specific heat capacity as a
+      function of temperature.
+    - `_viscosity_constants`: Constants for calculating viscosity as a function of
+      temperature.
+    - `_thermal_conductivity_constants`: Constants for calculating thermal conductivity
+      as a function of temperature.
+    - `_vapor_pressure_constants`: Constants for calculating vapor pressure as a
+      function of temperature using the Antoine equation or similar models.
+    - `_enthalpy_constants`: Constants for calculating enthalpy as a function of temperature.
+    """
+    name = "11Dichloropropane"
+    formula = "C3H6Cl2"
+    molecular_weight = 112.986
+    # Heat exchanger data, read by Component.hx_data() and httype()
+    _hx_family = "organic"
+    _hx_liquid_type = "organic"
+    _hx_fouling_key = "hydrocarbons"
+    _hx_corrosion_key = "hydrocarbon"
+
+    # Critical properties
+    _critical_temperature = Temperature(560.0, "K")
+    _critical_pressure = Pressure(4.24, "MPa")
+    _critical_volume = Volume(0.291, "m3")
+    _critical_zc = 0.265
+    _critical_acentric_factor = 0.2529
+
+    _density_constants = [0.9551, 0.27794, 560.0, 0.24132]
+    _specific_heat_constants = [144560, -53.605, 0.30617, 0.0, 0.0]
+    _viscosity_constants = [-10.872, 1033.1, -0.00067435, 0.0, 0.0]
+    _thermal_conductivity_constants = [0.18, -0.00023144, 0.0, 0.0, 0.0]
+    _vapor_pressure_constants = [83.495, -6661.40, -9.2386, 6.77e-06, 2.0]
+    _enthalpy_constants = [4.774e-7, 0.39204, 0.0, 0.0, 0.0]