processpi 0.2.0.1__tar.gz → 0.2.0.3__tar.gz

{processpi-0.2.0.1 → processpi-0.2.0.3}/PKG-INFO

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

{processpi-0.2.0.1 → processpi-0.2.0.3}/processpi/__init__.py

@@ -29,8 +29,11 @@ from . import calculations
 from . import pipelines
 from . import units
 from . import components
+from . import equipment
+from . import integration
+from . import streams
 
-__all__ = ["calculations", "pipelines", "units", "components"]
+__all__ = ["calculations", "pipelines", "units", "components","equipment","integration","streams"]
 
 # -------------------------------------------------------------------
 # Loading animation (only for interactive sessions)

processpi-0.2.0.3/processpi/equipment/__init__.py

@@ -0,0 +1,21 @@
+"""Equipment models and utilities for ProcessPI."""
+
+__all__ = [
+    "absorber",
+    "base",
+    "batch",
+    "compressor",
+    "cstr",
+    "decanter",
+    "distillation",
+    "flash",
+    "heater_cooler",
+    "heatexchangers",
+    "mixer",
+    "pfr",
+    "pumps",
+    "splitter",
+    "stripper",
+    "turbine",
+    "valves",
+]

processpi-0.2.0.3/processpi/equipment/absorber.py

@@ -0,0 +1,67 @@
+# processpi/equipment/absorber.py
+
+from __future__ import annotations
+from typing import Optional, Dict
+from .base import Equipment
+from ..streams import MaterialStream
+
+
+class Absorber(Equipment):
+    """
+    Absorber Column.
+    
+    Removes solute from gas stream into a liquid solvent.
+    
+    Assumptions (initial version):
+    - Steady state
+    - Counter-current contact
+    - Uses overall K-removal efficiency (fraction of solute absorbed)
+    - Single major solute for simplicity (extendable to multicomponent)
+    """
+
+    def __init__(self, name: str, stages: int, removal_efficiency: float):
+        super().__init__(name)
+        self.stages = stages
+        self.removal_efficiency = removal_efficiency  # 0–1 fraction
+
+        # Streams
+        self.gas_in: Optional[MaterialStream] = None
+        self.gas_out: Optional[MaterialStream] = None
+        self.liquid_in: Optional[MaterialStream] = None
+        self.liquid_out: Optional[MaterialStream] = None
+
+    def simulate(self) -> Dict:
+        if (self.gas_in is None or self.gas_out is None or
+            self.liquid_in is None or self.liquid_out is None):
+            raise ValueError(f"Absorber {self.name} must have gas_in, gas_out, liquid_in, liquid_out streams.")
+
+        F_gas = self.gas_in.flow_rate
+        F_liq = self.liquid_in.flow_rate
+
+        z_gas = self.gas_in.components.copy()
+        z_liq = self.liquid_in.components.copy()
+
+        # Pick solute (for demo: assume first component in gas is solute)
+        solute = list(z_gas.keys())[0]
+
+        # Apply removal efficiency
+        solute_in_gas = z_gas[solute] * F_gas
+        absorbed = solute_in_gas * self.removal_efficiency
+        solute_out_gas = solute_in_gas - absorbed
+
+        # Update outlet streams
+        self.gas_out.copy(self.gas_in)
+        self.liquid_out.copy(self.liquid_in)
+
+        self.gas_out.flow_rate = F_gas
+        self.liquid_out.flow_rate = F_liq + absorbed  # solute added to solvent
+
+        # Adjust compositions
+        self.gas_out.components[solute] = solute_out_gas / F_gas
+        self.liquid_out.components[solute] = absorbed / self.liquid_out.flow_rate
+
+        return {
+            "absorbed": absorbed,
+            "gas_out_comp": self.gas_out.components,
+            "liq_out_comp": self.liquid_out.components,
+        }

processpi-0.2.0.3/processpi/equipment/base.py

