processforge 0.2.30__tar.gz → 0.2.38__tar.gz

processforge-0.2.38/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: processforge
+Version: 0.2.38
+Summary: A Python-based process simulation framework for chemical engineering applications.
+Author-email: Processforge Team <team@processforge.dev>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/urjanova/processforge
+Project-URL: Repository, https://github.com/urjanova/processforge
+Project-URL: Issues, https://github.com/urjanova/processforge/issues
+Keywords: process,simulation,chemical,engineering,flowsheet
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: scipy>=1.14
+Requires-Dist: matplotlib>=3.9
+Requires-Dist: loguru>=0.7
+Requires-Dist: jsonschema>=4.20
+Requires-Dist: graphviz>=0.20
+Requires-Dist: pandas>=2.2
+Requires-Dist: zarr>=3.0
+Requires-Dist: coolprop>=7.2.0
+Provides-Extra: eo
+Requires-Dist: pyomo>=6.7; extra == "eo"
+Provides-Extra: eo-casadi
+Requires-Dist: pyomo>=6.7; extra == "eo-casadi"
+Requires-Dist: casadi>=3.6; extra == "eo-casadi"
+Provides-Extra: fmu
+Requires-Dist: pythonfmu>=0.6; extra == "fmu"
+Provides-Extra: modelica
+Requires-Dist: OMPython>=4.0.0; extra == "modelica"
+Requires-Dist: fmpy>=0.3; extra == "modelica"
+Provides-Extra: cantera
+Requires-Dist: cantera>=3.0; extra == "cantera"
+Provides-Extra: coolprop
+Requires-Dist: coolprop>=6.6; extra == "coolprop"
+Provides-Extra: pcl
+Requires-Dist: pint>=0.24; extra == "pcl"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Dynamic: license-file
+
+# Processforge
+
+![processforge-logo](images/processforge-logo.svg)
+
+A lightweight Python framework for process simulation, coupling hydraulic, thermal, and reactor workflows.
+
+## Install
+
+Install the `pf` command-line tool with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install processforge
+```
+
+For CoolProp-backed units:
+
+```bash
+uv tool install "processforge[coolprop]"
+```
+
+Optional solver backends:
+
+```bash
+uv tool install "processforge[eo]"
+uv tool install "processforge[eo-casadi]"
+uv tool install "processforge[modelica]"
+```
+
+## Quick start
+
+1. **Install the tool**
+
+   ```bash
+   uv tool install processforge
+   ```
+
+2. **Download an example flowsheet**
+
+   ```bash
+   curl -O https://raw.githubusercontent.com/urjanova/processforge/master/flowsheets/hydraulic-chain.json
+   ```
+
+3. **Initialize, plan, and apply**
+
+   ```bash
+   pf init
+   pf plan hydraulic-chain.json
+   pf apply hydraulic-chain.json
+   ```
+
+   `plan` validates the flowsheet (schema, DOF, units) without running the solver; `apply` solves it and stores a snapshot.
+
+4. **Look at the output**
+
+   `pf apply` writes results under `outputs/`:
+   - `*_results.zarr` — simulation results store
+   - `*_validation.xlsx` — validation report
+   - `*.pfstate/` — versioned snapshot store with a `latest` pointer
+
+   For flowsheets with Tank units (dynamic), use `pf run` instead of `pf apply` to solve with the SM solver.
+
+## Python API
+
+```python
+from processforge import EOFlowsheet, validate_flowsheet
+config = validate_flowsheet("flowsheets/hydraulic-chain.json")
+fs = EOFlowsheet(config, backend="scipy")
+results = fs.run()
+```
+
+## Usage and Docker
+Processforge is also available as Docker images, and can be run in the cloud. See the [usage guide](docs/usage.md) for CLI commands, workflows, Docker, and cloud notes.
+
+## Flowsheets
+The core of Processforge is the flowsheet JSON format, which defines materials, units, and recycle rules. See below for more information on the formats and example flowsheets.
+- [docs/flowsheets.md](docs/flowsheets.md) : flowsheet JSON format, materials, units, and recycle rules
+- [flowsheets/](flowsheets/) : example flowsheets shipped with the repo
+
+
+## License
+
+BSD 3-Clause License

processforge-0.2.38/README.md

@@ -0,0 +1,82 @@
+# Processforge
+
+![processforge-logo](images/processforge-logo.svg)
+
+A lightweight Python framework for process simulation, coupling hydraulic, thermal, and reactor workflows.
+
+## Install
+
+Install the `pf` command-line tool with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install processforge
+```
+
+For CoolProp-backed units:
+
+```bash
+uv tool install "processforge[coolprop]"
+```
+
+Optional solver backends:
+
+```bash
+uv tool install "processforge[eo]"
+uv tool install "processforge[eo-casadi]"
+uv tool install "processforge[modelica]"
+```
+
+## Quick start
+
+1. **Install the tool**
+
+   ```bash
+   uv tool install processforge
+   ```
+
+2. **Download an example flowsheet**
+
+   ```bash
+   curl -O https://raw.githubusercontent.com/urjanova/processforge/master/flowsheets/hydraulic-chain.json
+   ```
+
+3. **Initialize, plan, and apply**
+
+   ```bash
+   pf init
+   pf plan hydraulic-chain.json
+   pf apply hydraulic-chain.json
+   ```
+
+   `plan` validates the flowsheet (schema, DOF, units) without running the solver; `apply` solves it and stores a snapshot.
+
+4. **Look at the output**
+
+   `pf apply` writes results under `outputs/`:
+   - `*_results.zarr` — simulation results store
+   - `*_validation.xlsx` — validation report
+   - `*.pfstate/` — versioned snapshot store with a `latest` pointer
+
+   For flowsheets with Tank units (dynamic), use `pf run` instead of `pf apply` to solve with the SM solver.
+
+## Python API
+
+```python
+from processforge import EOFlowsheet, validate_flowsheet
+config = validate_flowsheet("flowsheets/hydraulic-chain.json")
+fs = EOFlowsheet(config, backend="scipy")
+results = fs.run()
+```
+
+## Usage and Docker
+Processforge is also available as Docker images, and can be run in the cloud. See the [usage guide](docs/usage.md) for CLI commands, workflows, Docker, and cloud notes.
+
+## Flowsheets
+The core of Processforge is the flowsheet JSON format, which defines materials, units, and recycle rules. See below for more information on the formats and example flowsheets.
+- [docs/flowsheets.md](docs/flowsheets.md) : flowsheet JSON format, materials, units, and recycle rules
+- [flowsheets/](flowsheets/) : example flowsheets shipped with the repo
+
+
+## License
+
+BSD 3-Clause License

