pythonfmu3 0.3.1__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonfmu3
-Version: 0.3.1
+Version: 0.3.2
 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
@@ -44,15 +44,6 @@ This project is a fork of the original PythonFMU repository available at https:/
 Please take a look at the examples to see the supported features.
 We currently support both the Model exchange and Cosimulation Interfaces.
 
-For both interfaces event mode is not supported.
-
-We currently do not support the following methods (beyond a default, trivial implementation)
-
-- fmi3UpdateDiscreteStates
-- fmi3GetNumberOfEventindicators
-- fmi3GetNominalsOfContinuousStates
-- fmi3EvaluateDiscreteStates
-
 ### How do I build an FMU from python code?
 
 1. Install `pythonfmu3` package:

{pythonfmu3-0.3.1 → pythonfmu3-0.3.2}/README.md

@@ -17,15 +17,6 @@ This project is a fork of the original PythonFMU repository available at https:/
 Please take a look at the examples to see the supported features.
 We currently support both the Model exchange and Cosimulation Interfaces.
 
-For both interfaces event mode is not supported.
-
-We currently do not support the following methods (beyond a default, trivial implementation)
-
-- fmi3UpdateDiscreteStates
-- fmi3GetNumberOfEventindicators
-- fmi3GetNominalsOfContinuousStates
-- fmi3EvaluateDiscreteStates
-
 ### How do I build an FMU from python code?
 
 1. Install `pythonfmu3` package:

{pythonfmu3-0.3.1 → pythonfmu3-0.3.2}/pythonfmu3/__init__.py

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

pythonfmu3-0.3.2/pythonfmu3/_version.py

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

{pythonfmu3-0.3.1 → pythonfmu3-0.3.2}/pythonfmu3/fmi3slave.py

@@ -50,6 +50,7 @@ class Fmi3SlaveBase(object):
 
     def __init__(self, **kwargs):
         self.vars = OrderedDict()
+        self.event_indicators: List[int] = []
         self.instance_name = kwargs["instance_name"]
         self.resources = kwargs.get("resources", None)
         self.visible = kwargs.get("visible", False)
@@ -184,7 +185,8 @@ class Fmi3SlaveBase(object):
         for v in initial_unknown:
             SubElement(structure, "InitialUnknown", attrib=dict(valueReference=str(v.value_reference)))
         
-
+        for v in self.event_indicators:
+            SubElement(structure, "EventIndicator", attrib=dict(valueReference=str(v)))
 
         return root
 
@@ -206,7 +208,7 @@ class Fmi3SlaveBase(object):
             raise Exception(f"Unsupported type {type(var)}!")
         var.start = refs if len(getattr(var, "dimensions", [])) > 0 else refs[0]
 
-    def register_variable(self, var: ModelVariable, nested: bool = True, var_type: Any = None):
+    def register_variable(self, var: ModelVariable, nested: bool = True, var_type: Any = None, has_event_indicator: bool = False):
         """Register a variable as FMU interface.
         
         Args:
@@ -238,6 +240,12 @@ class Fmi3SlaveBase(object):
         if var_type:
             self.type_definitions[var_type.name] = var_type
             var.declared_type = var_type.name
+            
+        if has_event_indicator:
+            self.register_event_indicator(var.value_reference)
+
+    def register_event_indicator(self, vr):
+        self.event_indicators.append(vr)
 
     def setup_experiment(self, start_time: float):
         pass
@@ -416,6 +424,9 @@ class Fmi3SlaveBase(object):
                 if v.setter is not None:
                     v.setter(value)
 
+    def get_number_of_event_indicators(self) -> int:
+        return len(self.event_indicators)
+
     def set_continuous_states(self, values: List[float]):
         offset = 0
         continuous_state_derivatives = list(

pythonfmu3-0.3.2/pythonfmu3/modelexchange.py

@@ -0,0 +1,52 @@
+from abc import ABC, ABCMeta, abstractmethod
+from dataclasses import dataclass
+
+@dataclass
+class Fmi3UpdateDiscreteStatesResult:
+    discreteStateNeedsUpdate: bool = False
+    terminateSimulation: bool = False
+    nominalsOfContinuousStatesChanged: bool = False
+    valuesOfContinuousStatesChanged: bool = False
+    nextEventTimeDefined: bool = False
+    nextEventTime: float = 0.0
+
+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.
+    
+    Required methods to override:
+    - `get_continuous_state_derivatives`: Must return a list of continuous state derivatives.
+
+    Optional methods:
+    - `get_event_indicators`: Should return a list of event indicators.
+    - `update_discrete_states`: Signify converged solution at current super-dense time instant.
+    """
+    
+    @abstractmethod
+    def get_continuous_state_derivatives(self):
+        """Return the continuous state derivatives of the model."""
+        pass
+    
+    def get_event_indicators(self):
+        """Return the event indicators of the model."""
+        return []
+    
+    def update_discrete_states(self):
+        """Update the discrete states of the model."""
+        return Fmi3UpdateDiscreteStatesResult()
+
+    def get_nominals_of_continuous_states(self, size: int) -> list[float]:
+        """Return the nominal values of the continuous states."""
+        return [1.0] * size

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

