processpi 0.0.0__tar.gz

processpi-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Raviteja Varma Nadimpalli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

processpi-0.0.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: processpi
+Version: 0.0.0
+License-File: LICENSE
+Dynamic: license-file

processpi-0.0.0/README.md

@@ -0,0 +1,174 @@
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Process_PI-🧪-blue?style=for-the-badge&logo=python" alt="Process PI Logo" height="40"/>
+</p>
+
+<h1 align="center">Process PI</h1>
+
+<p align="center">
+  <strong>Python toolkit for chemical engineering simulations, equipment design, and unit conversions</strong>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/🛠_Unit_Conversions-blue?style=for-the-badge" alt="Unit Conversions"/>
+  <img src="https://img.shields.io/badge/💧_Components-blue?style=for-the-badge" alt="Components"/>
+  <img src="https://img.shields.io/badge/🏭_Pumps-Pipelines-blue?style=for-the-badge" alt="Pumps & Pipelines"/>
+  <img src="https://img.shields.io/badge/♨️_Heat_Exchangers-blue?style=for-the-badge" alt="Heat Exchangers"/>
+  <img src="https://img.shields.io/badge/⚗️_Chemical_Flasks-blue?style=for-the-badge" alt="Chemical Flasks"/>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/processpi/">
+    <img src="https://img.shields.io/pypi/v/processpi?style=for-the-badge&logo=pypi" alt="PyPI Version"/>
+  </a>
+  <a href="https://github.com/varma666/ProcessPi/stargazers">
+    <img src="https://img.shields.io/github/stars/varma666/ProcessPi?style=for-the-badge&logo=github" alt="GitHub Stars"/>
+  </a>
+  <a href="https://github.com/varma666/ProcessPi/network/members">
+    <img src="https://img.shields.io/github/forks/varma666/ProcessPi?style=for-the-badge&logo=github" alt="GitHub Forks"/>
+  </a>
+  <a href="https://github.com/varma666/ProcessPi/actions">
+    <img src="https://img.shields.io/github/actions/workflow/status/varma666/ProcessPi/python-package.yml?branch=main&style=for-the-badge" alt="Build Status"/>
+  </a>
+</p>
+
+<p align="center">
+  <em>Built with ❤️ for chemical engineers.</em>
+</p>
+
+---
+
+## 📖 Overview
+
+**Process PI** is a cross-platform **Python toolkit** for chemical engineering equipment design, simulations, and unit conversions.  
+It provides a **modular framework** for learning, experimenting, and simulating process systems.
+
+---
+
+## 📑 Table of Contents
+- [Features](#-features)
+- [Installation](#-installation)
+- [Getting Started](#-getting-started)
+  - [Unit Conversions](#1-unit-conversions)
+  - [Components](#2-components)
+  - [Pipeline Network Analysis](#3-pipeline-network-analysis)
+- [Roadmap](#-roadmap)
+- [License](#-license)
+
+---
+
+## ⚡ Features
+
+- ⚙️ **Unit Conversion System** – Seamless conversion across SI, CGS, and Imperial units.  
+- 🧪 **Components Database (Work in Progress)** – Educational thermodynamic properties of 25+ components (Water, Ethanol, CO₂, etc.), expanding regularly.  
+- 🏭 **Equipment Design Modules (WIP)** – Pumps, pipelines, heat exchangers, reactors, and more.  
+- 🌐 **Pipeline Networks** – Analyze single pipes and complex networked systems, calculate flow, pressure drops, velocity, and Reynolds numbers.  
+- 📊 **Simulation Tools (Upcoming)** – Steady-state/dynamic process analysis, flow optimization, and energy management.
+
+---
+
+## 📦 Installation
+
+Install via **PyPI**:
+
+```bash
+pip install processpi
+```
+
+---
+
+## 🚀 Getting Started
+
+### 1. Unit Conversions
+
+Easily convert between SI, CGS, and Imperial units.
+
+```python
+from processpi.units import Length, Pressure, Temperature
+
+# Length
+l1 = Length(1.5, "m")
+print(l1.to("ft"))   # Output in feet
+
+# Pressure
+p = Pressure(2, "bar")
+print(p.to("Pa"))    # Output in Pascals
+
+# Temperature
+t = Temperature(100, "C")
+print(t.to("K"))     # Output in Kelvin
+```
+
+---
+
+### 2. Components
+
+Access educational thermodynamic properties of chemical components.
+
+```python
+from processpi.components import Water, Ethanol
+
+water = Water()
+ethanol = Ethanol()
+
+print(f"Water density: {water.density()} kg/m³")
+print(f"Ethanol viscosity: {ethanol.viscosity()} Pa·s")
+```
+
+⚠️ **Note**: Component data is provided for **educational and demonstration purposes**. The database is continuously expanding.
+
+---
+
+### 3. Pipeline Network Analysis
+
+Perform hydraulic calculations for pipelines and network systems.
+
+```python
+from processpi.pipelines.engine import PipelineEngine
+from processpi.pipelines.pipes import Pipe
+from processpi.components import Water
+from processpi.units import VolumetricFlowRate, Diameter, Length
+
+pipe = Pipe(
+    internal_diameter=Diameter(50, "mm"),
+    length=Length(10, "m")
+)
+
+engine = PipelineEngine()
+engine.fit(
+    flowrate=VolumetricFlowRate(0.001, "m^3/s"),
+    pipe=pipe,
+    fluid=Water()
+)
+
+results = engine.run()
+engine.summary()
+```
+
+#### Planned Enhancements
+
+- Support for branching and parallel pipeline networks  
+- Dynamic flow simulations and transient analysis  
+- Cost and energy optimization tools for network layouts  
+
+---
+
+## 🛣 Roadmap
+
+- Expand the Components Database to 50+ chemicals and fluids  
+- Add steady-state and dynamic simulation modules  
+- Implement energy optimization and cost analysis tools  
+- Build a GUI/web interface for interactive simulations  
+- Enable integration with real process data and sensor-driven workflows  
+
+---
+
+## 📜 License
+
+This project is licensed under the **MIT License** – see the LICENSE file for details.
+
+---
+
+<p align="center">
+  <em>Process PI – Built with ❤️ for chemical engineers.</em>
+</p>

processpi-0.0.0/processpi/__init__.py

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

processpi-0.0.0/processpi/calculations/__init__.py

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

processpi-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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-0.0.0/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")