Add FMUFieldFunction

Author: jschueller

ChangeLog

@@ -1,3 +1,6 @@
+2026-?? - release 0.18 (wip)
+- Add FMUFieldFunction (field -> field)
+
 2026-01-08 - release 0.17.1
 - Default function export mode changed to cxx
 - Fix multiple function export and cpython mode with conda envs

doc/api.rst

@@ -28,6 +28,16 @@ the output consisting of the values at the final simulation time.
 
    FMUFunction
 
+The class **FMUFieldFunction** wraps the FMU evaluation in an :py:class:`openturns.FieldFunction`.
+Its input is a :py:class:`openturns.Field` and its output is a
+:py:class:`openturns.Field` gathering the outputs as function of time.
+
+.. autosummary::
+   :toctree: _generated/
+   :template: class.rst_t
+
+   FMUFieldFunction
+
 The class **FMUFieldToPointFunction** wraps the FMU evaluation in an :py:class:`openturns.FieldToPointFunction`.
 Its input is a :py:class:`openturns.Field` and its output is a vector
 (:py:class:`openturns.Point`) consisting of the values at the final simulation time.

otfmi/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.17.1"
+__version__ = "0.18"
 
 from .otfmi import (
     FMUFunction,
@@ -7,11 +7,14 @@
     OpenTURNSFMUPointToFieldFunction,
     FMUFieldToPointFunction,
     OpenTURNSFMUFieldToPointFunction,
+    FMUFieldFunction,
+    OpenTURNSFMUFieldFunction,
 )
 from .function_exporter import FunctionExporter
 from .mo2fmu import mo2fmu
 
 __all__ = [FMUFunction, OpenTURNSFMUFunction,
            FMUPointToFieldFunction, OpenTURNSFMUPointToFieldFunction,
            FMUFieldToPointFunction, OpenTURNSFMUFieldToPointFunction,
+           FMUFieldFunction, OpenTURNSFMUFieldFunction,
            FunctionExporter, mo2fmu]

otfmi/otfmi.py

