parse fmi3 modeldescription.xml (#1512)

* check and set variable types when setting value
* handle special FMI3Types in class
* import FMI3 specical data types
* set value for fmi3 through ssv files
* update setValue.rst with FMI-3.0 data types

Author: arun3688

doc/UsersGuide/source/api/oms3/setValue.rst

@@ -11,6 +11,8 @@ when the model is simulated or exported.
     * The parameter must exist in the referenced FMU/component or a top level system connectors; otherwise, an error will be raised.
     * Values are stored at the SSP level and exported together with the model structure.
     * Supported data types are numerical (``float``, ``int``, ``str``, ``bool``).
+    * Special FMI-3.0 data types like ``Float64``, ``Float32``, ``Int8``, ``Int16``, ``Int32``, ``Int64``, ``UInt8``, ``UInt16``, ``UInt32``, ``UInt64`` are handled via special
+      classes in OMSimulator like ``Float64``, ``Int32``, etc. These classes can be imported from OMSimulator and used to set parameter values with specific fmi3 data types.
     * Parameters can be set before or after instantation.
 
 **Syntax:**
@@ -21,7 +23,7 @@ when the model is simulated or exported.
 
 **Parameters:**
   - ``cref`` (*CRef*): Reference to the parameter variable within a component. The :class:`CRef` must specify the system, component, and parameter name (e.g., ``CRef("default", "Add1", "k1")``).
-  - ``value`` (*float* | *int* | *str* | *bool* ): The value to assign to the parameter.
+  - ``value`` (*float* | *int* | *str* | *bool* | *Float64* | *Float32* | *Int8* | *Int16* | *Int32* | *Int64* | *UInt8* | *UInt16* | *UInt32* | *UInt64*): The value to assign to the parameter.
 
 **Example usage**:
 
@@ -54,3 +56,28 @@ when the model is simulated or exported.
 
    # Export the SSP with parameter values applied
    model.export("setValue2.ssp")
+
+
+**Example of setting FMI-3.0 specific data types:**
+
+.. code-block:: python
+
+   from OMSimulator import SSP, CRef, Settings, Float64, Int32, UInt16, Float32, Int8, Int16, Int64, UInt8, UInt32, UInt64
+
+   model = SSP()
+   model.addResource("../resources/Feedthrough3.fmu", new_name="resources/Feedthrough3.fmu")
+   model.addComponent(CRef("default", "Feedthrough1"), "resources/Feedthrough3.fmu")
+
+   model.setValue(CRef("default", "Feedthrough1", "Float64_continuous_input"), Float64(3.5))
+   model.setValue(CRef("default", "Feedthrough1", "Int64_input"), Int64(7))
+   model.setValue(CRef("default", "Feedthrough1", "Float32_continuous_input"), Float32(1.5))
+   model.setValue(CRef("default", "Feedthrough1", "Int8_input"), Int8(3))
+   model.setValue(CRef("default", "Feedthrough1", "Boolean_input"), True)
+
+   model.setValue(CRef("default", "Feedthrough1", "Float32_discrete_input"), Float32(2.5))
+   model.setValue(CRef("default", "Feedthrough1", "Enumeration_input"), 2)
+
+   model.setValue(CRef("default", "Feedthrough1", "Int16_input"), Int16(1000))
+   model.setValue(CRef("default", "Feedthrough1", "UInt16_input"), UInt16(2000))
+   model.setValue(CRef("default", "Feedthrough1", "UInt32_input"), UInt32(3000))
+   model.setValue(CRef("default", "Feedthrough1", "UInt64_input"), UInt64(4000))

src/OMSimulatorPython/__init__.py

@@ -15,7 +15,7 @@
 from OMSimulator.ssv import SSV
 from OMSimulator.ssm import SSM
 from OMSimulator.system import System
-from OMSimulator.variable import Causality, SignalType, Variable
+from OMSimulator.variable import Causality, SignalType, Variable, Float32, Float64, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64
 from OMSimulator.instantiated_model import InstantiatedModel
 
 # Define public API
@@ -26,6 +26,16 @@
     'Connector',
     'CRef',
     'FMU',
+    'Float32',
+    'Float64',
+    'Int8',
+    'Int16',
+    'Int32',
+    'Int64',
+    'UInt8',
+    'UInt16',
+    'UInt32',
+    'UInt64',
     'InstantiatedModel',
     'Settings',
     'SignalType',

src/OMSimulatorPython/connector.py

@@ -98,7 +98,9 @@ def importFromNode(node):
 
       # Find the connector type (Real, Integer, Boolean)
       con = None
-      for connectortype in ["ssc:Real", "ssc:Integer", "ssc:Boolean", "ssc:Enumeration"]:  # Expected connector types
+      ## Expected connector type including fmi3 types
+      types = ["ssc:Real", "ssc:Integer", "ssc:Boolean", "ssc:String", "ssc:Enumeration", "ssc:Float32", "ssc:Float64", "ssc:Int8", "ssc:UInt8", "ssc:Int16", "ssc:UInt16", "ssc:Int32", "ssc:UInt32", "ssc:Int64", "ssc:UInt64", "ssc:Binary"]
+      for connectortype in types:  # Expected connector types
         type_element = connector.find(connectortype, namespaces=namespace.ns)
         if type_element is not None:
           signal_type = connectortype.split(":")[-1]  # Extracts 'Real', 'Integer', or 'Boolean'

src/OMSimulatorPython/fmu.py

@@ -117,18 +117,20 @@ def _load_model_description(self):
           # Parse default experiment settings
           self._parse_default_experiment(model_description)
 
-          # Parse typeDefinitions
-          self._parse_typeDefinitions(model_description)
-
           # Parse UnitDefinitions
           self._parse_units(model_description)
 
           # Dispatch version-specific handling
           if self._fmiVersion == "2.0":
+            # Parse typeDefinitions
+            self._parse_typeDefinitions_fmi2(model_description)
+            # Parse ModelVariables
             self._parse_variables_fmi2(model_description)
           elif self._fmiVersion == "3.0":
-            ## TODO: implement FMI 3.0 variable parsing
-            pass
+            # Parse typeDefinitions
+            self._parse_typeDefinitions_fmi3(model_description)
+            # Parse ModelVariables
+            self._parse_variables_fmi3(model_description)
     except ET.XMLSyntaxError as e:
       raise ValueError(f'Error parsing {model_desc_name}: {e}')
 
@@ -197,6 +199,59 @@ def _parse_variables_fmi2(self, model_description):
     if not scalar_variables:
       raise Exception('ModelVariables section not found in modelDescription.xml')
 
+  def _parse_variables_fmi3(self, model_description):
+    '''Parses variables from the ModelVariables section of modelDescription.xml'''
+    model_variables = model_description.xpath('//ModelVariables')
+    ## iterate over all ModelVariables sections (fmi3 may have multiple)
+    for model_var_section in model_variables:
+      for element in model_var_section:
+        # Element tag (e.g., Float64, Int32, Boolean, String, etc.)
+        var_type = element.tag
+        # Extract standard FMI 3.0 attributes
+        name = element.get("name")
+        description = element.get("description")
+        value_reference = element.get("valueReference")
+        causality = element.get("causality", "local")
+        variability = element.get("variability", "continuous")
+        initial = element.get("initial")
+        start = element.get("start")
+        derivative_index = int(element.get('derivative', '-1'))
+        declaredType = element.get('declaredType')
+        unit = element.get("unit")
+
+        # Handle state variables if it's a derivative
+        if derivative_index > 0 and variability == 'continuous':
+          self._states.append(self._variables[derivative_index - 1])
+
+        # Handle nested <Start> element for String/Binary/Enumeration types
+        if start is None:
+          start_elem = element.find("Start")
+          if start_elem is not None:
+            start = start_elem.get("value")
+
+        # print(f"var_name: {name}, var_type: {var_type}, causality: {causality}, variability: {variability}, initial: {initial}, start: {start}")
+
+        # Create and store the variable
+        variable = Variable(name, description, value_reference, causality, variability, var_type, unit, start, declaredType)
+
+        # Assign unit definitions if applicable
+        if unit:
+          for defined_unit in self._unitDefinitions:
+            if defined_unit.name == variable.unit:
+              variable.unitDefinition.append(defined_unit)
+
+        # assign enumeration definitions if applicable
+        if declaredType:
+          for enumeration in self._enumerationDefinitions:
+            if declaredType == enumeration.name:
+              variable.enumerationDefinition.append(enumeration)
+
+        self._variables.append(variable)
+
+    # Raise an error if ModelVariables section is missing
+    if not model_variables:
+      raise Exception('ModelVariables section not found in modelDescription.xml')
+
   def _parse_units(self, model_description):
     '''Extracts unit definitions from modelDescription.xml.'''
 
@@ -212,7 +267,7 @@ def _parse_units(self, model_description):
 
       self._unitDefinitions.append(Unit(name, base_units))
 
-  def _parse_typeDefinitions(self, model_description):
+  def _parse_typeDefinitions_fmi2(self, model_description):
     '''Extracts only enumeration type definitions from modelDescription.xml.'''
     for simple_type in model_description.xpath('//TypeDefinitions/SimpleType'):
       type_name = simple_type.get('name')
@@ -225,6 +280,16 @@ def _parse_typeDefinitions(self, model_description):
           items[item.get("name")] = int(item.get("value"))
         self._enumerationDefinitions.append(Enumeration(type_name, items))
 
+  def _parse_typeDefinitions_fmi3(self, model_description):
+    '''Extracts only enumeration type definitions from modelDescription.xml.'''
+    for simple_type in model_description.xpath('//TypeDefinitions/EnumerationType'):
+      type_name = simple_type.get('name')
+      # Collect enumeration items
+      items = {}
+      for item in simple_type.xpath('./Item'):
+        items[item.get("name")] = int(item.get("value"))
+      self._enumerationDefinitions.append(Enumeration(type_name, items))
+
   def makeConnectors(self):
     connectors = []
     for var in self.variables:

src/OMSimulatorPython/instantiated_model.py

@@ -243,18 +243,20 @@ def apply_start_value(self, value_path:str, value):
     type, status = Capi.getVariableType(value_path)
     if status != Status.ok:
       raise RuntimeError(f"Failed to get variable type for {value_path}: {status}")
+    ## TODO: handle FMi3 data types directly, like Float64, Int32,
+    value_ = value.value if hasattr(value, 'value') else value
 
     match SignalType(type):
       case SignalType.Real:  # oms_signal_type_real
-        self._setReal(value_path, value)
+        self._setReal(value_path, float(value_))
       case SignalType.Integer:  # oms_signal_type_integer
-        self._setInteger(value_path, value)
+        self._setInteger(value_path, int(value_))
       case SignalType.Boolean:  # oms_signal_type_boolean
-        self._setBoolean(value_path, value)
+        self._setBoolean(value_path, bool(value_))
       case SignalType.String:  # oms_signal_type_string
-        self._setString(value_path, value)
+        self._setString(value_path, str(value_))
       case SignalType.Enumeration:  # oms_signal_type_enumeration
-        self._setInteger(value_path, value)  # Treat enumeration as integer
+        self._setInteger(value_path, int(value_))  # Treat enumeration as integer
       case _:
         raise TypeError(f"Unsupported type: {type}")
 
@@ -301,17 +303,19 @@ def setValue(self, cref: CRef, value):
     if status != Status.ok:
       raise RuntimeError(f"Failed to get variable type for {cref}: {status}")
 
+    value_ = value.value if hasattr(value, 'value') else value
+    ## TODO handle FMi3 data types directly, like Float64, Int32,etc..
     match SignalType(type):
       case SignalType.Real:  # oms_signal_type_real
-        return self._setReal(value_path, value)
+        return self._setReal(value_path, float(value_))
       case SignalType.Integer:  # oms_signal_type_integer
-        return self._setInteger(value_path, value)
+        return self._setInteger(value_path, int(value_))
       case SignalType.Boolean:  # oms_signal_type_boolean
-        return self._setBoolean(value_path, value)
+        return self._setBoolean(value_path, bool(value_))
       case SignalType.String:  # oms_signal_type_string
-        return self._setString(value_path, value)
+        return self._setString(value_path, str(value_))
       case SignalType.Enumeration:  # oms_signal_type_enumeration
-        return self._setInteger(value_path, value)  # Treat enumeration as integer
+        return self._setInteger(value_path, int(value_))  # Treat enumeration as integer
       case _:
         raise TypeError(f"Unsupported type: {type}")
 

src/OMSimulatorPython/utils.py

@@ -6,7 +6,7 @@
 from OMSimulator.connection import Connection, ConnectionGeometry
 from OMSimulator.connector import Connector, ConnectorGeometry
 from OMSimulator.unit import Unit
-from OMSimulator.variable import Causality, SignalType
+from OMSimulator.variable import Causality, SignalType, Float64, Float32, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64
 from OMSimulator.elementgeometry import ElementGeometry
 from OMSimulator import namespace, CRef
 from collections import defaultdict
@@ -154,7 +154,18 @@ def parseParameterBindingHelper(parameters):
                       "ssv:Real": float,
                       "ssv:Integer": int,
                       "ssv:Boolean": lambda v: v.lower() == "true",  # Convert "true"/"false" to bool
-                      "ssv:String": str
+                      "ssv:String": str,
+                       ## FMI-3.0 types
+                      "ssv:Float64": Float64,
+                      "ssv:Float32": Float32,
+                      "ssv:Int8": Int8,
+                      "ssv:Int16": Int16,
+                      "ssv:Int32": Int32,
+                      "ssv:Int64": Int64,
+                      "ssv:UInt8": UInt8,
+                      "ssv:UInt16": UInt16,
+                      "ssv:UInt32": UInt32,
+                      "ssv:UInt64": UInt64
                     }
       for value_type, cast_func in value_types.items():
         value_element = param.find(value_type, namespaces=namespace.ns)

