# -*- coding: utf-8 -*-

"""

Definition of main class to run Modelica simulations - ModelicaSystem.

"""

import ast

from dataclasses import dataclass

import itertools

import logging

import numbers

import os

import pathlib

import queue

import re

import textwrap

import threading

from typing import Any, cast, Optional

import warnings

import xml.etree.ElementTree as ET

import numpy as np

from OMPython.OMCSession import (

OMCSessionException,

OMCSessionRunData,

OMCSession,

OMCSessionLocal,

OMCPath,

)

# define logger using the current module name as ID

logger = logging.getLogger(__name__)

class ModelicaSystemError(Exception):

"""

Exception used in ModelicaSystem and ModelicaSystemCmd classes.

"""

@dataclass

class LinearizationResult:

"""Modelica model linearization results.

Attributes:

n: number of states

m: number of inputs

p: number of outputs

A: state matrix (n x n)

B: input matrix (n x m)

C: output matrix (p x n)

D: feedthrough matrix (p x m)

x0: fixed point

u0: input corresponding to the fixed point

stateVars: names of state variables

inputVars: names of inputs

outputVars: names of outputs

"""

n: int

m: int

p: int

A: list

B: list

C: list

D: list

x0: list[float]

u0: list[float]

stateVars: list[str]

inputVars: list[str]

outputVars: list[str]

def __iter__(self):

"""Allow unpacking A, B, C, D = result."""

yield self.A

yield self.B

yield self.C

yield self.D

def __getitem__(self, index: int):

"""Allow accessing A, B, C, D via result[0] through result[3].

This is needed for backwards compatibility, because

ModelicaSystem.linearize() used to return [A, B, C, D].

"""

return {0: self.A, 1: self.B, 2: self.C, 3: self.D}[index]

class ModelicaSystemCmd:

"""

All information about a compiled model executable. This should include data about all structured parameters, i.e.

parameters which need a recompilation of the model. All non-structured parameters can be easily changed without

the need for recompilation.

"""

def __init__(

self,

session: OMCSession,

runpath: OMCPath,

modelname: Optional[str] = None,

) -> None:

if modelname is None:

raise ModelicaSystemError("Missing model name!")

self._session = session

self._runpath = runpath

self._model_name = modelname

# dictionaries of command line arguments for the model executable

self._args: dict[str, str | None] = {}

# 'override' argument needs special handling, as it is a dict on its own saved as dict elements following the

# structure: 'key' => 'key=value'

self._arg_override: dict[str, str] = {}

def arg_set(

self,

key: str,

val: Optional[str | dict[str, Any] | numbers.Number] = None,

) -> None:

"""

Set one argument for the executable model.

Args:

key: identifier / argument name to be used for the call of the model executable.

val: value for the given key; None for no value and for key == 'override' a dictionary can be used which

indicates variables to override

"""

def override2str(

orkey: str,

orval: str | bool | numbers.Number,

) -> str:

"""

Convert a value for 'override' to a string taking into account differences between Modelica and Python.

"""

# check oval for any string representations of numbers (or bool) and convert these to Python representations

if isinstance(orval, str):

try:

val_evaluated = ast.literal_eval(orval)

if isinstance(val_evaluated, (numbers.Number, bool)):

orval = val_evaluated

except (ValueError, SyntaxError):

pass

if isinstance(orval, str):

val_str = orval.strip()

elif isinstance(orval, bool):

val_str = 'true' if orval else 'false'

elif isinstance(orval, numbers.Number):

val_str = str(orval)

else:

raise ModelicaSystemError(f"Invalid value for override key {orkey}: {type(orval)}")

return f"{orkey}={val_str}"

if not isinstance(key, str):

raise ModelicaSystemError(f"Invalid argument key: {repr(key)} (type: {type(key)})")

key = key.strip()

if isinstance(val, dict):

if key != 'override':

raise ModelicaSystemError("Dictionary input only possible for key 'override'!")

for okey, oval in val.items():

if not isinstance(okey, str):

raise ModelicaSystemError("Invalid key for argument 'override': "

f"{repr(okey)} (type: {type(okey)})")

if not isinstance(oval, (str, bool, numbers.Number, type(None))):

raise ModelicaSystemError(f"Invalid input for 'override'.{repr(okey)}: "

f"{repr(oval)} (type: {type(oval)})")

