processpi 0.0.0__py3-none-any.whl

processpi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

processpi/calculations/__init__.py

@@ -0,0 +1,3 @@
+from .engine import CalculationEngine
+from .base import CalculationBase
+__all__ = ["CalculationEngine", "CalculationBase"]

processpi/calculations/base.py

@@ -0,0 +1,55 @@
+# base.py
+from abc import ABC, abstractmethod
+
+class CalculationBase(ABC):
+    """
+    Abstract base for all calculation modules in processpi.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Store all input parameters as attributes.
+        """
+        self.inputs = kwargs
+        self.validate_inputs()
+
+    @abstractmethod
+    def validate_inputs(self):
+        """
+        Validate inputs and raise ValueError if invalid.
+        """
+        pass
+
+    @abstractmethod
+    def calculate(self):
+        """
+        Perform the calculation and return results as a dict.
+        """
+        pass
+
+    def get_inputs(self):
+        """
+        Return a dictionary of original inputs.
+        """
+        return self.inputs
+
+    def to_dict(self):
+        """
+        Return a dictionary with both inputs and results.
+        """
+        result = self.calculate()
+        return {
+            "inputs": self.inputs,
+            "results": result
+        }
+    @staticmethod
+    def _get_value(x, name):
+        """Return numeric value if x is numeric or x.value if it's a Variable-like object."""
+        if hasattr(x, "value"):
+            return x.value
+        try:
+            # accept numpy/scalar numbers
+            return float(x)
+        except Exception:
+            raise TypeError(f"Could not interpret {name} value: {x!r}")
+    

processpi/calculations/engine.py

@@ -0,0 +1,69 @@
+"""
+engine.py
+---------
+This module will act as the central engine for performing calculations in ProcessPI.
+
+Responsibilities:
+1. Receive input parameters for a calculation.
+2. Select the correct calculation class/function based on the requested operation.
+3. Handle validation and error reporting.
+4. Return results in a standardized format.
+"""
+
+from typing import Any, Dict, Type
+from processpi.units import *  # Import all unit classes
+from processpi.calculations import *  # Import all calculation classes
+
+# Import calculation classes here
+# Example: from processpi.calculations.heat_transfer import HeatTransferCalculator
+# We'll add them as we implement each calculation
+# For now, I'll just put placeholders for demonstration
+# ----------------------------------------------------------------------
+
+class CalculationEngine:
+    """
+    Central hub for all ProcessPI calculations.
+    """
+
+    def __init__(self):
+        """
+        Initializes the engine with a registry of available calculations.
+        The registry maps calculation names (strings) to their handler classes.
+        """
+        self.registry: Dict[str, Type] = {}
+
+    def register_calculation(self, name: str, calc_class: Type):
+        """
+        Register a new calculation class to the engine.
+
+        Args:
+            name (str): A unique string key for the calculation.
+            calc_class (Type): The class that implements the calculation logic.
+
+        Example:
+            engine.register_calculation("heat_transfer", HeatTransferCalculator)
+        """
+        self.registry[name] = calc_class
+
+    def calculate(self, name: str, **kwargs) -> Any:
+        """
+        Executes a calculation by name.
+
+        Args:
+            name (str): The registered name of the calculation.
+            **kwargs: All input parameters required for the calculation.
+
+        Returns:
+            Any: The result of the calculation.
+        
+        Raises:
+            ValueError: If the calculation name is not registered.
+        """
+        if name not in self.registry:
+            raise ValueError(f"Calculation '{name}' not found in registry.")
+
+        calc_class = self.registry[name]
+        calc_instance = calc_class(**kwargs)  # Pass all inputs to the class constructor
+        return calc_instance.calculate()  # All calculation classes must have a `.calculate()` method
+
+

processpi/calculations/fluids/__init__.py

@@ -0,0 +1,13 @@
+"""  Init   module for Process PI calculation engine."""
+
+# Implementation will be added here.
+from .pressure_drop_darcy import PressureDropDarcy
+from .pressure_drop_fanning import PressureDropFanning
+from .pump_power import PumpPower
+from .reynolds_number import ReynoldsNumber
+from .optimium_pipe_dia import OptimumPipeDiameter
+from .velocity import FluidVelocity
+from .cool_brook_white import ColebrookWhite
+from .flow_type import TypeOfFlow
+
+__all__ = ["PressureDropDarcy", "PressureDropFanning", "PumpPower", "ReynoldsNumber", "OptimumPipeDiameter", "FluidVelocity", "ColebrookWhite", "TypeOfFlow"]