src/OMSimulatorPython/values.py

@@ -2,7 +2,7 @@
 from OMSimulator.unit import Unit
 from OMSimulator.ssm import SSM
 from OMSimulator import namespace
-
+from OMSimulator.variable import Float32, Float64, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64
 
 class Values:
   def __init__(self):
@@ -27,18 +27,8 @@ def list(self, prefix = ""):
       return
 
     for key, (value, unit, description) in self.start_values.items():
-      match value:
-        case float():
-          type_tag = "Real"
-        case bool():  # Check for boolean first, because it is a subclass of int
-          type_tag = "Boolean"
-        case int():
-          type_tag = "Integer"
-        case str():
-          type_tag = "String"
-        case _:
-            raise TypeError(f"Unsupported type: {type(value)}")
-      print(f"{prefix} ({type_tag} {key}, {value}, {unit}, '{description}')")
+      type_tag = self._getVariableType(value)
+      print(f"{prefix} ({type_tag} {key}, {str(value.value if hasattr(value, 'value') else value)}, {unit}, '{description}')")
 
   def exportToSSD(self, node, parameterMapping : SSM | None = None, unitDefinitions = None):
     if self.empty():
@@ -82,18 +72,47 @@ def add_parameters(self, parameters_node, prefix = None):
         parameter_node.set("name", str(key))
       if description:
         parameter_node.set("description", description)