{processforge-0.2.30 → processforge-0.2.38}/flowsheets/closed-loop-chain.json

@@ -45,7 +45,7 @@
   },
   "material_mixes": {
     "Benzene_Toluene_Mix": {
-      "friendly_material_mix_id": 1,
+      "id": 1,
       "percent_type": "ao",
       "components": [
         {"name": "Benzene", "fraction": 0.5},

processforge-0.2.38/flowsheets/festim/hydrogen_transport_1d.json

@@ -0,0 +1,70 @@
+{
+  "metadata": {
+    "name": "FESTIM Hydrogen Transport — 1D Diffusion",
+    "description": "Simple 1D hydrogen diffusion through a slab. Fixed concentration BCs: c=1 on left, c=0 on right. D_0=1 m²/s, E_D=0 eV, T=300 K.",
+    "version": "1.0"
+  },
+  "providers": {
+    "festim": {
+      "type": "festim",
+      "url": "http://localhost:9002",
+      "output_dir": "festim"
+    }
+  },
+  "materials": {
+    "default": {
+      "id": 1,
+      "extra": {
+        "D_0": 1,
+        "E_D": 0.0
+      }
+    }
+  },
+  "streams": {},
+  "units": {
+    "festim_solver": {
+      "type": "SolverUnit",
+      "provider": "festim",
+      "sim_type": "hydrogen_transport",
+      "mesh": {
+        "vertices": [0.0, 0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009, 0.01]
+      },
+      "species": [
+        { "name": "H" }
+      ],
+      "subdomains": {
+        "volume": [
+          { "id": 1, "borders": [0.0, 0.01], "material": "default" }
+        ],
+        "surface": [
+          { "id": 2, "x": 0.0 },
+          { "id": 3, "x": 0.01 }
+        ]
+      },
+      "boundary_conditions": [
+        { "type": "fixed_concentration", "subdomain_id": 2, "species": "H", "value": 1 },
+        { "type": "fixed_concentration", "subdomain_id": 3, "species": "H", "value": 0 }
+      ],
+      "exports": [
+        { "type": "vtx_species", "field": "H", "filename": "hydrogen_concentration.bp", "times": "milestones" },
+        { "type": "profile_1d", "field": "H", "volume_id": 1, "times": "milestones" }
+      ],
+      "solver_config": {
+        "atol": 1e-10,
+        "rtol": 1e-10,
+        "final_time": 2,
+        "temperature": 300,
+        "stepsize": {
+          "initial_value": 0.05,
+          "growth_factor": 1.1,
+          "cutback_factor": 0.9,
+          "target_nb_iterations": 4,
+          "milestones": [0.05, 0.1, 0.2, 0.5, 1]
+        }
+      }
+    }
+  },
+  "simulation": {
+    "mode": "steady"
+  }
+}

{processforge-0.2.30 → processforge-0.2.38}/flowsheets/hydraulic-chain.json

@@ -22,7 +22,7 @@
   },
   "material_mixes": {
     "Water_Toluene_Mix": {
-      "friendly_material_mix_id": 1,
+      "id": 1,
       "percent_type": "ao",
       "components": [
         {"name": "Water", "fraction": 0.8},

{processforge-0.2.30 → processforge-0.2.38}/flowsheets/openmc/msre_eigenvalue.json

@@ -7,7 +7,8 @@
   "providers": {
     "openmc": {
       "type": "openmc",
-      "output_dir": "outputs/openmc/msre_run",
+      "url": "http://localhost:9001",
+      "output_dir": "openmc/msre_run",
       "cross_sections": "${OPENMC_DATA_ROOT}/cross_sections/cross_sections.xml"
     }
   },

{processforge-0.2.30 → processforge-0.2.38}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.2.30"
+version = "0.2.38"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"
 license-files = ["LICENSE"]
 requires-python = ">=3.12"
 authors = [
-    {name = "Process Forge Team", email = "team@processforge.dev"},
+    {name = "Processforge Team", email = "team@processforge.dev"},
 ]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -26,6 +26,7 @@ classifiers = [
 keywords = ["process", "simulation", "chemical", "engineering", "flowsheet"]
 dependencies = [
     "numpy>=2.0",
+    "pydantic>=2.0",
     "scipy>=1.14",
     "matplotlib>=3.9",
     "loguru>=0.7",
@@ -33,16 +34,10 @@ dependencies = [
     "graphviz>=0.20",
     "pandas>=2.2",
     "zarr>=3.0",
+    "coolprop>=7.2.0",
 ]
 
 [project.optional-dependencies]
-api = [
-    "fastapi>=0.110",
-    "uvicorn[standard]>=0.29",
-    "boto3>=1.34",
-    "s3fs>=2024.3",
-    "pydantic>=2.0",
-]
 eo = [
     "pyomo>=6.7",
 ]
@@ -86,7 +81,6 @@ Issues = "https://github.com/urjanova/processforge/issues"
 [project.scripts]
 processforge = "processforge.simulate:main"
 pf = "processforge.simulate:main"
-pf-serve = "processforge.api.serve:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]

processforge-0.2.38/src/processforge/compose.py

@@ -0,0 +1,47 @@
+"""Generate docker-compose.yml for containerized providers."""
+from __future__ import annotations
+
+import os
+
+COMPOSE_FILENAME = "docker-compose.yml"
+COMPOSE_HEADER = (
+    "# Auto-generated by pf init — do not edit manually.\n"
+    "# Re-generate: pf init <flowsheet.json>\n"
+)
+
+
+def _compose_path(pf_dir: str) -> str:
+    return os.path.join(pf_dir, COMPOSE_FILENAME)
+
+
+def generate_compose(
+    pf_dir: str,
+    containerized_providers: dict[str, dict],
+    outputs_dir: str = "outputs",
+) -> None:
+    """Generate docker-compose.yml for providers that need Docker.
+
+    Args:
+        pf_dir: Path to .processforge/ directory.
+        containerized_providers: Dict of provider_name -> {"url": ..., "docker_image": ..., "port": ...}.
+        outputs_dir: Host directory to mount as /data in containers.
+    """
+    if not containerized_providers:
+        return
+
+    lines = [COMPOSE_HEADER, "services:"]
+    for name, info in containerized_providers.items():
+        image = info["docker_image"]
+        port = info.get("port") or 9000
+        lines.append(f"  {name}:")
+        lines.append(f"    image: {image}")
+        lines.append(f"    ports:")
+        lines.append(f'      - "{port}:{port}"')
+        lines.append(f"    volumes:")
+        lines.append(f'      - "${{PROCESSFORGE_OUTPUT_DIR:-{outputs_dir}}}:/data"')
+        lines.append("")
+
+    os.makedirs(pf_dir, exist_ok=True)
+    path = _compose_path(pf_dir)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))

{processforge-0.2.30 → processforge-0.2.38}/src/processforge/eo/flowsheet.py

@@ -2,10 +2,14 @@
 from __future__ import annotations
 
 from copy import deepcopy
+from typing import TYPE_CHECKING
 
 import numpy as np
 from loguru import logger
 
+if TYPE_CHECKING:
+    from ..providers.manager import ProviderMap
+
 from .jacobian import GlobalJacobianManager
 from .solver import EOSolver
 from ..types import SnapshotState
@@ -43,7 +47,7 @@ class EOFlowsheet:
             or sim_cfg.get("default_backend", "scipy")
         )
         self._unit_objects: dict = {}
-        self._provider_map: dict = {}
+        self._provider_map: ProviderMap | None = None
         self.solver_tol: float = 1e-6
         self.solver_max_iter: int = 50
 
@@ -141,55 +145,15 @@ class EOFlowsheet:
 
         return manager
 
-    def _build_units(self, provider_map: dict | None = None) -> dict:
-        """Instantiate unit objects using the same factory logic as Flowsheet."""
-        from processforge.units.pump import Pump
-        from processforge.units.valve import Valve
-        from processforge.units.strainer import Strainer
-        from processforge.units.pipes import Pipes
-        from processforge.units.heater import Heater
-        from processforge.units.flash import Flash
-        from processforge.units.solver_unit import SolverUnit
-
-        unit_types = {
-            "Pump": (Pump, "kwargs"),
-            "Valve": (Valve, "kwargs"),
-            "Strainer": (Strainer, "kwargs"),
-            "Pipes": (Pipes, "kwargs"),
-            "Heater": (Heater, "params"),
-            "Flash": (Flash, "params"),
-            "SolverUnit": (SolverUnit, "kwargs"),
-        }
-
-        from processforge.providers.manager import get_unit_provider
-        _pm = provider_map or {}
+    def _build_units(self, provider_map: ProviderMap | None = None) -> dict:
+        """Instantiate unit objects using the shared registry."""
+        from ..flowsheet import _build_unit, _merge_provider_types
+        _merge_provider_types(provider_map)
 
         units = {}
         for unit_name, unit_cfg in self.config["units"].items():
-            unit_type = unit_cfg["type"]
-            if unit_type not in unit_types:
-                raise ValueError(f"Unknown unit type '{unit_type}'.")
-            cls, style = unit_types[unit_type]
-
-            exclude = {"type", "in", "out", "provider"}
-            if unit_type == "Flash":
-                # Flash uses out_vap / out_liq — exclude both from kwargs
-                exclude |= {"out_vap", "out_liq"}
-
-            params = {k: v for k, v in unit_cfg.items() if k not in exclude}
-            if style == "params":
-                # Heater / Flash use __init__(name, params_dict)
-                unit = cls(unit_name, params)
-            else:
-                unit = cls(unit_name, **params)
-
-            # Attach provider so EO residuals can route thermo calls.
-            if _pm:
-                unit._provider = get_unit_provider(_pm, unit_cfg)
-
-            units[unit_name] = unit
-            logger.info(f"Built unit '{unit_name}' ({unit_type})")
-
+            units[unit_name] = _build_unit(unit_name, unit_cfg, provider_map)
+            logger.info(f"Built unit '{unit_name}' ({unit_cfg['type']})")
         return units
 
     def _check_provider_backend_compat(self) -> None:

{processforge-0.2.30 → processforge-0.2.38}/src/processforge/eo/jacobian.py

@@ -376,14 +376,17 @@ class GlobalJacobianManager:
         """
         Return column groups that can be perturbed simultaneously.
 
-        Two columns can be grouped if they never appear together in the same
-        residual block.  Here we use the conservative grouping: one group per
-        stream, where columns within the same stream block are perturbed together.
+        Each group contains a single column so that the finite-difference
+        Jacobian correctly captures the derivative of each variable
+        independently.  Perturbing multiple variables in a stream block
+        simultaneously produces identical dF vectors for every column in
+        the group, which yields a rank-deficient Jacobian.
         """
         groups: list[list[int]] = []
         for sv in self._streams.values():
             o = sv.global_offset
-            groups.append(list(range(o, o + sv.n_vars)))
+            for i in range(sv.n_vars):
+                groups.append([o + i])
         return groups
 
     @property

{processforge-0.2.30 → processforge-0.2.38}/src/processforge/eo/solver.py

@@ -163,7 +163,6 @@ def solve_with_homotopy(
         )
 
     import numpy as np
-    x_sol, converged, stats = solver.solve(manager, x0)
 
     if not isinstance(state, SnapshotState):
         x0 = np.array(state["x"])