if okey in self._arg_override:

if oval is None:

logger.info(f"Remove model executable override argument: {repr(self._arg_override[okey])}")

del self._arg_override[okey]

continue

logger.info(f"Update model executable override argument: {repr(okey)} = {repr(oval)} "

f"(was: {repr(self._arg_override[okey])})")

if oval is not None:

self._arg_override[okey] = override2str(orkey=okey, orval=oval)

argval = ','.join(sorted(self._arg_override.values()))

elif val is None:

argval = None

elif isinstance(val, str):

argval = val.strip()

elif isinstance(val, numbers.Number):

argval = str(val)

else:

raise ModelicaSystemError(f"Invalid argument value for {repr(key)}: {repr(val)} (type: {type(val)})")

if key in self._args:

logger.warning(f"Override model executable argument: {repr(key)} = {repr(argval)} "

f"(was: {repr(self._args[key])})")

self._args[key] = argval

def arg_get(self, key: str) -> Optional[str | dict[str, str | bool | numbers.Number]]:

"""

Return the value for the given key

"""

if key in self._args:

return self._args[key]

return None

def args_set(

self,

args: dict[str, Optional[str | dict[str, Any] | numbers.Number]],

) -> None:

"""

Define arguments for the model executable.

"""

for arg in args:

self.arg_set(key=arg, val=args[arg])

def get_cmd_args(self) -> list[str]:

"""

Get a list with the command arguments for the model executable.

"""

cmdl = []

for key in sorted(self._args):

if self._args[key] is None:

cmdl.append(f"-{key}")

else:

cmdl.append(f"-{key}={self._args[key]}")

return cmdl

def definition(self) -> OMCSessionRunData:

"""

Define all needed data to run the model executable. The data is stored in an OMCSessionRunData object.

"""

# ensure that a result filename is provided

result_file = self.arg_get('r')

if not isinstance(result_file, str):

result_file = (self._runpath / f"{self._model_name}.mat").as_posix()

omc_run_data = OMCSessionRunData(

cmd_path=self._runpath.as_posix(),

cmd_model_name=self._model_name,

cmd_args=self.get_cmd_args(),

cmd_result_path=result_file,

)

omc_run_data_updated = self._session.omc_run_data_update(

omc_run_data=omc_run_data,

)

return omc_run_data_updated

@staticmethod

def parse_simflags(simflags: str) -> dict[str, Optional[str | dict[str, Any] | numbers.Number]]:

"""

Parse a simflag definition; this is deprecated!

The return data can be used as input for self.args_set().

"""

warnings.warn(message="The argument 'simflags' is depreciated and will be removed in future versions; "

"please use 'simargs' instead",

category=DeprecationWarning,

stacklevel=2)

simargs: dict[str, Optional[str | dict[str, Any] | numbers.Number]] = {}

args = [s for s in simflags.split(' ') if s]

for arg in args:

if arg[0] != '-':

raise ModelicaSystemError(f"Invalid simulation flag: {arg}")

arg = arg[1:]

parts = arg.split('=')

if len(parts) == 1:

simargs[parts[0]] = None

elif parts[0] == 'override':

override = '='.join(parts[1:])

override_dict = {}

for item in override.split(','):

kv = item.split('=')

if not 0 < len(kv) < 3:

raise ModelicaSystemError(f"Invalid value for '-override': {override}")

if kv[0]:

try:

override_dict[kv[0]] = kv[1]

except (KeyError, IndexError) as ex:

raise ModelicaSystemError(f"Invalid value for '-override': {override}") from ex

simargs[parts[0]] = override_dict

return simargs

class ModelicaSystem:

"""

Class to simulate a Modelica model using OpenModelica via OMCSession.

"""

def __init__(

self,

command_line_options: Optional[list[str]] = None,

work_directory: Optional[str | os.PathLike] = None,

omhome: Optional[str] = None,

session: Optional[OMCSession] = None,

) -> None:

"""Create a ModelicaSystem instance. To define the model use model() or convertFmu2Mo().

Args:

command_line_options: List with extra command line options as elements. The list elements are

provided to omc via setCommandLineOptions(). If set, the default values will be overridden.

To disable any command line options, use an empty list.

work_directory: Path to a directory to be used for temporary

files like the model executable. If left unspecified, a tmp

directory will be created.

omhome: path to OMC to be used when creating the OMC session (see OMCSession).

session: definition of a (local) OMC session to be used. If

unspecified, a new local session will be created.

"""