-      match value:
-        case float():
-          type_tag = "Real"
-        case bool():  # Check for boolean first, because it is a subclass of int
-          type_tag = "Boolean"
-        case int():
-          type_tag = "Integer"
-        case str():
-          type_tag = "String"
-        case _:
-            raise TypeError(f"Unsupported type: {type(value)}")
+
+      type_tag = self._getVariableType(value)
+
       parameter_type = ET.SubElement(parameter_node, namespace.tag("ssv", type_tag))
-      parameter_type.set("value", str(value))
+      value_ = str(value.value if hasattr(value, 'value') else value)
+      if type_tag == "Boolean":
+        value_ = "true" if value else "false"
+      parameter_type.set("value", value_)
       if unit is not None:
         parameter_type.set("unit", unit)
+
+  def _getVariableType(self, value):
+    match value:
+      case float():
+        return "Real"
+      case bool():  # Check for boolean first, because it is a subclass of int
+        return "Boolean"
+      case int():
+        return "Integer"
+      case str():
+        return "String"
+      ## handle fmi3 types
+      case Float32():
+        return "Float32"
+      case Float64():
+        return "Float64"
+      case Int8():
+        return "Int8"
+      case Int16():
+        return "Int16"
+      case Int32():
+        return "Int32"
+      case Int64():
+        return "Int64"
+      case UInt8():
+        return "UInt8"
+      case UInt16():
+        return "UInt16"
+      case UInt32():
+        return "UInt32"
+      case UInt64():
+        return "UInt64"
+      case _:
+          raise TypeError(f"Unsupported type: {type(value)}")