Implement model exchange (#26)

* Implement model exchange

* remove cout

* add methods to base class

* update example

* update mixin classess

* fix class name search

* update tests

* Remove unused interface enum

* update

* fix rebase

* remvove dockerfiles

* Test FMU with combined interfaces

* update example docs

* add vanderpol example

* update docs

* update supported doc

* fix log callback

* check logging callback before logging

* remove git ignore changes

* enforce requirement to have time variable

Author: StephenSmith25

README.md

@@ -1,6 +1,6 @@
 # PythonFMU3
 
-> A lightweight framework that enables the packaging of Python 3 code as co-simulation FMUs (following FMI version 3.0).
+> A lightweight framework that enables the packaging of Python 3 code as FMUs (following FMI version 3.0).
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/StephenSmith25/PythonFMU3/issues)
@@ -15,14 +15,16 @@ This project is a fork of the original PythonFMU repository available at https:/
 ### Support:
 
 Please take a look at the examples to see the supported features.
+We currently support both the Model exchange and Cosimulation Interfaces.
 
-### Future
+For both interfaces event mode is not supported.
 
-In no particular order, we plan to add support for:
+We currently do not support the following methods (beyond a default, trivial implementation)
 
-- Support more variable types from FMI3
-- Improve array support
-- Add event mode
+- fmi3UpdateDiscreteStates
+- fmi3GetNumberOfEventindicators
+- fmi3GetNominalsOfContinuousStates
+- fmi3EvaluateDiscreteStates
 
 ### How do I build an FMU from python code?
 
