event model excange

Author: StephenSmith25

examples/bouncingBall_me.py

@@ -0,0 +1,75 @@
+from pythonfmu3 import Fmi3Causality, Fmi3Variability, Fmi3SlaveBase, ModelExchange, Fmi3Status, Float64, Fmi3Initial, Unit, Float64Type, Fmi3StepResult
+
+from typing import List
+
+
+EVENT_EPS = 1e-12
+
+class BouncingBall(Fmi3SlaveBase, ModelExchange):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.author = "..."
+        self.description = "Bouncing Ball"
+
+        self.time = 0.0
+        self.h = 1.0
+        self.v = 0.0
+        self.derh = 0.0
+        self.derv = 0.0
+        self.g = -9.81
+        self.e = 0.7
+        self.v_min = 0.1
+
+        # define units
+        unit1 = Unit(name="m", m=1)
+        unit2 = Unit(name="m/s", m=1, s=-1)
+        unit3 = Unit(name="m/s2", m=1, s=-2)
+        self.register_units([unit1, unit2, unit3])
+
+
+        self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+
+        self.register_variable(Float64("ball.h", causality=Fmi3Causality.output, start=1, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact, unit=unit1.name),
+                                nested=False, has_event_indicator=True)
+        self.register_variable(Float64("ball.derh", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=1, unit=unit2.name),
+                                nested=False)
+        self.register_variable(Float64("ball.v", causality=Fmi3Causality.output, start=0, variability=Fmi3Variability.continuous, initial=Fmi3Initial.exact, unit=unit2.name),
+                               nested=False)
+        self.register_variable(Float64("ball.derv", causality=Fmi3Causality.local, variability=Fmi3Variability.continuous, derivative=3, unit=unit3.name),
+                                nested=False)
+
+        self.register_variable(Float64("g", causality=Fmi3Causality.parameter, variability=Fmi3Variability.fixed, unit=unit3.name))
+        self.register_variable(Float64("e", causality=Fmi3Causality.parameter, variability=Fmi3Variability.tunable))
+        self.register_variable(Float64("v_min", variability=Fmi3Variability.constant, start=0.1))
+        
+
+
+    def get_continuous_state_derivatives(self) -> List[float]:
+        self.derh = self.v
+        self.derv = self.g
+        
+    def get_event_indicators(self) -> List[float]:
+        z = [self.h]
+        if self.h > -EVENT_EPS and self.h <=0 and self.v > 0:
+            z[0] = -EVENT_EPS
+
+        return [self.h - 0.0]
+    
+    def update_discrete_states(self):
+        discrete_states_need_update = False
+        terminate_simulation = False
+        nominals_of_continuous_states_changed = False
+        values_of_continuous_states_changed = False
+        next_event_time_defined = False
+        next_event_time = 0.0
+
+        if self.h <= 0 and self.v < 0:
+            self.v = -self.e * self.v
+            if abs(self.v) < self.v_min:
+                self.v = 0.0
+                terminate_simulation = True
+            discrete_states_need_update = True
+
+        return Fmi3Status.ok, discrete_states_need_update, terminate_simulation

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 @@ def to_xml(self, model_options: Dict[str, str] = dict()) -> Element:
         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 @@ def __apply_start_value(self, var: ModelVariable):
             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 @@ def register_variable(self, var: ModelVariable, nested: bool = True, var_type: A
         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 @@ def _set_fmu_state(self, state: Dict[str, Any]):
                 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/modelexchange.py

@@ -20,4 +20,8 @@ class ModelExchange(ABC, metaclass=RequireTimeMeta):
     @abstractmethod
     def get_continuous_state_derivatives(self):
         """Return the continuous state derivatives of the model."""
-        pass
+        pass
+    
+    def get_event_indicators(self):
+        """Return the event indicators of the model."""
+        return []

pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_cs.hpp

@@ -141,6 +141,7 @@ class SlaveInstance
     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/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/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp

@@ -602,9 +602,34 @@ 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));
+        }
+        clearLogBuffer();
+    });
 }
 
+
 void PySlaveInstance::SetTime(cppfmu::FMIFloat64 time)
 {
     py_safe_run([this, time](PyGILState_STATE gilState) {