@@ -141,6 +141,7 @@ public:
     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 GetEventIndicators(cppfmu::FMIFloat64* eventIndicators, std::size_t nEventIndicators) const = 0;
     virtual void UpdateDiscreteStates(
         cppfmu::FMIBoolean* discreteStatesNeedUpdate,
         cppfmu::FMIBoolean* terminateSimulation,

{pythonfmu3-0.3.1 → pythonfmu3-0.3.2}/pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp

@@ -622,7 +622,17 @@ fmi3Status fmi3GetEventIndicators(
     fmi3Float64 eventIndicators[],
     size_t nEventIndicators)
 {
-    return fmi3OK;
+    const auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->GetEventIndicators(eventIndicators, nEventIndicators);
+        return fmi3OK;
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
 }
 
 fmi3Status fmi3GetNominalsOfContinuousStates(

{pythonfmu3-0.3.1 → pythonfmu3-0.3.2}/pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp

@@ -542,6 +542,7 @@ void PySlaveInstance::GetContinuousStates(cppfmu::FMIFloat64* continuousStates,
             PyObject* item = PyList_GetItem(f, i);
             continuousStates[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
         }
+        Py_DECREF(f);
         clearLogBuffer();
     });
 }
@@ -551,6 +552,7 @@ void PySlaveInstance::GetContinuousStateDerivatives(cppfmu::FMIFloat64* continuo
     py_safe_run([this, &continuousStateDerivatives, nStates](PyGILState_STATE gilState) {
         auto f = PyObject_CallMethod(pInstance_, "get_continuous_state_derivatives", nullptr);
         if (f == nullptr) {
+            PyErr_Print();
             handle_py_exception("[get_continuous_state_derivatives] PyObject_CallMethod", gilState);
         }
         // Assuming f is a list of floats
@@ -558,15 +560,27 @@ void PySlaveInstance::GetContinuousStateDerivatives(cppfmu::FMIFloat64* continuo
             PyObject* item = PyList_GetItem(f, i);
             continuousStateDerivatives[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
         }
+        Py_DECREF(f);
         clearLogBuffer();
     });
 }
 
 void PySlaveInstance::GetNominalsOfContinuousStates(cppfmu::FMIFloat64* nominalsOfContinuousStates, std::size_t nStates) const
 {
-    for (size_t i = 0u; i < nStates; i++) {
-        nominalsOfContinuousStates[i] = 1.0;
-    }
+    py_safe_run([this, &nominalsOfContinuousStates, nStates](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "get_nominals_of_continuous_states", "(i)", static_cast<int>(nStates));
+         // Check if f is a valid object
+         if (f == nullptr) {
+            handle_py_exception("[getNominalContinuousStates] PyObject_CallMethod", gilState);
+        }
+        // Assuming f is a list of floats
+        for (std::size_t i = 0; i < nStates; i++) {
+            PyObject* item = PyList_GetItem(f, i);
+            nominalsOfContinuousStates[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
+        }
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
 }
 
 void PySlaveInstance::SetContinuousStates(const cppfmu::FMIFloat64* continuousStates, std::size_t nStates)
@@ -602,9 +616,36 @@ void PySlaveInstance::GetNumberOfContinuousStates(std::size_t& nStates) const
 
 void PySlaveInstance::GetNumberOfEventIndicators(std::size_t& nIndicators) const
 {
-   nIndicators= 0u;
+    py_safe_run([this, &nIndicators](PyGILState_STATE gilState) {
+         auto f = PyObject_CallMethod(pInstance_, "get_number_of_event_indicators", nullptr);
+         if (f == nullptr) {
+             handle_py_exception("[getNumberOfEventIndicators] PyObject_CallMethod", gilState);
+         }
+         nIndicators = static_cast<std::size_t>(PyLong_AsLong(f));
+         Py_DECREF(f);
+         clearLogBuffer();
+    });
 }
 
+void PySlaveInstance::GetEventIndicators(cppfmu::FMIFloat64* eventIndicators, std::size_t nIndicators) const
+{
+    py_safe_run([this, &eventIndicators, nIndicators](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "get_event_indicators", nullptr);
+        if (f == nullptr) {
+            handle_py_exception("[getEventIndicators] PyObject_CallMethod", gilState);
+        }
+        // Assuming f is a list of floats
+        for (std::size_t i = 0; i < nIndicators; i++) {
+            PyObject* item = PyList_GetItem(f, i);
+            eventIndicators[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
+        }
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
+
+}
+
+
 void PySlaveInstance::SetTime(cppfmu::FMIFloat64 time)
 {
     py_safe_run([this, time](PyGILState_STATE gilState) {
@@ -625,12 +666,46 @@ void PySlaveInstance::UpdateDiscreteStates(
     cppfmu::FMIBoolean* nextEventTimeDefined,
     cppfmu::FMIFloat64* nextEventTime)
 {
-    *discreteStatesNeedUpdate = false;
-    *terminateSimulation = false;
-    *nominalContinuousStatesChanged = false;
-    *valuesOfContinuousStatesChanged = false;
-    *nextEventTimeDefined = false;
-    *nextEventTime = 0.0;
+    py_safe_run([this, discreteStatesNeedUpdate, terminateSimulation, nominalContinuousStatesChanged, valuesOfContinuousStatesChanged, nextEventTimeDefined, nextEventTime](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "update_discrete_states", nullptr);
+        if (f == nullptr) {
+            handle_py_exception("[updateDiscreteStates] PyObject_CallMethod", gilState);
+        }
+
+        if (PyObject_HasAttrString(f, "discreteStatesNeedUpdate")) {
+            PyObject * pyDiscreteStatesNeedUpdate = PyObject_GetAttrString(f, "discreteStatesNeedUpdate");
+            *discreteStatesNeedUpdate = static_cast<bool>(PyObject_IsTrue(pyDiscreteStatesNeedUpdate));
+            Py_DECREF(pyDiscreteStatesNeedUpdate);
+        }
+        if (PyObject_HasAttrString(f, "terminateSimulation")) {
+            PyObject* pyTerminateSimulation = PyObject_GetAttrString(f, "terminateSimulation");
+            *terminateSimulation = static_cast<bool>(PyObject_IsTrue(pyTerminateSimulation));
+            Py_DECREF(pyTerminateSimulation);
+        }
+        if (PyObject_HasAttrString(f, "nominalContinuousStatesChanged")) {
+            PyObject* pyNominalContinuousStatesChanged = PyObject_GetAttrString(f, "nominalContinuousStatesChanged");
+            *nominalContinuousStatesChanged = static_cast<bool>(PyObject_IsTrue(pyNominalContinuousStatesChanged));
+            Py_DECREF(pyNominalContinuousStatesChanged);
+        }
+        if (PyObject_HasAttrString(f, "valuesOfContinuousStatesChanged")) {
+            PyObject* pyValuesOfContinuousStatesChanged = PyObject_GetAttrString(f, "valuesOfContinuousStatesChanged");
+            *valuesOfContinuousStatesChanged = static_cast<bool>(PyObject_IsTrue(pyValuesOfContinuousStatesChanged));
+            Py_DECREF(pyValuesOfContinuousStatesChanged);
+        }
+        if (PyObject_HasAttrString(f, "nextEventTimeDefined")) {
+            PyObject* pyNextEventTimeDefined = PyObject_GetAttrString(f, "nextEventTimeDefined");
+            *nextEventTimeDefined = static_cast<bool>(PyObject_IsTrue(pyNextEventTimeDefined));
+            Py_DECREF(pyNextEventTimeDefined);
+        }
+        if (nextEventTimeDefined && *nextEventTimeDefined) {
+            PyObject* pyNextEventTime = PyObject_GetAttrString(f, "nextEventTime");
+            *nextEventTime = PyFloat_AsDouble(pyNextEventTime);
+            Py_DECREF(pyNextEventTime);
+        }
+
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
 }
 
 void PySlaveInstance::GetFMUstate(fmi3FMUState& state)

{pythonfmu3-0.3.1 → pythonfmu3-0.3.2}/pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp

@@ -57,6 +57,7 @@ public:
     void GetNumberOfEventIndicators(std::size_t& nEventIndicators) const override;
     void GetContinuousStateDerivatives(cppfmu::FMIFloat64* derivatives, std::size_t nStates) const override;
     void GetNominalsOfContinuousStates(cppfmu::FMIFloat64* nominalContinuousStates, std::size_t nStates) const override;
+    void GetEventIndicators(cppfmu::FMIFloat64* eventIndicators, std::size_t nEventIndicators) const override;
     void SetContinuousStates(const cppfmu::FMIFloat64* continuousStates, std::size_t nStates) override;
     void SetTime(cppfmu::FMIFloat64 time) override;
     void UpdateDiscreteStates(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonfmu3
-Version: 0.3.1
+Version: 0.3.2
 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
@@ -44,15 +44,6 @@ This project is a fork of the original PythonFMU repository available at https:/
 Please take a look at the examples to see the supported features.
 We currently support both the Model exchange and Cosimulation Interfaces.
 
-For both interfaces event mode is not supported.
-
-We currently do not support the following methods (beyond a default, trivial implementation)
-
-- fmi3UpdateDiscreteStates
-- fmi3GetNumberOfEventindicators
-- fmi3GetNominalsOfContinuousStates
-- fmi3EvaluateDiscreteStates
-
 ### How do I build an FMU from python code?
 
 1. Install `pythonfmu3` package:

pythonfmu3-0.3.1/pythonfmu3/_version.py

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

pythonfmu3-0.3.1/pythonfmu3/modelexchange.py

@@ -1,23 +0,0 @@
-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