@@ -96,7 +98,7 @@ optional arguments:
                         Requirements or environment file.
 ```
 
-### Example:
+### Cosimulation Example:
 
 #### Write the script
 
@@ -142,3 +144,54 @@ pythonfmu3 build -f pythonslave.py myproject
 In this example a python class named `PythonSlave` that extends `Fmi3Slave` is declared in a file named `pythonslave.py`,
 where `myproject` is an optional folder containing additional project files required by the python script.
 Project folders such as this will be recursively copied into the FMU. Multiple project files/folders may be added.
+
+
+### Model Exchange Example
+
+To create a model exchange FMU you must inherit from `Fmi3SlaveBase` and one of (or both) mixin classes `ModelExchange` or `CoSimulation`.
+
+#### Write the script
+
+```python
+
+from pythonfmu3 import Fmi3Causality, Fmi3SlaveBase, Float64, ModelExchange
+
+
+class PythonSlaveMX(Fmi3SlaveBase, ModelExchange):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.author = "John Doe"
+        self.description = "A simple description"
+
+        self.time = 0.0
+        self.mu = 1.0
+        self.x0 = 2
+        self.x1 = 0
+        self.derx0 = 0.0
+        self.derx1 = 0.0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+        self.register_variable(Float64("x0", causality=Fmi3Causality.output, start=2, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("x1", causality=Fmi3Causality.output, start=0, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("derx0", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=1))
+        self.register_variable(Float64("derx1", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=2))
+        self.register_variable(Float64("mu", causality=Fmi3Causality.parameter, variability=Fmi3Variability.fixed))
+
+
+    def get_continuous_state_derivatives(self) -> List[float]:
+        self.derx0 = self.x1
+        self.derx1 = self.mu * ((1 - self.x0**2) * self.x1) - self.x0
+        return [self.derx0, self.derx1]
+        
+
+```
+
+Note: There is a hard requirement that we have a `self.time` member in the derived class.
+
+#### Create the FMU
+
+```
+pythonfmu3 build -f pythonslaveMX.py
+```

examples/dahlquist_me.py

@@ -0,0 +1,27 @@
+from pythonfmu3 import Fmi3Causality,  ModelExchange, Fmi3Variability, Fmi3SlaveBase, Fmi3Status, Float64, Fmi3Initial, Unit, Float64Type, Fmi3StepResult
+
+from typing import List
+
+class Dahlquist(Fmi3SlaveBase, ModelExchange):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.author = "Stephen Smith"
+        self.description = "Dahlquist's test problem for model exchange FMUs"
+
+        self.time = 0.0
+        self.k = 1.0
+        self.x = 1.0
+        self.derx = 0.0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+        self.register_variable(Float64("x", causality=Fmi3Causality.output, start=1, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("derx", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=1))
+        self.register_variable(Float64("k", causality=Fmi3Causality.parameter, variability=Fmi3Variability.fixed))
+
+
+    def get_continuous_state_derivatives(self) -> List[float]:
+        self.derx = -self.k * self.x
+        return [self.derx]
+       

examples/dahlquist_me_cs.py

@@ -0,0 +1,31 @@
+from pythonfmu3 import Fmi3Causality, CoSimulation, ModelExchange, Fmi3Variability, Fmi3SlaveBase, Fmi3Status, Float64, Fmi3Initial, Unit, Float64Type, Fmi3StepResult
+
+from typing import List
+
+class Dahlquist(Fmi3SlaveBase, ModelExchange, CoSimulation):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.author = "Stephen Smith"
+        self.description = "Dahlquist's test problem"
+
+        self.time = 0.0
+        self.k = 1.0
+        self.x = 1.0
+        self.derx = 0.0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+        self.register_variable(Float64("x", causality=Fmi3Causality.output, start=1, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("derx", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=1))
+        self.register_variable(Float64("k", causality=Fmi3Causality.parameter, variability=Fmi3Variability.fixed))
+
+
+    def get_continuous_state_derivatives(self) -> List[float]:
+        self.derx = -self.k * self.x
+        return [self.derx]
+    
+    def do_step(self, current_time: float, step_size: float) -> Fmi3StepResult:
+        self.derx = -self.k * self.x
+        self.x += self.derx * step_size
+        return True

examples/runner.py

@@ -2,13 +2,13 @@
 from fmpy.util import plot_result  # import the plot function
 import numpy as np
 # fmu = '../LinearTransform.fmu'
-input_values = {'m': 3, 'n': 3, 'A': np.array([1, 2, 3, 9, 11, 14, 12, 4, 8]), 'scalar': 10.0} 
-fmu = 'LinearTransformVariable.fmu'
+input_values = {}
+fmu = 'dahlquist.fmu'
 # input_values = {'n': 4, 'm': 4}
 # input_values = {}
 dump(fmu)  # get information
 
-result = simulate_fmu(fmu, start_time=0, stop_time=1e-4, step_size=1e-3, fmi_call_logger=lambda s: print('[FMI] ' + s), start_values=input_values, debug_logging=True)
+result = simulate_fmu(fmu, start_time=0, stop_time=1, step_size=1e-3, fmi_call_logger=lambda s: print('[FMI] ' + s), debug_logging=True)
 
 
 plot_result(result)                # plot two variables

examples/vanderpol_me.py

@@ -0,0 +1,32 @@
+from pythonfmu3 import Fmi3Causality, ModelExchange, Fmi3Variability, Fmi3SlaveBase, Fmi3Status, Float64, Fmi3Initial, Unit, Float64Type, Fmi3StepResult
+
+from typing import List
+
+class VanDerPol(Fmi3SlaveBase, ModelExchange):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.author = "Stephen Smith"
+        self.description = "Van Der Pol oscillator problem for model exchange FMUs"
+
+        self.time = 0.0
+        self.mu = 1.0
+        self.x0 = 2
+        self.x1 = 0
+        self.derx0 = 0.0
+        self.derx1 = 0.0
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+        self.register_variable(Float64("x0", causality=Fmi3Causality.output, start=2, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("x1", causality=Fmi3Causality.output, start=0, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact))
+        self.register_variable(Float64("derx0", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=1))
+        self.register_variable(Float64("derx1", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=2))
+        self.register_variable(Float64("mu", causality=Fmi3Causality.parameter, variability=Fmi3Variability.fixed))
+
+
+    def get_continuous_state_derivatives(self) -> List[float]:
+        self.derx0 = self.x1
+        self.derx1 = self.mu * ((1 - self.x0**2) * self.x1) - self.x0
+        return [self.derx0, self.derx1]
+       

pythonfmu3/__init__.py

@@ -1,7 +1,9 @@
 from ._version import __version__
 from .builder import FmuBuilder
+from .cosimulation import CoSimulation
+from .modelexchange import ModelExchange
 from .enums import Fmi3Causality, Fmi3Initial, Fmi3Status, Fmi3Variability
-from .fmi3slave import Fmi3Slave, Fmi3StepResult
+from .fmi3slave import Fmi3Slave, Fmi3SlaveBase, Fmi3StepResult
 from .variables import Boolean, Enumeration, Int32, Int64, UInt64, Float64, String, Dimension
 from .default_experiment import DefaultExperiment
 from .variable_types import Float64Type, EnumerationType

pythonfmu3/builder.py

@@ -13,7 +13,7 @@
 from xml.dom.minidom import parseString
 from xml.etree.ElementTree import Element, SubElement, tostring
 from .osutil import get_lib_extension, get_platform
-from .fmi3slave import FMI3_MODEL_OPTIONS, Fmi3Slave
+from .fmi3slave import FMI3_MODEL_OPTIONS, Fmi3Slave, Fmi3SlaveBase
 
 FilePath = Union[str, Path]
 HERE = Path(__file__).parent
@@ -24,7 +24,7 @@
 def get_class_name(file_name: Path) -> str:
     with open(str(file_name), 'r') as file:
         data = file.read()
-        return re.search(r'class (\w+)\(\s*Fmi3Slave\s*\)\s*:', data).group(1)
+        return re.search(r'class (\w+)\(([^)]*\bFmi3Slave(?:Base)?\b[^)]*)\)\s*:', data).group(1)
 
 
 def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Element]:
@@ -50,9 +50,9 @@ def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Elemen
     finally:
         sys.path.remove(str(filepath.parent))  # remove inserted temporary path
 
-    if not isinstance(instance, Fmi3Slave):
+    if not isinstance(instance, Fmi3SlaveBase):
         raise TypeError(
-            f"The provided class '{class_name}' does not inherit from {Fmi3Slave.__qualname__}"
+            f"The provided class '{class_name}' does not inherit from {Fmi3SlaveBase.__qualname__}"
         )
     # Produce the xml
     return instance.modelName, instance.to_xml()
@@ -138,9 +138,16 @@ def build_FMU(
 
             type_node = xml.find("CoSimulation")
             option_names = [opt.name for opt in FMI3_MODEL_OPTIONS]
-            for option, value in options.items():
-                if option in option_names:
-                    type_node.set(option, str(value).lower())
+            if type_node:
+                for option, value in options.items():
+                    if option in option_names:
+                        type_node.set(option, str(value).lower())
+
+            type_node = xml.find("ModelExchange")
+            if type_node:
+                for option, value in options.items():
+                    if option in option_names:
+                        type_node.set(option, str(value).lower())
 
             with zipfile.ZipFile(dest_file, "w") as zip_fmu:
 

pythonfmu3/cosimulation.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+# co-simulation mixin
+class CoSimulation(ABC):
+
+    @abstractmethod
+    def do_step(self, current_time: float, step_size: float):
+        pass

pythonfmu3/fmi3slave.py

@@ -11,6 +11,8 @@
 
 from .logmsg import LogMsg
 from .default_experiment import DefaultExperiment
+from .cosimulation import CoSimulation
+from .modelexchange import ModelExchange
 from ._version import __version__ as VERSION
 from .enums import Fmi3Type, Fmi3Status, Fmi3Causality, Fmi3Initial, Fmi3Variability
 from .variables import Boolean, Enumeration, Int32, Int64, UInt64, Float64, ModelVariable, String
@@ -33,7 +35,8 @@ class Fmi3StepResult(NamedTuple):
     terminateSimulation: bool = False
     earlyReturn: bool = False
 
-class Fmi3Slave(ABC):
+
+class Fmi3SlaveBase(object):
     """Abstract facade class to execute Python through FMI standard."""
 
     # Dictionary of (category, description) entries
@@ -104,8 +107,18 @@ def to_xml(self, model_options: Dict[str, str] = dict()) -> Element:
             options[option.name] = str(value).lower()
         options["modelIdentifier"] = self.modelName
         options["canNotUseMemoryManagementFunctions"] = "true"
-
-        SubElement(root, "CoSimulation", attrib=options)
+        
+        options_me = dict()
+        options_me["canGetAndSetFMUState"] = "true"
+        options_me["modelIdentifier"] = self.modelName
+        options_me["needsCompletedIntegratorStep"] = "false"
+
+        # check if we have cosim mixin or model exchange mixin
+        if isinstance(self, ModelExchange):
+            SubElement(root, "ModelExchange", attrib=options_me)
+        
+        if isinstance(self, CoSimulation):
+            SubElement(root, "CoSimulation", attrib=options)
 
         if self.units:
             unit_defs = SubElement(root, "UnitDefinitions")
@@ -239,7 +252,6 @@ def enter_initialization_mode(self):
     def exit_initialization_mode(self):
         pass
 
-    @abstractmethod
     def do_step(self, current_time: float, step_size: float) -> Fmi3StepResult:
         pass
 
@@ -404,6 +416,50 @@ def _set_fmu_state(self, state: Dict[str, Any]):
                 if v.setter is not None:
                     v.setter(value)
 
+    def set_continuous_states(self, values: List[float]):
+        offset = 0
+        continuous_state_derivatives = list(
+            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
+        )
+
+        vrs = [v.derivative for v in continuous_state_derivatives]
+        
+        for vr in vrs:
+            var = self.vars[vr]
+            size = var.size(self.vars)
+            if size > 1:
+                var.setter(values[offset:offset+size])
+            else:
+                var.setter(values[offset])
+            offset += size
+        
+    def get_continuous_states(self) -> List[float]:
+        offset = 0
+        continuous_state_derivatives = list(
+            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
+        )
+
+        vrs = [v.derivative for v in continuous_state_derivatives]
+        
+        refs = list()
+        for vr in vrs:
+            var = self.vars[vr]
+            if len(var.dimensions) == 0:
+                refs.append(float(var.getter()))
+            else:
+                refs.extend(var.getter())
+                
+        return refs
+    
+    def get_number_of_continuous_states(self) -> int:
+        continuous_state_derivatives = list(
+            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
+        )
+        return len(continuous_state_derivatives)
+    
+    def set_time(self, time: float):
+        self.time = time
+
     @staticmethod
     def _fmu_state_to_bytes(state: Dict[str, Any]) -> bytes:
         return json.dumps(state).encode("utf-8")
@@ -436,3 +492,6 @@ def log(
                 category = "logAll"
         log_msg = LogMsg(status, category, msg, debug)
         self.log_queue.append(log_msg)
+
+class Fmi3Slave(Fmi3SlaveBase, CoSimulation):
+    pass