processforge 0.2.22__tar.gz → 0.2.30__tar.gz

{processforge-0.2.22/src/processforge.egg-info → processforge-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.2.22
+Version: 0.2.30
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Process Forge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -21,7 +21,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.0
 Requires-Dist: scipy>=1.14
-Requires-Dist: coolprop>=6.6
 Requires-Dist: matplotlib>=3.9
 Requires-Dist: loguru>=0.7
 Requires-Dist: jsonschema>=4.20
@@ -46,6 +45,8 @@ 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
@@ -62,7 +63,7 @@ Dynamic: license-file
 # Processforge
 
 
-![processforge-logo](images/processforge-logo.jpg)
+![processforge-logo](images/processforge-logo.svg)
 
 A Python-based process simulation framework for coupling different simulation engines.
 
@@ -75,12 +76,21 @@ A Python-based process simulation framework for coupling different simulation en
 - [Flowsheet Configuration](#flowsheet-configuration)
 - [Quick Start Examples](#quick-start-examples)
 - [Plan / Apply Workflow](#plan--apply-workflow-detail)
+- [Running on the cloud](#running-on-the-cloud)
 - [Project Structure](#project-structure)
 - [Dependencies](#dependencies)
 - [License](#license)
 
 ## Features
 
+### Plan / Apply Workflow
+- **`pf init`**: Initialises the `.processforge/` project directory and `outputs/` folder. Run once per project.
+- **`pf plan`**: Validates the flowsheet (schema, DOF, Pint unit consistency), performs a structural diff against the last saved state (`+` added, `~` modified, `-` removed units), and generates a Mermaid diagram — all without running the solver.
+- **`pf apply`**: Solves the flowsheet using the last converged state as a warm start. Falls back automatically to a step-wise homotopy/continuation solver if the direct Newton solve fails. Topology changes (added/removed units) trigger a cold start with a warning.
+- **Snapshot Versioning**: Every successful `apply` creates a new numbered snapshot in `.pfstate/snapshots/`. Previous snapshots are never deleted, enabling rollback to any prior converged design.
+- **Convergence Guardrails**: If both the direct solve and homotopy fail, the engine auto-reverts `latest` to the last good snapshot and writes a divergence debug report (`*_divergence.json`) with the final residual norm, drifted parameters, and solver statistics.
+- **Dynamic t=0 from State**: `pf run` (dynamic mode) automatically loads the latest `.pfstate` converged values as the initial conditions for time-integration, replacing arbitrary feed defaults with a physically meaningful starting point.
+
 ### Core Capabilities
 - Steady-state EO (equation-oriented) and dynamic process simulations
 - Thermodynamic property calculations using CoolProp
@@ -111,14 +121,6 @@ A Python-based process simulation framework for coupling different simulation en
 - Connectivity checks (inlet sources, unused outlets, unreachable units)
 - Comprehensive logging for debugging
 
-### Plan / Apply Workflow
-- **`pf init`**: Initialises the `.processforge/` project directory and `outputs/` folder. Run once per project.
-- **`pf plan`**: Validates the flowsheet (schema, DOF, Pint unit consistency), performs a structural diff against the last saved state (`+` added, `~` modified, `-` removed units), and generates a Mermaid diagram — all without running the solver.
-- **`pf apply`**: Solves the flowsheet using the last converged state as a warm start. Falls back automatically to a step-wise homotopy/continuation solver if the direct Newton solve fails. Topology changes (added/removed units) trigger a cold start with a warning.
-- **Snapshot Versioning**: Every successful `apply` creates a new numbered snapshot in `.pfstate/snapshots/`. Previous snapshots are never deleted, enabling rollback to any prior converged design.
-- **Convergence Guardrails**: If both the direct solve and homotopy fail, the engine auto-reverts `latest` to the last good snapshot and writes a divergence debug report (`*_divergence.json`) with the final residual norm, drifted parameters, and solver statistics.
-- **Dynamic t=0 from State**: `pf run` (dynamic mode) automatically loads the latest `.pfstate` converged values as the initial conditions for time-integration, replacing arbitrary feed defaults with a physically meaningful starting point.
-
 ## Available Unit Operations
 
 | Unit Type | Mode | Description | Key Parameters |
@@ -139,11 +141,15 @@ A Python-based process simulation framework for coupling different simulation en
 ### From PyPI
 
 ```bash
-# pip
+# pip (core features)
 pip install processforge
 
-# uv
+# uv (core features)
 uv add processforge
+
+# with CoolProp thermodynamics (required for Heater, Flash)
+pip install "processforge[coolprop]"
+uv add "processforge[coolprop]"
 ```
 
 ### With EO solver backends (optional)
@@ -404,24 +410,201 @@ If both the direct Newton solve and the homotopy fallback fail to converge:
 2. A `*_divergence.json` report is written with the drifted parameters, final `||F||`, homotopy step history, and the last `x` vector for debugging.
 
 
-## Running on the cloud 
-To run a simulation on any cloud provider (AWS EC2, Google Cloud, etc.) with Docker installed:
+## Running on the cloud
 
-Pull the image:
-```
+Processforge can run simulation jobs on any cloud VM with Docker installed. Two modes are available:
+
+- **Batch mode** — run a single flowsheet directly and store results locally or on S3.
+- **API server mode** — start `pf-serve` for programmatic flowsheet submission.
+
+### Prerequisites
+
+```bash
 docker pull ghcr.io/urjanova/processforge:latest
 ```
-Run a simulation and map an output folder:
-
-```Bash
-  docker run -p 8080:8080 \
-    -e AWS_ACCESS_KEY_ID=... \
-    -e AWS_SECRET_ACCESS_KEY=... \
-    -e AWS_DEFAULT_REGION=us-east-1 \
-    ghcr.io/urjanova/processforge:latest \
-    pf-serve
+
+### Step-by-step: Run a flowsheet via Docker (S3 results)
+
+This runs `pf apply` in the container and uploads results to an S3-compatible bucket.
+
+1. **Prepare your flowsheet JSON** — save it to a local file, e.g. `./flowsheets/my-flowsheet.json`.
+
+2. **Set S3 environment variables** in your Docker run command.
+
+3. **Run the container:**
+
+   ```bash
+   docker run --rm \
+     -v "$(pwd)/flowsheets:/app/flowsheets" \
+     -e S3_ACCESS_KEY='XXXXXX' \
+     -e S3_SECRET_KEY='YYYYYYYYY' \
+     -e S3_ENDPOINT_URL='https://processforge-files.ams3.digitaloceanspaces.com' \
+     -e S3_REGION_NAME='ams3' \
+     -e S3_BUCKET_NAME='my-bucket' \
+     ghcr.io/urjanova/processforge:latest \
+     pf apply /app/flowsheets/my-flowsheet.json
+   ```
+
+   Results (Zarr store, pfstate snapshots) are uploaded to S3 under the configured bucket.
+
+### Step-by-step: Run the API server (pf-serve)
+
+Start a persistent HTTP API that accepts flowsheet submissions:
+
+1. **Start the server:**
+
+   ```bash
+   docker run -d \
+     --name pf-api \
+     -p 9000:9000 \
+     -e S3_ACCESS_KEY='XXXXXX' \
+     -e S3_SECRET_KEY='YYYYYYYYY' \
+     -e S3_ENDPOINT_URL='https://processforge-files.nyc .digitaloceanspaces.com' \
+     -e S3_REGION_NAME='ams3' \
+     -e S3_BUCKET_NAME='my-bucket' \
+     ghcr.io/urjanova/processforge:latest \
+     pf-serve
+   ```
+
+2. **Submit a flowsheet via the API:**
+
+   ```bash
+   curl -X POST http://localhost:9000/run \
+     -H "Content-Type: application/json" \
+     -d @flowsheets/my-flowsheet.json
+   ```
+
+3. **Check job status** (replace `<job_id>` with the ID returned by the submission response):
+
+   ```bash
+   curl http://localhost:9000/status/<job_id>
+   ```
+
+4. **Retrieve results** — the results Zarr store and `.pfstate` snapshots are synced to your S3 bucket automatically on completion.
+
+   (Ensure you provide your S3-compatible credentials and endpoint URL; output and results will be synced directly to the specified bucket.)
+
+<h3 id="openmc-in-containers">Step-by-step: Run OpenMC simulations in Docker</h3>
+
+OpenMC simulations require nuclear cross-section data. The container's startup script (`scripts/fetch_openmc_data.sh`) downloads and caches these automatically.
+
+| Asset | Typical size | Managed via |
+|-------|-------------|-------------|
+| Cross-section library (`cross_sections.xml` + HDF5 data) | 100 MB – 5 GB | `OPENMC_DATA_URL` |
+
+**Step 1: Prepare a volume for cross-section data**
+
+You can either:
+- Use a **named Docker volume** (data persists across container restarts):
+  ```bash
+  docker volume create openmc_data
+  ```
+- Use a **host directory**:
+  ```bash
+  mkdir -p /path/to/openmc_data
+  ```
+
+**Step 2: Write your OpenMC flowsheet**
+
+Use environment variable expansion so the container can find the cross-sections at runtime:
+
+```json
+{
+  "providers": {
+    "openmc": {
+      "type": "openmc",
+      "cross_sections": "${OPENMC_DATA_ROOT}/cross_sections/cross_sections.xml"
+    }
+  },
+  "units": {
+    "reactor": {
+      "type": "SolverUnit",
+      "provider": "openmc",
+      "sim_type": "eigenvalue_csg",
+      "solver_config": {
+        "source_point": { "xyz": [0.0, 0.0, 0.0] },
+        "point_source_material": "salt",
+        "point_source_sphere_radius": 200.0,
+        "mesh_tallies": [...]
+      }
+    }
+  }
+}
+```
+
+The startup script exports `OPENMC_CROSS_SECTIONS` pointing to the downloaded library, so `${OPENMC_DATA_ROOT}` in your flowsheet is resolved automatically.
+
+**Step 3: Run the simulation**
+
+```bash
+docker run --rm \
+  -v openmc_data:/data \
+  -e OPENMC_DATA_URL='https://your-host.com/endfb-viii.0-hdf5.tar.gz' \
+  ghcr.io/urjanova/processforge:latest \
+  pf run /app/flowsheets/openmc/msre_eigenvalue.json
+```
+
+The cross-sections are downloaded on first run and cached on the volume. Subsequent runs skip the download.
+
+**Step 4 (optional): Use pre-downloaded cross-sections**
+
+If you already have the library on your host machine, mount it directly and skip the download:
+
+```bash
+docker run --rm \
+  -v /path/to/openmc_data:/data \
+  ghcr.io/urjanova/processforge:latest \
+  pf run /app/flowsheets/openmc/msre_eigenvalue.json
 ```
-(The -v flag ensures the .h5 or .xdmf files generated by OpenMC/FESTIM are saved to your actual hard drive, not lost inside the container.)
+
+The container checks for `cross_sections.xml` at the expected location and uses it if present.
+
+### Step-by-step: pf-serve with OpenMC cross-sections (local)
+
+Run the API server locally with OpenMC cross-section data so it can accept OpenMC flowsheet submissions.
+
+1. **Create a named volume for cross-sections:**
+
+   ```bash
+   docker volume create openmc_data
+   ```
+
+2. **Start pf-serve with the volume mounted and cross-section URL configured:**
+
+   ```bash
+   docker run -d \
+     --name pf-api \
+     -p 9000:9000 \
+     -v openmc_data:/data \
+     -e OPENMC_DATA_URL='https://your-host.com/endfb-viii.0-hdf5.tar.gz' \
+     ghcr.io/urjanova/processforge:latest \
+     pf-serve
+   ```
+
+   The startup script downloads cross-sections to the volume on first start. The server is ready once the container logs show the download completed.
+
+3. **Submit an OpenMC flowsheet to the API:**
+
+   ```bash
+   curl -X POST http://localhost:9000/run \
+     -H "Content-Type: application/json" \
+     -d @flowsheets/openmc/msre_eigenvalue.json
+   ```
+
+4. **Check the job status:**
+
+   ```bash
+   curl http://localhost:9000/status/<job_id>
+   ```
+
+5. **Stop the server when done:**
+
+   ```bash
+   docker stop pf-api && docker rm pf-api
+   ```
+
+   Results from completed jobs are stored inside the container; mount an output directory with `-v "$(pwd)/outputs:/app/outputs"` if you need them on the host.
+
 ## Logo credit
 Google Gemini / Nano Banana
 

{processforge-0.2.22 → processforge-0.2.30}/README.md

@@ -1,7 +1,7 @@
 # Processforge
 
 
-![processforge-logo](images/processforge-logo.jpg)
+![processforge-logo](images/processforge-logo.svg)
 
 A Python-based process simulation framework for coupling different simulation engines.
 
@@ -14,12 +14,21 @@ A Python-based process simulation framework for coupling different simulation en
 - [Flowsheet Configuration](#flowsheet-configuration)
 - [Quick Start Examples](#quick-start-examples)
 - [Plan / Apply Workflow](#plan--apply-workflow-detail)
+- [Running on the cloud](#running-on-the-cloud)
 - [Project Structure](#project-structure)
 - [Dependencies](#dependencies)
 - [License](#license)
 
 ## Features
 
+### Plan / Apply Workflow
+- **`pf init`**: Initialises the `.processforge/` project directory and `outputs/` folder. Run once per project.
+- **`pf plan`**: Validates the flowsheet (schema, DOF, Pint unit consistency), performs a structural diff against the last saved state (`+` added, `~` modified, `-` removed units), and generates a Mermaid diagram — all without running the solver.
+- **`pf apply`**: Solves the flowsheet using the last converged state as a warm start. Falls back automatically to a step-wise homotopy/continuation solver if the direct Newton solve fails. Topology changes (added/removed units) trigger a cold start with a warning.
+- **Snapshot Versioning**: Every successful `apply` creates a new numbered snapshot in `.pfstate/snapshots/`. Previous snapshots are never deleted, enabling rollback to any prior converged design.
+- **Convergence Guardrails**: If both the direct solve and homotopy fail, the engine auto-reverts `latest` to the last good snapshot and writes a divergence debug report (`*_divergence.json`) with the final residual norm, drifted parameters, and solver statistics.
+- **Dynamic t=0 from State**: `pf run` (dynamic mode) automatically loads the latest `.pfstate` converged values as the initial conditions for time-integration, replacing arbitrary feed defaults with a physically meaningful starting point.
+
 ### Core Capabilities
 - Steady-state EO (equation-oriented) and dynamic process simulations
 - Thermodynamic property calculations using CoolProp
@@ -50,14 +59,6 @@ A Python-based process simulation framework for coupling different simulation en
 - Connectivity checks (inlet sources, unused outlets, unreachable units)
 - Comprehensive logging for debugging
 
-### Plan / Apply Workflow
-- **`pf init`**: Initialises the `.processforge/` project directory and `outputs/` folder. Run once per project.
-- **`pf plan`**: Validates the flowsheet (schema, DOF, Pint unit consistency), performs a structural diff against the last saved state (`+` added, `~` modified, `-` removed units), and generates a Mermaid diagram — all without running the solver.
-- **`pf apply`**: Solves the flowsheet using the last converged state as a warm start. Falls back automatically to a step-wise homotopy/continuation solver if the direct Newton solve fails. Topology changes (added/removed units) trigger a cold start with a warning.
-- **Snapshot Versioning**: Every successful `apply` creates a new numbered snapshot in `.pfstate/snapshots/`. Previous snapshots are never deleted, enabling rollback to any prior converged design.
-- **Convergence Guardrails**: If both the direct solve and homotopy fail, the engine auto-reverts `latest` to the last good snapshot and writes a divergence debug report (`*_divergence.json`) with the final residual norm, drifted parameters, and solver statistics.
-- **Dynamic t=0 from State**: `pf run` (dynamic mode) automatically loads the latest `.pfstate` converged values as the initial conditions for time-integration, replacing arbitrary feed defaults with a physically meaningful starting point.
-
 ## Available Unit Operations
 
 | Unit Type | Mode | Description | Key Parameters |
@@ -78,11 +79,15 @@ A Python-based process simulation framework for coupling different simulation en
 ### From PyPI
 
 ```bash
-# pip
+# pip (core features)
 pip install processforge
 
-# uv
+# uv (core features)
 uv add processforge
+
+# with CoolProp thermodynamics (required for Heater, Flash)
+pip install "processforge[coolprop]"
+uv add "processforge[coolprop]"
 ```
 
 ### With EO solver backends (optional)
@@ -343,24 +348,201 @@ If both the direct Newton solve and the homotopy fallback fail to converge:
 2. A `*_divergence.json` report is written with the drifted parameters, final `||F||`, homotopy step history, and the last `x` vector for debugging.
 
 
-## Running on the cloud 
-To run a simulation on any cloud provider (AWS EC2, Google Cloud, etc.) with Docker installed:
+## Running on the cloud
 
-Pull the image:
-```
+Processforge can run simulation jobs on any cloud VM with Docker installed. Two modes are available:
+
+- **Batch mode** — run a single flowsheet directly and store results locally or on S3.
+- **API server mode** — start `pf-serve` for programmatic flowsheet submission.
+
+### Prerequisites
+
+```bash
 docker pull ghcr.io/urjanova/processforge:latest
 ```
-Run a simulation and map an output folder:
-
-```Bash
-  docker run -p 8080:8080 \
-    -e AWS_ACCESS_KEY_ID=... \
-    -e AWS_SECRET_ACCESS_KEY=... \
-    -e AWS_DEFAULT_REGION=us-east-1 \
-    ghcr.io/urjanova/processforge:latest \
-    pf-serve
+
+### Step-by-step: Run a flowsheet via Docker (S3 results)
+
+This runs `pf apply` in the container and uploads results to an S3-compatible bucket.
+
+1. **Prepare your flowsheet JSON** — save it to a local file, e.g. `./flowsheets/my-flowsheet.json`.
+
+2. **Set S3 environment variables** in your Docker run command.
+
+3. **Run the container:**
+
+   ```bash
+   docker run --rm \
+     -v "$(pwd)/flowsheets:/app/flowsheets" \
+     -e S3_ACCESS_KEY='XXXXXX' \
+     -e S3_SECRET_KEY='YYYYYYYYY' \
+     -e S3_ENDPOINT_URL='https://processforge-files.ams3.digitaloceanspaces.com' \
+     -e S3_REGION_NAME='ams3' \
+     -e S3_BUCKET_NAME='my-bucket' \
+     ghcr.io/urjanova/processforge:latest \
+     pf apply /app/flowsheets/my-flowsheet.json
+   ```
+
+   Results (Zarr store, pfstate snapshots) are uploaded to S3 under the configured bucket.
+
+### Step-by-step: Run the API server (pf-serve)
+
+Start a persistent HTTP API that accepts flowsheet submissions:
+
+1. **Start the server:**
+
+   ```bash
+   docker run -d \
+     --name pf-api \
+     -p 9000:9000 \
+     -e S3_ACCESS_KEY='XXXXXX' \
+     -e S3_SECRET_KEY='YYYYYYYYY' \
+     -e S3_ENDPOINT_URL='https://processforge-files.nyc .digitaloceanspaces.com' \
+     -e S3_REGION_NAME='ams3' \
+     -e S3_BUCKET_NAME='my-bucket' \
+     ghcr.io/urjanova/processforge:latest \
+     pf-serve
+   ```
+
+2. **Submit a flowsheet via the API:**
+
+   ```bash
+   curl -X POST http://localhost:9000/run \
+     -H "Content-Type: application/json" \
+     -d @flowsheets/my-flowsheet.json
+   ```
+
+3. **Check job status** (replace `<job_id>` with the ID returned by the submission response):
+
+   ```bash
+   curl http://localhost:9000/status/<job_id>
+   ```
+
+4. **Retrieve results** — the results Zarr store and `.pfstate` snapshots are synced to your S3 bucket automatically on completion.
+
+   (Ensure you provide your S3-compatible credentials and endpoint URL; output and results will be synced directly to the specified bucket.)
+
+<h3 id="openmc-in-containers">Step-by-step: Run OpenMC simulations in Docker</h3>
+
+OpenMC simulations require nuclear cross-section data. The container's startup script (`scripts/fetch_openmc_data.sh`) downloads and caches these automatically.
+
+| Asset | Typical size | Managed via |
+|-------|-------------|-------------|
+| Cross-section library (`cross_sections.xml` + HDF5 data) | 100 MB – 5 GB | `OPENMC_DATA_URL` |
+
+**Step 1: Prepare a volume for cross-section data**
+
+You can either:
+- Use a **named Docker volume** (data persists across container restarts):
+  ```bash
+  docker volume create openmc_data
+  ```
+- Use a **host directory**:
+  ```bash
+  mkdir -p /path/to/openmc_data
+  ```
+
+**Step 2: Write your OpenMC flowsheet**
+
+Use environment variable expansion so the container can find the cross-sections at runtime:
+
+```json
+{
+  "providers": {
+    "openmc": {
+      "type": "openmc",
+      "cross_sections": "${OPENMC_DATA_ROOT}/cross_sections/cross_sections.xml"
+    }
+  },
+  "units": {
+    "reactor": {
+      "type": "SolverUnit",
+      "provider": "openmc",
+      "sim_type": "eigenvalue_csg",
+      "solver_config": {
+        "source_point": { "xyz": [0.0, 0.0, 0.0] },
+        "point_source_material": "salt",
+        "point_source_sphere_radius": 200.0,
+        "mesh_tallies": [...]
+      }
+    }
+  }
+}
+```
+
+The startup script exports `OPENMC_CROSS_SECTIONS` pointing to the downloaded library, so `${OPENMC_DATA_ROOT}` in your flowsheet is resolved automatically.
+
+**Step 3: Run the simulation**
+
+```bash
+docker run --rm \
+  -v openmc_data:/data \
+  -e OPENMC_DATA_URL='https://your-host.com/endfb-viii.0-hdf5.tar.gz' \
+  ghcr.io/urjanova/processforge:latest \
+  pf run /app/flowsheets/openmc/msre_eigenvalue.json
+```
+
+The cross-sections are downloaded on first run and cached on the volume. Subsequent runs skip the download.
+
+**Step 4 (optional): Use pre-downloaded cross-sections**
+
+If you already have the library on your host machine, mount it directly and skip the download:
+
+```bash
+docker run --rm \
+  -v /path/to/openmc_data:/data \
+  ghcr.io/urjanova/processforge:latest \
+  pf run /app/flowsheets/openmc/msre_eigenvalue.json
 ```
-(The -v flag ensures the .h5 or .xdmf files generated by OpenMC/FESTIM are saved to your actual hard drive, not lost inside the container.)
+
+The container checks for `cross_sections.xml` at the expected location and uses it if present.
+
+### Step-by-step: pf-serve with OpenMC cross-sections (local)
+
+Run the API server locally with OpenMC cross-section data so it can accept OpenMC flowsheet submissions.
+
+1. **Create a named volume for cross-sections:**
+
+   ```bash
+   docker volume create openmc_data
+   ```
+
+2. **Start pf-serve with the volume mounted and cross-section URL configured:**
+
+   ```bash
+   docker run -d \
+     --name pf-api \
+     -p 9000:9000 \
+     -v openmc_data:/data \
+     -e OPENMC_DATA_URL='https://your-host.com/endfb-viii.0-hdf5.tar.gz' \
+     ghcr.io/urjanova/processforge:latest \
+     pf-serve
+   ```
+
+   The startup script downloads cross-sections to the volume on first start. The server is ready once the container logs show the download completed.
+
+3. **Submit an OpenMC flowsheet to the API:**
+
+   ```bash
+   curl -X POST http://localhost:9000/run \
+     -H "Content-Type: application/json" \
+     -d @flowsheets/openmc/msre_eigenvalue.json
+   ```
+
+4. **Check the job status:**
+
+   ```bash
+   curl http://localhost:9000/status/<job_id>
+   ```
+
+5. **Stop the server when done:**
+
+   ```bash
+   docker stop pf-api && docker rm pf-api
+   ```
+
+   Results from completed jobs are stored inside the container; mount an output directory with `-v "$(pwd)/outputs:/app/outputs"` if you need them on the host.
+
 ## Logo credit
 Google Gemini / Nano Banana
 

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

@@ -104,6 +104,8 @@
   },
   "simulation": {
     "mode": "steady",
-    "backend": "scipy"
+    "t0": 0.0,
+    "tf": 20.0,
+    "dt": 1.0
   }
 }

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

@@ -1,14 +1,14 @@
 {
   "metadata": {
-    "name": "MSRE Eigenvalue — DAGMC geometry",
-    "description": "Molten Salt Reactor Experiment eigenvalue simulation. Replicates openmc.py reference script. DAGMC geometry loaded from .h5m file. 7 materials matching h5m volume tags: graphite, inor, salt, inconel, helium, Graveyard, helium_comp.",
-    "version": "1.1"
+    "name": "MSRE Eigenvalue — CSG geometry",
+    "description": "Molten Salt Reactor Experiment criticality calculation. Fission source at reactor centre inside a homogeneous salt sphere. 5 materials: graphite, inor, salt, inconel, helium.",
+    "version": "1.3"
   },
   "providers": {
     "openmc": {
       "type": "openmc",
       "output_dir": "outputs/openmc/msre_run",
-      "cross_sections": "tmp_files/cross_sections/cross_sections.xml"
+      "cross_sections": "${OPENMC_DATA_ROOT}/cross_sections/cross_sections.xml"
     }
   },
   "materials": {
@@ -70,26 +70,23 @@
         { "name": "He4", "percent": 1.0, "percent_type": "ao" }
       ]
     }
-    
   },
   "streams": {},
   "units": {
     "openmc_solver": {
       "type": "SolverUnit",
       "provider": "openmc",
-      "material":3,
-      "sim_type": "eigenvalue_dagmc",
+      "material": 3,
+      "sim_type": "eigenvalue_csg",
       "solver_config": {
-        "dagmc_path": "/home/hrishiballal/Documents/Github/urjanova/processforge/tmp_files/geometry/msre_simple.h5m",
         "batches": 20,
         "inactive": 5,
         "particles": 20000,
-        "run_mode": "eigenvalue",
-        "source_box": {
-          "lower_left":  [-125, -125,   0],
-          "upper_right": [ 125,  125, 500],
-          "only_fissionable": true
+        "source_point": {
+          "xyz": [0.0, 0.0, 0.0]
         },
+        "point_source_sphere_radius": 200.0,
+        "point_source_material": "salt",
         "mesh_tallies": [
           {
             "tally_id": 1,

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.2.22"
+version = "0.2.30"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -27,7 +27,6 @@ keywords = ["process", "simulation", "chemical", "engineering", "flowsheet"]
 dependencies = [
     "numpy>=2.0",
     "scipy>=1.14",
-    "coolprop>=6.6",
     "matplotlib>=3.9",
     "loguru>=0.7",
     "jsonschema>=4.20",
@@ -61,6 +60,9 @@ modelica = [
 cantera = [
     "cantera>=3.0",
 ]
+coolprop = [
+    "coolprop>=6.6",
+]
 pcl = [
     "pint>=0.24",
 ]