processpi/calculations/fluids/cool_brook_white.py

@@ -0,0 +1,49 @@
+from ..base import CalculationBase
+from ...units import *
+
+import math
+
+
+class ColebrookWhite(CalculationBase):
+    """
+    Calculate Darcy friction factor using the Colebrook–White equation.
+    
+    Formula (implicit):
+        1/sqrt(f) = -2.0 * log10( (ε/D)/3.7 + 2.51/(Re*sqrt(f)) )
+    
+    Notes:
+        - For laminar flow (Re < 2000), f = 64/Re.
+        - Solved iteratively for turbulent flow.
+    """
+
+    def validate_inputs(self):
+        required = ["reynolds_number", "diameter", "roughness"]
+        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_number"], "reynolds_number")
+        D = self._get_value(self.inputs["diameter"], "diameter")  / 1000  # m
+        eps = self._get_value(self.inputs["roughness"], "roughness")   # m
+
+        # Laminar flow check
+        if Re < 2000:
+            f = 64.0 / Re
+            return Dimensionless(f)
+
+        # Initial guess
+        f = 0.02
+        tol = 1e-6
+        max_iter = 100
+
+        for _ in range(max_iter):
+            lhs = 1.0 / math.sqrt(f)
+            rhs = -2.0 * math.log10((eps / (3.7 * D)) + (2.51 / (Re * math.sqrt(f))))
+            new_f = 1.0 / (rhs**2)
+
+            if abs(new_f - f) < tol:
+                return Dimensionless(new_f)
+            f = new_f
+
+        return Dimensionless(f)

processpi/calculations/fluids/flow_type.py

@@ -0,0 +1,37 @@
+from ..base import CalculationBase
+from ...units import *
+
+
+class TypeOfFlow(CalculationBase):
+    """
+    Determine the type of flow based on Reynolds number.
+
+    Criteria:
+        - Laminar: Re < 2000
+        - Transitional: 2000 ≤ Re ≤ 4000
+        - Turbulent: Re > 4000
+
+    Inputs:
+        - reynolds_number (Re) [dimensionless]
+
+    Output:
+        - Flow type as a StringUnit
+    """
+
+    def validate_inputs(self):
+        required = ["reynolds_number"]
+        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_number"], "reynolds_number")
+
+        if Re < 2000:
+            flow_type = "Laminar"
+        elif 2000 <= Re <= 4000:
+            flow_type = "Transitional"
+        else:
+            flow_type = "Turbulent"
+
+        return StringUnit(flow_type, "flow_type")

processpi/calculations/fluids/optimium_pipe_dia.py