self._quantities: list[dict[str, Any]] = []

self._params: dict[str, str] = {} # even numerical values are stored as str

self._inputs: dict[str, list[tuple[float, float]]] = {}

self._outputs: dict[str, np.float64] = {} # numpy.float64 as it allows to define None values

self._continuous: dict[str, np.float64] = {} # numpy.float64 as it allows to define None values

self._simulate_options: dict[str, str] = {}

self._override_variables: dict[str, str] = {}

self._simulate_options_override: dict[str, str] = {}

self._linearization_options: dict[str, str] = {

'startTime': str(0.0),

'stopTime': str(1.0),

'stepSize': str(0.002),

'tolerance': str(1e-8),

}

self._optimization_options = self._linearization_options | {

'numberOfIntervals': str(500),

}

self._linearized_inputs: list[str] = [] # linearization input list

self._linearized_outputs: list[str] = [] # linearization output list

self._linearized_states: list[str] = [] # linearization states list

if session is not None:

self._session = session

else:

self._session = OMCSessionLocal(omhome=omhome)

# get OpenModelica version

version_str = self._session.get_version()

self._version = self._parse_om_version(version=version_str)

# set commandLineOptions using default values or the user defined list

if command_line_options is None:

# set default command line options to improve the performance of linearization and to avoid recompilation if

# the simulation executable is reused in linearize() via the runtime flag '-l'

command_line_options = [

"--linearizationDumpLanguage=python",

"--generateSymbolicLinearization",

]

for opt in command_line_options:

self.set_command_line_options(command_line_option=opt)

self._simulated = False # True if the model has already been simulated

self._result_file: Optional[OMCPath] = None # for storing result file

self._work_dir: OMCPath = self.setWorkDirectory(work_directory)

self._model_name: Optional[str] = None

self._libraries: Optional[list[str | tuple[str, str]]] = None

self._file_name: Optional[OMCPath] = None

self._variable_filter: Optional[str] = None

def model(

self,

model_name: Optional[str] = None,

model_file: Optional[str | os.PathLike] = None,

libraries: Optional[list[str | tuple[str, str]]] = None,

variable_filter: Optional[str] = None,

build: bool = True,

) -> None:

"""Load and build a Modelica model.

This method loads the model file and builds it if requested (build == True).

Args:

model_file: Path to the model file. Either absolute or relative to

the current working directory.

model_name: The name of the model class. If it is contained within

a package, "PackageName.ModelName" should be used.

libraries: List of libraries to be loaded before the model itself is

loaded. Two formats are supported for the list elements:

lmodel=["Modelica"] for just the library name

and lmodel=[("Modelica","3.2.3")] for specifying both the name

and the version.

variable_filter: A regular expression. Only variables fully

matching the regexp will be stored in the result file.

Leaving it unspecified is equivalent to ".*".

build: Boolean controlling whether the model should be

built when constructor is called. If False, the constructor

simply loads the model without compiling.

Examples:

mod = ModelicaSystem()

# and then one of the lines below

mod.model(name="modelName", file="ModelicaModel.mo", )

mod.model(name="modelName", file="ModelicaModel.mo", libraries=["Modelica"])

mod.model(name="modelName", file="ModelicaModel.mo", libraries=[("Modelica","3.2.3"), "PowerSystems"])

"""

if self._model_name is not None:

raise ModelicaSystemError("Can not reuse this instance of ModelicaSystem "

f"defined for {repr(self._model_name)}!")

if model_name is None or not isinstance(model_name, str):

raise ModelicaSystemError("A model name must be provided!")

if libraries is None:

libraries = []

if not isinstance(libraries, list):

raise ModelicaSystemError(f"Invalid input type for libraries: {type(libraries)} - list expected!")

# set variables

self._model_name = model_name # Model class name

self._libraries = libraries # may be needed if model is derived from other model

self._variable_filter = variable_filter

if self._libraries:

self._loadLibrary(libraries=self._libraries)

self._file_name = None

if model_file is not None:

file_path = pathlib.Path(model_file)