@@ -0,0 +1,57 @@
+# processpi/equipment/base.py
+from typing import List, Optional, Literal
+from ..streams import MaterialStream
+
+
+class Equipment:
+    """
+    Base class for all equipment units.
+    Manages inlet/outlet MaterialStreams and ensures consistent graph connections.
+    """
+
+    def __init__(self, name: str, inlet_ports: int = 0, outlet_ports: int = 0):
+        self.name = name
+        self.inlets: List[Optional[MaterialStream]] = [None] * inlet_ports
+        self.outlets: List[Optional[MaterialStream]] = [None] * outlet_ports
+
+    def attach_stream(self, stream: MaterialStream, port: Literal["inlet", "outlet"], index: int = 0):
+        """
+        Attach a MaterialStream to an inlet or outlet port.
+        Enforces port registration and ensures stream ↔ equipment consistency.
+
+        Parameters
+        ----------
+        stream : MaterialStream
+            The stream to connect
+        port : "inlet" or "outlet"
+            Whether this is an inlet or outlet connection
+        index : int
+            Port index (for multi-port equipment like mixers/splitters)
+        """
+        if not isinstance(stream, MaterialStream):
+            raise TypeError(f"Expected MaterialStream, got {type(stream).__name__}")
+
+        if port == "inlet":
+            if index >= len(self.inlets) or index < 0:
+                raise IndexError(f"Inlet port {index} out of range (max={len(self.inlets)-1})")
+            if self.inlets[index] is not None:
+                raise ValueError(f"Inlet port {index} of {self.name} already occupied")
+            self.inlets[index] = stream
+            #stream.connect_outlet(self)  # stream → equipment consistency
+
+        elif port == "outlet":
+            if index >= len(self.outlets) or index < 0:
+                raise IndexError(f"Outlet port {index} out of range (max={len(self.outlets)-1})")
+            if self.outlets[index] is not None:
+                raise ValueError(f"Outlet port {index} of {self.name} already occupied")
+            self.outlets[index] = stream
+            #stream.connect_inlet(self)  # stream ← equipment consistency
+
+        else:
+            raise ValueError("port must be 'inlet' or 'outlet'")
+
+    def __repr__(self) -> str:
+        return (
+            f"<Equipment {self.name}, "
+            f"inlets={len(self.inlets)}, outlets={len(self.outlets)}>"
+        )

processpi-0.2.0.3/processpi/equipment/batch.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from typing import Optional, Dict, Any
+from .base import Equipment
+from ..streams import MaterialStream
+
+
+class BatchReactor(Equipment):
+    """
+    Batch Reactor.
+
+    Assumptions:
+    - Closed system (no inlet/outlet during reaction).
+    - Time-dependent simulation.
+    - Reaction integrated over given time.
+    """
+
+    def __init__(self, name: str, volume: float, rate_fn: Optional[callable] = None):
+        super().__init__(name)
+        self.volume = volume
+        self.rate_fn = rate_fn
+
+    def simulate(self, time: float = 1.0, steps: int = 10) -> Dict[str, Any]:
+        stream: MaterialStream = self.inlet  # batch uses "inlet" as initial contents
+
+        if stream is None:
+            raise ValueError(f"BatchReactor {self.name} requires a feed MaterialStream as initial contents.")
+
+        if self.rate_fn:
+            dt = time / steps
+            for _ in range(steps):
+                rates = self.rate_fn(stream, stream.temperature, stream.pressure)
+                stream.apply_reaction(rates, residence_time=dt)
+
+        return {
+            "type": "BatchReactor",
+            "final_T": stream.temperature,
+            "final_F": stream.mass_flow,
+            "time": time
+        }

processpi-0.2.0.3/processpi/equipment/compressor.py