@@ -711,3 +711,118 @@ def _exec(self, value_input, **kwargs):
 
         """
         return self.base.simulate(value_input=value_input, **kwargs)
+
+
+class FMUFieldFunction(ot.FieldFunction):
+    """
+    Define a FieldFunction from a FMU file.
+
+    Parameters
+    ----------
+    path_fmu : str, path to the FMU file.
+
+    input_mesh : :class:`openturns.Mesh`, default=None
+        Time grid of the input variables, has to be included in the start/final time defined in the FMU.
+
+    output_mesh : :class:`openturns.Mesh`, default=None
+        Time grid of the output variables, has to be included in the start/final time defined in the FMU.
+
+    inputs_fmu : Sequence of str, default=None
+        Names of the variable from the fmu to be used as input variables.
+        By default assigns variables with FMI causality INPUT.
+
+    outputs_fmu : Sequence of str, default=None
+        Names of the variable from the fmu to be used as output variables.
+        By default assigns variables with FMI causality OUTPUT.
+
+    initialization_script : str, default=None
+        Path to the initialization script.
+
+    kind : str, default=None
+        Either "ME" (model exchange) or "CS" (co-simulation)
+        Select a kind of FMU if both are available.
+        Note:
+        Contrary to pyfmi, the default here is "CS" (co-simulation). The
+        rationale behind this choice is that co-simulation may be used to
+        impose a solver not available in pyfmi.
+
+    start_time : float, default=None
+        The FMU simulation start time.
+        The default behavior is to use the default start time defined the FMU.
+
+    final_time : float, default=None
+        The FMU simulation stop time.
+        The default behavior is to use the default stop time defined the FMU.
+
+    """
+
+    def __new__(
+        self,
+        path_fmu,
+        input_mesh=None,
+        output_mesh=None,
+        inputs_fmu=None,
+        outputs_fmu=None,
+        kind=None,
+        initialization_script=None,
+        start_time=None,
+        final_time=None,
+    ):
+        lowlevel = OpenTURNSFMUFieldFunction(
+            path_fmu=path_fmu,
+            input_mesh=input_mesh,
+            output_mesh=output_mesh,
+            inputs_fmu=inputs_fmu,
+            outputs_fmu=outputs_fmu,
+            kind=kind,
+            initialization_script=initialization_script,
+            start_time=start_time,
+            final_time=final_time,
+        )
+
+        highlevel = ot.FieldFunction(lowlevel)
+        # highlevel._model = lowlevel.model
+        return highlevel
+
+
+class OpenTURNSFMUFieldFunction(ot.OpenTURNSPythonFieldFunction):
+    """Define a FieldFunction from a FMU file."""
+
+    def __init__(
+        self,
+        path_fmu,
+        input_mesh=None,
+        output_mesh=None,
+        inputs_fmu=None,
+        outputs_fmu=None,
+        initialization_script=None,
+        kind=None,
+        start_time=None,
+        final_time=None,
+        **kwargs
+    ):
+        self.base = _FMUBaseFunction(path_fmu, kind=kind,
+                                     inputs_fmu=inputs_fmu, outputs_fmu=outputs_fmu,
+                                     start_time=start_time, final_time=final_time,
+                                     initialization_script=initialization_script,
+                                     field_input=True, input_mesh=input_mesh,
+                                     output_mesh=output_mesh, field_output=True)
+
+        super().__init__(
+            self.base.get_input_mesh(), len(self.base.get_inputs_fmu()),
+            self.base.get_output_mesh(), len(self.base.get_outputs_fmu())
+        )
+        self.setInputDescription(self.base.get_inputs_fmu())
+        self.setOutputDescription(self.base.get_outputs_fmu())
+
+    def _exec(self, value_input, **kwargs):
+        """Simulate the FMU for a given set of input values.
+
+        Parameters
+        ----------
+        value_input : Vector or array-like with time steps as rows.
+
+        See the 'simulate' method for additional keyword arguments.
+
+        """
+        return self.base.simulate(value_input=value_input, **kwargs)

test/test_f2f.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+
+import openturns as ot
+import openturns.testing as ott
+import otfmi
+import otfmi.example.utility
+import pytest
+
+
+@pytest.fixture
+def path_fmu():
+    """Load FMU and setup pure python reference."""
+    return otfmi.example.utility.get_path_fmu("epid")
+
+
+@pytest.fixture
+def input_mesh():
+    return ot.RegularGrid(2.0, 0.5, 50)
+
+
+def test_default_mesh(path_fmu):
+    f = otfmi.FMUFieldFunction(
+        path_fmu,
+        inputs_fmu=["infection_rate", "healing_rate"],
+        outputs_fmu=["infected"],
+    )
+    input_mesh = f.getInputMesh()
+    start_time = input_mesh.getVertices().getMin()[0]
+    end_time = input_mesh.getVertices().getMax()[0]
+    ott.assert_almost_equal(start_time, 0.0)
+    ott.assert_almost_equal(end_time, 200.0)
+
+    output_mesh = f.getOutputMesh()
+    start_time = output_mesh.getVertices().getMin()[0]
+    end_time = output_mesh.getVertices().getMax()[0]
+    ott.assert_almost_equal(start_time, 0.0)
+    ott.assert_almost_equal(end_time, 200.0)
+
+
+def test_start_time_coherence(path_fmu, input_mesh):
+    """Check if incoherent start time raises an error"""
+    with pytest.raises(ValueError):
+        _ = otfmi.FMUFieldFunction(
+            path_fmu,
+            input_mesh,
+            inputs_fmu=["infection_rate", "healing_rate"],
+            outputs_fmu=["infected"],
+            start_time=10,
+        )
+
+
+def test_start_time(path_fmu, input_mesh):
+    """Check if start times are taken into account."""
+    model_fmu_1 = otfmi.FMUFieldFunction(
+        path_fmu,
+        input_mesh,
+        inputs_fmu=["infection_rate", "healing_rate"],
+        outputs_fmu=["infected"],
+        start_time=0,
+    )
+    model_fmu_2 = otfmi.FMUFieldFunction(
+        path_fmu,
+        input_mesh,
+        inputs_fmu=["infection_rate", "healing_rate"],
+        outputs_fmu=["infected"],
+        start_time=1,
+    )
+    n = input_mesh.getVerticesNumber()
+    input_value = [[0.007, 0.02]] * n
+    y1 = model_fmu_1(input_value)[-1]
+    y2 = model_fmu_2(input_value)[-1]
+    assert y2[0] - y1[0] != 0.0
+
+
+def test_final_time_coherence(path_fmu, input_mesh):
+    """Check if incoherent final time raises an error."""
+    with pytest.raises(ValueError):
+        _ = otfmi.FMUFieldFunction(
+            path_fmu,
+            input_mesh,
+            inputs_fmu=["infection_rate", "healing_rate"],
+            outputs_fmu=["infected"],
+            final_time=10,
+        )