processforge 0.3.14__tar.gz → 0.3.16__tar.gz

{processforge-0.3.14/src/processforge.egg-info → processforge-0.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.14
+Version: 0.3.16
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause

processforge-0.3.16/flowsheets/coupled/msre_coupled.json

@@ -0,0 +1,172 @@
+{
+  "metadata": {
+    "name": "MSRE coupled neutronics + thermal (CoolProp thermo source)",
+    "description": "Demonstrates cross-engine parameter coupling using the per-unit 'inputs' block. A CoolProp-backed heater produces the 'coolant' stream; its temperature feeds both the OpenMC reactor material temperature and the FESTIM thermal model. The OpenMC reactor's fission power then drives a second OpenMC fixed-source unit, exercising the iterative coupling resolver (units are resolved in topological order and converged over iterations).",
+    "version": "1.0"
+  },
+  "providers": {
+    "openmc": {
+      "type": "openmc",
+      "url": "http://localhost:9001",
+      "output_dir": "openmc/msre_coupled_run",
+      "cross_sections": "${OPENMC_DATA_ROOT}/cross_sections/cross_sections.xml"
+    },
+    "festim": {
+      "type": "festim",
+      "url": "http://localhost:9002",
+      "output_dir": "festim/msre_coupled_run"
+    },
+    "coolprop": {
+      "type": "coolprop"
+    }
+  },
+  "materials": {
+    "graphite": {
+      "id": 1,
+      "density": 2.26,
+      "density_units": "g/cm3",
+      "temperature": 300.0,
+      "elements": [{ "element": "C", "percent": 1.0, "percent_type": "ao" }]
+    },
+    "inconel": {
+      "id": 4,
+      "density": 8.9,
+      "density_units": "g/cm3",
+      "temperature": 300.0,
+      "elements": [
+        { "element": "Ni", "percent": 0.72, "percent_type": "ao" },
+        { "element": "Cr", "percent": 0.20, "percent_type": "ao" },
+        { "element": "Fe", "percent": 0.08, "percent_type": "ao" }
+      ]
+    },
+    "salt": {
+      "id": 3,
+      "density": 2.2,
+      "density_units": "g/cm3",
+      "temperature": 300.0,
+      "depletable": true,
+      "nuclides": [
+        { "name": "Li7",  "percent": 0.335000, "percent_type": "ao" },
+        { "name": "U235", "percent": 0.000527, "percent_type": "ao" },
+        { "name": "U238", "percent": 0.001053, "percent_type": "ao" }
+      ],
+      "elements": [
+        { "element": "F",  "percent": 0.534653, "percent_type": "ao" },
+        { "element": "Be", "percent": 0.076667, "percent_type": "ao" },
+        { "element": "Zr", "percent": 0.010000, "percent_type": "ao" }
+      ]
+    },
+    "tungsten": {
+      "id": 6,
+      "extra": { "D_0": 1, "E_D": 0.0 }
+    }
+  },
+  "streams": {
+    "feed": {
+      "T": 900.0,
+      "P": 101325.0,
+      "flowrate": 1.0,
+      "z": { "salt": 1.0 }
+    }
+  },
+  "units": {
+    "coolant_heater": {
+      "type": "Heater",
+      "provider": "coolprop",
+      "material": 1,
+      "in": "feed",
+      "out": "coolant",
+      "solver_config": { "delta_T": 0.0 }
+    },
+    "openmc_reactor": {
+      "type": "SolverUnit",
+      "provider": "openmc",
+      "sim_type": "eigenvalue_reactor",
+      "material": 3,
+      "solver_config": {
+        "batches": 20,
+        "inactive": 5,
+        "particles": 20000
+      },
+      "geometry_config": {
+        "type": "reactor_core",
+        "core_radius": 72.5,
+        "core_height": 160.0,
+        "reflector_thickness": 50.0,
+        "core_material": "salt",
+        "reflector_material": "graphite",
+        "vessel_material": "inconel",
+        "source_point": { "xyz": [0.0, 0.0, 0.0] }
+      },
+      "inputs": {
+        "solver_config.temperature_default": { "ref": "coolant.T", "as_unit": "K" }
+      }
+    },
+    "thermal": {
+      "type": "SolverUnit",
+      "provider": "festim",
+      "sim_type": "hydrogen_transport_tds",
+      "material": 6,
+      "solver_config": {
+        "mesh": {
+          "vertices": [0.0, 0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009, 0.01]
+        },
+        "subdomains": {
+          "volume": [
+            { "id": 1, "borders": [0.0, 0.01], "material": "tungsten" }
+          ],
+          "surface": [
+            { "id": 2, "x": 0.0 },
+            { "id": 3, "x": 0.01 }
+          ]
+        },
+        "species": [
+          { "name": "H", "mobile": true }
+        ],
+        "boundary_conditions": [
+          { "type": "fixed_concentration", "subdomain": 2, "species": "H", "value": 1 },
+          { "type": "fixed_concentration", "subdomain": 3, "species": "H", "value": 0 }
+        ],
+        "exports": [
+          { "type": "profile_1d", "field": "H", "volume": 1, "times": [0.05, 0.1, 0.2, 0.5, 1] }
+        ],
+        "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]
+        }
+      },
+      "inputs": {
+        "solver_config.temperature": { "ref": "coolant.T", "as_unit": "K" }
+      }
+    },
+    "openmc_source": {
+      "type": "SolverUnit",
+      "provider": "openmc",
+      "sim_type": "fixed_source_point",
+      "material": 3,
+      "solver_config": {
+        "batches": 20,
+        "inactive": 5,
+        "particles": 20000
+      },
+      "geometry_config": {
+        "source_point": { "xyz": [0.0, 0.0, 0.0] },
+        "sphere_radius": 200.0,
+        "sphere_material": "salt"
+      },
+      "inputs": {
+        "solver_config.source_strength": { "ref": "openmc_reactor.power", "as_unit": "W" }
+      }
+    }
+  },
+  "simulation": {
+    "mode": "steady"
+  }
+}