@@ -0,0 +1,80 @@
+# processpi/equipment/compressor.py
+
+from __future__ import annotations
+from typing import Optional, Dict, Any
+from .base import Equipment
+from ..streams import MaterialStream
+from ..units import Power
+
+
+class Compressor(Equipment):
+    """
+    Gas-phase compressor.
+    
+    Assumptions:
+    - Single stage.
+    - Isentropic relation with efficiency correction.
+    - No heat exchange (adiabatic).
+    """
+
+    def __init__(self, name: str,
+                 isentropic_efficiency: float = 0.75,
+                 outlet_pressure: Optional[float] = None,
+                 pressure_ratio: Optional[float] = None):
+        super().__init__(name, inlet_ports=1, outlet_ports=1)
+        self.eta = isentropic_efficiency
+        self.outlet_pressure = outlet_pressure
+        self.pressure_ratio = pressure_ratio
+
+    def simulate(self) -> Dict[str, Any]:
+        inlet: MaterialStream = self.inlets[0]
+        outlet: MaterialStream = self.outlets[0]
+
+        if inlet is None or outlet is None:
+            raise ValueError(f"{self.name}: Must have inlet and outlet streams connected.")
+
+        if inlet.phase != "vapor":
+            raise ValueError(f"{self.name}: Compressor requires vapor phase at inlet.")
+
+        P1 = inlet.pressure.to("Pa").value
+        T1 = inlet.temperature.to("K").value
+        cp = inlet.get_property("cp")          # J/kg-K
+        gamma = inlet.get_property("gamma")    # cp/cv
+        m_dot = inlet.mass_flow().to("kg/s").value
+
+        # Determine outlet pressure
+        if self.outlet_pressure is not None:
+            P2 = self.outlet_pressure.to("Pa").value
+        elif self.pressure_ratio is not None:
+            P2 = P1 * self.pressure_ratio
+        else:
+            raise ValueError("Must specify outlet_pressure or pressure_ratio.")
+
+        if P2 <= P1:
+            raise ValueError("Compressor must increase pressure (P2 > P1).")
+
+        # Ideal (isentropic) outlet temperature
+        T2s = T1 * (P2 / P1) ** ((gamma - 1) / gamma)
+
+        # Actual outlet temperature with efficiency
+        T2 = T1 + (T2s - T1) / self.eta
+
+        # Work requirement (W = m_dot * cp * ΔT)
+        w_dot = m_dot * cp * (T2 - T1)
+        power = Power(w_dot, "W")
+
+        # Update outlet stream
+        outlet.copy_from(inlet)
+        outlet.pressure = P2
+        outlet.temperature.value = T2
+        # Phase remains vapor
+
+        return {
+            "inlet_P": P1,
+            "outlet_P": P2,
+            "Tin": T1,
+            "Tout": T2,
+            "m_dot": m_dot,
+            "power": power,
+            "efficiency": self.eta
+        }

processpi-0.2.0.3/processpi/equipment/cstr.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+from typing import Optional, Dict, Any
+from .base import Equipment
+from ..streams import MaterialStream
+
+
+class CSTR(Equipment):
+    """
+    Continuous Stirred Tank Reactor (CSTR).
+
+    Assumptions:
+    - Perfect mixing (outlet composition = reactor composition).
+    - Steady-state operation.
+    - Reaction kinetics placeholder (rate function can be injected).
+    """
+
+    def __init__(self, name: str, volume: float, rate_fn: Optional[callable] = None):
+        super().__init__(name)
+        self.volume = volume
+        self.rate_fn = rate_fn
+
+    def simulate(self) -> Dict[str, Any]:
+        inlet: MaterialStream = self.inlet
+        outlet: MaterialStream = self.outlet
+
+        if inlet is None or outlet is None:
+            raise ValueError(f"CSTR {self.name} must have inlet and outlet streams.")
+
+        outlet.copy_from(inlet)
+
+        if self.rate_fn:
+            rates = self.rate_fn(outlet, outlet.temperature, outlet.pressure)
+            outlet.apply_reaction(rates, residence_time=self.volume / inlet.volumetric_flow)
+
+        return {
+            "type": "CSTR",
+            "inlet_T": inlet.temperature,
+            "outlet_T": outlet.temperature,
+            "inlet_F": inlet.mass_flow,
+            "outlet_F": outlet.mass_flow
+        }

processpi-0.2.0.3/processpi/equipment/decanter.py

