pythonfmu3 0.2.4__tar.gz → 0.3.1__tar.gz

{pythonfmu3-0.2.4/pythonfmu3.egg-info → pythonfmu3-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonfmu3
-Version: 0.2.4
+Version: 0.3.1
 Summary: A lightweight framework that enables the packaging of Python3.x code as co-simulation FMUs.
 Home-page: https://github.com/stephensmith25/PythonFMU3
 Author: Stephen Smith
@@ -27,7 +27,7 @@ Dynamic: license-file
 
 # 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)
@@ -42,14 +42,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?
 
@@ -123,7 +125,7 @@ optional arguments:
                         Requirements or environment file.
 ```
 
-### Example:
+### Cosimulation Example:
 
 #### Write the script
 
@@ -169,3 +171,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
+```

{pythonfmu3-0.2.4 → pythonfmu3-0.3.1}/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
+```

{pythonfmu3-0.2.4 → pythonfmu3-0.3.1}/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-0.3.1/pythonfmu3/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

{pythonfmu3-0.2.4 → pythonfmu3-0.3.1}/pythonfmu3/builder.py

@@ -13,7 +13,7 @@ from typing import Iterable, Optional, Tuple, Union
 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 @@ logger = logging.getLogger(__name__)
 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 @@ class FmuBuilder:
 
             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-0.3.1/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-0.2.4 → pythonfmu3-0.3.1}/pythonfmu3/fmi3slave.py

@@ -11,6 +11,8 @@ from xml.etree.ElementTree import Element, SubElement
 
 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 @@ class Fmi3Slave(ABC):
             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 @@ class Fmi3Slave(ABC):
     def exit_initialization_mode(self):
         pass
 
-    @abstractmethod
     def do_step(self, current_time: float, step_size: float) -> Fmi3StepResult:
         pass
 
@@ -404,6 +416,50 @@ class Fmi3Slave(ABC):
                 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 @@ class Fmi3Slave(ABC):
                 category = "logAll"
         log_msg = LogMsg(status, category, msg, debug)
         self.log_queue.append(log_msg)
+
+class Fmi3Slave(Fmi3SlaveBase, CoSimulation):
+    pass

pythonfmu3-0.3.1/pythonfmu3/modelexchange.py

@@ -0,0 +1,23 @@
+from abc import ABC, ABCMeta, abstractmethod
+
+class RequireTimeMeta(ABCMeta):
+    def __init__(cls, name, bases, namespace):
+        super().__init__(name, bases, namespace)
+        orig_init = cls.__init__
+        def new_init(self, *args, **kwargs):
+            orig_init(self, *args, **kwargs)
+            if not hasattr(self, 'time'):
+                raise AttributeError(f"{cls.__name__} must define 'self.time' in __init__")
+        cls.__init__ = new_init
+
+
+# model exchange mixin
+class ModelExchange(ABC, metaclass=RequireTimeMeta):
+    """
+    Classes derived from ModelExchange must define a 'self.time' member variable.
+    """
+    
+    @abstractmethod
+    def get_continuous_state_derivatives(self):
+        """Return the continuous state derivatives of the model."""
+        pass

{pythonfmu3-0.2.4 → pythonfmu3-0.3.1}/pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_cs.hpp

@@ -133,6 +133,23 @@ public:
         FMIBoolean* earlyReturn,
         FMIFloat64& endOfStep) = 0;
 
+    // Model Exchange methods
+    virtual void GetContinuousStates(cppfmu::FMIFloat64* continuousStates, std::size_t nStates) const = 0;
+    virtual void GetContinuousStateDerivatives(cppfmu::FMIFloat64* derivatives, std::size_t nStates) const = 0;
+    virtual void GetNominalsOfContinuousStates(cppfmu::FMIFloat64* nominalContinuousStates, std::size_t nStates) const = 0;
+    virtual void SetContinuousStates(const cppfmu::FMIFloat64* continuousStates, std::size_t nStates) = 0;
+    virtual void SetTime(cppfmu::FMIFloat64 time) = 0;
+    virtual void GetNumberOfContinuousStates(std::size_t& nStates) const = 0;
+    virtual void GetNumberOfEventIndicators(std::size_t& nEventIndicators) const = 0;
+    virtual void UpdateDiscreteStates(
+        cppfmu::FMIBoolean* discreteStatesNeedUpdate,
+        cppfmu::FMIBoolean* terminateSimulation,
+        cppfmu::FMIBoolean* nominalContinuousStatesChanged,
+        cppfmu::FMIBoolean* valuesOfContinuousStatesChanged,
+        cppfmu::FMIBoolean* nextEventTimeDefined,
+        cppfmu::FMIFloat64* nextEventTime) = 0;
+    
+
     virtual void GetFMUstate(fmi3FMUState& state) = 0;
     virtual void SetFMUstate(const fmi3FMUState& state) = 0;
     virtual void FreeFMUstate(fmi3FMUState& state) = 0;