@@ -0,0 +1,45 @@
+# processpi/calculations/fluids/optimum_pipe_diameter.py
+from ..base import CalculationBase
+from ...units import *
+from ...pipelines.standards import get_nearest_diameter
+
+class OptimumPipeDiameter(CalculationBase):
+    """
+    Calculate the optimum pipe diameter using empirical formula and map to nearest standard:
+
+        D_opt = 293 * (Q^0.53) * (ρ^-0.37)
+
+    Where:
+        - Q = Volumetric flow rate [m³/s]
+        - ρ = Fluid density [kg/m³]
+        - D_opt = Optimum diameter [mm]
+
+    Inputs:
+        - flow_rate (Q) [m³/s]
+        - density (ρ) [kg/m³]
+
+    Output:
+        - Nearest standard diameter [Diameter object, mm]
+    """
+
+    def validate_inputs(self):
+        required = ["flow_rate", "density"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        # Get inputs
+        Q_volumetric = self._get_value(self.inputs["flow_rate"], "flow_rate")  # m³/s
+        rho = self._get_value(self.inputs["density"], "density")  # kg/m³
+
+        # Mass flow for formula
+        Q_mass = Q_volumetric * rho  # kg/s
+
+        # Empirical formula for optimum diameter
+        D_opt = 293 * (Q_mass ** 0.53) * (rho ** -0.37)  # mm
+        D_opt = Diameter(D_opt, "mm")
+
+        # Map to nearest standard diameter
+        nearest_std = get_nearest_diameter(D_opt)
+        return nearest_std

processpi/calculations/fluids/pressure_drop_darcy.py

@@ -0,0 +1,25 @@
+from ..base import CalculationBase
+from ...units import *
+
+class PressureDropDarcy(CalculationBase):
+    """
+    Calculate pressure drop using Darcy–Weisbach equation.
+    Formula:
+        ΔP = f * (L/D) * (ρ * v² / 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")
+        L = self._get_value(self.inputs["length"], "length")        # m
+        D = self._get_value(self.inputs["diameter"], "diameter")    # m
+        rho = self._get_value(self.inputs["density"], "density")    # kg/m³
+        v = self._get_value(self.inputs["velocity"], "velocity")    # m/s
+
+        delta_P = f * (L / D) * (rho * v**2 / 2)
+        return Pressure(delta_P, "Pa")  # Return result as Pressure object

processpi/calculations/fluids/pressure_drop_fanning.py

@@ -0,0 +1,25 @@
+from ..base import CalculationBase
+from ...units import *
+
+class PressureDropFanning(CalculationBase):
+    """
+    Calculate pressure drop using Fanning equation.
+    Formula:
+        ΔP = 4 * f * (L/D) * (ρ * v² / 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")
+        L = self._get_value(self.inputs["length"], "length")        # m
+        D = self._get_value(self.inputs["diameter"], "diameter")    # m
+        rho = self._get_value(self.inputs["density"], "density")    # kg/m³
+        v = self._get_value(self.inputs["velocity"], "velocity")    # m/s
+
+        delta_P = 4 * f * (L / D) * (rho * v**2 / 2)
+        return Pressure(delta_P, "Pa")  # Return result as Pressure object

processpi/calculations/fluids/pump_power.py

@@ -0,0 +1,34 @@
+from ..base import CalculationBase
+from ...units import *
+
+class PumpPower(CalculationBase):
+    """
+    Calculate pump power from flow rate, head, density, and efficiency.
+    """
+        
+    def validate_inputs(self):
+        # Ensure required inputs are present and valid
+        required = ["flow_rate", "head", "density", "efficiency"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+        if not (0 < self.inputs["efficiency"] <= 1):
+            raise ValueError("Efficiency must be between 0 and 1")
+
+    def calculate(self):
+        g = 9.81  # m/s²
+        flow_rate = self._get_value(self.inputs["flow_rate"], "flow_rate")  # m³/s
+        head = self._get_value(self.inputs["head"], "head")  # m
+        density = self._get_value(self.inputs["density"], "density")  # kg/m³
+        efficiency = self._get_value(self.inputs["efficiency"], "efficiency")  # decimal
+
+        # Hydraulic Power (Watts)
+        hydraulic_power = density * g * flow_rate * head
+
+        # Shaft Power (Watts)
+        shaft_power = hydraulic_power / efficiency
+
+        return {
+            "hydraulic_power_W": hydraulic_power,
+            "shaft_power_W": shaft_power
+        }

processpi/calculations/fluids/reynolds_number.py

@@ -0,0 +1,24 @@
+from ..base import CalculationBase
+from ...units import *
+
+class ReynoldsNumber(CalculationBase):
+    """
+    Calculate Reynolds number for pipe flow.
+    Formula:
+        Re = (ρ * v * D) / μ
+    """
+
+    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")    # kg/m³
+        v = self._get_value(self.inputs["velocity"], "velocity")    # m/s
+        D = self._get_value(self.inputs["diameter"], "diameter")    # m
+        mu = self._get_value(self.inputs["viscosity"], "viscosity") # Pa·s
+
+        Re = rho * v * D / mu
+        return Dimensionless(Re)

processpi/calculations/fluids/velocity.py

@@ -0,0 +1,36 @@
+from ..base import CalculationBase
+from ...units import *
+
+import math
+
+
+class FluidVelocity(CalculationBase):
+    """
+    Calculate fluid velocity in a circular pipe.
+    
+    Formula:
+        v = Q / A
+          = 4Q / (πD²)
+    
+    Inputs:
+        - volumetric_flow_rate (Q) [m³/s]
+        - diameter (D) [m]
+    
+    Output:
+        - velocity (v) [m/s]
+    """
+
+    def validate_inputs(self):
+        required = ["volumetric_flow_rate", "diameter"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        Q = self._get_value(self.inputs["volumetric_flow_rate"], "volumetric_flow_rate")  # m³/s
+        D = self._get_value(self.inputs["diameter"], "diameter") # m
+
+        A = math.pi * (D**2) / 4.0   # cross-sectional area [m²]
+        v = Q / A                    # velocity [m/s]
+
+        return Velocity(v, "m/s")

processpi/calculations/heat_transfer/__init__.py

@@ -0,0 +1,4 @@
+from .conduction_heat_loss import ConductionHeatLoss
+from .convection_heat_loss import ConvectionHeatLoss
+from .heat_exchanger_area import HeatExchangerArea
+__all__ = ["ConductionHeatLoss", "ConvectionHeatLoss", "HeatExchangerArea"]

processpi/calculations/heat_transfer/conduction_heat_loss.py

@@ -0,0 +1,26 @@
+from ..base import CalculationBase
+from ...units import *
+
+class ConductionHeatLoss(CalculationBase):
+    """
+    Calculate steady-state conduction heat loss through a wall.
+    Formula:
+        Q = k * A * ΔT / L
+    """
+
+    def validate_inputs(self):
+        required = ["thermal_conductivity", "area", "temp_difference", "thickness"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+        if self.inputs["thickness"] <= 0:
+            raise ValueError("Wall thickness must be greater than 0")
+
+    def calculate(self):
+        k = self._get_value(self.inputs["thermal_conductivity"], "thermal_conductivity")  # W/m·K
+        A = self._get_value(self.inputs["area"], "area")                                  # m²
+        ΔT = self._get_value(self.inputs["temp_difference"], "temp_difference")           # K
+        L = self._get_value(self.inputs["thickness"], "thickness")                        # m
+
+        Q = k * A * ΔT / L
+        return HeatFlux(Q, "W")

processpi/calculations/heat_transfer/convection_heat_loss.py

@@ -0,0 +1,23 @@
+from ..base import CalculationBase
+from ...units import *
+
+class ConvectionHeatLoss(CalculationBase):
+    """
+    Calculate convection heat loss.
+    Formula:
+        Q = h * A * ΔT
+    """
+
+    def validate_inputs(self):
+        required = ["heat_transfer_coeff", "area", "temp_difference"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+
+    def calculate(self):
+        h = self._get_value(self.inputs["heat_transfer_coeff"], "heat_transfer_coeff")  # W/m²·K
+        A = self._get_value(self.inputs["area"], "area")                                # m²
+        ΔT = self._get_value(self.inputs["temp_difference"], "temp_difference")         # K
+
+        Q = h * A * ΔT
+        return HeatFlux(Q, "W")

processpi/calculations/heat_transfer/heat_exchanger_area.py

@@ -0,0 +1,26 @@
+from ..base import CalculationBase
+from ...units import *
+
+class HeatExchangerArea(CalculationBase):
+    """
+    Calculate required heat exchanger area.
+    Formula:
+        Q = U * A * ΔTlm
+        => A = Q / (U * ΔTlm)
+    """
+
+    def validate_inputs(self):
+        required = ["heat_duty", "overall_heat_transfer_coeff", "log_mean_temp_diff"]
+        for key in required:
+            if key not in self.inputs:
+                raise ValueError(f"Missing required input: {key}")
+        if self.inputs["log_mean_temp_diff"] <= 0:
+            raise ValueError("Log mean temperature difference must be positive")
+
+    def calculate(self):
+        Q = self._get_value(self.inputs["heat_duty"], "heat_duty")  # W
+        U = self._get_value(self.inputs["overall_heat_transfer_coeff"], "overall_heat_transfer_coeff")  # W/m²·K
+        ΔTlm = self._get_value(self.inputs["log_mean_temp_diff"], "log_mean_temp_diff")  # K
+
+        A = Q / (U * ΔTlm)
+        return Area(A, "m2")

processpi/calculations/mass_transfer/__init__.py

@@ -0,0 +1,3 @@
+from .distillation_stage_count import DistillationStageCount
+from .drying_rate import DryingRate     
+__all__ = ["DistillationStageCount","DryingRate"]