@@ -0,0 +1,61 @@
+# processpi/equipment/decanter.py
+
+from __future__ import annotations
+from typing import Optional, Dict
+from .base import Equipment
+from ..streams import MaterialStream
+
+
+class Decanter(Equipment):
+    """
+    Decanter (liquid–liquid phase separator).
+
+    Assumptions:
+    - Two immiscible liquid phases (e.g., water-rich and organic-rich).
+    - Separation based on density: heavy phase → bottom, light phase → top.
+    - User specifies split fractions OR component affinity (partitioning).
+    - For now: simple split fraction for light/heavy phase.
+    """
+
+    def __init__(self, name: str, light_fraction: float = 0.5):
+        super().__init__(name, inlet_ports=1, outlet_ports=2)
+        self.light_fraction = light_fraction  # fraction of flow to light phase (0–1)
+
+    def simulate(self) -> Dict:
+        inlet: MaterialStream = self.inlets[0]
+        if inlet is None:
+            raise ValueError(f"Decanter {self.name} must have an inlet stream.")
+
+        outlet_light: MaterialStream = self.outlets[0]
+        outlet_heavy: MaterialStream = self.outlets[1]
+
+        if outlet_light is None or outlet_heavy is None:
+            raise ValueError(f"Decanter {self.name} must have two outlet streams attached.")
+
+        F_total = inlet.flow
+        z = inlet.composition.copy()
+
+        # Flow split
+        F_light = F_total * self.light_fraction
+        F_heavy = F_total - F_light
+
+        # For now: assume components split proportional to flow
+        # (extend later with partition coefficients)
+        outlet_light.copy_from(inlet)
+        outlet_heavy.copy_from(inlet)
+
+        outlet_light.flow = F_light
+        outlet_heavy.flow = F_heavy
+
+        # Normalize compositions (still same, just different flow basis)
+        outlet_light.composition = {k: v for k, v in z.items()}
+        outlet_heavy.composition = {k: v for k, v in z.items()}
+
+        return {
+            "F_in": F_total,
+            "F_light": F_light,
+            "F_heavy": F_heavy,
+            "z_in": z,
+            "z_light": outlet_light.composition,
+            "z_heavy": outlet_heavy.composition,
+        }

processpi-0.2.0.3/processpi/equipment/distillation.py

@@ -0,0 +1,82 @@
+# processpi/equipment/distillation.py
+
+from __future__ import annotations
+from typing import Optional, Dict
+from .base import Equipment
+from ..streams import MaterialStream
+
+
+class DistillationColumn(Equipment):
+    """
+    Simplified Distillation Column (binary or multicomponent).
+    
+    Assumptions (initial version):
+    - Steady-state.
+    - Total condenser (distillate is liquid).
+    - Partial reboiler (bottoms is liquid).
+    - Uses constant relative volatility shortcut (Fenske-Underwood-Gilliland).
+    - Feed at specified stage.
+    - No rigorous stage-by-stage solving (yet).
+    """
+
+    def __init__(self, name: str, n_stages: int, feed_stage: int,
+                 reflux_ratio: Optional[float] = None,
+                 distillate_rate: Optional[float] = None):
+        super().__init__(name)
+        self.n_stages = n_stages
+        self.feed_stage = feed_stage
+        self.reflux_ratio = reflux_ratio
+        self.distillate_rate = distillate_rate
+
+        # Streams
+        self.feed: Optional[MaterialStream] = None
+        self.distillate: Optional[MaterialStream] = None
+        self.bottoms: Optional[MaterialStream] = None
+
+    def simulate(self) -> Dict:
+        if self.feed is None or self.distillate is None or self.bottoms is None:
+            raise ValueError(f"DistillationColumn {self.name} must have feed, distillate, and bottoms streams attached.")
+
+        # --- Step 1: Material balance ---
+        F = self.feed.flow
+        if self.distillate_rate is not None:
+            D = self.distillate_rate
+            B = F - D
+        else:
+            raise ValueError("distillate_rate must be specified (initial version).")
+
+        # --- Step 2: Split compositions using shortcut method ---
+        z_feed = self.feed.composition  # dict: {component: mole fraction}
+        xD, xB = {}, {}
+
+        for comp, z in z_feed.items():
+            # Simple split rule: more volatile → enriched in distillate
+            if comp.relative_volatility >= 1.5:  # crude threshold
+                xD[comp] = min(1.0, z * 1.5)
+                xB[comp] = max(0.0, z - (xD[comp] * D / F))
+            else:
+                xB[comp] = min(1.0, z * 1.5)
+                xD[comp] = max(0.0, z - (xB[comp] * B / F))
+
+        # Normalize
+        sum_xD = sum(xD.values())
+        sum_xB = sum(xB.values())
+        for comp in xD: xD[comp] /= sum_xD
+        for comp in xB: xB[comp] /= sum_xB
+
+        # --- Step 3: Copy to outlet streams ---
+        self.distillate.copy_from(self.feed)
+        self.distillate.flow = D
+        self.distillate.composition = xD
+
+        self.bottoms.copy_from(self.feed)
+        self.bottoms.flow = B
+        self.bottoms.composition = xB
+
+        return {
+            "feed_flow": F,
+            "distillate_flow": D,
+            "bottoms_flow": B,
+            "distillate_composition": xD,
+            "bottoms_composition": xB
+        }