# special handling for OMCProcessLocal - consider a relative path

if isinstance(self._session, OMCSessionLocal) and not file_path.is_absolute():

file_path = pathlib.Path.cwd() / file_path

if not file_path.is_file():

raise IOError(f"Model file {file_path} does not exist!")

self._file_name = self.getWorkDirectory() / file_path.name

if (isinstance(self._session, OMCSessionLocal)

and file_path.as_posix() == self._file_name.as_posix()):

pass

elif self._file_name.is_file():

raise IOError(f"Simulation model file {self._file_name} exist - not overwriting!")

else:

content = file_path.read_text(encoding='utf-8')

self._file_name.write_text(content)

if self._file_name is not None:

self._loadFile(fileName=self._file_name)

if build:

self.buildModel(variable_filter)

def get_session(self) -> OMCSession:

"""

Return the OMC session used for this class.

"""

return self._session

def set_command_line_options(self, command_line_option: str):

"""

Set the provided command line option via OMC setCommandLineOptions().

"""

expr = f'setCommandLineOptions("{command_line_option}")'

self.sendExpression(expr=expr)

def _loadFile(self, fileName: OMCPath):

# load file

self.sendExpression(expr=f'loadFile("{fileName.as_posix()}")')

# for loading file/package, loading model and building model

def _loadLibrary(self, libraries: list):

# load Modelica standard libraries or Modelica files if needed

for element in libraries:

if element is not None:

if isinstance(element, str):

if element.endswith(".mo"):

api_call = "loadFile"

else:

api_call = "loadModel"

self._requestApi(apiName=api_call, entity=element)

elif isinstance(element, tuple):

if not element[1]:

expr_load_lib = f"loadModel({element[0]})"

else:

expr_load_lib = f'loadModel({element[0]}, {{"{element[1]}"}})'

self.sendExpression(expr=expr_load_lib)

else:

raise ModelicaSystemError("loadLibrary() failed, Unknown type detected: "

f"{element} is of type {type(element)}, "

"The following patterns are supported:\n"

'1)["Modelica"]\n'

'2)[("Modelica","3.2.3"), "PowerSystems"]\n')

def setWorkDirectory(self, work_directory: Optional[str | os.PathLike] = None) -> OMCPath:

"""

Define the work directory for the ModelicaSystem / OpenModelica session. The model is build within this

directory. If no directory is defined a unique temporary directory is created.

"""

if work_directory is not None:

workdir = self._session.omcpath(work_directory).absolute()

if not workdir.is_dir():

raise IOError(f"Provided work directory does not exists: {work_directory}!")

else:

workdir = self._session.omcpath_tempdir().absolute()

if not workdir.is_dir():

raise IOError(f"{workdir} could not be created")

logger.info("Define work dir as %s", workdir)

self._session.set_workdir(workdir=workdir)

# set the class variable _work_dir ...

self._work_dir = workdir

# ... and also return the defined path

return workdir

def getWorkDirectory(self) -> OMCPath:

"""

Return the defined working directory for this ModelicaSystem / OpenModelica session.

"""

return self._work_dir

def buildModel(self, variableFilter: Optional[str] = None):

filter_def: Optional[str] = None

if variableFilter is not None:

filter_def = variableFilter

elif self._variable_filter is not None:

filter_def = self._variable_filter

if filter_def is not None:

var_filter = f'variableFilter="{filter_def}"'

else:

var_filter = 'variableFilter=".*"'

build_model_result = self._requestApi(apiName="buildModel", entity=self._model_name, properties=var_filter)

logger.debug("OM model build result: %s", build_model_result)

# check if the executable exists ...

om_cmd = ModelicaSystemCmd(

session=self._session,

runpath=self.getWorkDirectory(),

modelname=self._model_name,

)

# ... by running it - output help for command help

om_cmd.arg_set(key="help", val="help")

cmd_definition = om_cmd.definition()

returncode = self._session.run_model_executable(cmd_run_data=cmd_definition)

if returncode != 0:

raise ModelicaSystemError("Model executable not working!")

xml_file = self._session.omcpath(build_model_result[0]).parent / build_model_result[1]

self._xmlparse(xml_file=xml_file)

def sendExpression(self, expr: str, parsed: bool = True) -> Any:

"""

Wrapper for OMCSession.sendExpression().

"""

try:

retval = self._session.sendExpression(expr=expr, parsed=parsed)

except OMCSessionException as ex:

raise ModelicaSystemError(f"Error executing {repr(expr)}: {ex}") from ex

logger.debug(f"Result of executing {repr(expr)}: {textwrap.shorten(repr(retval), width=100)}")

return retval

# request to OMC

def _requestApi(

self,

apiName: str,

entity: Optional[str] = None,

properties: Optional[str] = None,

) -> Any:

if entity is not None and properties is not None:

expr = f'{apiName}({entity}, {properties})'

elif entity is not None and properties is None:

if apiName in ("loadFile", "importFMU"):

expr = f'{apiName}("{entity}")'

else:

expr = f'{apiName}({entity})'

else:

expr = f'{apiName}()'

return self.sendExpression(expr=expr)

def _xmlparse(self, xml_file: OMCPath):

if not xml_file.is_file():

raise ModelicaSystemError(f"XML file not generated: {xml_file}")

xml_content = xml_file.read_text()

tree = ET.ElementTree(ET.fromstring(xml_content))

root = tree.getroot()

for attr in root.iter('DefaultExperiment'):

for key in ("startTime", "stopTime", "stepSize", "tolerance",

"solver", "outputFormat"):

self._simulate_options[key] = str(attr.get(key))

for sv in root.iter('ScalarVariable'):

translations = {

"alias": "alias",

"aliasvariable": "aliasVariable",

"causality": "causality",

"changeable": "isValueChangeable",

"description": "description",

"name": "name",

"variability": "variability",

}

scalar: dict[str, Any] = {}

for key_dst, key_src in translations.items():

val = sv.get(key_src)

scalar[key_dst] = None if val is None else str(val)

ch = list(sv)

for att in ch:

scalar["start"] = att.get('start')

scalar["min"] = att.get('min')

scalar["max"] = att.get('max')

scalar["unit"] = att.get('unit')

# save parameters in the corresponding class variables

if scalar["variability"] == "parameter":

if scalar["name"] in self._override_variables:

self._params[scalar["name"]] = self._override_variables[scalar["name"]]

else:

self._params[scalar["name"]] = scalar["start"]

if scalar["variability"] == "continuous":

self._continuous[scalar["name"]] = np.float64(scalar["start"])

if scalar["causality"] == "input":

self._inputs[scalar["name"]] = scalar["start"]

if scalar["causality"] == "output":

self._outputs[scalar["name"]] = np.float64(scalar["start"])

self._quantities.append(scalar)

def getQuantities(self, names: Optional[str | list[str]] = None) -> list[dict]:

"""

This method returns list of dictionaries. It displays details of

quantities such as name, value, changeable, and description.

Examples:

>>> mod.getQuantities()

[

{

'alias': 'noAlias',

'aliasvariable': None,

'causality': 'local',

'changeable': 'true',

'description': None,

'max': None,

'min': None,

'name': 'x',

'start': '1.0',

'unit': None,

'variability': 'continuous',

},

{

'name': 'der(x)',

# ...

},

# ...

]

>>> getQuantities("y")

[{

'name': 'y', # ...

}]

>>> getQuantities(["y","x"])

[

{

'name': 'y', # ...

},

{

'name': 'x', # ...

}

]

"""

if names is None:

return self._quantities

if isinstance(names, str):

r = [x for x in self._quantities if x["name"] == names]

if r == []:

raise KeyError(names)

return r

if isinstance(names, list):

return [x for y in names for x in self._quantities if x["name"] == y]

raise ModelicaSystemError("Unhandled input for getQuantities()")

def getContinuousInitial(

self,

names: Optional[str | list[str]] = None,

) -> dict[str, np.float64] | list[np.float64]:

"""

Get (initial) values of continuous signals.

Args:

names: Either None (default), a string with the continuous signal

name, or a list of signal name strings.

Returns:

If `names` is None, a dict in the format

{signal_name: signal_value} is returned.

If `names` is a string, a single element list [signal_value] is

returned.

If `names` is a list, a list with one value for each signal name

in names is returned: [signal1_value, signal2_value, ...].

Examples:

>>> mod.getContinuousInitial()

{'x': '1.0', 'der(x)': None, 'y': '-0.4'}

>>> mod.getContinuousInitial("y")

['-0.4']

>>> mod.getContinuousInitial(["y","x"])

['-0.4', '1.0']

"""

