processforge 0.2.4__tar.gz → 0.2.7__tar.gz

{processforge-0.2.4/src/processforge.egg-info → processforge-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.2.4
+Version: 0.2.7
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Process Forge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -34,6 +34,8 @@ 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: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: black; extra == "dev"

{processforge-0.2.4 → processforge-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.2.4"
+version = "0.2.7"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -45,6 +45,9 @@ eo-casadi = [
     "pyomo>=6.7",
     "casadi>=3.6",
 ]
+fmu = [
+    "pythonfmu>=0.6",
+]
 dev = [
     "pytest>=7.0",
     "black",

{processforge-0.2.4 → processforge-0.2.7}/src/processforge/__init__.py

@@ -11,6 +11,7 @@ Provides steady-state and dynamic process simulation capabilities including:
 """
 
 from .flowsheet import Flowsheet
+from .provenance import build_run_info
 from .solver import Solver
 from .thermo import get_enthalpy_molar, get_Cp_molar, get_K_values, rachford_rice
 from .validate import validate_flowsheet
@@ -45,6 +46,7 @@ __all__ = [
     "plot_results",
     "plot_timeseries",
     "save_results_zarr",
+    "build_run_info",
     "Pump",
     "Valve",
     "Strainer",

{processforge-0.2.4 → processforge-0.2.7}/src/processforge/eo/flowsheet.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 from copy import deepcopy
 
+import numpy as np
 from loguru import logger
 
 from .jacobian import GlobalJacobianManager
@@ -64,12 +65,19 @@ class EOFlowsheet:
         """
         Build and solve the EO system.
 
+        After this method returns, ``self.x0`` holds the initial-guess vector
+        and ``self.var_names`` holds a human-readable label for each element —
+        both can be passed directly to
+        :func:`processforge.provenance.build_run_info` for reproducibility.
+
         Returns:
             Stream result dict in the same format as ``Flowsheet.run()``:
             ``{stream_name: {"T": ..., "P": ..., "flowrate": ..., "z": {...}}}``
         """
         manager = self._build()
         x0 = self._warm_start(manager)
+        self.x0: "np.ndarray" = x0.copy()
+        self.var_names: list[str] = self._build_var_names(manager)
         solver = EOSolver(backend=self.backend)
         x_sol, converged, stats = solver.solve(manager, x0)
         if not converged:
@@ -172,6 +180,26 @@ class EOFlowsheet:
             comps.update(stream.get("z", {}).keys())
         return sorted(comps)
 
+    # ------------------------------------------------------------------
+    # Provenance helpers
+    # ------------------------------------------------------------------
+
+    def _build_var_names(self, manager: "GlobalJacobianManager") -> list[str]:
+        """Return a human-readable label for every scalar in the x vector.
+
+        Variable order mirrors ``GlobalJacobianManager`` layout:
+        ``T``, ``P``, ``flowrate``, then one entry per component ``z_<comp>``
+        for each registered stream in registration order.
+        """
+        suffixes = ["T", "P", "flowrate"] + [
+            f"z_{c}" for c in manager.components
+        ]
+        names: list[str] = []
+        for stream_name in manager._streams:
+            for suffix in suffixes:
+                names.append(f"{stream_name}/{suffix}")
+        return names
+
     # ------------------------------------------------------------------
     # Warm-start
     # ------------------------------------------------------------------

processforge-0.2.7/src/processforge/fmu/__init__.py

@@ -0,0 +1,3 @@
+from .builder import build_fmu
+
+__all__ = ["build_fmu"]

processforge-0.2.7/src/processforge/fmu/_fmi_vars.py

@@ -0,0 +1,143 @@
+"""FMI variable spec generation for ProcessForge FMU export."""
+from __future__ import annotations
+
+import re
+
+
+def _sanitize_name(s: str) -> str:
+    """Replace characters invalid in Python identifiers with underscores."""
+    return re.sub(r"[^a-zA-Z0-9_]", "_", s)
+
+
+def get_fmi_variable_specs(
+    feed_streams: list[str],
+    output_streams: list[str],
+    components: list[str],
+    unit_params: dict[str, dict],
+    config: dict,
+    mode: str,
+) -> list[dict]:
+    """Return ordered list of FMI variable spec dicts for a flowsheet.
+
+    Each dict contains:
+        attr_name     – Python attribute name on the slave instance
+        initial_value – float initial value
+        causality     – "input" | "output" | "parameter"
+        variability   – "continuous" | "fixed"
+        description   – human-readable string
+    """
+    specs: list[dict] = []
+
+    # --- Inputs: feed stream boundary conditions ---
+    for stream_name in feed_streams:
+        stream_cfg = config["streams"][stream_name]
+        safe_s = _sanitize_name(stream_name)
+
+        specs.append({
+            "attr_name": f"feed_{safe_s}_T",
+            "initial_value": float(stream_cfg.get("T", 298.15)),
+            "causality": "input",
+            "variability": "continuous",
+            "description": f"Temperature of feed stream '{stream_name}' [K]",
+        })
+        specs.append({
+            "attr_name": f"feed_{safe_s}_P",
+            "initial_value": float(stream_cfg.get("P", 101325.0)),
+            "causality": "input",
+            "variability": "continuous",
+            "description": f"Pressure of feed stream '{stream_name}' [Pa]",
+        })
+        specs.append({
+            "attr_name": f"feed_{safe_s}_flowrate",
+            "initial_value": float(stream_cfg.get("flowrate", 1.0)),
+            "causality": "input",
+            "variability": "continuous",
+            "description": f"Molar flowrate of feed stream '{stream_name}' [mol/s]",
+        })
+        z_cfg = stream_cfg.get("z", {})
+        for comp in components:
+            safe_c = _sanitize_name(comp)
+            specs.append({
+                "attr_name": f"feed_{safe_s}_z_{safe_c}",
+                "initial_value": float(z_cfg.get(comp, 0.0)),
+                "causality": "input",
+                "variability": "continuous",
+                "description": f"Mole fraction of {comp} in feed stream '{stream_name}'",
+            })
+
+    # --- Outputs: calculated stream properties ---
+    for stream_name in output_streams:
+        safe_s = _sanitize_name(stream_name)
+
+        specs.append({
+            "attr_name": f"out_{safe_s}_T",
+            "initial_value": 0.0,
+            "causality": "output",
+            "variability": "continuous",
+            "description": f"Temperature of stream '{stream_name}' [K]",
+        })
+        specs.append({
+            "attr_name": f"out_{safe_s}_P",
+            "initial_value": 0.0,
+            "causality": "output",
+            "variability": "continuous",
+            "description": f"Pressure of stream '{stream_name}' [Pa]",
+        })
+        specs.append({
+            "attr_name": f"out_{safe_s}_flowrate",
+            "initial_value": 0.0,
+            "causality": "output",
+            "variability": "continuous",
+            "description": f"Molar flowrate of stream '{stream_name}' [mol/s]",
+        })
+        for comp in components:
+            safe_c = _sanitize_name(comp)
+            specs.append({
+                "attr_name": f"out_{safe_s}_z_{safe_c}",
+                "initial_value": 0.0,
+                "causality": "output",
+                "variability": "continuous",
+                "description": f"Mole fraction of {comp} in stream '{stream_name}'",
+            })
+
+    # --- Parameters: unit design values (fixed for FMU lifetime) ---
+    for unit_name, params in unit_params.items():
+        safe_u = _sanitize_name(unit_name)
+        for key, value in params.items():
+            if not isinstance(value, (int, float)):
+                continue
+            safe_k = _sanitize_name(key)
+            specs.append({
+                "attr_name": f"param_{safe_u}_{safe_k}",
+                "initial_value": float(value),
+                "causality": "parameter",
+                "variability": "fixed",
+                "description": f"Parameter '{key}' of unit '{unit_name}'",
+            })
+
+    # --- Tank state outputs (dynamic mode only) ---
+    if mode == "dynamic":
+        for unit_name, unit_cfg in config["units"].items():
+            if unit_cfg.get("type") != "Tank":
+                continue
+            safe_u = _sanitize_name(unit_name)
+            initial_T = float(unit_cfg.get("initial_T", 298.15))
+            specs.append({
+                "attr_name": f"state_{safe_u}_T",
+                "initial_value": initial_T,
+                "causality": "output",
+                "variability": "continuous",
+                "description": f"Tank temperature in unit '{unit_name}' [K]",
+            })
+            initial_n = unit_cfg.get("initial_n", {})
+            for comp in components:
+                safe_c = _sanitize_name(comp)
+                specs.append({
+                    "attr_name": f"state_{safe_u}_n_{safe_c}",
+                    "initial_value": float(initial_n.get(comp, 0.0)),
+                    "causality": "output",
+                    "variability": "continuous",
+                    "description": f"Molar holdup of {comp} in tank '{unit_name}' [mol]",
+                })
+
+    return specs

processforge-0.2.7/src/processforge/fmu/builder.py

@@ -0,0 +1,190 @@
+"""Build a PythonFMU co-simulation FMU from a ProcessForge flowsheet config."""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+
+from ..utils.validate_flowsheet import validate_flowsheet
+from ._fmi_vars import _sanitize_name
+from .slave_template import render_slave_source
+
+
+def build_fmu(
+    config_path: str,
+    output_dir: str = "outputs",
+    backend: str = "scipy",
+) -> str:
+    """Build an FMI 2.0 co-simulation FMU from a ProcessForge flowsheet JSON.
+
+    Args:
+        config_path: Path to the flowsheet JSON file.
+        output_dir:  Directory where the ``.fmu`` file will be written.
+        backend:     EO solver backend for steady-state mode
+                     (``"scipy"``, ``"pyomo"``, or ``"casadi"``).
+
+    Returns:
+        Absolute path to the generated ``.fmu`` file.
+
+    Raises:
+        RuntimeError: If ``pythonfmu`` is not installed or the build fails.
+    """
+    if not shutil.which("pythonfmu"):
+        raise RuntimeError(
+            "PythonFMU is not installed or not on PATH. "
+            "Install it with:  pip install processforge[fmu]"
+        )
+
+    config = validate_flowsheet(config_path)
+    interface = _analyze_config(config)
+    slave_class_name = _get_slave_class_name(config, config_path)
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    with tempfile.TemporaryDirectory() as staging_dir:
+        # Place the config JSON in the staging directory so PythonFMU bundles
+        # it into the FMU's resources/ directory.
+        config_staging = os.path.join(staging_dir, "flowsheet_config.json")
+        shutil.copy(config_path, config_staging)
+
+        slave_source = render_slave_source(
+            slave_class_name=slave_class_name,
+            mode=interface["mode"],
+            backend=backend,
+            feed_streams=interface["feed_streams"],
+            output_streams=interface["output_streams"],
+            components=interface["components"],
+            unit_params=interface["unit_params"],
+            config=config,
+        )
+
+        slave_py = os.path.join(staging_dir, f"{slave_class_name}.py")
+        with open(slave_py, "w") as f:
+            f.write(slave_source)
+
+        try:
+            result = subprocess.run(
+                [
+                    "pythonfmu",
+                    "build",
+                    "-f", slave_py,
+                    "-d", os.path.abspath(output_dir),
+                    config_staging,
+                ],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except subprocess.CalledProcessError as exc:
+            raise RuntimeError(
+                f"pythonfmu build failed:\n{exc.stderr}"
+            ) from exc
+
+    fmu_path = os.path.abspath(
+        os.path.join(output_dir, f"{slave_class_name}.fmu")
+    )
+    return fmu_path
+
+
+# ---------------------------------------------------------------------------
+# Config analysis
+# ---------------------------------------------------------------------------
+
+def _analyze_config(config: dict) -> dict:
+    """Extract the FMI interface description from a validated config dict.
+
+    Returns a dict with:
+        feed_streams   – list of feed stream names (from config["streams"])
+        output_streams – all unit outlet stream names (not feeds)
+        components     – sorted list of component names
+        unit_params    – {unit_name: {param_key: value}} for numeric params
+        mode           – "steady" or "dynamic"
+    """
+    feed_streams: list[str] = list(config["streams"].keys())
+
+    # Collect all outlet stream names from unit definitions
+    all_outlet_streams: set[str] = set()
+    for unit_cfg in config["units"].values():
+        for outlet in _get_outlets(unit_cfg):
+            all_outlet_streams.add(outlet)
+
+    # Output streams = outlets not already in feeds
+    feed_set = set(feed_streams)
+    output_streams: list[str] = [s for s in all_outlet_streams if s not in feed_set]
+    # Preserve stable order (insertion order of config["units"])
+    seen: set[str] = set()
+    output_streams_ordered: list[str] = []
+    for unit_cfg in config["units"].values():
+        for outlet in _get_outlets(unit_cfg):
+            if outlet not in feed_set and outlet not in seen:
+                output_streams_ordered.append(outlet)
+                seen.add(outlet)
+
+    # Component discovery — same logic as EOFlowsheet._collect_components()
+    comp_set: set[str] = set()
+    for stream in config["streams"].values():
+        comp_set.update(stream.get("z", {}).keys())
+    components = sorted(comp_set)
+
+    # Unit parameters — numeric config keys, excluding topology keys
+    _topology_keys = {"type", "in", "out", "out_liq", "out_vap"}
+    unit_params: dict[str, dict] = {}
+    for unit_name, unit_cfg in config["units"].items():
+        params = {
+            k: v
+            for k, v in unit_cfg.items()
+            if k not in _topology_keys and isinstance(v, (int, float))
+        }
+        if params:
+            unit_params[unit_name] = params
+
+    # Simulation mode — force "dynamic" if any Tank is present
+    mode = config.get("simulation", {}).get("mode", "steady")
+    has_tank = any(
+        cfg.get("type") == "Tank" for cfg in config["units"].values()
+    )
+    if has_tank:
+        mode = "dynamic"
+
+    return {
+        "feed_streams": feed_streams,
+        "output_streams": output_streams_ordered,
+        "components": components,
+        "unit_params": unit_params,
+        "mode": mode,
+    }
+
+
+def _get_outlets(unit_cfg: dict) -> list[str]:
+    """Return outlet stream name(s) — handles Flash (out_vap + out_liq)."""
+    if unit_cfg.get("type") == "Flash":
+        outlets = []
+        if unit_cfg.get("out_liq"):
+            outlets.append(unit_cfg["out_liq"])
+        if unit_cfg.get("out_vap"):
+            outlets.append(unit_cfg["out_vap"])
+        return outlets
+    out = unit_cfg.get("out")
+    return [out] if out else []
+
+
+def _get_slave_class_name(config: dict, config_path: str) -> str:
+    """Derive a valid Python class name for the FMU slave."""
+    name = config.get("metadata", {}).get("name", "")
+    if not name:
+        name = os.path.splitext(os.path.basename(config_path))[0]
+
+    # Convert to PascalCase-safe identifier
+    name = re.sub(r"[^a-zA-Z0-9]", "_", name)
+    name = re.sub(r"_+", "_", name).strip("_")
+    # Ensure starts with a letter
+    if name and name[0].isdigit():
+        name = "FMU_" + name
+    if not name:
+        name = "ProcessForgeFMU"
+
+    # PascalCase: capitalise each word segment
+    name = "".join(part.capitalize() for part in name.split("_"))
+    return name or "ProcessForgeFMU"

processforge-0.2.7/src/processforge/fmu/slave_template.py

@@ -0,0 +1,252 @@
+"""Generate per-flowsheet FMU slave source code for PythonFMU."""
+from __future__ import annotations
+
+import json
+
+from ._fmi_vars import _sanitize_name, get_fmi_variable_specs
+
+
+def render_slave_source(
+    slave_class_name: str,
+    mode: str,
+    backend: str,
+    feed_streams: list[str],
+    output_streams: list[str],
+    components: list[str],
+    unit_params: dict[str, dict],
+    config: dict,
+) -> str:
+    """Return complete Python source for the per-flowsheet FMU slave.
+
+    The generated file is stand-alone: ``_sanitize_name`` is embedded so the
+    slave does not depend on processforge internals for name resolution.
+    """
+    specs = get_fmi_variable_specs(
+        feed_streams, output_streams, components, unit_params, config, mode
+    )
+
+    lines: list[str] = []
+
+    # ------------------------------------------------------------------ header
+    lines += [
+        "# AUTO-GENERATED by processforge.fmu.slave_template — DO NOT EDIT",
+        "from __future__ import annotations",
+        "import json",
+        "import os",
+        "import re",
+        "from copy import deepcopy",
+        "from pythonfmu import Fmi2Slave, Fmi2Causality, Fmi2Variability, Real",
+        "",
+        "",
+        "def _sanitize_name(s: str) -> str:",
+        '    return re.sub(r"[^a-zA-Z0-9_]", "_", s)',
+        "",
+        "",
+        f"class {slave_class_name}(Fmi2Slave):",
+        "",
+        "    def __init__(self, **kwargs):",
+        "        super().__init__(**kwargs)",
+        "        _cfg_path = os.path.join(self.resources, 'flowsheet_config.json')",
+        "        with open(_cfg_path) as _f:",
+        "            self._config = json.load(_f)",
+        "",
+    ]
+
+    # -------------------------------------------------------- instance attrs
+    lines.append("        # --- instance attribute initial values ---")
+    for spec in specs:
+        lines.append(f"        self.{spec['attr_name']} = {spec['initial_value']!r}")
+
+    lines.append("")
+
+    # -------------------------------------------------------- register_variable
+    lines.append("        # --- FMI variable registration ---")
+    _causality_map = {
+        "input": "Fmi2Causality.input",
+        "output": "Fmi2Causality.output",
+        "parameter": "Fmi2Causality.parameter",
+    }
+    _variability_map = {
+        "continuous": "Fmi2Variability.continuous",
+        "fixed": "Fmi2Variability.fixed",
+    }
+    for spec in specs:
+        caus = _causality_map[spec["causality"]]
+        var = _variability_map[spec["variability"]]
+        desc = spec["description"].replace("'", "\\'")
+        lines.append(
+            f"        self.register_variable(Real("
+            f"'{spec['attr_name']}', causality={caus}, "
+            f"variability={var}, "
+            f"description='{desc}'))"
+        )
+
+    lines.append("")
+
+    # -------------------------------------------------------- embedded metadata
+    components_repr = repr(components)
+    feed_streams_repr = repr(feed_streams)
+    output_streams_repr = repr(output_streams)
+    # unit_params keys used for writing params back into config
+    unit_param_keys_repr = repr({k: list(v.keys()) for k, v in unit_params.items()})
+    tank_units = [n for n, c in config["units"].items() if c.get("type") == "Tank"]
+    tank_units_repr = repr(tank_units)
+
+    lines += [
+        "        self._components = " + components_repr,
+        "        self._feed_stream_names = " + feed_streams_repr,
+        "        self._output_stream_names = " + output_streams_repr,
+        "        self._unit_param_keys = " + unit_param_keys_repr,
+        "        self._tank_units = " + tank_units_repr,
+        "",
+    ]
+
+    if mode == "dynamic":
+        lines += _render_dynamic_init(tank_units, components)
+
+    # ---------------------------------------------------------- do_step
+    lines.append("    def do_step(self, current_time: float, step_size: float) -> bool:")
+
+    if mode == "steady":
+        lines += _render_steady_do_step(backend)
+    else:
+        lines += _render_dynamic_do_step()
+
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Steady-state do_step body
+# ---------------------------------------------------------------------------
+
+def _render_steady_do_step(backend: str) -> list[str]:
+    return [
+        f"        from processforge.eo import EOFlowsheet",
+        "        config = deepcopy(self._config)",
+        "",
+        "        # Write FMI inputs → feed stream conditions",
+        "        for _sn in self._feed_stream_names:",
+        "            _ss = _sanitize_name(_sn)",
+        "            config['streams'][_sn]['T'] = getattr(self, f'feed_{_ss}_T')",
+        "            config['streams'][_sn]['P'] = getattr(self, f'feed_{_ss}_P')",
+        "            config['streams'][_sn]['flowrate'] = getattr(self, f'feed_{_ss}_flowrate')",
+        "            for _c in self._components:",
+        "                _sc = _sanitize_name(_c)",
+        "                config['streams'][_sn]['z'][_c] = getattr(self, f'feed_{_ss}_z_{_sc}')",
+        "",
+        "        # Write FMI parameters → unit design values",
+        "        for _un, _pkeys in self._unit_param_keys.items():",
+        "            _su = _sanitize_name(_un)",
+        "            for _pk in _pkeys:",
+        "                _spk = _sanitize_name(_pk)",
+        "                _attr = f'param_{_su}_{_spk}'",
+        "                if hasattr(self, _attr):",
+        "                    config['units'][_un][_pk] = getattr(self, _attr)",
+        "",
+        f"        _fs = EOFlowsheet(config, backend='{backend}')",
+        "        try:",
+        "            _results = _fs.run()",
+        "        except Exception:",
+        "            return False",
+        "",
+        "        # Write solver results → FMI outputs",
+        "        for _sn in self._output_stream_names:",
+        "            _ss = _sanitize_name(_sn)",
+        "            _stream = _results.get(_sn, {})",
+        "            setattr(self, f'out_{_ss}_T', float(_stream.get('T', 0.0)))",
+        "            setattr(self, f'out_{_ss}_P', float(_stream.get('P', 0.0)))",
+        "            setattr(self, f'out_{_ss}_flowrate', float(_stream.get('flowrate', 0.0)))",
+        "            for _c in self._components:",
+        "                _sc = _sanitize_name(_c)",
+        "                setattr(self, f'out_{_ss}_z_{_sc}',",
+        "                        float(_stream.get('z', {}).get(_c, 0.0)))",
+        "        return True",
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Dynamic __init__ tail and do_step body
+# ---------------------------------------------------------------------------
+
+def _render_dynamic_init(tank_units: list[str], components: list[str]) -> list[str]:
+    lines = [
+        "        # --- Build Flowsheet once for dynamic stepping ---",
+        "        from processforge.flowsheet import Flowsheet as _Flowsheet",
+        "        self._flowsheet = _Flowsheet(self._config)",
+        "        self._flowsheet.build_units()",
+        "        self._processing_order = self._flowsheet._get_processing_order()",
+        "",
+        "        # Initialise Tank state from config",
+        "        self._tank_states = {}",
+        "        for _un in self._tank_units:",
+        "            _unit = self._flowsheet.units[_un]",
+        "            _ucfg = self._config['units'][_un]",
+        "            _init_n = _ucfg.get('initial_n', {})",
+        "            self._tank_states[_un] = {",
+        "                'n': {_c: float(_init_n.get(_c, 0.0)) for _c in self._components},",
+        "                'T': float(_ucfg.get('initial_T', 298.15)),",
+        "            }",
+        "",
+    ]
+    return lines
+
+
+def _render_dynamic_do_step() -> list[str]:
+    return [
+        "        # Build feed snapshots from FMI inputs",
+        "        _current = {}",
+        "        for _sn in self._feed_stream_names:",
+        "            _ss = _sanitize_name(_sn)",
+        "            _current[_sn] = {",
+        "                'T': getattr(self, f'feed_{_ss}_T'),",
+        "                'P': getattr(self, f'feed_{_ss}_P'),",
+        "                'flowrate': getattr(self, f'feed_{_ss}_flowrate'),",
+        "                'z': {_c: getattr(self, f'feed_{_ss}_z_{_sanitize_name(_c)}')",
+        "                      for _c in self._components},",
+        "            }",
+        "",
+        "        _components_set = set(self._components)",
+        "",
+        "        # Process units in topological order",
+        "        for _un in self._processing_order:",
+        "            _unit = self._flowsheet.units[_un]",
+        "            _ucfg = self._config['units'][_un]",
+        "            _inlet = self._flowsheet._get_merged_inlet(_current, _ucfg)",
+        "",
+        "            if _ucfg['type'] == 'Tank':",
+        "                _outlet, self._tank_states[_un] = \\",
+        "                    self._flowsheet._integrate_tank_step(",
+        "                        _unit, _inlet, self._tank_states[_un],",
+        "                        step_size, _components_set",
+        "                    )",
+        "            else:",
+        "                _outlet = _unit.run(_inlet)",
+        "",
+        "            _outlet_name = _ucfg['out']",
+        "            _current[_outlet_name] = _outlet",
+        "",
+        "        # Write stream results → FMI outputs",
+        "        for _sn in self._output_stream_names:",
+        "            _ss = _sanitize_name(_sn)",
+        "            _stream = _current.get(_sn, {})",
+        "            setattr(self, f'out_{_ss}_T', float(_stream.get('T', 0.0)))",
+        "            setattr(self, f'out_{_ss}_P', float(_stream.get('P', 0.0)))",
+        "            setattr(self, f'out_{_ss}_flowrate', float(_stream.get('flowrate', 0.0)))",
+        "            for _c in self._components:",
+        "                _sc = _sanitize_name(_c)",
+        "                setattr(self, f'out_{_ss}_z_{_sc}',",
+        "                        float(_stream.get('z', {}).get(_c, 0.0)))",
+        "",
+        "        # Write Tank state outputs",
+        "        for _un, _state in self._tank_states.items():",
+        "            _su = _sanitize_name(_un)",
+        "            setattr(self, f'state_{_su}_T', float(_state['T']))",
+        "            for _c in self._components:",
+        "                _sc = _sanitize_name(_c)",
+        "                setattr(self, f'state_{_su}_n_{_sc}',",
+        "                        float(_state['n'].get(_c, 0.0)))",
+        "",
+        "        return True",
+    ]

processforge-0.2.7/src/processforge/provenance.py

@@ -0,0 +1,123 @@
+"""Provenance and metadata utilities for ProcessForge runs."""
+from __future__ import annotations
+
+import platform
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+import numpy as np
+
+_KEY_PACKAGES = [
+    "numpy",
+    "scipy",
+    "zarr",
+    "coolprop",
+    "loguru",
+    "pandas",
+    "openpyxl",
+    "matplotlib",
+    "jsonschema",
+    "graphviz",
+]
+
+
+def _git_hash() -> str:
+    """Return the current git commit hash, or 'unknown' if not in a git repo."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    return "unknown"
+
+
+def _package_versions(packages: list[str]) -> dict[str, str]:
+    """Return installed versions for each package (or 'unknown')."""
+    from importlib.metadata import PackageNotFoundError, version
+
+    versions: dict[str, str] = {}
+    for pkg in packages:
+        try:
+            versions[pkg] = version(pkg)
+        except PackageNotFoundError:
+            versions[pkg] = "unknown"
+    return versions
+
+
+def build_run_info(
+    config: dict,
+    x0: np.ndarray | None = None,
+    var_names: list[str] | None = None,
+) -> dict:
+    """Build a run_info metadata dict for provenance tracking.
+
+    Args:
+        config:    The validated flowsheet configuration dict.
+        x0:        Initial guess vector (EO mode) or flattened feed-stream
+                   initial conditions (dynamic mode).
+        var_names: Human-readable label for each element of x0 (e.g.
+                   ``"feed/T"``, ``"feed/P"``, ``"product/z_H2O"``).
+
+    Returns:
+        A dict suitable for passing to ``save_results_zarr`` as *run_info*.
+        Keys:
+          - ``git_hash``             – current HEAD commit SHA
+          - ``timestamp``            – ISO-8601 UTC timestamp
+          - ``python_version``       – full ``sys.version`` string
+          - ``platform``             – ``platform.platform()`` string
+          - ``processforge_version`` – installed processforge version
+          - ``mode``                 – ``"steady"`` or ``"dynamic"``
+          - ``backend``              – EO backend name (steady-state only)
+          - ``pkg_versions``         – dict of {package: version}
+          - ``x0``                   – numpy float64 array or ``None``
+          - ``var_names``            – list of str labels or ``None``
+    """
+    from . import __version__ as _pf_version
+
+    sim_cfg = config.get("simulation", {})
+    return {
+        "git_hash": _git_hash(),
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "python_version": sys.version,
+        "platform": platform.platform(),
+        "processforge_version": _pf_version,
+        "mode": sim_cfg.get("mode", "steady"),
+        "backend": sim_cfg.get("backend", "scipy"),
+        "pkg_versions": _package_versions(_KEY_PACKAGES),
+        "x0": np.asarray(x0, dtype=float) if x0 is not None else None,
+        "var_names": list(var_names) if var_names is not None else None,
+    }
+
+
+def build_dynamic_x0(config: dict) -> tuple[np.ndarray, list[str]]:
+    """Flatten feed-stream initial conditions into a reproducibility vector.
+
+    For dynamic simulations there is no single ``x0`` passed to a global
+    solver; instead the starting state is fully determined by the feed streams
+    in the config.  This helper packs those values into a flat numpy array so
+    the same schema used for EO runs can be applied here.
+
+    Returns:
+        (x0_array, var_names) where ``x0_array[i]`` corresponds to
+        ``var_names[i]`` (e.g. ``"feed/T"``, ``"feed/z_H2O"``).
+    """
+    values: list[float] = []
+    names: list[str] = []
+
+    for stream_name, stream in config.get("streams", {}).items():
+        for prop in ("T", "P", "flowrate"):
+            val = stream.get(prop, 0.0)
+            values.append(float(val))
+            names.append(f"{stream_name}/{prop}")
+        for comp, frac in sorted(stream.get("z", {}).items()):
+            values.append(float(frac))
+            names.append(f"{stream_name}/z_{comp}")
+
+    return np.asarray(values, dtype=float), names

{processforge-0.2.4 → processforge-0.2.7}/src/processforge/result.py

@@ -39,8 +39,63 @@ def _store_stream(stream_group, stream_data):
         stream_group.create_dataset(key, data=arr, shape=arr.shape)
 
 
-def save_results_zarr(results, fname="results.zarr"):
-    """Persist simulation results in a Zarr directory."""
+def _store_run_info(root, run_info: dict) -> None:
+    """Persist provenance metadata in a ``run_info`` Zarr sub-group.
+
+    Layout::
+
+        run_info/
+            .attrs  → git_hash, timestamp, python_version, platform,
+                       processforge_version, mode, backend
+            pkg_versions/
+                .attrs  → {package: version, ...}
+            initial_guess/
+                x0          – float64 array  (length = n_vars)
+                .attrs      → var_names  (JSON list of string labels)
+    """
+    ri_group = root.create_group("run_info")
+
+    scalar_keys = [
+        "git_hash",
+        "timestamp",
+        "python_version",
+        "platform",
+        "processforge_version",
+        "mode",
+        "backend",
+    ]
+    ri_group.attrs.update(
+        {k: str(run_info[k]) for k in scalar_keys if k in run_info}
+    )
+
+    pkg_versions = run_info.get("pkg_versions") or {}
+    if pkg_versions:
+        pkg_group = ri_group.create_group("pkg_versions")
+        pkg_group.attrs.update({k: str(v) for k, v in pkg_versions.items()})
+
+    x0 = run_info.get("x0")
+    if x0 is not None:
+        x0_arr = np.asarray(x0, dtype=float)
+        ig_group = ri_group.create_group("initial_guess")
+        ig_group.create_dataset("x0", data=x0_arr, shape=x0_arr.shape)
+        var_names = run_info.get("var_names")
+        if var_names:
+            ig_group.attrs["var_names"] = list(var_names)
+
+
+def save_results_zarr(results, fname="results.zarr", run_info=None):
+    """Persist simulation results in a Zarr directory.
+
+    Args:
+        results:  Stream result dict as returned by ``Flowsheet.run()``
+                  or ``EOFlowsheet.run()``.
+        fname:    Output path for the Zarr store directory.
+        run_info: Optional provenance dict from
+                  :func:`processforge.provenance.build_run_info`.  When
+                  supplied, a ``run_info`` sub-group is written inside the
+                  store containing the git hash, package versions, and
+                  initial-guess vector for full reproducibility.
+    """
     store_path = os.path.abspath(fname)
     if os.path.exists(store_path):
         if os.path.isdir(store_path):
@@ -55,6 +110,8 @@ def save_results_zarr(results, fname="results.zarr"):
     for stream_name, stream_data in results.items():
         stream_group = root.create_group(stream_name)
         _store_stream(stream_group, stream_data)
+    if run_info is not None:
+        _store_run_info(root, run_info)
     logger.info(f"Saved Zarr results to {store_path}")
     return store_path
 
@@ -190,7 +247,7 @@ def _build_dataframe_row(group, stream_name, idx, comp_names, include_time):
 def _load_dataframe_from_zarr(store_path):
     store = zarr.storage.LocalStore(store_path)
     root = zarr.open(store=store, mode="r")
-    streams = sorted(root.group_keys())
+    streams = sorted(k for k in root.group_keys() if k != "run_info")
     rows = []
     components = set()
     mode = root.attrs.get("mode", "steady")

{processforge-0.2.4 → processforge-0.2.7}/src/processforge/simulate.py

@@ -7,6 +7,7 @@ from loguru import logger
 from .utils.validate_flowsheet import validate_flowsheet
 from .flowsheet import Flowsheet
 from .eo import EOFlowsheet
+from .provenance import build_dynamic_x0, build_run_info
 from .result import (
     generate_validation_excel,
     plot_results,
@@ -40,15 +41,20 @@ def _cmd_run(args):
     if is_dynamic:
         fs = Flowsheet(config)
         logger.info("=== Dynamic Results ===")
+        results = fs.run()
+        x0, var_names = build_dynamic_x0(config)
+        run_info = build_run_info(config, x0=x0, var_names=var_names)
     else:
         backend = sim_cfg.get("backend", "scipy")
         fs = EOFlowsheet(config, backend=backend)
         logger.info("=== Steady-State EO Results ===")
+        results = fs.run()
+        run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
 
-    results = fs.run()
     zarr_path = save_results_zarr(
         results,
         os.path.join("outputs", f"{base_name}_results.zarr"),
+        run_info=run_info,
     )
     validation_path = os.path.join("outputs", f"{base_name}_validation.xlsx")
     generate_validation_excel(
@@ -77,6 +83,26 @@ def _cmd_validate(args):
         raise SystemExit(1)
 
 
+def _cmd_export_fmu(args):
+    """Export a flowsheet as an FMI 2.0 co-simulation FMU."""
+    fname = args.flowsheet
+    if not os.path.exists(fname):
+        logger.error(f"Flowsheet file '{fname}' not found.")
+        raise SystemExit(1)
+
+    from .fmu import build_fmu  # local import — pythonfmu is optional
+
+    output_dir = args.output_dir or "outputs"
+    backend = args.backend or "scipy"
+
+    try:
+        fmu_path = build_fmu(fname, output_dir=output_dir, backend=backend)
+        logger.info(f"FMU written to: {fmu_path}")
+    except Exception as e:
+        logger.error(f"FMU export failed: {e}")
+        raise SystemExit(1)
+
+
 def _cmd_diagram(args):
     """Generate a flowsheet diagram from a JSON file."""
     fname = args.flowsheet
@@ -126,6 +152,18 @@ def main():
     diagram_parser.add_argument("--output-dir", "-o", default=".", help="Output directory (default: current directory)")
     diagram_parser.add_argument("--format", "-f", default="png", choices=["png", "svg", "pdf"], help="Output format (default: png)")
 
+    # processforge export-fmu
+    fmu_parser = subparsers.add_parser("export-fmu", help="Export flowsheet as FMI 2.0 co-simulation FMU")
+    fmu_parser.add_argument("flowsheet", help="Path to the flowsheet JSON file")
+    fmu_parser.add_argument(
+        "--output-dir", "-o", default="outputs",
+        help="Directory for the output FMU (default: outputs/)",
+    )
+    fmu_parser.add_argument(
+        "--backend", choices=["scipy", "pyomo", "casadi"], default="scipy",
+        help="EO solver backend for steady-state mode (default: scipy)",
+    )
+
     args = parser.parse_args()
 
     if args.command is None:
@@ -136,6 +174,7 @@ def main():
         "run": _cmd_run,
         "validate": _cmd_validate,
         "diagram": _cmd_diagram,
+        "export-fmu": _cmd_export_fmu,
     }
     commands[args.command](args)
 

{processforge-0.2.4 → processforge-0.2.7/src/processforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.2.4
+Version: 0.2.7
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Process Forge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -34,6 +34,8 @@ 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: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: black; extra == "dev"

{processforge-0.2.4 → processforge-0.2.7}/src/processforge.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ flowsheets/archive/hydraulic_chain.json
 src/processforge/__init__.py
 src/processforge/_schema.py
 src/processforge/flowsheet.py
+src/processforge/provenance.py
 src/processforge/result.py
 src/processforge/simulate.py
 src/processforge/solver.py
@@ -40,6 +41,10 @@ src/processforge/eo/units/pipes_eo.py
 src/processforge/eo/units/pump_eo.py
 src/processforge/eo/units/strainer_eo.py
 src/processforge/eo/units/valve_eo.py
+src/processforge/fmu/__init__.py
+src/processforge/fmu/_fmi_vars.py
+src/processforge/fmu/builder.py
+src/processforge/fmu/slave_template.py
 src/processforge/schemas/__init__.py
 src/processforge/schemas/flowsheet_schema.json
 src/processforge/units/__init__.py

{processforge-0.2.4 → processforge-0.2.7}/src/processforge.egg-info/requires.txt

@@ -26,3 +26,6 @@ pyomo>=6.7
 [eo-casadi]
 pyomo>=6.7
 casadi>=3.6
+
+[fmu]
+pythonfmu>=0.6