processforge 0.2.5__tar.gz → 0.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.2.5
+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.5 → processforge-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.2.5"
+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.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.5 → processforge-0.2.7}/src/processforge/simulate.py

@@ -83,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
@@ -132,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:
@@ -142,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.5 → processforge-0.2.7/src/processforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.2.5
+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.5 → processforge-0.2.7}/src/processforge.egg-info/SOURCES.txt

@@ -41,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.5 → 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