if names is None:

return self._continuous

if isinstance(names, str):

return [self._continuous[names]]

if isinstance(names, list):

return [self._continuous[x] for x in names]

raise ModelicaSystemError("Unhandled input for getContinousInitial()")

def getContinuousFinal(

self,

names: Optional[str | list[str]] = None,

) -> dict[str, np.float64] | list[np.float64]:

"""

Get (final) values of continuous signals (at stopTime).

Args:

names: Either None (default), a string with the continuous signal

name, or a list of signal name strings.

Returns:

If `names` is None, a dict in the format

{signal_name: signal_value} is returned.

If `names` is a string, a single element list [signal_value] is

returned.

If `names` is a list, a list with one value for each signal name

in names is returned: [signal1_value, signal2_value, ...].

Examples:

>>> mod.getContinuousFinal()

{'x': np.float64(0.68), 'der(x)': np.float64(-0.24), 'y': np.float64(-0.24)}

>>> mod.getContinuousFinal("x")

[np.float64(0.68)]

>>> mod.getContinuousFinal(["y","x"])

[np.float64(-0.24), np.float64(0.68)]

"""

if not self._simulated:

raise ModelicaSystemError("Please use getContinuousInitial() before the simulation was started!")

def get_continuous_solution(name_list: list[str]) -> None:

for name in name_list:

if name in self._continuous:

value = self.getSolutions(name)

self._continuous[name] = np.float64(value[0][-1])

else:

raise KeyError(f"{names} is not continuous")

if names is None:

get_continuous_solution(name_list=list(self._continuous.keys()))

return self._continuous

if isinstance(names, str):

get_continuous_solution(name_list=[names])

return [self._continuous[names]]

if isinstance(names, list):

get_continuous_solution(name_list=names)

values = []

for name in names:

values.append(self._continuous[name])

return values

raise ModelicaSystemError("Unhandled input for getContinousFinal()")

def getContinuous(

self,

names: Optional[str | list[str]] = None,

) -> dict[str, np.float64] | list[np.float64]:

"""Get values of continuous signals.

If called before simulate(), the initial values are returned.

If called after simulate(), the final values (at stopTime) are returned.

The return format is always numpy.float64.

Args:

names: Either None (default), a string with the continuous signal

name, or a list of signal name strings.

Returns:

If `names` is None, a dict in the format

{signal_name: signal_value} is returned.

If `names` is a string, a single element list [signal_value] is

returned.

If `names` is a list, a list with one value for each signal name

in names is returned: [signal1_value, signal2_value, ...].

Examples:

Before simulate():

>>> mod.getContinuous()

{'x': '1.0', 'der(x)': None, 'y': '-0.4'}

>>> mod.getContinuous("y")

['-0.4']

>>> mod.getContinuous(["y","x"])

['-0.4', '1.0']

After simulate():

>>> mod.getContinuous()

{'x': np.float64(0.68), 'der(x)': np.float64(-0.24), 'y': np.float64(-0.24)}

>>> mod.getContinuous("x")

[np.float64(0.68)]

>>> mod.getContinuous(["y","x"])

[np.float64(-0.24), np.float64(0.68)]

"""

if not self._simulated:

return self.getContinuousInitial(names=names)

return self.getContinuousFinal(names=names)

def getParameters(

self,

names: Optional[str | list[str]] = None,

) -> dict[str, str] | list[str]:

"""Get parameter values.

Args:

names: Either None (default), a string with the parameter name,

or a list of parameter name strings.

Returns:

If `names` is None, a dict in the format

{parameter_name: parameter_value} is returned.

If `names` is a string, a single element list is returned.

If `names` is a list, a list with one value for each parameter name

in names is returned.

In all cases, parameter values are returned as strings.

Examples:

>>> mod.getParameters()

{'Name1': '1.23', 'Name2': '4.56'}

>>> mod.getParameters("Name1")

['1.23']

>>> mod.getParameters(["Name1","Name2"])

['1.23', '4.56']

"""

if names is None:

return self._params

if isinstance(names, str):

return [self._params[names]]

if isinstance(names, list):