processpi-0.2.0.3/processpi/equipment/flash.py

@@ -0,0 +1,84 @@
+# processpi/equipment/flash.py
+
+from __future__ import annotations
+from typing import Optional, Dict, Any
+from .base import Equipment
+from ..streams import MaterialStream
+from ..thermo.vle import flash_equilibrium  # placeholder VLE calc function
+
+class FlashDrum(Equipment):
+    """
+    Flash Drum for vapor-liquid separation.
+
+    Modes:
+    - T, P specified (isothermal flash)
+    - P, Q specified (adiabatic flash with duty)
+    """
+
+    def __init__(self, name: str):
+        super().__init__(name, inlet_ports=1, outlet_ports=2)
+        self.vapor_out: Optional[MaterialStream] = None
+        self.liquid_out: Optional[MaterialStream] = None
+
+    def attach_stream(self, stream: MaterialStream, port: str):
+        if port == "in":
+            self.inlets[0] = stream
+            stream.connect_outlet(self)
+        elif port == "vapor":
+            self.vapor_out = stream
+            stream.connect_inlet(self)
+        elif port == "liquid":
+            self.liquid_out = stream
+            stream.connect_inlet(self)
+        else:
+            raise ValueError(f"Invalid port: {port}")
+
+    def simulate(self,
+                 pressure: Optional[float] = None,
+                 temperature: Optional[float] = None,
+                 duty: Optional[float] = None) -> Dict[str, Any]:
+        """
+        Perform flash separation.
+
+        Parameters:
+        - pressure: operating P [Pa]
+        - temperature: operating T [K]
+        - duty: optional heat duty (W)
+
+        Returns:
+        - dict with vapor_fraction, liquid_fraction, compositions, enthalpies
+        """
+        feed = self.inlets[0]
+        if feed is None or self.vapor_out is None or self.liquid_out is None:
+            raise ValueError(f"{self.name}: must attach feed, vapor, and liquid streams")
+
+        # Use feed enthalpy/composition
+        z = feed.components
+        P = pressure or feed.pressure.value
+        T = temperature or feed.temperature.value
+
+        # Call thermo package (placeholder)
+        flash_results = flash_equilibrium(z, T, P, duty=duty)
+
+        Vfrac = flash_results["vapor_fraction"]
+        Lfrac = 1 - Vfrac
+
+        # Update outlet streams
+        self.vapor_out.set_composition(flash_results["y"], basis="mole")
+        self.vapor_out.pressure = feed.pressure
+        self.vapor_out.temperature = feed.temperature
+        self.vapor_out.phase = "vapor"
+
+        self.liquid_out.set_composition(flash_results["x"], basis="mole")
+        self.liquid_out.pressure = feed.pressure
+        self.liquid_out.temperature = feed.temperature
+        self.liquid_out.phase = "liquid"
+
+        return {
+            "Vfrac": Vfrac,
+            "Lfrac": Lfrac,
+            "y": flash_results["y"],
+            "x": flash_results["x"],
+            "T": T,
+            "P": P
+        }