{processforge-0.3.14 → processforge-0.3.16}/flowsheets/openmc/msre_eigenvalue.json

@@ -1,8 +1,8 @@
 {
   "metadata": {
-    "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"
+    "name": "MSRE Eigenvalue — approximate reactor geometry",
+    "description": "Molten Salt Reactor Experiment criticality calculation using an approximate cylindrical reactor-core geometry (salt core, graphite reflector, inconel vessel, helium gap, inor structure). Uses all 5 declared materials. Fission source at reactor centre.",
+    "version": "1.4"
   },
   "providers": {
     "openmc": {
@@ -78,34 +78,26 @@
       "type": "SolverUnit",
       "provider": "openmc",
       "material": 3,
-      "sim_type": "eigenvalue_csg",
+      "sim_type": "eigenvalue_reactor",
       "solver_config": {
         "batches": 20,
         "inactive": 5,
-        "particles": 20000,
-        "source_point": {
-          "xyz": [0.0, 0.0, 0.0]
-        },
-        "point_source_sphere_radius": 200.0,
-        "point_source_material": "salt",
-        "mesh_tallies": [
-          {
-            "tally_id": 1,
-            "name": "flux1",
-            "lower_left":  [-125, -125,  90],
-            "upper_right": [ 125,  125, 110],
-            "dimension": [400, 400, 1],
-            "scores": ["flux", "fission"]
-          },
-          {
-            "tally_id": 2,
-            "name": "flux2",
-            "lower_left":  [-175, -10, -50],
-            "upper_right": [ 175,  10, 400],
-            "dimension": [400, 1, 400],
-            "scores": ["flux", "fission"]
-          }
-        ]
+        "particles": 20000
+      },
+      "geometry_config": {
+        "type": "reactor_core",
+        "core_radius": 72.5,
+        "core_height": 160.0,
+        "reflector_thickness": 50.0,
+        "vessel_thickness": 5.0,
+        "gap_thickness": 3.0,
+        "structure_thickness": 10.0,
+        "core_material": "salt",
+        "reflector_material": "graphite",
+        "vessel_material": "inconel",
+        "gap_material": "helium",
+        "structure_material": "inor",
+        "source_point": {"xyz": [0.0, 0.0, 0.0]}
       }
     }
   },

{processforge-0.3.14 → processforge-0.3.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.3.14"
+version = "0.3.16"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"

{processforge-0.3.14 → processforge-0.3.16}/src/processforge/__init__.py

@@ -29,7 +29,7 @@ from .units.flash import Flash
 from .units.heater import Heater
 from .eo import EOFlowsheet, EOSolver
 
-__version__ = "0.3.14"
+__version__ = "0.3.16"
 
 __all__ = [
     "Flowsheet",

processforge-0.3.16/src/processforge/coupling.py

@@ -0,0 +1,183 @@
+"""Multi-physics coupling resolver for Processforge flowsheets.
+
+This module implements *parameter-reference coupling* between heterogeneous
+solver units (OpenMC neutronics, FESTIM thermal, CoolProp thermo, …).  Each
+solver unit may declare an ``inputs`` block mapping a dotted configuration
+path to a reference to another unit's (or stream's) output field::
+
+    "inputs": {
+        "solver_config.heat_source": {"ref": "openmc_solver.power", "as_unit": "W"},
+        "solver_config.temperature": {"ref": "thermal.temperature", "reduce": "mean", "as_unit": "K"}
+    }
+
+A single shared :class:`ParameterStore` collects every unit/stream output as a
+unit-bearing :class:`~processforge.quantity.Quantity` (the same ``Quantity``
+type every engine already emits — see Phase 5A).  The :class:`CouplingResolver`
+then, for each consumer unit and each declared input:
+
+1. looks the referenced ``<unit>.<field>`` quantity up in the store,
+2. reduces array-valued fields to a scalar (``mean`` / ``sum`` / ``max`` /
+   ``min`` — the natural choice for uniform coupling),
+3. converts units through the process-wide ``pint`` registry, and
+4. injects the bare magnitude into the consumer's config at the dotted path.
+
+Because solver units run in topological order, a single forward pass resolves
+acyclic couplings; cyclic couplings (e.g. neutronics power ↔ thermal
+temperature) converge via the iterative loop in :mod:`processforge.flowsheet`.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Optional
+
+from loguru import logger
+
+from .quantity import Quantity, ureg
+
+__all__ = [
+    "CouplingError",
+    "ParameterStore",
+    "CouplingResolver",
+    "deep_merge",
+]
+
+
+class CouplingError(ValueError):
+    """Raised when a coupling reference cannot be resolved."""
+
+
+_REF_RE = re.compile(r"^(?P<src>[A-Za-z0-9_]+)\.(?P<field>[A-Za-z0-9_]+)$")
+
+
+def _reduce_value(value: Any, mode: str) -> float:
+    """Collapse an (optionally array) value to a scalar for uniform coupling."""
+    if isinstance(value, (list, tuple)):
+        arr = [float(x) for x in value]
+        if not arr:
+            return 0.0
+        if mode == "sum":
+            return sum(arr)
+        if mode == "max":
+            return max(arr)
+        if mode == "min":
+            return min(arr)
+        return sum(arr) / len(arr)
+    if value is None:
+        return 0.0
+    return float(value)
+
+
+def _convert(scalar: float, from_unit: str, to_unit: Optional[str]) -> float:
+    """Convert *scalar* from *from_unit* to *to_unit* via the shared registry."""
+    if not to_unit or not from_unit:
+        return float(scalar)
+    try:
+        return float(ureg.Quantity(float(scalar), from_unit).to(to_unit).magnitude)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(
+            f"Coupling unit conversion {from_unit} -> {to_unit} failed ({exc}); "
+            f"using raw magnitude {scalar}."
+        )
+        return float(scalar)
+
+
+def _deep_set(d: dict, dotted_path: str, value: Any) -> None:
+    """Set *value* at *dotted_path* inside nested dict *d*, creating maps."""
+    parts = dotted_path.split(".")
+    cur = d
+    for p in parts[:-1]:
+        nxt = cur.get(p)
+        if not isinstance(nxt, dict):
+            nxt = {}
+            cur[p] = nxt
+        cur = nxt
+    cur[parts[-1]] = value
+
+
+def deep_merge(base: dict, overrides: dict) -> dict:
+    """Recursively merge *overrides* into a copy of *base*."""
+    out = dict(base)
+    for k, v in (overrides or {}).items():
+        if isinstance(v, dict) and isinstance(out.get(k), dict):
+            out[k] = deep_merge(out[k], v)
+        else:
+            out[k] = v
+    return out
+
+
+class ParameterStore:
+    """Registry of unit/stream output quantities, keyed by ``<src>.<field>``."""
+
+    def __init__(self) -> None:
+        self._quantities: dict[str, Quantity] = {}
+
+    def register(self, src: str, field: str, quantity: Quantity) -> None:
+        self._quantities[f"{src}.{field}"] = quantity
+
+    def register_unit(self, unit_name: str, engine_output: Any) -> None:
+        """Register every field of an :class:`EngineOutput`."""
+        for field in getattr(engine_output, "fields", []) or []:
+            self.register(unit_name, field.name, field.quantity)
+
+    def register_stream(
+        self,
+        stream_name: str,
+        stream_dict: dict,
+        thermo_fields: Optional[dict] = None,
+    ) -> None:
+        """Register stream scalars (T in K, P in Pa) and any thermo fields."""
+        if "T" in stream_dict:
+            self.register(
+                stream_name, "T", Quantity(value=float(stream_dict["T"]), unit="K")
+            )
+        if "P" in stream_dict:
+            self.register(
+                stream_name, "P", Quantity(value=float(stream_dict["P"]), unit="Pa")
+            )
+        for fname, q in (thermo_fields or {}).items():
+            if isinstance(q, Quantity):
+                self.register(stream_name, fname, q)
+
+    def get(self, ref: str) -> Optional[Quantity]:
+        return self._quantities.get(ref)
+
+    def __contains__(self, ref: str) -> bool:
+        return ref in self._quantities
+
+
+class CouplingResolver:
+    """Resolve a unit's ``inputs`` block against a :class:`ParameterStore`."""
+
+    def __init__(self, store: ParameterStore) -> None:
+        self.store = store
+
+    def resolve(self, spec: dict) -> float:
+        ref = spec.get("ref") if isinstance(spec, dict) else None
+        if not ref:
+            raise CouplingError("coupling spec missing 'ref'")
+        if not _REF_RE.match(ref):
+            raise CouplingError(
+                f"invalid coupling ref '{ref}' (expected '<unit>.<field>')"
+            )
+        quantity = self.store.get(ref)
+        if quantity is None:
+            raise CouplingError(f"coupling ref '{ref}' not found in store")
+        reduced = _reduce_value(quantity.value, spec.get("reduce", "mean"))
+        return _convert(reduced, quantity.unit, spec.get("as_unit"))
+
+    def build_overrides(self, inputs: dict):
+        """Return ``(nested_overrides, injected_scalars)`` for a unit.
+
+        *nested_overrides* mirrors the dotted input paths and is deep-merged
+        into the unit config before the provider runs.  *injected_scalars*
+        maps each local path to the resolved float, used for convergence
+        checking by the flowsheet driver.
+        """
+        overrides: dict = {}
+        injected: dict = {}
+        for path, spec in (inputs or {}).items():
+            value = self.resolve(spec)
+            _deep_set(overrides, path, value)
+            injected[path] = value
+        return overrides, injected