Merge branch 'master' into simulation

Author: lochel

schema/CMakeLists.txt

@@ -1,2 +1,2 @@
 install(DIRECTORY fmi2 fmi3 ssp
-        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/OMSimulator/schema)
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/OMSimulator/schema)

src/OMSimulatorPython/component.py

@@ -6,15 +6,16 @@
 from OMSimulator.elementgeometry import ElementGeometry
 from OMSimulator import namespace
 
-
 class Component:
   def __init__(self, name: CRef, fmuPath: Path | str, connectors=None, unitDefinitions=None):
     self.name = CRef(name)
     self.fmuPath = Path(fmuPath)
     self.connectors = connectors or list()
     self.unitDefinitions = unitDefinitions or list()
     self.elementgeometry = None
-    self.value = Values() ## TODO propogate Values
+    self.description = None
+    self.value = Values()
+    self.solver = None
     self.parameterResources = []
 
   def addConnector(self, connector):
@@ -26,7 +27,7 @@ def addSSV(self, resource: str):
     self.parameterResources.append(resource)
 
   def list(self, prefix=""):
-    print(f"{prefix} FMU: ({self.name})")
+    print(f"{prefix} FMU: {self.name} '{self.description}'")
     prefix += ' |--'
     print(f"{prefix} path: {self.fmuPath}")
 
@@ -56,11 +57,18 @@ def list(self, prefix=""):
       for resource in self.parameterResources:
         print(f"{prefix} Parameter Bindings: {resource}")
 
+    ## list solver settings
+    if self.solver:
+      print(f"{prefix} Solver Settings:")
+      print(f"{prefix} |-- name: {self.solver}")
+
   def exportToSSD(self, node):
     component_node = ET.SubElement(node, namespace.tag("ssd", "Component"))
     component_node.set("name", str(self.name))
     component_node.set("type", "application/x-fmu-sharedlibrary")
     component_node.set("source", str(self.fmuPath))
+    if self.description:
+      component_node.set("description", self.description)
 
     if len(self.connectors) > 0:
       connectors_node = ET.SubElement(component_node, namespace.tag("ssd", "Connectors"))
@@ -82,5 +90,13 @@ def exportToSSD(self, node):
         parameter_binding_node = ET.SubElement(parameter_bindings_node, namespace.tag("ssd", "ParameterBinding"))
         parameter_binding_node.set("source", resource)
 
-  def setValue(self, cref:str, value, unit=None):
-    self.value.setValue(cref, value, unit)
+    ## export Annotations
+    if self.solver:
+      from OMSimulator import utils
+      utils.exportAnnotations(component_node, self.solver)
+
+  def setValue(self, cref:str, value, unit=None, description = None):
+    self.value.setValue(cref, value, unit, description)
+
+  def setSolver(self, name: str):
+    self.solver = name

src/OMSimulatorPython/connection.py