return [self._params[x] for x in names]

raise ModelicaSystemError("Unhandled input for getParameters()")

def getInputs(

self,

names: Optional[str | list[str]] = None,

) -> dict[str, list[tuple[float, float]]] | list[list[tuple[float, float]]]:

"""Get values of input signals.

Args:

names: Either None (default), a string with the input name,

or a list of input name strings.

Returns:

If `names` is None, a dict in the format

{input_name: input_value} is returned.

If `names` is a string, a single element list [input_value] is

returned.

If `names` is a list, a list with one value for each input name

in names is returned: [input1_values, input2_values, ...].

In all cases, input values are returned as a list of tuples,

where the first element in the tuple is the time and the second

element is the input value.

Examples:

>>> mod.getInputs()

{'Name1': [(0.0, 0.0), (1.0, 1.0)], 'Name2': None}

>>> mod.getInputs("Name1")

[[(0.0, 0.0), (1.0, 1.0)]]

>>> mod.getInputs(["Name1","Name2"])

[[(0.0, 0.0), (1.0, 1.0)], None]

"""

if names is None:

return self._inputs

if isinstance(names, str):

return [self._inputs[names]]

if isinstance(names, list):

return [self._inputs[x] for x in names]

raise ModelicaSystemError("Unhandled input for getInputs()")

def getOutputsInitial(

self,

names: Optional[str | list[str]] = None,

) -> dict[str, np.float64] | list[np.float64]:

"""

Get (initial) values of output signals.

Args:

names: Either None (default), a string with the output name,

or a list of output name strings.

Returns:

If `names` is None, a dict in the format

{output_name: output_value} is returned.

If `names` is a string, a single element list [output_value] is

returned.

If `names` is a list, a list with one value for each output name

in names is returned: [output1_value, output2_value, ...].

Examples:

>>> mod.getOutputsInitial()

{'out1': '-0.4', 'out2': '1.2'}

>>> mod.getOutputsInitial("out1")

['-0.4']

>>> mod.getOutputsInitial(["out1","out2"])

['-0.4', '1.2']

"""

if names is None:

return self._outputs

if isinstance(names, str):

return [self._outputs[names]]

if isinstance(names, list):

return [self._outputs[x] for x in names]

raise ModelicaSystemError("Unhandled input for getOutputsInitial()")

def getOutputsFinal(

self,

names: Optional[str | list[str]] = None,

) -> dict[str, np.float64] | list[np.float64]:

"""Get (final) values of output signals (at stopTime).

Args:

names: Either None (default), a string with the output name,

or a list of output name strings.

Returns:

If `names` is None, a dict in the format

{output_name: output_value} is returned.

If `names` is a string, a single element list [output_value] is

returned.

If `names` is a list, a list with one value for each output name

in names is returned: [output1_value, output2_value, ...].

Examples:

>>> mod.getOutputsFinal()

{'out1': np.float64(-0.1234), 'out2': np.float64(2.1)}

>>> mod.getOutputsFinal("out1")

[np.float64(-0.1234)]

>>> mod.getOutputsFinal(["out1","out2"])

[np.float64(-0.1234), np.float64(2.1)]

"""

if not self._simulated:

raise ModelicaSystemError("Please use getOuputsInitial() before the simulation was started!")

def get_outputs_solution(name_list: list[str]) -> None:

for name in name_list:

if name in self._outputs:

value = self.getSolutions(name)

self._outputs[name] = np.float64(value[0][-1])

else:

raise KeyError(f"{names} is not a valid output")

if names is None:

get_outputs_solution(name_list=list(self._outputs.keys()))

return self._outputs

if isinstance(names, str):

get_outputs_solution(name_list=[names])

return [self._outputs[names]]

if isinstance(names, list):

get_outputs_solution(name_list=names)

values = []

for name in names:

values.append(self._outputs[name])

return values

raise ModelicaSystemError("Unhandled input for getOutputs()")

def getOutputs(

self,

names: Optional[str | list[str]] = None,

) -> dict[str, np.float64] | list[np.float64]:

"""Get values of output signals.

If called before simulate(), the initial values are returned.

If called after simulate(), the final values (at stopTime) are returned.

The return format is always numpy.float64.

Args:

names: Either None (default), a string with the output name,

or a list of output name strings.