processpi-0.2.0.3/processpi/equipment/heater_cooler.py

@@ -0,0 +1,103 @@
+from typing import Optional, Dict, Any
+from ..streams import MaterialStream, EnergyStream
+from .base import Equipment
+
+
+class HeatTransferUnit(Equipment):
+    """
+    Base class for heater/cooler type units.
+    Supports sensible (+ latent, via MaterialStream auto phase handling).
+    Energy balance:
+        Q = m * cp * ΔT   [+/- m * Hvap if phase change occurs]
+    """
+
+    def __init__(self, name: str, mode: str = "heater", energy_stream: Optional[EnergyStream] = None):
+        super().__init__(name, inlet_ports=1, outlet_ports=1)
+        self.mode = mode  # "heater" or "cooler"
+        self.energy_stream = energy_stream
+
+        # Auto-bind energy stream if provided
+        if self.energy_stream:
+            self.energy_stream.bind_equipment(self)
+
+    def simulate(
+        self,
+        heat_duty: Optional[float] = None,
+        outlet_temperature: Optional[float] = None
+    ) -> Dict[str, Any]:
+        """
+        Simulate heater/cooler.
+
+        Parameters:
+        - heat_duty (W) [optional]
+        - outlet_temperature (float) [optional]
+
+        Returns:
+        - dict with results: Q (W), Tin, Tout, phase_in, phase_out
+        """
+        inlet: MaterialStream = self.inlets[0]
+        outlet: MaterialStream = self.outlets[0]
+
+        if inlet is None or outlet is None:
+            raise ValueError(f"{self.name}: Must have both inlet and outlet connected.")
+
+        m_dot = inlet.mass_flow().to("kg/s").value
+        cp = inlet.get_property("cp")  # J/kg-K
+
+        Tin = inlet.temperature.value
+        Tout = outlet.temperature.value if outlet.temperature else None
+        Qin = 0.0
+
+        # -------------------------
+        # Case 1: Duty specified
+        # -------------------------
+        if heat_duty is not None:
+            dT = heat_duty / (m_dot * cp)
+            Tout = Tin + dT
+            Qin = heat_duty
+
+        # -------------------------
+        # Case 2: Outlet T specified
+        # -------------------------
+        elif outlet_temperature is not None:
+            Tout = outlet_temperature
+            Qin = m_dot * cp * (Tout - Tin)
+
+        else:
+            raise ValueError("Must specify either heat_duty or outlet_temperature.")
+
+        # Update outlet stream — phase auto-updates inside MaterialStream
+        outlet.temperature.value = Tout
+        outlet.P = inlet.P
+        outlet.flow_rate = inlet.flow_rate
+
+        # Flip sign for cooler
+        if self.mode == "cooler" and Qin > 0:
+            Qin *= -1
+
+        # -------------------------
+        # EnergyStream logging
+        # -------------------------
+        if self.energy_stream:
+            tag = "Q_in" if Qin > 0 else "Q_out"
+            self.energy_stream.record(abs(Qin), tag=tag, equipment=self.name)
+
+        return {
+            "Q": Qin,
+            "Tin": Tin,
+            "Tout": Tout,
+            "phase_in": inlet.phase,
+            "phase_out": outlet.phase,  # comes directly from MaterialStream auto-detection
+            "cp": cp,
+            "m_dot": m_dot,
+        }
+
+
+class Heater(HeatTransferUnit):
+    def __init__(self, name: str, energy_stream: Optional[EnergyStream] = None):
+        super().__init__(name, mode="heater", energy_stream=energy_stream)
+
+
+class Cooler(HeatTransferUnit):
+    def __init__(self, name: str, energy_stream: Optional[EnergyStream] = None):
+        super().__init__(name, mode="cooler", energy_stream=energy_stream)

processpi-0.2.0.3/processpi/equipment/heatexchangers/__init__.py

@@ -0,0 +1,7 @@
+from .base import HeatExchanger
+from .mechanical import run_mechanical_design
+
+__all__ = [
+    "HeatExchanger",
+    "run_mechanical_design",
+]