@@ -22,6 +22,7 @@ def __init__(self, startElement : str, startConnector : str, endElement : str, e
     self.startConnector = startConnector
     self.endElement = endElement
     self.endConnector = endConnector
+    self.description = None
     self.connectionGeometry = None
 
   def list(self, prefix=""):
@@ -35,5 +36,30 @@ def exportToSSD(self, node):
     connection_node.set("startConnector", self.startConnector)
     connection_node.set("endElement", self.endElement)
     connection_node.set("endConnector", self.endConnector)
+    if self.description:
+      connection_node.set("description", self.description)
     if self.connectionGeometry:
       self.connectionGeometry.exportToSSD(connection_node)
+
+  @staticmethod
+  def importFromNode(node, root):
+    connections_node = node.find("ssd:Connections", namespaces=namespace.ns)
+    if connections_node is None:
+      return
+    for connection in connections_node.findall("ssd:Connection", namespaces=namespace.ns):
+      startElement = connection.get("startElement", '')
+      startConnector = connection.get("startConnector")
+      endElement = connection.get("endElement", '')
+      endConnector = connection.get("endConnector")
+      description = connection.get("description")
+      root.addConnection(startElement, startConnector, endElement, endConnector)
+      if description:
+        root.connections[-1].description = description
+      connection_geometry = connection.find("ssd:ConnectionGeometry", namespaces=namespace.ns)
+      if connection_geometry is not None:
+        pointsX = connection_geometry.get("pointsX")
+        pointsY = connection_geometry.get("pointsY")
+        # print (f"ConnectionGeometry: pointsX: {pointsX}, pointsY: {pointsY}")
+        if pointsX and pointsY:
+          connectionGeometry = ConnectionGeometry([float(x) for x in pointsX.split()], [float(y) for y in pointsY.split()])
+          root.connections[-1].connectionGeometry = connectionGeometry

src/OMSimulatorPython/connector.py

@@ -42,6 +42,7 @@ def __init__(self, name : Union[str, CRef], causality : Causality, signal_type :
     self.signal_type = signal_type if isinstance(signal_type, SignalType) else SignalType[signal_type]
     self.unit = None
     self.connectorGeometry = None
+    self.description = None
 
   def getCref(self):
     return self.name
@@ -56,16 +57,67 @@ def setUnit(self, unit: str):
     self.unit = unit
 
   def list(self, prefix=""):
-    print(f"{prefix} ({self.name}, {self.causality}, {self.signal_type}, {self.unit})")
+    print(f"{prefix} ({self.name}, {self.causality}, {self.signal_type}, {self.unit}, '{self.description}')")
     if self.connectorGeometry:
       self.connectorGeometry.list(prefix)
 
   def exportToSSD(self, node):
     connector_node = ET.SubElement(node, namespace.tag("ssd", "Connector"))
     connector_node.set("name", str(self.name))
     connector_node.set("kind", self.causality.name)
+    if self.description:
+      connector_node.set("description", self.description)
     connectors_type = ET.SubElement(connector_node, namespace.tag("ssc", self.signal_type.name))
     if self.unit is not None:
       connectors_type.set("unit", self.unit)
     if self.connectorGeometry is not None:
       self.connectorGeometry.exportToSSD(connector_node)
+
+  @staticmethod
+  def importFromNode(node):
+    """Extract and print system connectors"""
+    connectors = []
+    connectors_node = node.find("ssd:Connectors", namespaces=namespace.ns)
+
+    # No connectors found
+    if connectors_node is None:
+      return connectors
+
+    for connector in connectors_node.findall("ssd:Connector", namespaces=namespace.ns):
+      name = connector.get("name")
+      kind = connector.get("kind")
+      description = connector.get("description")
+      # Convert kind string to enum type
+      kind = Causality[kind]
+
+      # Find the connector type (Real, Integer, Boolean)
+      con = None
+      for connectortype in ["ssc:Real", "ssc:Integer", "ssc:Boolean"]:  # 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'
+          con = Connector(name, kind, SignalType[signal_type])
+          unit = type_element.get("unit")
+          if description:
+            con.description = description
+          # Set unit if it exists
+          if unit:
+              con.setUnit(unit)
+          # print(f"Connector: {name}, Kind: {kind}, SignalType: {signal_type}, Unit: {unit}")
+          break  # Stop after the first valid type is found
+
+      # Check if connector has geometry information
+      connector_geometry = connector.find("ssd:ConnectorGeometry", namespaces=namespace.ns)
+      if connector_geometry is not None:
+        x = connector_geometry.get("x")
+        y = connector_geometry.get("y")
+        if x and y:
+          connectorGeometry = ConnectorGeometry(float(x), float(y))
+          connectorGeometry.x = float(x)  # Set x coordinate
+          connectorGeometry.y = float(y)  # Set y coordinate
+          con.connectorGeometry = connectorGeometry
+
+      if con:
+        connectors.append(con)
+
+    return connectors

src/OMSimulatorPython/fmu.py

@@ -102,6 +102,7 @@ def _parse_variables(self, model_description):
     scalar_variables = model_description.xpath('//ModelVariables/ScalarVariable')
     for scalar_var in scalar_variables:
       name = scalar_var.get('name')
+      description = scalar_var.get('description')
       value_reference = scalar_var.get('valueReference')
       causality = scalar_var.get('causality', 'local')
       variability = scalar_var.get('variability', 'continuous')
@@ -125,7 +126,7 @@ def _parse_variables(self, model_description):
           self._states.append(self._variables[derivative_index - 1])
 
       # Create and store the variable
-      variable = Variable(name, value_reference, causality, variability, var_type, unit, start)
+      variable = Variable(name, description, value_reference, causality, variability, var_type, unit, start)
 
       # Assign unit definitions if applicable
       if unit:
@@ -161,6 +162,7 @@ def makeConnectors(self):
       if var.isInput() or var.isOutput() or var.isParameter() or var.isCalculatedParameter():
         connector = Connector(var.name, var.causality, var.signal_type)
         connector.setUnit(var.unit)
+        connector.description = var.description
         connectors.append(connector)
     return connectors
 

src/OMSimulatorPython/ssd.py

@@ -2,13 +2,15 @@
 from pathlib import Path
 
 from lxml import etree as ET
+from OMSimulator import capi
 from OMSimulator.cref import CRef
 from OMSimulator.fmu import FMU
 from OMSimulator.settings import suppress_path_to_str
 from OMSimulator.system import System
 from OMSimulator.ssv import SSV
 from OMSimulator.unit import Unit
 from OMSimulator import namespace, utils
+from datetime import datetime
 
 logger = logging.getLogger(__name__)
 
@@ -34,6 +36,7 @@ def importFromFile(filename: Path, resources = None):
     try:
       tree = ET.parse(filename)
       root = tree.getroot()
+      utils.validateSSP(root, filename, "SystemStructureDescription.xsd")
       variant_name = root.get("name")
       ssd = SSD(variant_name)
       ssd._filename = Path(filename).resolve()
@@ -43,9 +46,8 @@ def importFromFile(filename: Path, resources = None):
         raise ValueError(f"Invalid SSD file: Missing <ssd:System> in {filename}")
 
       ssd.system = System.importFromNode(system, ssd, resources)
-
       utils.parseDefaultExperiment(root, ssd)
-      utils.parseUnitDefinitions(root, ssd)
+      Unit.importFromNode(root, ssd)
       logger.debug(f"SSD '{variant_name}' successfully imported from {filename}")
       return ssd
 
@@ -79,6 +81,13 @@ def addSSV(self, cref: CRef, resource):
     subcref = self._validateCref(cref)
     self.system.addSSV(subcref, resource)
 
+  def newSolver(self, options: dict):
+    self.system.solvers.append(options)
+
+  def setSolver(self, cref: CRef, name: str):
+    subcref = self._validateCref(cref)
+    self.system.setSolver(subcref, name)
+
   def _getComponentResourcePath(self, cref: CRef):
     subcref = self._validateCref(cref)
     return self.system._getComponentResourcePath(subcref)
@@ -120,6 +129,8 @@ def export(self, filename: str):
       nsmap=namespace.ns,
       name=self._name,
       version="2.0",
+      generationTool= capi.capi().getVersion(),
+      generationDateAndTime=datetime.now().isoformat()
     )
 
     self.system.export(root)
@@ -137,9 +148,10 @@ def export(self, filename: str):
 
   def _exportUnitDefinitions(self, node):
     '''Exports unit definitions to the given XML node.'''
-    unit_definitions_node = ET.SubElement(node, namespace.tag("ssd", "Units"))
-    for unit in self.unitDefinitions:
-      unit.exportToSSD(unit_definitions_node)
+    if self.unitDefinitions:
+      unit_definitions_node = ET.SubElement(node, namespace.tag("ssd", "Units"))
+      for unit in self.unitDefinitions:
+        unit.exportToSSD(unit_definitions_node)
 
   def _exportDefaultExperiment(self, node):
     '''Exports default experiment settings.'''

src/OMSimulatorPython/ssp.py

@@ -129,6 +129,11 @@ def addComponent(self, cref: CRef, resource: str):
 
     return self.activeVariant.addComponent(cref, resource, inst=fmu_inst)
 
+  def newSolver(self, options: dict):
+    if self.activeVariant is None:
+      raise ValueError("No active variant set in the SSP.")
+    self.activeVariant.newSolver(options)
+
   def addSSV(self, cref: CRef, resource: str):
     if self.activeVariant is None:
       raise ValueError("No active variant set in the SSP.")
@@ -155,6 +160,13 @@ def setValue(self, cref: CRef, value, unit = None):
 
     self.activeVariant.setValue(cref, value, unit)
 
+  def setSolver(self, cref: CRef, name: str):
+    if self.activeVariant is None:
+      raise ValueError("No active variant set in the SSP.")
+
+    self.activeVariant.setSolver(cref, name)
+
+
   def addSystem(self, cref: CRef):
     if self.activeVariant is None:
       raise ValueError("No active variant set in the SSP.")

src/OMSimulatorPython/ssv.py

@@ -14,8 +14,8 @@ def __init__(self, ssv_path : str | None = None):
       self.filename = Path(ssv_path)
       self.importFromSSV(self.filename)
 
-  def setValue(self, cref:str, value, unit = None):
-    self.value.setValue(cref, value, unit)
+  def setValue(self, cref:str, value, unit = None, description = None):
+    self.value.setValue(cref, value, unit, description)
 
   def list(self, prefix = ""):
     self.value.list(prefix)
@@ -40,5 +40,5 @@ def export(self, filename = str):
 
   def importFromSSV(self, filename):
     parameterValues = utils.parseSSV(filename)
-    for key, (value, unit) in parameterValues.items():
-      self.setValue(key, value, unit)
+    for key, (value, unit, description) in parameterValues.items():
+      self.setValue(key, value, unit, description)