From 01f531097d54225c85cf1fa639114fcc3f205f62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Thu, 12 Jun 2025 11:52:35 +0200 Subject: [PATCH 01/66] Fix typo --- OMPython/ModelicaSystem.py | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index e9c247b3..db060ecb 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -278,17 +278,9 @@ def run(self) -> int: @staticmethod def parse_simflags(simflags: str) -> dict[str, Optional[str | dict[str, str]]]: """ - Parse a simflag definition; this is depreciated! + Parse a simflag definition; this is deprecated! The return data can be used as input for self.args_set(). - - Parameters - ---------- - simflags : str - - Returns - ------- - dict """ warnings.warn("The argument 'simflags' is depreciated and will be removed in future versions; " "please use 'simargs' instead", DeprecationWarning, stacklevel=2) From 176ff03e7176ca790fa6167f33ed1e901f9aa0d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:36:03 +0200 Subject: [PATCH 02/66] Rename quantitiesList to _quantitiesList --- OMPython/ModelicaSystem.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index db060ecb..595149e0 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -370,7 +370,7 @@ def __init__( if modelName is None: raise ModelicaSystemError("A modelname must be provided (argument modelName)!") - self.quantitiesList: list[dict[str, Any]] = [] + self._quantitiesList: list[dict[str, Any]] = [] self.paramlist: dict[str, str] = {} # even numerical values are stored as str self.inputlist: dict[str, list | None] = {} # outputlist values are str before simulate(), but they can be @@ -567,7 +567,7 @@ def xmlparse(self): if scalar["causality"] == "output": self.outputlist[scalar["name"]] = scalar["start"] - self.quantitiesList.append(scalar) + self._quantitiesList.append(scalar) def getQuantities(self, names: Optional[str | list[str]] = None) -> list[dict]: """ @@ -613,16 +613,16 @@ def getQuantities(self, names: Optional[str | list[str]] = None) -> list[dict]: ] """ if names is None: - return self.quantitiesList + return self._quantitiesList if isinstance(names, str): - r = [x for x in self.quantitiesList if x["name"] == names] + r = [x for x in self._quantitiesList 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.quantitiesList if x["name"] == y] + return [x for y in names for x in self._quantitiesList if x["name"] == y] raise ModelicaSystemError("Unhandled input for getQuantities()") From 5d6038a79e74c7d18afe64accc5ed9b08116f3f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:42:15 +0200 Subject: [PATCH 03/66] Rename paramlist to _paramlist --- OMPython/ModelicaSystem.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 595149e0..a97b6e4f 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -371,7 +371,7 @@ def __init__( raise ModelicaSystemError("A modelname must be provided (argument modelName)!") self._quantitiesList: list[dict[str, Any]] = [] - self.paramlist: dict[str, str] = {} # even numerical values are stored as str + self._paramlist: dict[str, str] = {} # even numerical values are stored as str self.inputlist: dict[str, list | None] = {} # outputlist values are str before simulate(), but they can be # np.float64 after simulate(). @@ -557,9 +557,9 @@ def xmlparse(self): if scalar["variability"] == "parameter": if scalar["name"] in self.overridevariables: - self.paramlist[scalar["name"]] = self.overridevariables[scalar["name"]] + self._paramlist[scalar["name"]] = self.overridevariables[scalar["name"]] else: - self.paramlist[scalar["name"]] = scalar["start"] + self._paramlist[scalar["name"]] = scalar["start"] if scalar["variability"] == "continuous": self.continuouslist[scalar["name"]] = scalar["start"] if scalar["causality"] == "input": @@ -697,11 +697,11 @@ def getParameters(self, names: Optional[str | list[str]] = None) -> dict[str, st ['1.23', '4.56'] """ if names is None: - return self.paramlist + return self._paramlist elif isinstance(names, str): - return [self.paramlist[names]] + return [self._paramlist[names]] elif isinstance(names, list): - return [self.paramlist[x] for x in names] + return [self._paramlist[x] for x in names] raise ModelicaSystemError("Unhandled input for getParameters()") @@ -1050,7 +1050,7 @@ def setParameters(self, pvals): # 14 >>> setParameters("Name=value") >>> setParameters(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(pvals, self.paramlist, "parameter", self.overridevariables) + return self.setMethodHelper(pvals, self._paramlist, "parameter", self.overridevariables) def isParameterChangeable(self, name, value): q = self.getQuantities(name) From 868748676e7d3abe287fee83144ab9d6104df7c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:44:03 +0200 Subject: [PATCH 04/66] Rename inputlist to _inputlist --- OMPython/ModelicaSystem.py | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index a97b6e4f..a2d4f6c3 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -372,7 +372,7 @@ def __init__( self._quantitiesList: list[dict[str, Any]] = [] self._paramlist: dict[str, str] = {} # even numerical values are stored as str - self.inputlist: dict[str, list | None] = {} + self._inputlist: dict[str, list | None] = {} # outputlist values are str before simulate(), but they can be # np.float64 after simulate(). self.outputlist: dict[str, Any] = {} @@ -563,7 +563,7 @@ def xmlparse(self): if scalar["variability"] == "continuous": self.continuouslist[scalar["name"]] = scalar["start"] if scalar["causality"] == "input": - self.inputlist[scalar["name"]] = scalar["start"] + self._inputlist[scalar["name"]] = scalar["start"] if scalar["causality"] == "output": self.outputlist[scalar["name"]] = scalar["start"] @@ -731,11 +731,11 @@ def getInputs(self, names: Optional[str | list[str]] = None) -> dict | list: # [[(0.0, 0.0), (1.0, 1.0)], None] """ if names is None: - return self.inputlist + return self._inputlist elif isinstance(names, str): - return [self.inputlist[names]] + return [self._inputlist[names]] elif isinstance(names, list): - return [self.inputlist[x] for x in names] + return [self._inputlist[x] for x in names] raise ModelicaSystemError("Unhandled input for getInputs()") @@ -902,13 +902,13 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N om_cmd.arg_set(key="overrideFile", val=overrideFile.as_posix()) if self.inputFlag: # if model has input quantities - for i in self.inputlist: - val = self.inputlist[i] + for i in self._inputlist: + val = self._inputlist[i] if val is None: val = [(float(self.simulateOptions["startTime"]), 0.0), (float(self.simulateOptions["stopTime"]), 0.0)] - self.inputlist[i] = [(float(self.simulateOptions["startTime"]), 0.0), - (float(self.simulateOptions["stopTime"]), 0.0)] + self._inputlist[i] = [(float(self.simulateOptions["startTime"]), 0.0), + (float(self.simulateOptions["stopTime"]), 0.0)] if float(self.simulateOptions["startTime"]) != val[0][0]: raise ModelicaSystemError(f"startTime not matched for Input {i}!") if float(self.simulateOptions["stopTime"]) != val[-1][0]: @@ -1103,14 +1103,14 @@ def setInputs(self, name): # 15 if isinstance(name, str): name = self._strip_space(name) value = name.split("=") - if value[0] in self.inputlist: + if value[0] in self._inputlist: tmpvalue = eval(value[1]) if isinstance(tmpvalue, (int, float)): - self.inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])), - (float(self.simulateOptions["stopTime"]), float(value[1]))] + self._inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])), + (float(self.simulateOptions["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): self.checkValidInputs(tmpvalue) - self.inputlist[value[0]] = tmpvalue + self._inputlist[value[0]] = tmpvalue self.inputFlag = True else: raise ModelicaSystemError(f"{value[0]} is not an input") @@ -1118,14 +1118,14 @@ def setInputs(self, name): # 15 name = self._strip_space(name) for var in name: value = var.split("=") - if value[0] in self.inputlist: + if value[0] in self._inputlist: tmpvalue = eval(value[1]) if isinstance(tmpvalue, (int, float)): - self.inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])), - (float(self.simulateOptions["stopTime"]), float(value[1]))] + self._inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])), + (float(self.simulateOptions["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): self.checkValidInputs(tmpvalue) - self.inputlist[value[0]] = tmpvalue + self._inputlist[value[0]] = tmpvalue self.inputFlag = True else: raise ModelicaSystemError(f"{value[0]} is not an input!") @@ -1149,7 +1149,7 @@ def createCSVData(self) -> pathlib.Path: # Replace None inputs with a default constant zero signal inputs: dict[str, list[tuple[float, float]]] = {} - for input_name, input_signal in self.inputlist.items(): + for input_name, input_signal in self._inputlist.items(): if input_signal is None: inputs[input_name] = [(start_time, 0.0), (stop_time, 0.0)] else: From b579d6b3a303486cafca3f713744621072e6cae9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:44:45 +0200 Subject: [PATCH 05/66] Rename outputlist to _outputlist --- OMPython/ModelicaSystem.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index a2d4f6c3..d9a1c13a 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -373,9 +373,9 @@ def __init__( self._quantitiesList: list[dict[str, Any]] = [] self._paramlist: dict[str, str] = {} # even numerical values are stored as str self._inputlist: dict[str, list | None] = {} - # outputlist values are str before simulate(), but they can be + # _outputlist values are str before simulate(), but they can be # np.float64 after simulate(). - self.outputlist: dict[str, Any] = {} + self._outputlist: dict[str, Any] = {} # same for continuouslist self.continuouslist: dict[str, Any] = {} self.simulateOptions: dict[str, str] = {} @@ -565,7 +565,7 @@ def xmlparse(self): if scalar["causality"] == "input": self._inputlist[scalar["name"]] = scalar["start"] if scalar["causality"] == "output": - self.outputlist[scalar["name"]] = scalar["start"] + self._outputlist[scalar["name"]] = scalar["start"] self._quantitiesList.append(scalar) @@ -776,30 +776,30 @@ def getOutputs(self, names: Optional[str | list[str]] = None): # 7 """ if not self.simulationFlag: if names is None: - return self.outputlist + return self._outputlist elif isinstance(names, str): - return [self.outputlist[names]] + return [self._outputlist[names]] else: - return [self.outputlist[x] for x in names] + return [self._outputlist[x] for x in names] else: if names is None: - for i in self.outputlist: + for i in self._outputlist: value = self.getSolutions(i) - self.outputlist[i] = value[0][-1] - return self.outputlist + self._outputlist[i] = value[0][-1] + return self._outputlist elif isinstance(names, str): - if names in self.outputlist: + if names in self._outputlist: value = self.getSolutions(names) - self.outputlist[names] = value[0][-1] - return [self.outputlist[names]] + self._outputlist[names] = value[0][-1] + return [self._outputlist[names]] else: raise KeyError(names) elif isinstance(names, list): valuelist = [] for i in names: - if i in self.outputlist: + if i in self._outputlist: value = self.getSolutions(i) - self.outputlist[i] = value[0][-1] + self._outputlist[i] = value[0][-1] valuelist.append(value[0][-1]) else: raise KeyError(i) From 16d4fe291278ab62df6680cf766a8b0a3ae46647 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:45:47 +0200 Subject: [PATCH 06/66] Rename continuouslist to _continuouslist --- OMPython/ModelicaSystem.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index d9a1c13a..c80b71b8 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -376,8 +376,8 @@ def __init__( # _outputlist values are str before simulate(), but they can be # np.float64 after simulate(). self._outputlist: dict[str, Any] = {} - # same for continuouslist - self.continuouslist: dict[str, Any] = {} + # same for _continuouslist + self._continuouslist: dict[str, Any] = {} self.simulateOptions: dict[str, str] = {} self.overridevariables: dict[str, str] = {} self.simoptionsoverride: dict[str, str] = {} @@ -561,7 +561,7 @@ def xmlparse(self): else: self._paramlist[scalar["name"]] = scalar["start"] if scalar["variability"] == "continuous": - self.continuouslist[scalar["name"]] = scalar["start"] + self._continuouslist[scalar["name"]] = scalar["start"] if scalar["causality"] == "input": self._inputlist[scalar["name"]] = scalar["start"] if scalar["causality"] == "output": @@ -636,37 +636,37 @@ def getContinuous(self, names=None): # 4 """ if not self.simulationFlag: if names is None: - return self.continuouslist + return self._continuouslist if isinstance(names, str): - return [self.continuouslist[names]] + return [self._continuouslist[names]] if isinstance(names, list): - return [self.continuouslist[x] for x in names] + return [self._continuouslist[x] for x in names] else: if names is None: - for i in self.continuouslist: + for i in self._continuouslist: try: value = self.getSolutions(i) - self.continuouslist[i] = value[0][-1] + self._continuouslist[i] = value[0][-1] except (OMCSessionException, ModelicaSystemError) as ex: raise ModelicaSystemError(f"{i} could not be computed") from ex - return self.continuouslist + return self._continuouslist if isinstance(names, str): - if names in self.continuouslist: + if names in self._continuouslist: value = self.getSolutions(names) - self.continuouslist[names] = value[0][-1] - return [self.continuouslist[names]] + self._continuouslist[names] = value[0][-1] + return [self._continuouslist[names]] else: raise ModelicaSystemError(f"{names} is not continuous") if isinstance(names, list): valuelist = [] for i in names: - if i in self.continuouslist: + if i in self._continuouslist: value = self.getSolutions(i) - self.continuouslist[i] = value[0][-1] + self._continuouslist[i] = value[0][-1] valuelist.append(value[0][-1]) else: raise ModelicaSystemError(f"{i} is not continuous") @@ -1040,7 +1040,7 @@ def setContinuous(self, cvals): # 13 >>> setContinuous("Name=value") >>> setContinuous(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(cvals, self.continuouslist, "continuous", self.overridevariables) + return self.setMethodHelper(cvals, self._continuouslist, "continuous", self.overridevariables) def setParameters(self, pvals): # 14 """ From c5053dba36553df6175c82aa24e4c47c1e4536b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:46:43 +0200 Subject: [PATCH 07/66] Rename simulateOptions to _simulateOptions --- OMPython/ModelicaSystem.py | 40 +++++++++++++++++++------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index c80b71b8..cd82c0b4 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -378,7 +378,7 @@ def __init__( self._outputlist: dict[str, Any] = {} # same for _continuouslist self._continuouslist: dict[str, Any] = {} - self.simulateOptions: dict[str, str] = {} + self._simulateOptions: dict[str, str] = {} self.overridevariables: dict[str, str] = {} self.simoptionsoverride: dict[str, str] = {} self.linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} @@ -540,7 +540,7 @@ def xmlparse(self): for attr in rootCQ.iter('DefaultExperiment'): for key in ("startTime", "stopTime", "stepSize", "tolerance", "solver", "outputFormat"): - self.simulateOptions[key] = attr.get(key) + self._simulateOptions[key] = attr.get(key) for sv in rootCQ.iter('ScalarVariable'): scalar = {} @@ -817,11 +817,11 @@ def getSimulationOptions(self, names=None): # 8 >>> getSimulationOptions(["Name1","Name2"]) """ if names is None: - return self.simulateOptions + return self._simulateOptions elif isinstance(names, str): - return [self.simulateOptions[names]] + return [self._simulateOptions[names]] elif isinstance(names, list): - return [self.simulateOptions[x] for x in names] + return [self._simulateOptions[x] for x in names] raise ModelicaSystemError("Unhandled input for getSimulationOptions()") @@ -905,13 +905,13 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N for i in self._inputlist: val = self._inputlist[i] if val is None: - val = [(float(self.simulateOptions["startTime"]), 0.0), - (float(self.simulateOptions["stopTime"]), 0.0)] - self._inputlist[i] = [(float(self.simulateOptions["startTime"]), 0.0), - (float(self.simulateOptions["stopTime"]), 0.0)] - if float(self.simulateOptions["startTime"]) != val[0][0]: + val = [(float(self._simulateOptions["startTime"]), 0.0), + (float(self._simulateOptions["stopTime"]), 0.0)] + self._inputlist[i] = [(float(self._simulateOptions["startTime"]), 0.0), + (float(self._simulateOptions["stopTime"]), 0.0)] + if float(self._simulateOptions["startTime"]) != val[0][0]: raise ModelicaSystemError(f"startTime not matched for Input {i}!") - if float(self.simulateOptions["stopTime"]) != val[-1][0]: + if float(self._simulateOptions["stopTime"]) != val[-1][0]: raise ModelicaSystemError(f"stopTime not matched for Input {i}!") self.csvFile = self.createCSVData() # create csv file @@ -1070,7 +1070,7 @@ def setSimulationOptions(self, simOptions): # 16 >>> setSimulationOptions("Name=value") >>> setSimulationOptions(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(simOptions, self.simulateOptions, "simulation-option", self.simoptionsoverride) + return self.setMethodHelper(simOptions, self._simulateOptions, "simulation-option", self.simoptionsoverride) def setLinearizationOptions(self, linearizationOptions): # 18 """ @@ -1106,8 +1106,8 @@ def setInputs(self, name): # 15 if value[0] in self._inputlist: tmpvalue = eval(value[1]) if isinstance(tmpvalue, (int, float)): - self._inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])), - (float(self.simulateOptions["stopTime"]), float(value[1]))] + self._inputlist[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), + (float(self._simulateOptions["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): self.checkValidInputs(tmpvalue) self._inputlist[value[0]] = tmpvalue @@ -1121,8 +1121,8 @@ def setInputs(self, name): # 15 if value[0] in self._inputlist: tmpvalue = eval(value[1]) if isinstance(tmpvalue, (int, float)): - self._inputlist[value[0]] = [(float(self.simulateOptions["startTime"]), float(value[1])), - (float(self.simulateOptions["stopTime"]), float(value[1]))] + self._inputlist[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), + (float(self._simulateOptions["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): self.checkValidInputs(tmpvalue) self._inputlist[value[0]] = tmpvalue @@ -1136,7 +1136,7 @@ def checkValidInputs(self, name): for l in name: if isinstance(l, tuple): # if l[0] < float(self.simValuesList[0]): - if l[0] < float(self.simulateOptions["startTime"]): + if l[0] < float(self._simulateOptions["startTime"]): raise ModelicaSystemError('Input time value is less than simulation startTime') if len(l) != 2: raise ModelicaSystemError(f'Value for {l} is in incorrect format!') @@ -1144,8 +1144,8 @@ def checkValidInputs(self, name): raise ModelicaSystemError('Error!!! Value must be in tuple format') def createCSVData(self) -> pathlib.Path: - start_time: float = float(self.simulateOptions["startTime"]) - stop_time: float = float(self.simulateOptions["stopTime"]) + start_time: float = float(self._simulateOptions["startTime"]) + stop_time: float = float(self._simulateOptions["stopTime"]) # Replace None inputs with a default constant zero signal inputs: dict[str, list[tuple[float, float]]] = {} @@ -1304,7 +1304,7 @@ def load_module_from_path(module_name, file_path): tupleList = nameVal.get(n) if tupleList is not None: for l in tupleList: - if l[0] < float(self.simulateOptions["startTime"]): + if l[0] < float(self._simulateOptions["startTime"]): raise ModelicaSystemError('Input time value is less than simulation startTime') self.csvFile = self.createCSVData() om_cmd.arg_set(key="csvInput", val=self.csvFile.as_posix()) From d6a7efa421f44b96bdeeb5774260cd483402367c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:47:32 +0200 Subject: [PATCH 08/66] Rename overridevariables to _overridevariables --- OMPython/ModelicaSystem.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index cd82c0b4..4a18d240 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -379,7 +379,7 @@ def __init__( # same for _continuouslist self._continuouslist: dict[str, Any] = {} self._simulateOptions: dict[str, str] = {} - self.overridevariables: dict[str, str] = {} + self._overridevariables: dict[str, str] = {} self.simoptionsoverride: dict[str, str] = {} self.linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} self.optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, @@ -556,8 +556,8 @@ def xmlparse(self): scalar["unit"] = att.get('unit') if scalar["variability"] == "parameter": - if scalar["name"] in self.overridevariables: - self._paramlist[scalar["name"]] = self.overridevariables[scalar["name"]] + if scalar["name"] in self._overridevariables: + self._paramlist[scalar["name"]] = self._overridevariables[scalar["name"]] else: self._paramlist[scalar["name"]] = scalar["start"] if scalar["variability"] == "continuous": @@ -891,8 +891,8 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N om_cmd.args_set(args=simargs) overrideFile = self.tempdir / f"{self.modelName}_override.txt" - if self.overridevariables or self.simoptionsoverride: - tmpdict = self.overridevariables.copy() + if self._overridevariables or self.simoptionsoverride: + tmpdict = self._overridevariables.copy() tmpdict.update(self.simoptionsoverride) # write to override file with open(file=overrideFile, mode="w", encoding="utf-8") as fh: @@ -1040,7 +1040,7 @@ def setContinuous(self, cvals): # 13 >>> setContinuous("Name=value") >>> setContinuous(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(cvals, self._continuouslist, "continuous", self.overridevariables) + return self.setMethodHelper(cvals, self._continuouslist, "continuous", self._overridevariables) def setParameters(self, pvals): # 14 """ @@ -1050,7 +1050,7 @@ def setParameters(self, pvals): # 14 >>> setParameters("Name=value") >>> setParameters(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(pvals, self._paramlist, "parameter", self.overridevariables) + return self.setMethodHelper(pvals, self._paramlist, "parameter", self._overridevariables) def isParameterChangeable(self, name, value): q = self.getQuantities(name) @@ -1291,7 +1291,7 @@ def load_module_from_path(module_name, file_path): overrideLinearFile = self.tempdir / f'{self.modelName}_override_linear.txt' with open(file=overrideLinearFile, mode="w", encoding="utf-8") as fh: - for key, value in self.overridevariables.items(): + for key, value in self._overridevariables.items(): fh.write(f"{key}={value}\n") for key, value in self.linearOptions.items(): fh.write(f"{key}={value}\n") From 7d47f93d727b4602618f4062b4287824afefa90a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:48:11 +0200 Subject: [PATCH 09/66] Rename simoptionsoverride to _simoptionsoverride --- OMPython/ModelicaSystem.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 4a18d240..d59b665b 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -380,7 +380,7 @@ def __init__( self._continuouslist: dict[str, Any] = {} self._simulateOptions: dict[str, str] = {} self._overridevariables: dict[str, str] = {} - self.simoptionsoverride: dict[str, str] = {} + self._simoptionsoverride: dict[str, str] = {} self.linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} self.optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-8} @@ -891,9 +891,9 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N om_cmd.args_set(args=simargs) overrideFile = self.tempdir / f"{self.modelName}_override.txt" - if self._overridevariables or self.simoptionsoverride: + if self._overridevariables or self._simoptionsoverride: tmpdict = self._overridevariables.copy() - tmpdict.update(self.simoptionsoverride) + tmpdict.update(self._simoptionsoverride) # write to override file with open(file=overrideFile, mode="w", encoding="utf-8") as fh: for key, value in tmpdict.items(): @@ -1070,7 +1070,7 @@ def setSimulationOptions(self, simOptions): # 16 >>> setSimulationOptions("Name=value") >>> setSimulationOptions(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(simOptions, self._simulateOptions, "simulation-option", self.simoptionsoverride) + return self.setMethodHelper(simOptions, self._simulateOptions, "simulation-option", self._simoptionsoverride) def setLinearizationOptions(self, linearizationOptions): # 18 """ From 499c799a06849cce3171a22471bb3f6439412430 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:51:16 +0200 Subject: [PATCH 10/66] Rename linearOptions to _linearOptions --- OMPython/ModelicaSystem.py | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index d59b665b..e5ef2bae 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -381,7 +381,7 @@ def __init__( self._simulateOptions: dict[str, str] = {} self._overridevariables: dict[str, str] = {} self._simoptionsoverride: dict[str, str] = {} - self.linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} + self._linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} self.optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-8} self.linearinputs: list[str] = [] # linearization input list @@ -835,11 +835,11 @@ def getLinearizationOptions(self, names=None): # 9 >>> getLinearizationOptions(["Name1","Name2"]) """ if names is None: - return self.linearOptions + return self._linearOptions elif isinstance(names, str): - return [self.linearOptions[names]] + return [self._linearOptions[names]] elif isinstance(names, list): - return [self.linearOptions[x] for x in names] + return [self._linearOptions[x] for x in names] raise ModelicaSystemError("Unhandled input for getLinearizationOptions()") @@ -1080,7 +1080,7 @@ def setLinearizationOptions(self, linearizationOptions): # 18 >>> setLinearizationOptions("Name=value") >>> setLinearizationOptions(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(linearizationOptions, self.linearOptions, "Linearization-option", None) + return self.setMethodHelper(linearizationOptions, self._linearOptions, "Linearization-option", None) def setOptimizationOptions(self, optimizationOptions): # 17 """ @@ -1253,10 +1253,12 @@ def optimize(self): # 21 def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = None, simargs: Optional[dict[str, Optional[str | dict[str, str]]]] = None, timeout: Optional[int] = None) -> LinearizationResult: - """Linearize the model according to linearOptions. + """Linearize the model according to linearization options. + + See setLinearizationOptions. Args: - lintime: Override linearOptions["stopTime"] value. + lintime: Override "stopTime" value. simflags: A string of extra command line flags for the model binary. - depreciated in favor of simargs simargs: A dict with command line flags and possible options; example: "simargs={'csvInput': 'a.csv'}" @@ -1293,7 +1295,7 @@ def load_module_from_path(module_name, file_path): with open(file=overrideLinearFile, mode="w", encoding="utf-8") as fh: for key, value in self._overridevariables.items(): fh.write(f"{key}={value}\n") - for key, value in self.linearOptions.items(): + for key, value in self._linearOptions.items(): fh.write(f"{key}={value}\n") om_cmd.arg_set(key="overrideFile", val=overrideLinearFile.as_posix()) @@ -1309,7 +1311,7 @@ def load_module_from_path(module_name, file_path): self.csvFile = self.createCSVData() om_cmd.arg_set(key="csvInput", val=self.csvFile.as_posix()) - om_cmd.arg_set(key="l", val=str(lintime or self.linearOptions["stopTime"])) + om_cmd.arg_set(key="l", val=str(lintime or self._linearOptions["stopTime"])) # allow runtime simulation flags from user input if simflags is not None: From 1a72b213b41d281485d2ba022ad1a92da66b97b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:52:14 +0200 Subject: [PATCH 11/66] Rename optimizeOptions to _optimizeOptions --- OMPython/ModelicaSystem.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index e5ef2bae..09269c22 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -382,8 +382,8 @@ def __init__( self._overridevariables: dict[str, str] = {} self._simoptionsoverride: dict[str, str] = {} self._linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} - self.optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, - 'tolerance': 1e-8} + self._optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, + 'tolerance': 1e-8} self.linearinputs: list[str] = [] # linearization input list self.linearoutputs: list[str] = [] # linearization output list self.linearstates: list[str] = [] # linearization states list @@ -851,11 +851,11 @@ def getOptimizationOptions(self, names=None): # 10 >>> getOptimizationOptions(["Name1","Name2"]) """ if names is None: - return self.optimizeOptions + return self._optimizeOptions elif isinstance(names, str): - return [self.optimizeOptions[names]] + return [self._optimizeOptions[names]] elif isinstance(names, list): - return [self.optimizeOptions[x] for x in names] + return [self._optimizeOptions[x] for x in names] raise ModelicaSystemError("Unhandled input for getOptimizationOptions()") @@ -1090,7 +1090,7 @@ def setOptimizationOptions(self, optimizationOptions): # 17 >>> setOptimizationOptions("Name=value") >>> setOptimizationOptions(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(optimizationOptions, self.optimizeOptions, "optimization-option", None) + return self.setMethodHelper(optimizationOptions, self._optimizeOptions, "optimization-option", None) def setInputs(self, name): # 15 """ @@ -1244,7 +1244,7 @@ def optimize(self): # 21 >>> optimize() """ cName = self.modelName - properties = ','.join(f"{key}={val}" for key, val in self.optimizeOptions.items()) + properties = ','.join(f"{key}={val}" for key, val in self._optimizeOptions.items()) self.setCommandLineOptions("-g=Optimica") optimizeResult = self.requestApi('optimize', cName, properties) From 71963a08544647149e1f4eb87c78ab0b089f0c65 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:53:27 +0200 Subject: [PATCH 12/66] Rename linearinputs to _linearinputs --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 09269c22..cd8631aa 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -384,7 +384,7 @@ def __init__( self._linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} self._optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-8} - self.linearinputs: list[str] = [] # linearization input list + self._linearinputs: list[str] = [] # linearization input list self.linearoutputs: list[str] = [] # linearization output list self.linearstates: list[str] = [] # linearization states list @@ -1345,7 +1345,7 @@ def load_module_from_path(module_name, file_path): result = module.linearized_model() (n, m, p, x0, u0, A, B, C, D, stateVars, inputVars, outputVars) = result - self.linearinputs = inputVars + self._linearinputs = inputVars self.linearoutputs = outputVars self.linearstates = stateVars return LinearizationResult(n, m, p, A, B, C, D, x0, u0, stateVars, @@ -1359,7 +1359,7 @@ def getLinearInputs(self): usage >>> getLinearInputs() """ - return self.linearinputs + return self._linearinputs def getLinearOutputs(self): """ From 44bbc2cfe473e8c6766af3299d335d724e76b8c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:53:56 +0200 Subject: [PATCH 13/66] Rename linearoutputs to _linearoutputs --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index cd8631aa..21c4f898 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -385,7 +385,7 @@ def __init__( self._optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-8} self._linearinputs: list[str] = [] # linearization input list - self.linearoutputs: list[str] = [] # linearization output list + self._linearoutputs: list[str] = [] # linearization output list self.linearstates: list[str] = [] # linearization states list if session is not None: @@ -1346,7 +1346,7 @@ def load_module_from_path(module_name, file_path): result = module.linearized_model() (n, m, p, x0, u0, A, B, C, D, stateVars, inputVars, outputVars) = result self._linearinputs = inputVars - self.linearoutputs = outputVars + self._linearoutputs = outputVars self.linearstates = stateVars return LinearizationResult(n, m, p, A, B, C, D, x0, u0, stateVars, inputVars, outputVars) @@ -1367,7 +1367,7 @@ def getLinearOutputs(self): usage >>> getLinearOutputs() """ - return self.linearoutputs + return self._linearoutputs def getLinearStates(self): """ From f6a6b09f915cf0970ac494e48150872530cdb8b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:54:22 +0200 Subject: [PATCH 14/66] Rename linearstates to _linearstates --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 21c4f898..b64ae744 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -386,7 +386,7 @@ def __init__( 'tolerance': 1e-8} self._linearinputs: list[str] = [] # linearization input list self._linearoutputs: list[str] = [] # linearization output list - self.linearstates: list[str] = [] # linearization states list + self._linearstates: list[str] = [] # linearization states list if session is not None: if not isinstance(session, OMCSessionZMQ): @@ -1347,7 +1347,7 @@ def load_module_from_path(module_name, file_path): (n, m, p, x0, u0, A, B, C, D, stateVars, inputVars, outputVars) = result self._linearinputs = inputVars self._linearoutputs = outputVars - self.linearstates = stateVars + self._linearstates = stateVars return LinearizationResult(n, m, p, A, B, C, D, x0, u0, stateVars, inputVars, outputVars) except ModuleNotFoundError as ex: @@ -1375,4 +1375,4 @@ def getLinearStates(self): usage >>> getLinearStates() """ - return self.linearstates + return self._linearstates From 8bc1a7a8afc3b642479bb0720bf48abb236903b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:56:23 +0200 Subject: [PATCH 15/66] Improve docstrings for getLinear*() --- OMPython/ModelicaSystem.py | 24 ++++++------------------ 1 file changed, 6 insertions(+), 18 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index b64ae744..9e44f737 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -1353,26 +1353,14 @@ def load_module_from_path(module_name, file_path): except ModuleNotFoundError as ex: raise ModelicaSystemError("No module named 'linearized_model'") from ex - def getLinearInputs(self): - """ - function which returns the LinearInputs after Linearization is performed - usage - >>> getLinearInputs() - """ + def getLinearInputs(self) -> list[str]: + """Return names of input variables of the linearized model.""" return self._linearinputs - def getLinearOutputs(self): - """ - function which returns the LinearInputs after Linearization is performed - usage - >>> getLinearOutputs() - """ + def getLinearOutputs(self) -> list[str]: + """Return names of output variables of the linearized model.""" return self._linearoutputs - def getLinearStates(self): - """ - function which returns the LinearInputs after Linearization is performed - usage - >>> getLinearStates() - """ + def getLinearStates(self) -> list[str]: + """Return names of state variables of the linearized model.""" return self._linearstates From 988c7537e57fe15bfd72c9c4caee5b122b275920 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:57:18 +0200 Subject: [PATCH 16/66] Rename xmlFile to _xmlFile --- OMPython/ModelicaSystem.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 9e44f737..1cdd083f 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -404,7 +404,7 @@ def __init__( if not isinstance(lmodel, list): raise ModelicaSystemError(f"Invalid input type for lmodel: {type(lmodel)} - list expected!") - self.xmlFile = None + self._xmlFile = None self.lmodel = lmodel # may be needed if model is derived from other model self.modelName = modelName # Model class name self.fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name @@ -504,7 +504,7 @@ def buildModel(self, variableFilter: Optional[str] = None): buildModelResult = self.requestApi("buildModel", self.modelName, properties=varFilter) logger.debug("OM model build result: %s", buildModelResult) - self.xmlFile = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1] + self._xmlFile = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1] self.xmlparse() def sendExpression(self, expr: str, parsed: bool = True): @@ -532,10 +532,10 @@ def requestApi(self, apiName, entity=None, properties=None): # 2 return self.sendExpression(exp) def xmlparse(self): - if not self.xmlFile.is_file(): - raise ModelicaSystemError(f"XML file not generated: {self.xmlFile}") + if not self._xmlFile.is_file(): + raise ModelicaSystemError(f"XML file not generated: {self._xmlFile}") - tree = ET.parse(self.xmlFile) + tree = ET.parse(self._xmlFile) rootCQ = tree.getroot() for attr in rootCQ.iter('DefaultExperiment'): for key in ("startTime", "stopTime", "stepSize", "tolerance", @@ -1282,7 +1282,7 @@ def load_module_from_path(module_name, file_path): return module_def - if self.xmlFile is None: + if self._xmlFile is None: raise ModelicaSystemError( "Linearization cannot be performed as the model is not build, " "use ModelicaSystem() to build the model first" From de68d6bd4e5dea6f3c356d96c54a883216fa348c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:58:07 +0200 Subject: [PATCH 17/66] Rename lmodel to _lmodel --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 1cdd083f..573466e0 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -405,7 +405,7 @@ def __init__( raise ModelicaSystemError(f"Invalid input type for lmodel: {type(lmodel)} - list expected!") self._xmlFile = None - self.lmodel = lmodel # may be needed if model is derived from other model + self._lmodel = lmodel # may be needed if model is derived from other model self.modelName = modelName # Model class name self.fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self.inputFlag = False # for model with input quantity @@ -427,12 +427,12 @@ def __init__( self.tempdir = self.setTempDirectory(customBuildDirectory) if self.fileName is not None: - self.loadLibrary(lmodel=self.lmodel) + self.loadLibrary(lmodel=self._lmodel) self.loadFile(fileName=self.fileName) # allow directly loading models from MSL without fileName elif fileName is None and modelName is not None: - self.loadLibrary(lmodel=self.lmodel) + self.loadLibrary(lmodel=self._lmodel) if build: self.buildModel(variableFilter) From 1440074dff0b9dae31f29abc78741ba1c5e6efa2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:59:16 +0200 Subject: [PATCH 18/66] Rename modelName to _modelName --- OMPython/ModelicaSystem.py | 26 +++++++++++++------------- tests/test_ModelicaSystemCmd.py | 17 ++++++++++++----- 2 files changed, 25 insertions(+), 18 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 573466e0..edc37afa 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -406,7 +406,7 @@ def __init__( self._xmlFile = None self._lmodel = lmodel # may be needed if model is derived from other model - self.modelName = modelName # Model class name + self._modelName = modelName # Model class name self.fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self.inputFlag = False # for model with input quantity self.simulationFlag = False # if the model is simulated? @@ -501,7 +501,7 @@ def buildModel(self, variableFilter: Optional[str] = None): else: varFilter = 'variableFilter=".*"' - buildModelResult = self.requestApi("buildModel", self.modelName, properties=varFilter) + buildModelResult = self.requestApi("buildModel", self._modelName, properties=varFilter) logger.debug("OM model build result: %s", buildModelResult) self._xmlFile = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1] @@ -871,11 +871,11 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N >>> simulate(simargs={"noEventEmit": None, "noRestart": None, "override": "e=0.3,g=10"}) # using simargs """ - om_cmd = ModelicaSystemCmd(runpath=self.tempdir, modelname=self.modelName, timeout=timeout) + om_cmd = ModelicaSystemCmd(runpath=self.tempdir, modelname=self._modelName, timeout=timeout) if resultfile is None: # default result file generated by OM - self.resultfile = self.tempdir / f"{self.modelName}_res.mat" + self.resultfile = self.tempdir / f"{self._modelName}_res.mat" elif os.path.exists(resultfile): self.resultfile = pathlib.Path(resultfile) else: @@ -890,7 +890,7 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N if simargs: om_cmd.args_set(args=simargs) - overrideFile = self.tempdir / f"{self.modelName}_override.txt" + overrideFile = self.tempdir / f"{self._modelName}_override.txt" if self._overridevariables or self._simoptionsoverride: tmpdict = self._overridevariables.copy() tmpdict.update(self._simoptionsoverride) @@ -1057,7 +1057,7 @@ def isParameterChangeable(self, name, value): if q[0]["changeable"] == "false": logger.debug(f"setParameters() failed : It is not possible to set the following signal {repr(name)}. " "It seems to be structural, final, protected or evaluated or has a non-constant binding, " - f"use sendExpression(\"setParameterValue({self.modelName}, {name}, {value})\") " + f"use sendExpression(\"setParameterValue({self._modelName}, {name}, {value})\") " "and rebuild the model using buildModel() API") return False return True @@ -1184,7 +1184,7 @@ def createCSVData(self) -> pathlib.Path: ] csv_rows.append(row) - csvFile = self.tempdir / f'{self.modelName}.csv' + csvFile = self.tempdir / f'{self._modelName}.csv' with open(file=csvFile, mode="w", encoding="utf-8", newline="") as fh: writer = csv.writer(fh) @@ -1204,13 +1204,13 @@ def convertMo2Fmu(self, version="2.0", fmuType="me_cs", fileNamePrefix="": - fileNamePrefix = self.modelName + fileNamePrefix = self._modelName if includeResources: includeResourcesStr = "true" else: includeResourcesStr = "false" properties = f'version="{version}", fmuType="{fmuType}", fileNamePrefix="{fileNamePrefix}", includeResources={includeResourcesStr}' - fmu = self.requestApi('buildModelFMU', self.modelName, properties) + fmu = self.requestApi('buildModelFMU', self._modelName, properties) # report proper error message if not os.path.exists(fmu): @@ -1243,7 +1243,7 @@ def optimize(self): # 21 usage >>> optimize() """ - cName = self.modelName + cName = self._modelName properties = ','.join(f"{key}={val}" for key, val in self._optimizeOptions.items()) self.setCommandLineOptions("-g=Optimica") optimizeResult = self.requestApi('optimize', cName, properties) @@ -1288,9 +1288,9 @@ def load_module_from_path(module_name, file_path): "use ModelicaSystem() to build the model first" ) - om_cmd = ModelicaSystemCmd(runpath=self.tempdir, modelname=self.modelName, timeout=timeout) + om_cmd = ModelicaSystemCmd(runpath=self.tempdir, modelname=self._modelName, timeout=timeout) - overrideLinearFile = self.tempdir / f'{self.modelName}_override_linear.txt' + overrideLinearFile = self.tempdir / f'{self._modelName}_override_linear.txt' with open(file=overrideLinearFile, mode="w", encoding="utf-8") as fh: for key, value in self._overridevariables.items(): @@ -1331,7 +1331,7 @@ def load_module_from_path(module_name, file_path): # support older openmodelica versions before OpenModelica v1.16.2 where linearize() generates "linear_modelname.mo" file if not linearFile.exists(): - linearFile = pathlib.Path(f'linear_{self.modelName}.py') + linearFile = pathlib.Path(f'linear_{self._modelName}.py') if not linearFile.exists(): raise ModelicaSystemError(f"Linearization failed: {linearFile} not found!") diff --git a/tests/test_ModelicaSystemCmd.py b/tests/test_ModelicaSystemCmd.py index 420193df..6fd45a4d 100644 --- a/tests/test_ModelicaSystemCmd.py +++ b/tests/test_ModelicaSystemCmd.py @@ -15,12 +15,18 @@ def model_firstorder(tmp_path): return mod -def test_simflags(model_firstorder): +@pytest.fixture +def mscmd_firstorder(model_firstorder): mod = OMPython.ModelicaSystem(fileName=model_firstorder.as_posix(), modelName="M") - mscmd = OMPython.ModelicaSystemCmd(runpath=mod.tempdir, modelname=mod.modelName) + mscmd = OMPython.ModelicaSystemCmd(runpath=mod.tempdir, modelname=mod._modelName) + return mscmd + + +def test_simflags(mscmd_firstorder): + mscmd = mscmd_firstorder + mscmd.args_set({ "noEventEmit": None, - "noRestart": None, "override": {'b': 2} }) with pytest.deprecated_call(): @@ -28,6 +34,7 @@ def test_simflags(model_firstorder): assert mscmd.get_cmd() == [ mscmd.get_exe().as_posix(), - '-noEventEmit', '-noRestart', - '-override=b=2,a=1,x=3' + '-noEventEmit', + '-override=b=2,a=1,x=3', + '-noRestart', ] From 17af95935905e725531d5c4763bbda2a80e35d4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Fri, 13 Jun 2025 23:59:58 +0200 Subject: [PATCH 19/66] Rename fileName to _fileName --- OMPython/ModelicaSystem.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index edc37afa..54db8bb1 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -407,7 +407,7 @@ def __init__( self._xmlFile = None self._lmodel = lmodel # may be needed if model is derived from other model self._modelName = modelName # Model class name - self.fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name + self._fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self.inputFlag = False # for model with input quantity self.simulationFlag = False # if the model is simulated? self.outputFlag = False @@ -415,8 +415,8 @@ def __init__( self.resultfile: Optional[pathlib.Path] = None # for storing result file self.variableFilter = variableFilter - if self.fileName is not None and not self.fileName.is_file(): # if file does not exist - raise IOError(f"{self.fileName} does not exist!") + if self._fileName is not None and not self._fileName.is_file(): # if file does not exist + raise IOError(f"{self._fileName} does not exist!") # set default command Line Options for linearization as # linearize() will use the simulation executable and runtime @@ -426,9 +426,9 @@ def __init__( self.tempdir = self.setTempDirectory(customBuildDirectory) - if self.fileName is not None: + if self._fileName is not None: self.loadLibrary(lmodel=self._lmodel) - self.loadFile(fileName=self.fileName) + self.loadFile(fileName=self._fileName) # allow directly loading models from MSL without fileName elif fileName is None and modelName is not None: From 3026d83396492f913bad83a94b800bae027b44bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:02:00 +0200 Subject: [PATCH 20/66] Rename inputFlag to _inputFlag --- OMPython/ModelicaSystem.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 54db8bb1..c122c000 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -408,7 +408,7 @@ def __init__( self._lmodel = lmodel # may be needed if model is derived from other model self._modelName = modelName # Model class name self._fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name - self.inputFlag = False # for model with input quantity + self._inputFlag = False # for model with input quantity self.simulationFlag = False # if the model is simulated? self.outputFlag = False self.csvFile: Optional[pathlib.Path] = None # for storing inputs condition @@ -901,7 +901,7 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N om_cmd.arg_set(key="overrideFile", val=overrideFile.as_posix()) - if self.inputFlag: # if model has input quantities + if self._inputFlag: # if model has input quantities for i in self._inputlist: val = self._inputlist[i] if val is None: @@ -1111,7 +1111,7 @@ def setInputs(self, name): # 15 elif isinstance(tmpvalue, list): self.checkValidInputs(tmpvalue) self._inputlist[value[0]] = tmpvalue - self.inputFlag = True + self._inputFlag = True else: raise ModelicaSystemError(f"{value[0]} is not an input") elif isinstance(name, list): @@ -1126,7 +1126,7 @@ def setInputs(self, name): # 15 elif isinstance(tmpvalue, list): self.checkValidInputs(tmpvalue) self._inputlist[value[0]] = tmpvalue - self.inputFlag = True + self._inputFlag = True else: raise ModelicaSystemError(f"{value[0]} is not an input!") @@ -1300,7 +1300,7 @@ def load_module_from_path(module_name, file_path): om_cmd.arg_set(key="overrideFile", val=overrideLinearFile.as_posix()) - if self.inputFlag: + if self._inputFlag: nameVal = self.getInputs() for n in nameVal: tupleList = nameVal.get(n) From 31960fe01fc0ca82541ddbefd2e17479ebcaddbc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:02:54 +0200 Subject: [PATCH 21/66] Rename simulationFlag to _simulationFlag --- OMPython/ModelicaSystem.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index c122c000..d7129d0d 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -409,7 +409,7 @@ def __init__( self._modelName = modelName # Model class name self._fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self._inputFlag = False # for model with input quantity - self.simulationFlag = False # if the model is simulated? + self._simulationFlag = False # if the model is simulated? self.outputFlag = False self.csvFile: Optional[pathlib.Path] = None # for storing inputs condition self.resultfile: Optional[pathlib.Path] = None # for storing result file @@ -634,7 +634,7 @@ def getContinuous(self, names=None): # 4 >>> getContinuous("Name1") >>> getContinuous(["Name1","Name2"]) """ - if not self.simulationFlag: + if not self._simulationFlag: if names is None: return self._continuouslist @@ -774,7 +774,7 @@ def getOutputs(self, names: Optional[str | list[str]] = None): # 7 >>> mod.getOutputs(["out1","out2"]) [np.float64(-0.1234), np.float64(2.1)] """ - if not self.simulationFlag: + if not self._simulationFlag: if names is None: return self._outputlist elif isinstance(names, str): @@ -933,7 +933,7 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N logger.warning(f"Return code = {returncode} but result file exists!") - self.simulationFlag = True + self._simulationFlag = True # to extract simulation results def getSolutions(self, varList=None, resultfile=None): # 12 @@ -1324,7 +1324,7 @@ def load_module_from_path(module_name, file_path): if returncode != 0: raise ModelicaSystemError(f"Linearize failed with return code: {returncode}") - self.simulationFlag = True + self._simulationFlag = True # code to get the matrix and linear inputs, outputs and states linearFile = self.tempdir / "linearized_model.py" From fdc953c2b0c36630f4d6d1000288324d2fca6745 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:03:30 +0200 Subject: [PATCH 22/66] Remove unused variable outputFlag --- OMPython/ModelicaSystem.py | 1 - 1 file changed, 1 deletion(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index d7129d0d..70270cdc 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -410,7 +410,6 @@ def __init__( self._fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self._inputFlag = False # for model with input quantity self._simulationFlag = False # if the model is simulated? - self.outputFlag = False self.csvFile: Optional[pathlib.Path] = None # for storing inputs condition self.resultfile: Optional[pathlib.Path] = None # for storing result file self.variableFilter = variableFilter From c32a87ff62ae65082196e36c7c871d5b9e862b3f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:04:28 +0200 Subject: [PATCH 23/66] Rename csvFile to _csvFile --- OMPython/ModelicaSystem.py | 10 +++++----- tests/test_ModelicaSystem.py | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 70270cdc..de632fc2 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -410,7 +410,7 @@ def __init__( self._fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self._inputFlag = False # for model with input quantity self._simulationFlag = False # if the model is simulated? - self.csvFile: Optional[pathlib.Path] = None # for storing inputs condition + self._csvFile: Optional[pathlib.Path] = None # for storing inputs condition self.resultfile: Optional[pathlib.Path] = None # for storing result file self.variableFilter = variableFilter @@ -912,9 +912,9 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N raise ModelicaSystemError(f"startTime not matched for Input {i}!") if float(self._simulateOptions["stopTime"]) != val[-1][0]: raise ModelicaSystemError(f"stopTime not matched for Input {i}!") - self.csvFile = self.createCSVData() # create csv file + self._csvFile = self.createCSVData() # create csv file - om_cmd.arg_set(key="csvInput", val=self.csvFile.as_posix()) + om_cmd.arg_set(key="csvInput", val=self._csvFile.as_posix()) # delete resultfile ... if self.resultfile.is_file(): @@ -1307,8 +1307,8 @@ def load_module_from_path(module_name, file_path): for l in tupleList: if l[0] < float(self._simulateOptions["startTime"]): raise ModelicaSystemError('Input time value is less than simulation startTime') - self.csvFile = self.createCSVData() - om_cmd.arg_set(key="csvInput", val=self.csvFile.as_posix()) + self._csvFile = self.createCSVData() + om_cmd.arg_set(key="csvInput", val=self._csvFile.as_posix()) om_cmd.arg_set(key="l", val=str(lintime or self._linearOptions["stopTime"])) diff --git a/tests/test_ModelicaSystem.py b/tests/test_ModelicaSystem.py index 156dde03..b4d328e9 100644 --- a/tests/test_ModelicaSystem.py +++ b/tests/test_ModelicaSystem.py @@ -397,7 +397,7 @@ def test_simulate_inputs(tmp_path): "u2=[(0.0, 0), (0.25, 0.5), (0.5, 1.0), (1.0, 0)]", ]) mod.simulate() - assert pathlib.Path(mod.csvFile).read_text() == """time,u1,u2,end + assert pathlib.Path(mod._csvFile).read_text() == """time,u1,u2,end 0.0,0.0,0.0,0 0.25,0.25,0.5,0 0.5,0.5,1.0,0 From 364fb2640ad47d67b28743ba55d0aecaf0744824 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:05:09 +0200 Subject: [PATCH 24/66] Rename resultfile to _resultfile --- OMPython/ModelicaSystem.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index de632fc2..1aa4b560 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -411,7 +411,7 @@ def __init__( self._inputFlag = False # for model with input quantity self._simulationFlag = False # if the model is simulated? self._csvFile: Optional[pathlib.Path] = None # for storing inputs condition - self.resultfile: Optional[pathlib.Path] = None # for storing result file + self._resultfile: Optional[pathlib.Path] = None # for storing result file self.variableFilter = variableFilter if self._fileName is not None and not self._fileName.is_file(): # if file does not exist @@ -874,13 +874,13 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N if resultfile is None: # default result file generated by OM - self.resultfile = self.tempdir / f"{self._modelName}_res.mat" + self._resultfile = self.tempdir / f"{self._modelName}_res.mat" elif os.path.exists(resultfile): - self.resultfile = pathlib.Path(resultfile) + self._resultfile = pathlib.Path(resultfile) else: - self.resultfile = self.tempdir / resultfile + self._resultfile = self.tempdir / resultfile # always define the resultfile to use - om_cmd.arg_set(key="r", val=self.resultfile.as_posix()) + om_cmd.arg_set(key="r", val=self._resultfile.as_posix()) # allow runtime simulation flags from user input if simflags is not None: @@ -917,17 +917,17 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N om_cmd.arg_set(key="csvInput", val=self._csvFile.as_posix()) # delete resultfile ... - if self.resultfile.is_file(): - self.resultfile.unlink() + if self._resultfile.is_file(): + self._resultfile.unlink() # ... run simulation ... returncode = om_cmd.run() # and check returncode *AND* resultfile - if returncode != 0 and self.resultfile.is_file(): + if returncode != 0 and self._resultfile.is_file(): # check for an empty (=> 0B) result file which indicates a crash of the model executable # see: https://github.com/OpenModelica/OMPython/issues/261 # https://github.com/OpenModelica/OpenModelica/issues/13829 - if self.resultfile.stat().st_size == 0: - self.resultfile.unlink() + if self._resultfile.stat().st_size == 0: + self._resultfile.unlink() raise ModelicaSystemError("Empty result file - this indicates a crash of the model executable!") logger.warning(f"Return code = {returncode} but result file exists!") @@ -948,7 +948,7 @@ def getSolutions(self, varList=None, resultfile=None): # 12 >>> getSolutions(["Name1","Name2"],resultfile=""c:/a.mat"") """ if resultfile is None: - result_file = self.resultfile + result_file = self._resultfile else: result_file = pathlib.Path(resultfile) From 72ffb704730bd8706bfa8505d366ec61648f399d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:05:51 +0200 Subject: [PATCH 25/66] Rename variableFilter to _variableFilter --- OMPython/ModelicaSystem.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 1aa4b560..6eb55c02 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -412,7 +412,7 @@ def __init__( self._simulationFlag = False # if the model is simulated? self._csvFile: Optional[pathlib.Path] = None # for storing inputs condition self._resultfile: Optional[pathlib.Path] = None # for storing result file - self.variableFilter = variableFilter + self._variableFilter = variableFilter if self._fileName is not None and not self._fileName.is_file(): # if file does not exist raise IOError(f"{self._fileName} does not exist!") @@ -493,10 +493,10 @@ def getWorkDirectory(self) -> pathlib.Path: def buildModel(self, variableFilter: Optional[str] = None): if variableFilter is not None: - self.variableFilter = variableFilter + self._variableFilter = variableFilter - if self.variableFilter is not None: - varFilter = f'variableFilter="{self.variableFilter}"' + if self._variableFilter is not None: + varFilter = f'variableFilter="{self._variableFilter}"' else: varFilter = 'variableFilter=".*"' From a40f03673c8ff2db6a6c20eef38c3a782badcc7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:08:55 +0200 Subject: [PATCH 26/66] Rename getconn to _getconn --- OMPython/ModelicaSystem.py | 6 +++--- tests/test_OMSessionCmd.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 6eb55c02..cfca13d2 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -391,9 +391,9 @@ def __init__( if session is not None: if not isinstance(session, OMCSessionZMQ): raise ModelicaSystemError("Invalid session data provided!") - self.getconn = session + self._getconn = session else: - self.getconn = OMCSessionZMQ(omhome=omhome) + self._getconn = OMCSessionZMQ(omhome=omhome) # set commandLineOptions if provided by users self.setCommandLineOptions(commandLineOptions=commandLineOptions) @@ -508,7 +508,7 @@ def buildModel(self, variableFilter: Optional[str] = None): def sendExpression(self, expr: str, parsed: bool = True): try: - retval = self.getconn.sendExpression(expr, parsed) + retval = self._getconn.sendExpression(expr, parsed) except OMCSessionException as ex: raise ModelicaSystemError(f"Error executing {repr(expr)}") from ex diff --git a/tests/test_OMSessionCmd.py b/tests/test_OMSessionCmd.py index c76e8ca3..1588fac8 100644 --- a/tests/test_OMSessionCmd.py +++ b/tests/test_OMSessionCmd.py @@ -10,7 +10,7 @@ def test_isPackage(): def test_isPackage2(): mod = OMPython.ModelicaSystem(modelName="Modelica.Electrical.Analog.Examples.CauerLowPassAnalog", lmodel=["Modelica"]) - omccmd = OMPython.OMCSessionCmd(session=mod.getconn) + omccmd = OMPython.OMCSessionCmd(session=mod._getconn) assert omccmd.isPackage('Modelica') From a85b0d5c1719ccca6ba2fee778789259a590249d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:09:38 +0200 Subject: [PATCH 27/66] Rename tempdir to _tempdir --- OMPython/ModelicaSystem.py | 20 ++++++++++---------- tests/test_ModelicaSystemCmd.py | 2 +- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index cfca13d2..f08f8549 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -423,7 +423,7 @@ def __init__( self.setCommandLineOptions("--linearizationDumpLanguage=python") self.setCommandLineOptions("--generateSymbolicLinearization") - self.tempdir = self.setTempDirectory(customBuildDirectory) + self._tempdir = self.setTempDirectory(customBuildDirectory) if self._fileName is not None: self.loadLibrary(lmodel=self._lmodel) @@ -489,7 +489,7 @@ def setTempDirectory(self, customBuildDirectory: Optional[str | os.PathLike | pa return tempdir def getWorkDirectory(self) -> pathlib.Path: - return self.tempdir + return self._tempdir def buildModel(self, variableFilter: Optional[str] = None): if variableFilter is not None: @@ -870,15 +870,15 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N >>> simulate(simargs={"noEventEmit": None, "noRestart": None, "override": "e=0.3,g=10"}) # using simargs """ - om_cmd = ModelicaSystemCmd(runpath=self.tempdir, modelname=self._modelName, timeout=timeout) + om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._modelName, timeout=timeout) if resultfile is None: # default result file generated by OM - self._resultfile = self.tempdir / f"{self._modelName}_res.mat" + self._resultfile = self._tempdir / f"{self._modelName}_res.mat" elif os.path.exists(resultfile): self._resultfile = pathlib.Path(resultfile) else: - self._resultfile = self.tempdir / resultfile + self._resultfile = self._tempdir / resultfile # always define the resultfile to use om_cmd.arg_set(key="r", val=self._resultfile.as_posix()) @@ -889,7 +889,7 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N if simargs: om_cmd.args_set(args=simargs) - overrideFile = self.tempdir / f"{self._modelName}_override.txt" + overrideFile = self._tempdir / f"{self._modelName}_override.txt" if self._overridevariables or self._simoptionsoverride: tmpdict = self._overridevariables.copy() tmpdict.update(self._simoptionsoverride) @@ -1183,7 +1183,7 @@ def createCSVData(self) -> pathlib.Path: ] csv_rows.append(row) - csvFile = self.tempdir / f'{self._modelName}.csv' + csvFile = self._tempdir / f'{self._modelName}.csv' with open(file=csvFile, mode="w", encoding="utf-8", newline="") as fh: writer = csv.writer(fh) @@ -1287,9 +1287,9 @@ def load_module_from_path(module_name, file_path): "use ModelicaSystem() to build the model first" ) - om_cmd = ModelicaSystemCmd(runpath=self.tempdir, modelname=self._modelName, timeout=timeout) + om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._modelName, timeout=timeout) - overrideLinearFile = self.tempdir / f'{self._modelName}_override_linear.txt' + overrideLinearFile = self._tempdir / f'{self._modelName}_override_linear.txt' with open(file=overrideLinearFile, mode="w", encoding="utf-8") as fh: for key, value in self._overridevariables.items(): @@ -1326,7 +1326,7 @@ def load_module_from_path(module_name, file_path): self._simulationFlag = True # code to get the matrix and linear inputs, outputs and states - linearFile = self.tempdir / "linearized_model.py" + linearFile = self._tempdir / "linearized_model.py" # support older openmodelica versions before OpenModelica v1.16.2 where linearize() generates "linear_modelname.mo" file if not linearFile.exists(): diff --git a/tests/test_ModelicaSystemCmd.py b/tests/test_ModelicaSystemCmd.py index 6fd45a4d..20b61045 100644 --- a/tests/test_ModelicaSystemCmd.py +++ b/tests/test_ModelicaSystemCmd.py @@ -18,7 +18,7 @@ def model_firstorder(tmp_path): @pytest.fixture def mscmd_firstorder(model_firstorder): mod = OMPython.ModelicaSystem(fileName=model_firstorder.as_posix(), modelName="M") - mscmd = OMPython.ModelicaSystemCmd(runpath=mod.tempdir, modelname=mod._modelName) + mscmd = OMPython.ModelicaSystemCmd(runpath=mod.getWorkDirectory(), modelname=mod._modelName) return mscmd From 6e221e9f22cf82b275eed1bf87147093be04872d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:14:38 +0200 Subject: [PATCH 28/66] Rename xmlparse() to _xmlparse() --- OMPython/ModelicaSystem.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index f08f8549..aee281fe 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -504,7 +504,7 @@ def buildModel(self, variableFilter: Optional[str] = None): logger.debug("OM model build result: %s", buildModelResult) self._xmlFile = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1] - self.xmlparse() + self._xmlparse() def sendExpression(self, expr: str, parsed: bool = True): try: @@ -530,7 +530,7 @@ def requestApi(self, apiName, entity=None, properties=None): # 2 return self.sendExpression(exp) - def xmlparse(self): + def _xmlparse(self): if not self._xmlFile.is_file(): raise ModelicaSystemError(f"XML file not generated: {self._xmlFile}") From e43c10eca1a1a94b82e9851e97d376f8e42455f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:16:32 +0200 Subject: [PATCH 29/66] Rename checkValidInputs() to _checkValidInputs() --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index aee281fe..02bc0171 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -1108,7 +1108,7 @@ def setInputs(self, name): # 15 self._inputlist[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), (float(self._simulateOptions["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): - self.checkValidInputs(tmpvalue) + self._checkValidInputs(tmpvalue) self._inputlist[value[0]] = tmpvalue self._inputFlag = True else: @@ -1123,13 +1123,13 @@ def setInputs(self, name): # 15 self._inputlist[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), (float(self._simulateOptions["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): - self.checkValidInputs(tmpvalue) + self._checkValidInputs(tmpvalue) self._inputlist[value[0]] = tmpvalue self._inputFlag = True else: raise ModelicaSystemError(f"{value[0]} is not an input!") - def checkValidInputs(self, name): + def _checkValidInputs(self, name): if name != sorted(name, key=lambda x: x[0]): raise ModelicaSystemError('Time value should be in increasing order') for l in name: From 194ef4e41282c0f24dbe7f000e3bb24b86b4990a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:17:50 +0200 Subject: [PATCH 30/66] Rename createCSVData() to _createCSVData() --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 02bc0171..907b39b5 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -912,7 +912,7 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = N raise ModelicaSystemError(f"startTime not matched for Input {i}!") if float(self._simulateOptions["stopTime"]) != val[-1][0]: raise ModelicaSystemError(f"stopTime not matched for Input {i}!") - self._csvFile = self.createCSVData() # create csv file + self._csvFile = self._createCSVData() # create csv file om_cmd.arg_set(key="csvInput", val=self._csvFile.as_posix()) @@ -1142,7 +1142,7 @@ def _checkValidInputs(self, name): else: raise ModelicaSystemError('Error!!! Value must be in tuple format') - def createCSVData(self) -> pathlib.Path: + def _createCSVData(self) -> pathlib.Path: start_time: float = float(self._simulateOptions["startTime"]) stop_time: float = float(self._simulateOptions["stopTime"]) @@ -1307,7 +1307,7 @@ def load_module_from_path(module_name, file_path): for l in tupleList: if l[0] < float(self._simulateOptions["startTime"]): raise ModelicaSystemError('Input time value is less than simulation startTime') - self._csvFile = self.createCSVData() + self._csvFile = self._createCSVData() om_cmd.arg_set(key="csvInput", val=self._csvFile.as_posix()) om_cmd.arg_set(key="l", val=str(lintime or self._linearOptions["stopTime"])) From ca88aca653c58d047d4f0ef3eed0ee4db6645203 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:21:07 +0200 Subject: [PATCH 31/66] Rename loadFile() to _loadFile() --- OMPython/ModelicaSystem.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 907b39b5..82d5c56a 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -427,7 +427,7 @@ def __init__( if self._fileName is not None: self.loadLibrary(lmodel=self._lmodel) - self.loadFile(fileName=self._fileName) + self._loadFile(fileName=self._fileName) # allow directly loading models from MSL without fileName elif fileName is None and modelName is not None: @@ -443,7 +443,7 @@ def setCommandLineOptions(self, commandLineOptions: Optional[str] = None): exp = f'setCommandLineOptions("{commandLineOptions}")' self.sendExpression(exp) - def loadFile(self, fileName: pathlib.Path): + def _loadFile(self, fileName: pathlib.Path): # load file self.sendExpression(f'loadFile("{fileName.as_posix()}")') From 5f3c9b2147e92c1d39b09753b1ef88c7681bdc57 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:21:46 +0200 Subject: [PATCH 32/66] Rename loadLibrary() to _loadLibrary() --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 82d5c56a..88296610 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -426,12 +426,12 @@ def __init__( self._tempdir = self.setTempDirectory(customBuildDirectory) if self._fileName is not None: - self.loadLibrary(lmodel=self._lmodel) + self._loadLibrary(lmodel=self._lmodel) self._loadFile(fileName=self._fileName) # allow directly loading models from MSL without fileName elif fileName is None and modelName is not None: - self.loadLibrary(lmodel=self._lmodel) + self._loadLibrary(lmodel=self._lmodel) if build: self.buildModel(variableFilter) @@ -448,7 +448,7 @@ def _loadFile(self, fileName: pathlib.Path): self.sendExpression(f'loadFile("{fileName.as_posix()}")') # for loading file/package, loading model and building model - def loadLibrary(self, lmodel: list): + def _loadLibrary(self, lmodel: list): # load Modelica standard libraries or Modelica files if needed for element in lmodel: if element is not None: From 49f294f4bd2e2246210a0463a961d1a77af8a1fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:22:51 +0200 Subject: [PATCH 33/66] Rename requestApi() to _requestApi() --- OMPython/ModelicaSystem.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 88296610..6586bb95 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -457,7 +457,7 @@ def _loadLibrary(self, lmodel: list): apiCall = "loadFile" else: apiCall = "loadModel" - self.requestApi(apiCall, element) + self._requestApi(apiCall, element) elif isinstance(element, tuple): if not element[1]: expr_load_lib = f"loadModel({element[0]})" @@ -500,7 +500,7 @@ def buildModel(self, variableFilter: Optional[str] = None): else: varFilter = 'variableFilter=".*"' - buildModelResult = self.requestApi("buildModel", self._modelName, properties=varFilter) + buildModelResult = self._requestApi("buildModel", self._modelName, properties=varFilter) logger.debug("OM model build result: %s", buildModelResult) self._xmlFile = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1] @@ -517,7 +517,7 @@ def sendExpression(self, expr: str, parsed: bool = True): return retval # request to OMC - def requestApi(self, apiName, entity=None, properties=None): # 2 + def _requestApi(self, apiName, entity=None, properties=None): # 2 if entity is not None and properties is not None: exp = f'{apiName}({entity}, {properties})' elif entity is not None and properties is None: @@ -1209,7 +1209,7 @@ def convertMo2Fmu(self, version="2.0", fmuType="me_cs", fileNamePrefix=">> convertFmu2Mo("c:/BouncingBall.Fmu") """ - fileName = self.requestApi('importFMU', fmuName) + fileName = self._requestApi('importFMU', fmuName) # report proper error message if not os.path.exists(fileName): @@ -1245,7 +1245,7 @@ def optimize(self): # 21 cName = self._modelName properties = ','.join(f"{key}={val}" for key, val in self._optimizeOptions.items()) self.setCommandLineOptions("-g=Optimica") - optimizeResult = self.requestApi('optimize', cName, properties) + optimizeResult = self._requestApi('optimize', cName, properties) return optimizeResult From c1785c34f88ded38e1f9e68d0a40cf34ab97e649 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:25:10 +0200 Subject: [PATCH 34/66] Rename setMethodHelper() to _setMethodHelper() --- OMPython/ModelicaSystem.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 6586bb95..00df582d 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -992,7 +992,7 @@ def _strip_space(name): raise ModelicaSystemError("Unhandled input for strip_space()") - def setMethodHelper(self, args1, args2, args3, args4=None): + def _setMethodHelper(self, args1, args2, args3, args4=None): """ Helper function for setParameter(),setContinuous(),setSimulationOptions(),setLinearizationOption(),setOptimizationOption() args1 - string or list of string given by user @@ -1016,7 +1016,7 @@ def apply_single(args1): return True else: - raise ModelicaSystemError("Unhandled case in setMethodHelper.apply_single() - " + raise ModelicaSystemError("Unhandled case in _setMethodHelper.apply_single() - " f"{repr(value[0])} is not a {repr(args3)} variable") result = [] @@ -1039,7 +1039,7 @@ def setContinuous(self, cvals): # 13 >>> setContinuous("Name=value") >>> setContinuous(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(cvals, self._continuouslist, "continuous", self._overridevariables) + return self._setMethodHelper(cvals, self._continuouslist, "continuous", self._overridevariables) def setParameters(self, pvals): # 14 """ @@ -1049,7 +1049,7 @@ def setParameters(self, pvals): # 14 >>> setParameters("Name=value") >>> setParameters(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(pvals, self._paramlist, "parameter", self._overridevariables) + return self._setMethodHelper(pvals, self._paramlist, "parameter", self._overridevariables) def isParameterChangeable(self, name, value): q = self.getQuantities(name) @@ -1069,7 +1069,7 @@ def setSimulationOptions(self, simOptions): # 16 >>> setSimulationOptions("Name=value") >>> setSimulationOptions(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(simOptions, self._simulateOptions, "simulation-option", self._simoptionsoverride) + return self._setMethodHelper(simOptions, self._simulateOptions, "simulation-option", self._simoptionsoverride) def setLinearizationOptions(self, linearizationOptions): # 18 """ @@ -1079,7 +1079,7 @@ def setLinearizationOptions(self, linearizationOptions): # 18 >>> setLinearizationOptions("Name=value") >>> setLinearizationOptions(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(linearizationOptions, self._linearOptions, "Linearization-option", None) + return self._setMethodHelper(linearizationOptions, self._linearOptions, "Linearization-option", None) def setOptimizationOptions(self, optimizationOptions): # 17 """ @@ -1089,7 +1089,7 @@ def setOptimizationOptions(self, optimizationOptions): # 17 >>> setOptimizationOptions("Name=value") >>> setOptimizationOptions(["Name1=value1","Name2=value2"]) """ - return self.setMethodHelper(optimizationOptions, self._optimizeOptions, "optimization-option", None) + return self._setMethodHelper(optimizationOptions, self._optimizeOptions, "optimization-option", None) def setInputs(self, name): # 15 """ From 7407b704cf0ae603c4d3c90188b1dd44a283be7c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:44:10 +0200 Subject: [PATCH 35/66] Improve docstrings --- OMPython/ModelicaSystem.py | 45 ++++++++++++++++++++++++-------------- 1 file changed, 28 insertions(+), 17 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 00df582d..c9e1d851 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -705,7 +705,7 @@ def getParameters(self, names: Optional[str | list[str]] = None) -> dict[str, st raise ModelicaSystemError("Unhandled input for getParameters()") def getInputs(self, names: Optional[str | list[str]] = None) -> dict | list: # 6 - """Get input values. + """Get values of input signals. Args: names: Either None (default), a string with the input name, @@ -739,7 +739,7 @@ def getInputs(self, names: Optional[str | list[str]] = None) -> dict | list: # raise ModelicaSystemError("Unhandled input for getInputs()") def getOutputs(self, names: Optional[str | list[str]] = None): # 7 - """Get output values. + """Get values of output signals. If called before simulate(), the initial values are returned as strings. If called after simulate(), the final values (at stopTime) @@ -858,16 +858,27 @@ def getOptimizationOptions(self, names=None): # 10 raise ModelicaSystemError("Unhandled input for getOptimizationOptions()") - def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = None, + def simulate(self, + resultfile: Optional[str] = None, + simflags: Optional[str] = None, simargs: Optional[dict[str, Optional[str | dict[str, str]]]] = None, - timeout: Optional[int] = None): # 11 - """ - This method simulates model according to the simulation options. - usage - >>> simulate() - >>> simulate(resultfile="a.mat") - >>> simulate(simflags="-noEventEmit -noRestart -override=e=0.3,g=10") # set runtime simulation flags - >>> simulate(simargs={"noEventEmit": None, "noRestart": None, "override": "e=0.3,g=10"}) # using simargs + timeout: Optional[int] = None) -> None: + """Simulate the model according to simulation options. + + See setSimulationOptions(). + + Args: + resultfile: Path to a custom result file + simflags: String of space separated simulation runtime flags. + This argument is deprecated, use simargs instead. + simargs: Dict with simulation runtime flags. + timeout: Execution timeout in seconds. + + Examples: + mod.simulate() + mod.simulate(resultfile="a.mat") + mod.simulate(simflags="-noEventEmit -noRestart -override=e=0.3,g=10") # set runtime simulation flags, deprecated + mod.simulate(simargs={"noEventEmit": None, "noRestart": None, "override": "e=0.3,g=10"}) # using simargs """ om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._modelName, timeout=timeout) @@ -993,8 +1004,8 @@ def _strip_space(name): raise ModelicaSystemError("Unhandled input for strip_space()") def _setMethodHelper(self, args1, args2, args3, args4=None): - """ - Helper function for setParameter(),setContinuous(),setSimulationOptions(),setLinearizationOption(),setOptimizationOption() + """Helper function for setters. + args1 - string or list of string given by user args2 - dict() containing the values of different variables(eg:, parameter,continuous,simulation parameters) args3 - function name (eg; continuous, parameter, simulation, linearization,optimization) @@ -1261,7 +1272,7 @@ def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = N simflags: A string of extra command line flags for the model binary. - depreciated in favor of simargs simargs: A dict with command line flags and possible options; example: "simargs={'csvInput': 'a.csv'}" - timeout: Possible timeout for the execution of OM. + timeout: Execution timeout in seconds. Returns: A LinearizationResult object is returned. This allows several @@ -1353,13 +1364,13 @@ def load_module_from_path(module_name, file_path): raise ModelicaSystemError("No module named 'linearized_model'") from ex def getLinearInputs(self) -> list[str]: - """Return names of input variables of the linearized model.""" + """Get names of input variables of the linearized model.""" return self._linearinputs def getLinearOutputs(self) -> list[str]: - """Return names of output variables of the linearized model.""" + """Get names of output variables of the linearized model.""" return self._linearoutputs def getLinearStates(self) -> list[str]: - """Return names of state variables of the linearized model.""" + """Get names of state variables of the linearized model.""" return self._linearstates From 6fac980992cad6caa2a9c2792f3850cf4d517c59 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:47:53 +0200 Subject: [PATCH 36/66] Allow float timeouts The type hints were misleadingly saying int, when in fact subprocess.run accepts float timeouts. --- OMPython/ModelicaSystem.py | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index c9e1d851..fd735977 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -117,16 +117,7 @@ class ModelicaSystemCmd: Execute a simulation by running the compiled model. """ - def __init__(self, runpath: pathlib.Path, modelname: str, timeout: Optional[int] = None) -> None: - """ - Initialisation - - Parameters - ---------- - runpath : pathlib.Path - modelname : str - timeout : Optional[int], None - """ + def __init__(self, runpath: pathlib.Path, modelname: str, timeout: Optional[float] = None) -> None: self._runpath = pathlib.Path(runpath).resolve().absolute() self._modelname = modelname self._timeout = timeout @@ -862,7 +853,7 @@ def simulate(self, resultfile: Optional[str] = None, simflags: Optional[str] = None, simargs: Optional[dict[str, Optional[str | dict[str, str]]]] = None, - timeout: Optional[int] = None) -> None: + timeout: Optional[float] = None) -> None: """Simulate the model according to simulation options. See setSimulationOptions(). @@ -1262,7 +1253,7 @@ def optimize(self): # 21 def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = None, simargs: Optional[dict[str, Optional[str | dict[str, str]]]] = None, - timeout: Optional[int] = None) -> LinearizationResult: + timeout: Optional[float] = None) -> LinearizationResult: """Linearize the model according to linearization options. See setLinearizationOptions. From de63417dc8ab4b50b96f1d61d9b04f95a72f84f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 00:56:13 +0200 Subject: [PATCH 37/66] Improve docstring for simulate() --- OMPython/ModelicaSystem.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index fd735977..0f0f0c5d 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -869,7 +869,7 @@ def simulate(self, mod.simulate() mod.simulate(resultfile="a.mat") mod.simulate(simflags="-noEventEmit -noRestart -override=e=0.3,g=10") # set runtime simulation flags, deprecated - mod.simulate(simargs={"noEventEmit": None, "noRestart": None, "override": "e=0.3,g=10"}) # using simargs + mod.simulate(simargs={"noEventEmit": None, "noRestart": None, "override": "override": {"e": 0.3, "g": 10}}) # using simargs """ om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._modelName, timeout=timeout) From d063d72ea6aefb44d3be8972aca06267b6b94b68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 01:04:11 +0200 Subject: [PATCH 38/66] Improve docstrings --- OMPython/ModelicaSystem.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 0f0f0c5d..0f115a8e 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -113,9 +113,7 @@ def __getitem__(self, index: int): class ModelicaSystemCmd: - """ - Execute a simulation by running the compiled model. - """ + """A compiled model executable.""" def __init__(self, runpath: pathlib.Path, modelname: str, timeout: Optional[float] = None) -> None: self._runpath = pathlib.Path(runpath).resolve().absolute() @@ -860,10 +858,10 @@ def simulate(self, Args: resultfile: Path to a custom result file - simflags: String of space separated simulation runtime flags. + simflags: String of extra command line flags for the model binary. This argument is deprecated, use simargs instead. simargs: Dict with simulation runtime flags. - timeout: Execution timeout in seconds. + timeout: Maximum execution time in seconds. Examples: mod.simulate() @@ -1260,10 +1258,10 @@ def linearize(self, lintime: Optional[float] = None, simflags: Optional[str] = N Args: lintime: Override "stopTime" value. - simflags: A string of extra command line flags for the model - binary. - depreciated in favor of simargs + simflags: String of extra command line flags for the model binary. + This argument is deprecated, use simargs instead. simargs: A dict with command line flags and possible options; example: "simargs={'csvInput': 'a.csv'}" - timeout: Execution timeout in seconds. + timeout: Maximum execution time in seconds. Returns: A LinearizationResult object is returned. This allows several From 783161e310c3fa130ce1dd1f4fccb4e3905f32bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sat, 14 Jun 2025 23:53:00 +0200 Subject: [PATCH 39/66] Improve ModelicaSystemCmd docstrings --- OMPython/ModelicaSystem.py | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 0f115a8e..279d7d89 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -177,13 +177,7 @@ def args_set(self, args: dict[str, Optional[str | dict[str, str]]]) -> None: self.arg_set(key=arg, val=args[arg]) def get_exe(self) -> pathlib.Path: - """ - Get the path to the executable / complied model. - - Returns - ------- - pathlib.Path - """ + """Get the path to the compiled model executable.""" if platform.system() == "Windows": path_exe = self._runpath / f"{self._modelname}.exe" else: @@ -195,12 +189,9 @@ def get_exe(self) -> pathlib.Path: return path_exe def get_cmd(self) -> list: - """ - Run the requested simulation + """Get a list with the path to the executable and all command line args. - Returns - ------- - list + This can later be used as an argument for subprocess.run(). """ path_exe = self.get_exe() @@ -215,12 +206,11 @@ def get_cmd(self) -> list: return cmdl def run(self) -> int: - """ - Run the requested simulation + """Run the requested simulation. Returns ------- - int + Subprocess return code (0 on success). """ cmdl: list = self.get_cmd() From ad42514e4602f4773d03a4f98e301221f6770bb6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sun, 15 Jun 2025 00:05:01 +0200 Subject: [PATCH 40/66] Improve docstring for getContinuous() --- OMPython/ModelicaSystem.py | 41 +++++++++++++++++++++++++++++++------- 1 file changed, 34 insertions(+), 7 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 279d7d89..8d2e66fe 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -604,13 +604,40 @@ def getQuantities(self, names: Optional[str | list[str]] = None) -> list[dict]: raise ModelicaSystemError("Unhandled input for getQuantities()") - def getContinuous(self, names=None): # 4 - """ - This method returns dict. The key is continuous names and value is corresponding continuous value. - usage: - >>> getContinuous() - >>> getContinuous("Name1") - >>> getContinuous(["Name1","Name2"]) + def getContinuous(self, names: Optional[str | list[str]] = None): + """Get values of continuous signals. + + If called before simulate(), the initial values are returned as + strings (or None). If called after simulate(), the final values (at + stopTime) are returned as 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.getOutputs(["y","x"]) + [np.float64(-0.24), np.float64(0.68)] """ if not self._simulationFlag: if names is None: From 9857263b081975a5f0a9d18d704ac600295c0070 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sun, 15 Jun 2025 00:14:47 +0200 Subject: [PATCH 41/66] Improve docstring for getSimulationOptions() --- OMPython/ModelicaSystem.py | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 8d2e66fe..44932062 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -812,14 +812,29 @@ def getOutputs(self, names: Optional[str | list[str]] = None): # 7 raise ModelicaSystemError("Unhandled input for getOutputs()") - def getSimulationOptions(self, names=None): # 8 - """ - This method returns dict. The key is simulation option names and value is corresponding simulation option value. - If name is None then the function will return dict which contain all simulation option names as key and value as corresponding values. eg., getSimulationOptions() - usage: - >>> getSimulationOptions() - >>> getSimulationOptions("Name1") - >>> getSimulationOptions(["Name1","Name2"]) + def getSimulationOptions(self, names: Optional[str | list[str]] = None) -> dict[str, str] | list[str]: + """Get simulation options such as stopTime and tolerance. + + Args: + names: Either None (default), a string with the simulation option + name, or a list of option name strings. + + Returns: + If `names` is None, a dict in the format + {option_name: option_value} is returned. + If `names` is a string, a single element list [option_value] is + returned. + If `names` is a list, a list with one value for each option name + in names is returned: [option1_value, option2_value, ...]. + Option values are always returned as strings. + + Examples: + >>> mod.getSimulationOptions() + {'startTime': '0', 'stopTime': '1.234', 'stepSize': '0.002', 'tolerance': '1.1e-08', 'solver': 'dassl', 'outputFormat': 'mat'} + >>> mod.getSimulationOptions("stopTime") + ['1.234'] + >>> mod.getSimulationOptions(["tolerance", "stopTime"]) + ['1.1e-08', '1.234'] """ if names is None: return self._simulateOptions From 58f7eea55c665b99a4d7e5b0d8056a5585eb8682 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sun, 15 Jun 2025 00:20:50 +0200 Subject: [PATCH 42/66] Improve docstring for getLinearizationOptions() --- OMPython/ModelicaSystem.py | 33 +++++++++++++++++++++++++-------- 1 file changed, 25 insertions(+), 8 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 44932062..9afba2f2 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -845,14 +845,31 @@ def getSimulationOptions(self, names: Optional[str | list[str]] = None) -> dict[ raise ModelicaSystemError("Unhandled input for getSimulationOptions()") - def getLinearizationOptions(self, names=None): # 9 - """ - This method returns dict. The key is linearize option names and value is corresponding linearize option value. - If name is None then the function will return dict which contain all linearize option names as key and value as corresponding values. eg., getLinearizationOptions() - usage: - >>> getLinearizationOptions() - >>> getLinearizationOptions("Name1") - >>> getLinearizationOptions(["Name1","Name2"]) + def getLinearizationOptions(self, names: Optional[str | list[str]] = None) -> dict | list: + """Get simulation options used for linearization. + + Args: + names: Either None (default), a string with the linearization option + name, or a list of option name strings. + + Returns: + If `names` is None, a dict in the format + {option_name: option_value} is returned. + If `names` is a string, a single element list [option_value] is + returned. + If `names` is a list, a list with one value for each option name + in names is returned: [option1_value, option2_value, ...]. + Some option values are returned as float when first initialized, + but always as strings after setLinearizationOptions is used to + change them. + + Examples: + >>> mod.getLinearizationOptions() + {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-08} + >>> mod.getLinearizationOptions("stopTime") + [1.0] + >>> mod.getLinearizationOptions(["tolerance", "stopTime"]) + [1e-08, 1.0] """ if names is None: return self._linearOptions From 09e121e3789ebbd0864bcbae364078a49aa20347 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sun, 15 Jun 2025 00:24:54 +0200 Subject: [PATCH 43/66] Improve docstring for getOptimizationOptions() --- OMPython/ModelicaSystem.py | 31 +++++++++++++++++++++++++------ 1 file changed, 25 insertions(+), 6 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 9afba2f2..9baea9cd 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -880,12 +880,31 @@ def getLinearizationOptions(self, names: Optional[str | list[str]] = None) -> di raise ModelicaSystemError("Unhandled input for getLinearizationOptions()") - def getOptimizationOptions(self, names=None): # 10 - """ - usage: - >>> getOptimizationOptions() - >>> getOptimizationOptions("Name1") - >>> getOptimizationOptions(["Name1","Name2"]) + def getOptimizationOptions(self, names: Optional[str | list[str]] = None) -> dict | list: + """Get simulation options used for optimization. + + Args: + names: Either None (default), a string with the optimization option + name, or a list of option name strings. + + Returns: + If `names` is None, a dict in the format + {option_name: option_value} is returned. + If `names` is a string, a single element list [option_value] is + returned. + If `names` is a list, a list with one value for each option name + in names is returned: [option1_value, option2_value, ...]. + Some option values are returned as float when first initialized, + but always as strings after setOptimizationOptions is used to + change them. + + Examples: + >>> mod.getOptimizationOptions() + {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-08} + >>> mod.getOptimizationOptions("stopTime") + [1.0] + >>> mod.getOptimizationOptions(["tolerance", "stopTime"]) + [1e-08, 1.0] """ if names is None: return self._optimizeOptions From 9bae435a03020ac7ab95295bed2377a49135f74f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sun, 15 Jun 2025 00:48:34 +0200 Subject: [PATCH 44/66] Improve docstring for getSolutions() --- OMPython/ModelicaSystem.py | 45 ++++++++++++++++++++++++++++---------- 1 file changed, 33 insertions(+), 12 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 9baea9cd..344b3ea5 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -1002,20 +1002,41 @@ def simulate(self, self._simulationFlag = True - # to extract simulation results - def getSolutions(self, varList=None, resultfile=None): # 12 - """ - This method returns tuple of numpy arrays. It can be called: - •with a list of quantities name in string format as argument: it returns the simulation results of the corresponding names in the same order. Here it supports Python unpacking depending upon the number of variables assigned. - usage: - >>> getSolutions() - >>> getSolutions("Name1") - >>> getSolutions(["Name1","Name2"]) - >>> getSolutions(resultfile="c:/a.mat") - >>> getSolutions("Name1",resultfile=""c:/a.mat"") - >>> getSolutions(["Name1","Name2"],resultfile=""c:/a.mat"") + def getSolutions(self, varList: Optional[str | list[str]] = None, resultfile: Optional[str] = None) -> tuple[str] | np.ndarray: + """Extract simulation results from a result data file. + + Args: + varList: Names of variables to be extracted. Either unspecified to + get names of available variables, or a single variable name + as a string, or a list of variable names. + resultfile: Path to the result file. If unspecified, the result + file created by simulate() is used. + + Returns: + If varList is None, a tuple with names of all variables + is returned. + If varList is a string, a 1D numpy array is returned. + If varList is a list, a 2D numpy array is returned. + + Examples: + >>> mod.getSolutions() + ('a', 'der(x)', 'time', 'x') + >>> mod.getSolutions("x") + np.array([[1. , 0.90483742, 0.81873075]]) + >>> mod.getSolutions(["x", "der(x)"]) + np.array([[1. , 0.90483742 , 0.81873075], + [-1. , -0.90483742, -0.81873075]]) + >>> mod.getSolutions(resultfile="c:/a.mat") + ('a', 'der(x)', 'time', 'x') + >>> mod.getSolutions("x", resultfile="c:/a.mat") + np.array([[1. , 0.90483742, 0.81873075]]) + >>> mod.getSolutions(["x", "der(x)"], resultfile="c:/a.mat") + np.array([[1. , 0.90483742 , 0.81873075], + [-1. , -0.90483742, -0.81873075]]) """ if resultfile is None: + if self._resultfile is None: + raise ModelicaSystemError("No result file found. Run simulate() first.") result_file = self._resultfile else: result_file = pathlib.Path(resultfile) From 167453fbe939b6d43918431e038b644aca4201b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sun, 15 Jun 2025 00:59:11 +0200 Subject: [PATCH 45/66] Improve docstring for optimize() --- OMPython/ModelicaSystem.py | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 344b3ea5..d9cfcd79 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -1323,13 +1323,32 @@ def convertFmu2Mo(self, fmuName): # 20 return fileName - # to optimize model - def optimize(self): # 21 - """ - This method optimizes model according to the optimized options. It can be called: - only without any arguments - usage - >>> optimize() + def optimize(self) -> dict[str, Any]: + """Perform model-based optimization. + + Optimization options set by setOptimizationOptions() are used. + + Returns: + A dict with various values is returned. One of these values is the + path to the result file. + + Examples: + >>> mod.optimize() + {'messages': 'LOG_SUCCESS | info | The initialization finished successfully without homotopy method. ...' + 'resultFile': '/tmp/tmp68guvjhs/BangBang2021_res.mat', + 'simulationOptions': 'startTime = 0.0, stopTime = 1.0, numberOfIntervals = ' + "1000, tolerance = 1e-8, method = 'optimization', " + "fileNamePrefix = 'BangBang2021', options = '', " + "outputFormat = 'mat', variableFilter = '.*', cflags = " + "'', simflags = '-s=\\'optimization\\' " + "-optimizerNP=\\'1\\''", + 'timeBackend': 0.008684897, + 'timeCompile': 0.7546678929999999, + 'timeFrontend': 0.045438053000000006, + 'timeSimCode': 0.0018537170000000002, + 'timeSimulation': 0.266354356, + 'timeTemplates': 0.002007785, + 'timeTotal': 1.079097854} """ cName = self._modelName properties = ','.join(f"{key}={val}" for key, val in self._optimizeOptions.items()) From 0d6fdb76ed5e3c74d1526ac03236283f64aa01f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Sun, 15 Jun 2025 01:08:24 +0200 Subject: [PATCH 46/66] Improve docstring for convertMo2Fmu() --- OMPython/ModelicaSystem.py | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index d9cfcd79..147c828e 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -1280,15 +1280,22 @@ def _createCSVData(self) -> pathlib.Path: return csvFile - # to convert Modelica model to FMU - def convertMo2Fmu(self, version="2.0", fmuType="me_cs", fileNamePrefix="", includeResources=True): # 19 - """ - This method is used to generate FMU from the given Modelica model. It creates "modelName.fmu" in the current working directory. It can be called: - with no arguments - with arguments of https://build.openmodelica.org/Documentation/OpenModelica.Scripting.translateModelFMU.html - usage - >>> convertMo2Fmu() - >>> convertMo2Fmu(version="2.0", fmuType="me|cs|me_cs", fileNamePrefix="", includeResources=True) + def convertMo2Fmu(self, version: str = "2.0", fmuType: str = "me_cs", + fileNamePrefix: str = "", + includeResources: bool = True) -> str: + """Translate the model into a Functional Mockup Unit. + + Args: + See https://build.openmodelica.org/Documentation/OpenModelica.Scripting.translateModelFMU.html + + Returns: + str: Path to the created '*.fmu' file. + + Examples: + >>> mod.convertMo2Fmu() + '/tmp/tmpmhfx9umo/CauerLowPassAnalog.fmu' + >>> mod.convertMo2Fmu(version="2.0", fmuType="me|cs|me_cs", fileNamePrefix="", includeResources=True) + '/tmp/tmpmhfx9umo/CauerLowPassAnalog.fmu' """ if fileNamePrefix == "": From 60034560c906da8e052daabdfc3cfdfefe07774e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 07:11:46 +0200 Subject: [PATCH 47/66] Rename _quantitiesList to _quantities --- OMPython/ModelicaSystem.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 147c828e..77937374 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -349,7 +349,7 @@ def __init__( if modelName is None: raise ModelicaSystemError("A modelname must be provided (argument modelName)!") - self._quantitiesList: list[dict[str, Any]] = [] + self._quantities: list[dict[str, Any]] = [] self._paramlist: dict[str, str] = {} # even numerical values are stored as str self._inputlist: dict[str, list | None] = {} # _outputlist values are str before simulate(), but they can be @@ -545,7 +545,7 @@ def _xmlparse(self): if scalar["causality"] == "output": self._outputlist[scalar["name"]] = scalar["start"] - self._quantitiesList.append(scalar) + self._quantities.append(scalar) def getQuantities(self, names: Optional[str | list[str]] = None) -> list[dict]: """ @@ -591,16 +591,16 @@ def getQuantities(self, names: Optional[str | list[str]] = None) -> list[dict]: ] """ if names is None: - return self._quantitiesList + return self._quantities if isinstance(names, str): - r = [x for x in self._quantitiesList if x["name"] == names] + 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._quantitiesList if x["name"] == y] + return [x for y in names for x in self._quantities if x["name"] == y] raise ModelicaSystemError("Unhandled input for getQuantities()") From aeedf5f4a4e8364f6a7b117d7350dd0192311087 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 07:14:02 +0200 Subject: [PATCH 48/66] Rename _paramlist to _params --- OMPython/ModelicaSystem.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 77937374..660428df 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -350,7 +350,7 @@ def __init__( raise ModelicaSystemError("A modelname must be provided (argument modelName)!") self._quantities: list[dict[str, Any]] = [] - self._paramlist: dict[str, str] = {} # even numerical values are stored as str + self._params: dict[str, str] = {} # even numerical values are stored as str self._inputlist: dict[str, list | None] = {} # _outputlist values are str before simulate(), but they can be # np.float64 after simulate(). @@ -535,9 +535,9 @@ def _xmlparse(self): if scalar["variability"] == "parameter": if scalar["name"] in self._overridevariables: - self._paramlist[scalar["name"]] = self._overridevariables[scalar["name"]] + self._params[scalar["name"]] = self._overridevariables[scalar["name"]] else: - self._paramlist[scalar["name"]] = scalar["start"] + self._params[scalar["name"]] = scalar["start"] if scalar["variability"] == "continuous": self._continuouslist[scalar["name"]] = scalar["start"] if scalar["causality"] == "input": @@ -702,11 +702,11 @@ def getParameters(self, names: Optional[str | list[str]] = None) -> dict[str, st ['1.23', '4.56'] """ if names is None: - return self._paramlist + return self._params elif isinstance(names, str): - return [self._paramlist[names]] + return [self._params[names]] elif isinstance(names, list): - return [self._paramlist[x] for x in names] + return [self._params[x] for x in names] raise ModelicaSystemError("Unhandled input for getParameters()") @@ -1138,7 +1138,7 @@ def setParameters(self, pvals): # 14 >>> setParameters("Name=value") >>> setParameters(["Name1=value1","Name2=value2"]) """ - return self._setMethodHelper(pvals, self._paramlist, "parameter", self._overridevariables) + return self._setMethodHelper(pvals, self._params, "parameter", self._overridevariables) def isParameterChangeable(self, name, value): q = self.getQuantities(name) From 6f7b82ab0daea3ead3ef3d23c046a35c1c23d63d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 07:16:14 +0200 Subject: [PATCH 49/66] Rename _inputlist to _inputs --- OMPython/ModelicaSystem.py | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 660428df..636a7b1b 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -351,7 +351,7 @@ def __init__( self._quantities: list[dict[str, Any]] = [] self._params: dict[str, str] = {} # even numerical values are stored as str - self._inputlist: dict[str, list | None] = {} + self._inputs: dict[str, list | None] = {} # _outputlist values are str before simulate(), but they can be # np.float64 after simulate(). self._outputlist: dict[str, Any] = {} @@ -541,7 +541,7 @@ def _xmlparse(self): if scalar["variability"] == "continuous": self._continuouslist[scalar["name"]] = scalar["start"] if scalar["causality"] == "input": - self._inputlist[scalar["name"]] = scalar["start"] + self._inputs[scalar["name"]] = scalar["start"] if scalar["causality"] == "output": self._outputlist[scalar["name"]] = scalar["start"] @@ -736,11 +736,11 @@ def getInputs(self, names: Optional[str | list[str]] = None) -> dict | list: # [[(0.0, 0.0), (1.0, 1.0)], None] """ if names is None: - return self._inputlist + return self._inputs elif isinstance(names, str): - return [self._inputlist[names]] + return [self._inputs[names]] elif isinstance(names, list): - return [self._inputlist[x] for x in names] + return [self._inputs[x] for x in names] raise ModelicaSystemError("Unhandled input for getInputs()") @@ -969,13 +969,13 @@ def simulate(self, om_cmd.arg_set(key="overrideFile", val=overrideFile.as_posix()) if self._inputFlag: # if model has input quantities - for i in self._inputlist: - val = self._inputlist[i] + for i in self._inputs: + val = self._inputs[i] if val is None: val = [(float(self._simulateOptions["startTime"]), 0.0), (float(self._simulateOptions["stopTime"]), 0.0)] - self._inputlist[i] = [(float(self._simulateOptions["startTime"]), 0.0), - (float(self._simulateOptions["stopTime"]), 0.0)] + self._inputs[i] = [(float(self._simulateOptions["startTime"]), 0.0), + (float(self._simulateOptions["stopTime"]), 0.0)] if float(self._simulateOptions["startTime"]) != val[0][0]: raise ModelicaSystemError(f"startTime not matched for Input {i}!") if float(self._simulateOptions["stopTime"]) != val[-1][0]: @@ -1191,14 +1191,14 @@ def setInputs(self, name): # 15 if isinstance(name, str): name = self._strip_space(name) value = name.split("=") - if value[0] in self._inputlist: + if value[0] in self._inputs: tmpvalue = eval(value[1]) if isinstance(tmpvalue, (int, float)): - self._inputlist[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), - (float(self._simulateOptions["stopTime"]), float(value[1]))] + self._inputs[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), + (float(self._simulateOptions["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): self._checkValidInputs(tmpvalue) - self._inputlist[value[0]] = tmpvalue + self._inputs[value[0]] = tmpvalue self._inputFlag = True else: raise ModelicaSystemError(f"{value[0]} is not an input") @@ -1206,14 +1206,14 @@ def setInputs(self, name): # 15 name = self._strip_space(name) for var in name: value = var.split("=") - if value[0] in self._inputlist: + if value[0] in self._inputs: tmpvalue = eval(value[1]) if isinstance(tmpvalue, (int, float)): - self._inputlist[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), - (float(self._simulateOptions["stopTime"]), float(value[1]))] + self._inputs[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), + (float(self._simulateOptions["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): self._checkValidInputs(tmpvalue) - self._inputlist[value[0]] = tmpvalue + self._inputs[value[0]] = tmpvalue self._inputFlag = True else: raise ModelicaSystemError(f"{value[0]} is not an input!") @@ -1237,7 +1237,7 @@ def _createCSVData(self) -> pathlib.Path: # Replace None inputs with a default constant zero signal inputs: dict[str, list[tuple[float, float]]] = {} - for input_name, input_signal in self._inputlist.items(): + for input_name, input_signal in self._inputs.items(): if input_signal is None: inputs[input_name] = [(start_time, 0.0), (stop_time, 0.0)] else: From 2fb6fee21eaeac8e6f84dee7b5f5402650cdcf84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 07:17:32 +0200 Subject: [PATCH 50/66] Rename _outputlist to _outputs --- OMPython/ModelicaSystem.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 636a7b1b..640e06c0 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -352,9 +352,9 @@ def __init__( self._quantities: list[dict[str, Any]] = [] self._params: dict[str, str] = {} # even numerical values are stored as str self._inputs: dict[str, list | None] = {} - # _outputlist values are str before simulate(), but they can be + # _outputs values are str before simulate(), but they can be # np.float64 after simulate(). - self._outputlist: dict[str, Any] = {} + self._outputs: dict[str, Any] = {} # same for _continuouslist self._continuouslist: dict[str, Any] = {} self._simulateOptions: dict[str, str] = {} @@ -543,7 +543,7 @@ def _xmlparse(self): if scalar["causality"] == "input": self._inputs[scalar["name"]] = scalar["start"] if scalar["causality"] == "output": - self._outputlist[scalar["name"]] = scalar["start"] + self._outputs[scalar["name"]] = scalar["start"] self._quantities.append(scalar) @@ -781,30 +781,30 @@ def getOutputs(self, names: Optional[str | list[str]] = None): # 7 """ if not self._simulationFlag: if names is None: - return self._outputlist + return self._outputs elif isinstance(names, str): - return [self._outputlist[names]] + return [self._outputs[names]] else: - return [self._outputlist[x] for x in names] + return [self._outputs[x] for x in names] else: if names is None: - for i in self._outputlist: + for i in self._outputs: value = self.getSolutions(i) - self._outputlist[i] = value[0][-1] - return self._outputlist + self._outputs[i] = value[0][-1] + return self._outputs elif isinstance(names, str): - if names in self._outputlist: + if names in self._outputs: value = self.getSolutions(names) - self._outputlist[names] = value[0][-1] - return [self._outputlist[names]] + self._outputs[names] = value[0][-1] + return [self._outputs[names]] else: raise KeyError(names) elif isinstance(names, list): valuelist = [] for i in names: - if i in self._outputlist: + if i in self._outputs: value = self.getSolutions(i) - self._outputlist[i] = value[0][-1] + self._outputs[i] = value[0][-1] valuelist.append(value[0][-1]) else: raise KeyError(i) From afd239f51a684d3d2c1be5bf18318af180f8fd6a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 07:18:49 +0200 Subject: [PATCH 51/66] Rename _continuouslist to _continuous --- OMPython/ModelicaSystem.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 640e06c0..e139ffca 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -355,8 +355,8 @@ def __init__( # _outputs values are str before simulate(), but they can be # np.float64 after simulate(). self._outputs: dict[str, Any] = {} - # same for _continuouslist - self._continuouslist: dict[str, Any] = {} + # same for _continuous + self._continuous: dict[str, Any] = {} self._simulateOptions: dict[str, str] = {} self._overridevariables: dict[str, str] = {} self._simoptionsoverride: dict[str, str] = {} @@ -539,7 +539,7 @@ def _xmlparse(self): else: self._params[scalar["name"]] = scalar["start"] if scalar["variability"] == "continuous": - self._continuouslist[scalar["name"]] = scalar["start"] + self._continuous[scalar["name"]] = scalar["start"] if scalar["causality"] == "input": self._inputs[scalar["name"]] = scalar["start"] if scalar["causality"] == "output": @@ -641,37 +641,37 @@ def getContinuous(self, names: Optional[str | list[str]] = None): """ if not self._simulationFlag: if names is None: - return self._continuouslist + return self._continuous if isinstance(names, str): - return [self._continuouslist[names]] + return [self._continuous[names]] if isinstance(names, list): - return [self._continuouslist[x] for x in names] + return [self._continuous[x] for x in names] else: if names is None: - for i in self._continuouslist: + for i in self._continuous: try: value = self.getSolutions(i) - self._continuouslist[i] = value[0][-1] + self._continuous[i] = value[0][-1] except (OMCSessionException, ModelicaSystemError) as ex: raise ModelicaSystemError(f"{i} could not be computed") from ex - return self._continuouslist + return self._continuous if isinstance(names, str): - if names in self._continuouslist: + if names in self._continuous: value = self.getSolutions(names) - self._continuouslist[names] = value[0][-1] - return [self._continuouslist[names]] + self._continuous[names] = value[0][-1] + return [self._continuous[names]] else: raise ModelicaSystemError(f"{names} is not continuous") if isinstance(names, list): valuelist = [] for i in names: - if i in self._continuouslist: + if i in self._continuous: value = self.getSolutions(i) - self._continuouslist[i] = value[0][-1] + self._continuous[i] = value[0][-1] valuelist.append(value[0][-1]) else: raise ModelicaSystemError(f"{i} is not continuous") @@ -1128,7 +1128,7 @@ def setContinuous(self, cvals): # 13 >>> setContinuous("Name=value") >>> setContinuous(["Name1=value1","Name2=value2"]) """ - return self._setMethodHelper(cvals, self._continuouslist, "continuous", self._overridevariables) + return self._setMethodHelper(cvals, self._continuous, "continuous", self._overridevariables) def setParameters(self, pvals): # 14 """ From 5930d67d678c33b8cc171f7d515aa46a4b1daba4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 07:20:00 +0200 Subject: [PATCH 52/66] Rename _simulateOptions to _simulate_options --- OMPython/ModelicaSystem.py | 40 +++++++++++++++++++------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index e139ffca..cd195fdf 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -357,7 +357,7 @@ def __init__( self._outputs: dict[str, Any] = {} # same for _continuous self._continuous: dict[str, Any] = {} - self._simulateOptions: dict[str, str] = {} + self._simulate_options: dict[str, str] = {} self._overridevariables: dict[str, str] = {} self._simoptionsoverride: dict[str, str] = {} self._linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} @@ -518,7 +518,7 @@ def _xmlparse(self): for attr in rootCQ.iter('DefaultExperiment'): for key in ("startTime", "stopTime", "stepSize", "tolerance", "solver", "outputFormat"): - self._simulateOptions[key] = attr.get(key) + self._simulate_options[key] = attr.get(key) for sv in rootCQ.iter('ScalarVariable'): scalar = {} @@ -837,11 +837,11 @@ def getSimulationOptions(self, names: Optional[str | list[str]] = None) -> dict[ ['1.1e-08', '1.234'] """ if names is None: - return self._simulateOptions + return self._simulate_options elif isinstance(names, str): - return [self._simulateOptions[names]] + return [self._simulate_options[names]] elif isinstance(names, list): - return [self._simulateOptions[x] for x in names] + return [self._simulate_options[x] for x in names] raise ModelicaSystemError("Unhandled input for getSimulationOptions()") @@ -972,13 +972,13 @@ def simulate(self, for i in self._inputs: val = self._inputs[i] if val is None: - val = [(float(self._simulateOptions["startTime"]), 0.0), - (float(self._simulateOptions["stopTime"]), 0.0)] - self._inputs[i] = [(float(self._simulateOptions["startTime"]), 0.0), - (float(self._simulateOptions["stopTime"]), 0.0)] - if float(self._simulateOptions["startTime"]) != val[0][0]: + val = [(float(self._simulate_options["startTime"]), 0.0), + (float(self._simulate_options["stopTime"]), 0.0)] + self._inputs[i] = [(float(self._simulate_options["startTime"]), 0.0), + (float(self._simulate_options["stopTime"]), 0.0)] + if float(self._simulate_options["startTime"]) != val[0][0]: raise ModelicaSystemError(f"startTime not matched for Input {i}!") - if float(self._simulateOptions["stopTime"]) != val[-1][0]: + if float(self._simulate_options["stopTime"]) != val[-1][0]: raise ModelicaSystemError(f"stopTime not matched for Input {i}!") self._csvFile = self._createCSVData() # create csv file @@ -1158,7 +1158,7 @@ def setSimulationOptions(self, simOptions): # 16 >>> setSimulationOptions("Name=value") >>> setSimulationOptions(["Name1=value1","Name2=value2"]) """ - return self._setMethodHelper(simOptions, self._simulateOptions, "simulation-option", self._simoptionsoverride) + return self._setMethodHelper(simOptions, self._simulate_options, "simulation-option", self._simoptionsoverride) def setLinearizationOptions(self, linearizationOptions): # 18 """ @@ -1194,8 +1194,8 @@ def setInputs(self, name): # 15 if value[0] in self._inputs: tmpvalue = eval(value[1]) if isinstance(tmpvalue, (int, float)): - self._inputs[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), - (float(self._simulateOptions["stopTime"]), float(value[1]))] + self._inputs[value[0]] = [(float(self._simulate_options["startTime"]), float(value[1])), + (float(self._simulate_options["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): self._checkValidInputs(tmpvalue) self._inputs[value[0]] = tmpvalue @@ -1209,8 +1209,8 @@ def setInputs(self, name): # 15 if value[0] in self._inputs: tmpvalue = eval(value[1]) if isinstance(tmpvalue, (int, float)): - self._inputs[value[0]] = [(float(self._simulateOptions["startTime"]), float(value[1])), - (float(self._simulateOptions["stopTime"]), float(value[1]))] + self._inputs[value[0]] = [(float(self._simulate_options["startTime"]), float(value[1])), + (float(self._simulate_options["stopTime"]), float(value[1]))] elif isinstance(tmpvalue, list): self._checkValidInputs(tmpvalue) self._inputs[value[0]] = tmpvalue @@ -1224,7 +1224,7 @@ def _checkValidInputs(self, name): for l in name: if isinstance(l, tuple): # if l[0] < float(self.simValuesList[0]): - if l[0] < float(self._simulateOptions["startTime"]): + if l[0] < float(self._simulate_options["startTime"]): raise ModelicaSystemError('Input time value is less than simulation startTime') if len(l) != 2: raise ModelicaSystemError(f'Value for {l} is in incorrect format!') @@ -1232,8 +1232,8 @@ def _checkValidInputs(self, name): raise ModelicaSystemError('Error!!! Value must be in tuple format') def _createCSVData(self) -> pathlib.Path: - start_time: float = float(self._simulateOptions["startTime"]) - stop_time: float = float(self._simulateOptions["stopTime"]) + start_time: float = float(self._simulate_options["startTime"]) + stop_time: float = float(self._simulate_options["stopTime"]) # Replace None inputs with a default constant zero signal inputs: dict[str, list[tuple[float, float]]] = {} @@ -1420,7 +1420,7 @@ def load_module_from_path(module_name, file_path): tupleList = nameVal.get(n) if tupleList is not None: for l in tupleList: - if l[0] < float(self._simulateOptions["startTime"]): + if l[0] < float(self._simulate_options["startTime"]): raise ModelicaSystemError('Input time value is less than simulation startTime') self._csvFile = self._createCSVData() om_cmd.arg_set(key="csvInput", val=self._csvFile.as_posix()) From 997e9b6ad9cf12151ee6fafd55096e7eac318a59 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 07:20:57 +0200 Subject: [PATCH 53/66] Rename _overridevariables to _override_variables --- OMPython/ModelicaSystem.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index cd195fdf..3326ec70 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -358,7 +358,7 @@ def __init__( # same for _continuous self._continuous: dict[str, Any] = {} self._simulate_options: dict[str, str] = {} - self._overridevariables: dict[str, str] = {} + self._override_variables: dict[str, str] = {} self._simoptionsoverride: dict[str, str] = {} self._linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} self._optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, @@ -534,8 +534,8 @@ def _xmlparse(self): scalar["unit"] = att.get('unit') if scalar["variability"] == "parameter": - if scalar["name"] in self._overridevariables: - self._params[scalar["name"]] = self._overridevariables[scalar["name"]] + 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": @@ -958,8 +958,8 @@ def simulate(self, om_cmd.args_set(args=simargs) overrideFile = self._tempdir / f"{self._modelName}_override.txt" - if self._overridevariables or self._simoptionsoverride: - tmpdict = self._overridevariables.copy() + if self._override_variables or self._simoptionsoverride: + tmpdict = self._override_variables.copy() tmpdict.update(self._simoptionsoverride) # write to override file with open(file=overrideFile, mode="w", encoding="utf-8") as fh: @@ -1128,7 +1128,7 @@ def setContinuous(self, cvals): # 13 >>> setContinuous("Name=value") >>> setContinuous(["Name1=value1","Name2=value2"]) """ - return self._setMethodHelper(cvals, self._continuous, "continuous", self._overridevariables) + return self._setMethodHelper(cvals, self._continuous, "continuous", self._override_variables) def setParameters(self, pvals): # 14 """ @@ -1138,7 +1138,7 @@ def setParameters(self, pvals): # 14 >>> setParameters("Name=value") >>> setParameters(["Name1=value1","Name2=value2"]) """ - return self._setMethodHelper(pvals, self._params, "parameter", self._overridevariables) + return self._setMethodHelper(pvals, self._params, "parameter", self._override_variables) def isParameterChangeable(self, name, value): q = self.getQuantities(name) @@ -1407,7 +1407,7 @@ def load_module_from_path(module_name, file_path): overrideLinearFile = self._tempdir / f'{self._modelName}_override_linear.txt' with open(file=overrideLinearFile, mode="w", encoding="utf-8") as fh: - for key, value in self._overridevariables.items(): + for key, value in self._override_variables.items(): fh.write(f"{key}={value}\n") for key, value in self._linearOptions.items(): fh.write(f"{key}={value}\n") From 619fdb5adaa9911f216d142bde955afcb0bcc7e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 14:53:03 +0200 Subject: [PATCH 54/66] Rename _simoptionsoverride to _simulate_options_override --- OMPython/ModelicaSystem.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 3326ec70..76f65c1a 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -359,7 +359,7 @@ def __init__( self._continuous: dict[str, Any] = {} self._simulate_options: dict[str, str] = {} self._override_variables: dict[str, str] = {} - self._simoptionsoverride: dict[str, str] = {} + self._simulate_options_override: dict[str, str] = {} self._linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} self._optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-8} @@ -958,9 +958,9 @@ def simulate(self, om_cmd.args_set(args=simargs) overrideFile = self._tempdir / f"{self._modelName}_override.txt" - if self._override_variables or self._simoptionsoverride: + if self._override_variables or self._simulate_options_override: tmpdict = self._override_variables.copy() - tmpdict.update(self._simoptionsoverride) + tmpdict.update(self._simulate_options_override) # write to override file with open(file=overrideFile, mode="w", encoding="utf-8") as fh: for key, value in tmpdict.items(): @@ -1158,7 +1158,7 @@ def setSimulationOptions(self, simOptions): # 16 >>> setSimulationOptions("Name=value") >>> setSimulationOptions(["Name1=value1","Name2=value2"]) """ - return self._setMethodHelper(simOptions, self._simulate_options, "simulation-option", self._simoptionsoverride) + return self._setMethodHelper(simOptions, self._simulate_options, "simulation-option", self._simulate_options_override) def setLinearizationOptions(self, linearizationOptions): # 18 """ From c1b0e0cb246a1fffcb92086ea66453a800684ff7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 14:53:59 +0200 Subject: [PATCH 55/66] Rename _linearOptions to _linearization_options --- OMPython/ModelicaSystem.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 76f65c1a..2a5a8864 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -360,7 +360,7 @@ def __init__( self._simulate_options: dict[str, str] = {} self._override_variables: dict[str, str] = {} self._simulate_options_override: dict[str, str] = {} - self._linearOptions = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} + self._linearization_options = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} self._optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-8} self._linearinputs: list[str] = [] # linearization input list @@ -872,11 +872,11 @@ def getLinearizationOptions(self, names: Optional[str | list[str]] = None) -> di [1e-08, 1.0] """ if names is None: - return self._linearOptions + return self._linearization_options elif isinstance(names, str): - return [self._linearOptions[names]] + return [self._linearization_options[names]] elif isinstance(names, list): - return [self._linearOptions[x] for x in names] + return [self._linearization_options[x] for x in names] raise ModelicaSystemError("Unhandled input for getLinearizationOptions()") @@ -1168,7 +1168,7 @@ def setLinearizationOptions(self, linearizationOptions): # 18 >>> setLinearizationOptions("Name=value") >>> setLinearizationOptions(["Name1=value1","Name2=value2"]) """ - return self._setMethodHelper(linearizationOptions, self._linearOptions, "Linearization-option", None) + return self._setMethodHelper(linearizationOptions, self._linearization_options, "Linearization-option", None) def setOptimizationOptions(self, optimizationOptions): # 17 """ @@ -1409,7 +1409,7 @@ def load_module_from_path(module_name, file_path): with open(file=overrideLinearFile, mode="w", encoding="utf-8") as fh: for key, value in self._override_variables.items(): fh.write(f"{key}={value}\n") - for key, value in self._linearOptions.items(): + for key, value in self._linearization_options.items(): fh.write(f"{key}={value}\n") om_cmd.arg_set(key="overrideFile", val=overrideLinearFile.as_posix()) @@ -1425,7 +1425,7 @@ def load_module_from_path(module_name, file_path): self._csvFile = self._createCSVData() om_cmd.arg_set(key="csvInput", val=self._csvFile.as_posix()) - om_cmd.arg_set(key="l", val=str(lintime or self._linearOptions["stopTime"])) + om_cmd.arg_set(key="l", val=str(lintime or self._linearization_options["stopTime"])) # allow runtime simulation flags from user input if simflags is not None: From eeadc3cf07fe3407cde4a6c9265f2e397106949c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 14:55:44 +0200 Subject: [PATCH 56/66] Rename _optimizeOptions to _optimization_options --- OMPython/ModelicaSystem.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 2a5a8864..a1a03e99 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -361,8 +361,8 @@ def __init__( self._override_variables: dict[str, str] = {} self._simulate_options_override: dict[str, str] = {} self._linearization_options = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} - self._optimizeOptions = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, - 'tolerance': 1e-8} + self._optimization_options = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, + 'tolerance': 1e-8} self._linearinputs: list[str] = [] # linearization input list self._linearoutputs: list[str] = [] # linearization output list self._linearstates: list[str] = [] # linearization states list @@ -907,11 +907,11 @@ def getOptimizationOptions(self, names: Optional[str | list[str]] = None) -> dic [1e-08, 1.0] """ if names is None: - return self._optimizeOptions + return self._optimization_options elif isinstance(names, str): - return [self._optimizeOptions[names]] + return [self._optimization_options[names]] elif isinstance(names, list): - return [self._optimizeOptions[x] for x in names] + return [self._optimization_options[x] for x in names] raise ModelicaSystemError("Unhandled input for getOptimizationOptions()") @@ -1178,7 +1178,7 @@ def setOptimizationOptions(self, optimizationOptions): # 17 >>> setOptimizationOptions("Name=value") >>> setOptimizationOptions(["Name1=value1","Name2=value2"]) """ - return self._setMethodHelper(optimizationOptions, self._optimizeOptions, "optimization-option", None) + return self._setMethodHelper(optimizationOptions, self._optimization_options, "optimization-option", None) def setInputs(self, name): # 15 """ @@ -1358,7 +1358,7 @@ def optimize(self) -> dict[str, Any]: 'timeTotal': 1.079097854} """ cName = self._modelName - properties = ','.join(f"{key}={val}" for key, val in self._optimizeOptions.items()) + properties = ','.join(f"{key}={val}" for key, val in self._optimization_options.items()) self.setCommandLineOptions("-g=Optimica") optimizeResult = self._requestApi('optimize', cName, properties) From c38c01949d5094f9560af74348d08529f492fd1c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 14:57:15 +0200 Subject: [PATCH 57/66] Rename _linearinputs to _linearized_inputs --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index a1a03e99..09c98c0e 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -363,7 +363,7 @@ def __init__( self._linearization_options = {'startTime': 0.0, 'stopTime': 1.0, 'stepSize': 0.002, 'tolerance': 1e-8} self._optimization_options = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-8} - self._linearinputs: list[str] = [] # linearization input list + self._linearized_inputs: list[str] = [] # linearization input list self._linearoutputs: list[str] = [] # linearization output list self._linearstates: list[str] = [] # linearization states list @@ -1459,7 +1459,7 @@ def load_module_from_path(module_name, file_path): result = module.linearized_model() (n, m, p, x0, u0, A, B, C, D, stateVars, inputVars, outputVars) = result - self._linearinputs = inputVars + self._linearized_inputs = inputVars self._linearoutputs = outputVars self._linearstates = stateVars return LinearizationResult(n, m, p, A, B, C, D, x0, u0, stateVars, @@ -1469,7 +1469,7 @@ def load_module_from_path(module_name, file_path): def getLinearInputs(self) -> list[str]: """Get names of input variables of the linearized model.""" - return self._linearinputs + return self._linearized_inputs def getLinearOutputs(self) -> list[str]: """Get names of output variables of the linearized model.""" From bad9c992db7073a5534ecbaa5e41a37e973a5bf0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 14:57:58 +0200 Subject: [PATCH 58/66] Rename _linearoutputs to _linearized_outputs --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 09c98c0e..c42c2b42 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -364,7 +364,7 @@ def __init__( self._optimization_options = {'startTime': 0.0, 'stopTime': 1.0, 'numberOfIntervals': 500, 'stepSize': 0.002, 'tolerance': 1e-8} self._linearized_inputs: list[str] = [] # linearization input list - self._linearoutputs: list[str] = [] # linearization output list + self._linearized_outputs: list[str] = [] # linearization output list self._linearstates: list[str] = [] # linearization states list if session is not None: @@ -1460,7 +1460,7 @@ def load_module_from_path(module_name, file_path): result = module.linearized_model() (n, m, p, x0, u0, A, B, C, D, stateVars, inputVars, outputVars) = result self._linearized_inputs = inputVars - self._linearoutputs = outputVars + self._linearized_outputs = outputVars self._linearstates = stateVars return LinearizationResult(n, m, p, A, B, C, D, x0, u0, stateVars, inputVars, outputVars) @@ -1473,7 +1473,7 @@ def getLinearInputs(self) -> list[str]: def getLinearOutputs(self) -> list[str]: """Get names of output variables of the linearized model.""" - return self._linearoutputs + return self._linearized_outputs def getLinearStates(self) -> list[str]: """Get names of state variables of the linearized model.""" From dcaf2cfde0cabd1bd0f566690311d4987e887fe2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 14:59:04 +0200 Subject: [PATCH 59/66] Rename _linearstates to _linearized_states --- OMPython/ModelicaSystem.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index c42c2b42..238cbe3a 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -365,7 +365,7 @@ def __init__( 'tolerance': 1e-8} self._linearized_inputs: list[str] = [] # linearization input list self._linearized_outputs: list[str] = [] # linearization output list - self._linearstates: list[str] = [] # linearization states list + self._linearized_states: list[str] = [] # linearization states list if session is not None: if not isinstance(session, OMCSessionZMQ): @@ -1461,7 +1461,7 @@ def load_module_from_path(module_name, file_path): (n, m, p, x0, u0, A, B, C, D, stateVars, inputVars, outputVars) = result self._linearized_inputs = inputVars self._linearized_outputs = outputVars - self._linearstates = stateVars + self._linearized_states = stateVars return LinearizationResult(n, m, p, A, B, C, D, x0, u0, stateVars, inputVars, outputVars) except ModuleNotFoundError as ex: @@ -1477,4 +1477,4 @@ def getLinearOutputs(self) -> list[str]: def getLinearStates(self) -> list[str]: """Get names of state variables of the linearized model.""" - return self._linearstates + return self._linearized_states From 257448501bb69284d76134216d9b50732a5ce083 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 15:00:07 +0200 Subject: [PATCH 60/66] Rename _xmlFile to _xml_file --- OMPython/ModelicaSystem.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 238cbe3a..ca24bc6c 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -383,7 +383,7 @@ def __init__( if not isinstance(lmodel, list): raise ModelicaSystemError(f"Invalid input type for lmodel: {type(lmodel)} - list expected!") - self._xmlFile = None + self._xml_file = None self._lmodel = lmodel # may be needed if model is derived from other model self._modelName = modelName # Model class name self._fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name @@ -482,7 +482,7 @@ def buildModel(self, variableFilter: Optional[str] = None): buildModelResult = self._requestApi("buildModel", self._modelName, properties=varFilter) logger.debug("OM model build result: %s", buildModelResult) - self._xmlFile = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1] + self._xml_file = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1] self._xmlparse() def sendExpression(self, expr: str, parsed: bool = True): @@ -510,10 +510,10 @@ def _requestApi(self, apiName, entity=None, properties=None): # 2 return self.sendExpression(exp) def _xmlparse(self): - if not self._xmlFile.is_file(): - raise ModelicaSystemError(f"XML file not generated: {self._xmlFile}") + if not self._xml_file.is_file(): + raise ModelicaSystemError(f"XML file not generated: {self._xml_file}") - tree = ET.parse(self._xmlFile) + tree = ET.parse(self._xml_file) rootCQ = tree.getroot() for attr in rootCQ.iter('DefaultExperiment'): for key in ("startTime", "stopTime", "stepSize", "tolerance", @@ -1396,7 +1396,7 @@ def load_module_from_path(module_name, file_path): return module_def - if self._xmlFile is None: + if self._xml_file is None: raise ModelicaSystemError( "Linearization cannot be performed as the model is not build, " "use ModelicaSystem() to build the model first" From d89cd2978c96e987585c2e74189f665c9d517e16 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 15:01:37 +0200 Subject: [PATCH 61/66] Rename _modelName to _model_name --- OMPython/ModelicaSystem.py | 36 ++++++++++++++++----------------- tests/test_ModelicaSystemCmd.py | 2 +- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index ca24bc6c..488dcae4 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -117,7 +117,7 @@ class ModelicaSystemCmd: def __init__(self, runpath: pathlib.Path, modelname: str, timeout: Optional[float] = None) -> None: self._runpath = pathlib.Path(runpath).resolve().absolute() - self._modelname = modelname + self._model_name = modelname self._timeout = timeout self._args: dict[str, str | None] = {} self._arg_override: dict[str, str] = {} @@ -179,9 +179,9 @@ def args_set(self, args: dict[str, Optional[str | dict[str, str]]]) -> None: def get_exe(self) -> pathlib.Path: """Get the path to the compiled model executable.""" if platform.system() == "Windows": - path_exe = self._runpath / f"{self._modelname}.exe" + path_exe = self._runpath / f"{self._model_name}.exe" else: - path_exe = self._runpath / self._modelname + path_exe = self._runpath / self._model_name if not path_exe.exists(): raise ModelicaSystemError(f"Application file path not found: {path_exe}") @@ -221,7 +221,7 @@ def run(self) -> int: path_dll = "" # set the process environment from the generated .bat file in windows which should have all the dependencies - path_bat = self._runpath / f"{self._modelname}.bat" + path_bat = self._runpath / f"{self._model_name}.bat" if not path_bat.exists(): raise ModelicaSystemError("Batch file (*.bat) does not exist " + str(path_bat)) @@ -385,7 +385,7 @@ def __init__( self._xml_file = None self._lmodel = lmodel # may be needed if model is derived from other model - self._modelName = modelName # Model class name + self._model_name = modelName # Model class name self._fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self._inputFlag = False # for model with input quantity self._simulationFlag = False # if the model is simulated? @@ -479,7 +479,7 @@ def buildModel(self, variableFilter: Optional[str] = None): else: varFilter = 'variableFilter=".*"' - buildModelResult = self._requestApi("buildModel", self._modelName, properties=varFilter) + buildModelResult = self._requestApi("buildModel", self._model_name, properties=varFilter) logger.debug("OM model build result: %s", buildModelResult) self._xml_file = pathlib.Path(buildModelResult[0]).parent / buildModelResult[1] @@ -938,11 +938,11 @@ def simulate(self, mod.simulate(simargs={"noEventEmit": None, "noRestart": None, "override": "override": {"e": 0.3, "g": 10}}) # using simargs """ - om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._modelName, timeout=timeout) + om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._model_name, timeout=timeout) if resultfile is None: # default result file generated by OM - self._resultfile = self._tempdir / f"{self._modelName}_res.mat" + self._resultfile = self._tempdir / f"{self._model_name}_res.mat" elif os.path.exists(resultfile): self._resultfile = pathlib.Path(resultfile) else: @@ -957,7 +957,7 @@ def simulate(self, if simargs: om_cmd.args_set(args=simargs) - overrideFile = self._tempdir / f"{self._modelName}_override.txt" + overrideFile = self._tempdir / f"{self._model_name}_override.txt" if self._override_variables or self._simulate_options_override: tmpdict = self._override_variables.copy() tmpdict.update(self._simulate_options_override) @@ -1145,7 +1145,7 @@ def isParameterChangeable(self, name, value): if q[0]["changeable"] == "false": logger.debug(f"setParameters() failed : It is not possible to set the following signal {repr(name)}. " "It seems to be structural, final, protected or evaluated or has a non-constant binding, " - f"use sendExpression(\"setParameterValue({self._modelName}, {name}, {value})\") " + f"use sendExpression(\"setParameterValue({self._model_name}, {name}, {value})\") " "and rebuild the model using buildModel() API") return False return True @@ -1272,7 +1272,7 @@ def _createCSVData(self) -> pathlib.Path: ] csv_rows.append(row) - csvFile = self._tempdir / f'{self._modelName}.csv' + csvFile = self._tempdir / f'{self._model_name}.csv' with open(file=csvFile, mode="w", encoding="utf-8", newline="") as fh: writer = csv.writer(fh) @@ -1299,13 +1299,13 @@ def convertMo2Fmu(self, version: str = "2.0", fmuType: str = "me_cs", """ if fileNamePrefix == "": - fileNamePrefix = self._modelName + fileNamePrefix = self._model_name if includeResources: includeResourcesStr = "true" else: includeResourcesStr = "false" properties = f'version="{version}", fmuType="{fmuType}", fileNamePrefix="{fileNamePrefix}", includeResources={includeResourcesStr}' - fmu = self._requestApi('buildModelFMU', self._modelName, properties) + fmu = self._requestApi('buildModelFMU', self._model_name, properties) # report proper error message if not os.path.exists(fmu): @@ -1357,7 +1357,7 @@ def optimize(self) -> dict[str, Any]: 'timeTemplates': 0.002007785, 'timeTotal': 1.079097854} """ - cName = self._modelName + cName = self._model_name properties = ','.join(f"{key}={val}" for key, val in self._optimization_options.items()) self.setCommandLineOptions("-g=Optimica") optimizeResult = self._requestApi('optimize', cName, properties) @@ -1402,9 +1402,9 @@ def load_module_from_path(module_name, file_path): "use ModelicaSystem() to build the model first" ) - om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._modelName, timeout=timeout) + om_cmd = ModelicaSystemCmd(runpath=self._tempdir, modelname=self._model_name, timeout=timeout) - overrideLinearFile = self._tempdir / f'{self._modelName}_override_linear.txt' + overrideLinearFile = self._tempdir / f'{self._model_name}_override_linear.txt' with open(file=overrideLinearFile, mode="w", encoding="utf-8") as fh: for key, value in self._override_variables.items(): @@ -1443,9 +1443,9 @@ def load_module_from_path(module_name, file_path): # code to get the matrix and linear inputs, outputs and states linearFile = self._tempdir / "linearized_model.py" - # support older openmodelica versions before OpenModelica v1.16.2 where linearize() generates "linear_modelname.mo" file + # support older openmodelica versions before OpenModelica v1.16.2 where linearize() generates "linear_model_name.mo" file if not linearFile.exists(): - linearFile = pathlib.Path(f'linear_{self._modelName}.py') + linearFile = pathlib.Path(f'linear_{self._model_name}.py') if not linearFile.exists(): raise ModelicaSystemError(f"Linearization failed: {linearFile} not found!") diff --git a/tests/test_ModelicaSystemCmd.py b/tests/test_ModelicaSystemCmd.py index 20b61045..3b28699c 100644 --- a/tests/test_ModelicaSystemCmd.py +++ b/tests/test_ModelicaSystemCmd.py @@ -18,7 +18,7 @@ def model_firstorder(tmp_path): @pytest.fixture def mscmd_firstorder(model_firstorder): mod = OMPython.ModelicaSystem(fileName=model_firstorder.as_posix(), modelName="M") - mscmd = OMPython.ModelicaSystemCmd(runpath=mod.getWorkDirectory(), modelname=mod._modelName) + mscmd = OMPython.ModelicaSystemCmd(runpath=mod.getWorkDirectory(), modelname=mod._model_name) return mscmd From 09d7678231d8b267559319581489891bbc369270 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 15:02:40 +0200 Subject: [PATCH 62/66] Rename _fileName to _file_name --- OMPython/ModelicaSystem.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 488dcae4..8fe975e4 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -386,15 +386,15 @@ def __init__( self._xml_file = None self._lmodel = lmodel # may be needed if model is derived from other model self._model_name = modelName # Model class name - self._fileName = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name + self._file_name = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self._inputFlag = False # for model with input quantity self._simulationFlag = False # if the model is simulated? self._csvFile: Optional[pathlib.Path] = None # for storing inputs condition self._resultfile: Optional[pathlib.Path] = None # for storing result file self._variableFilter = variableFilter - if self._fileName is not None and not self._fileName.is_file(): # if file does not exist - raise IOError(f"{self._fileName} does not exist!") + if self._file_name is not None and not self._file_name.is_file(): # if file does not exist + raise IOError(f"{self._file_name} does not exist!") # set default command Line Options for linearization as # linearize() will use the simulation executable and runtime @@ -404,9 +404,9 @@ def __init__( self._tempdir = self.setTempDirectory(customBuildDirectory) - if self._fileName is not None: + if self._file_name is not None: self._loadLibrary(lmodel=self._lmodel) - self._loadFile(fileName=self._fileName) + self._loadFile(fileName=self._file_name) # allow directly loading models from MSL without fileName elif fileName is None and modelName is not None: From 3224067659dcecd8753afb0a1ad8430489e2626e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 15:04:54 +0200 Subject: [PATCH 63/66] Rename _inputFlag to _has_inputs --- OMPython/ModelicaSystem.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 8fe975e4..390ecf99 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -387,7 +387,7 @@ def __init__( self._lmodel = lmodel # may be needed if model is derived from other model self._model_name = modelName # Model class name self._file_name = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name - self._inputFlag = False # for model with input quantity + self._has_inputs = False # for model with input quantity self._simulationFlag = False # if the model is simulated? self._csvFile: Optional[pathlib.Path] = None # for storing inputs condition self._resultfile: Optional[pathlib.Path] = None # for storing result file @@ -968,7 +968,7 @@ def simulate(self, om_cmd.arg_set(key="overrideFile", val=overrideFile.as_posix()) - if self._inputFlag: # if model has input quantities + if self._has_inputs: # if model has input quantities for i in self._inputs: val = self._inputs[i] if val is None: @@ -1199,7 +1199,7 @@ def setInputs(self, name): # 15 elif isinstance(tmpvalue, list): self._checkValidInputs(tmpvalue) self._inputs[value[0]] = tmpvalue - self._inputFlag = True + self._has_inputs = True else: raise ModelicaSystemError(f"{value[0]} is not an input") elif isinstance(name, list): @@ -1214,7 +1214,7 @@ def setInputs(self, name): # 15 elif isinstance(tmpvalue, list): self._checkValidInputs(tmpvalue) self._inputs[value[0]] = tmpvalue - self._inputFlag = True + self._has_inputs = True else: raise ModelicaSystemError(f"{value[0]} is not an input!") @@ -1414,7 +1414,7 @@ def load_module_from_path(module_name, file_path): om_cmd.arg_set(key="overrideFile", val=overrideLinearFile.as_posix()) - if self._inputFlag: + if self._has_inputs: nameVal = self.getInputs() for n in nameVal: tupleList = nameVal.get(n) From 56a673af0f8011956c708c5dd1698e05d0afa52b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 15:07:34 +0200 Subject: [PATCH 64/66] Rename _simulationFlag to _simulated --- OMPython/ModelicaSystem.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 390ecf99..47bf97ef 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -388,7 +388,7 @@ def __init__( self._model_name = modelName # Model class name self._file_name = pathlib.Path(fileName).resolve() if fileName is not None else None # Model file/package name self._has_inputs = False # for model with input quantity - self._simulationFlag = False # if the model is simulated? + self._simulated = False # True if the model has already been simulated self._csvFile: Optional[pathlib.Path] = None # for storing inputs condition self._resultfile: Optional[pathlib.Path] = None # for storing result file self._variableFilter = variableFilter @@ -639,7 +639,7 @@ def getContinuous(self, names: Optional[str | list[str]] = None): >>> mod.getOutputs(["y","x"]) [np.float64(-0.24), np.float64(0.68)] """ - if not self._simulationFlag: + if not self._simulated: if names is None: return self._continuous @@ -779,7 +779,7 @@ def getOutputs(self, names: Optional[str | list[str]] = None): # 7 >>> mod.getOutputs(["out1","out2"]) [np.float64(-0.1234), np.float64(2.1)] """ - if not self._simulationFlag: + if not self._simulated: if names is None: return self._outputs elif isinstance(names, str): @@ -1000,7 +1000,7 @@ def simulate(self, logger.warning(f"Return code = {returncode} but result file exists!") - self._simulationFlag = True + self._simulated = True def getSolutions(self, varList: Optional[str | list[str]] = None, resultfile: Optional[str] = None) -> tuple[str] | np.ndarray: """Extract simulation results from a result data file. @@ -1438,7 +1438,7 @@ def load_module_from_path(module_name, file_path): if returncode != 0: raise ModelicaSystemError(f"Linearize failed with return code: {returncode}") - self._simulationFlag = True + self._simulated = True # code to get the matrix and linear inputs, outputs and states linearFile = self._tempdir / "linearized_model.py" From f9bee563779f0a42d3ebcd1d4391fd0d2282f1f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 15:09:03 +0200 Subject: [PATCH 65/66] Rename _resultfile to _result_file --- OMPython/ModelicaSystem.py | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 47bf97ef..183f6384 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -390,7 +390,7 @@ def __init__( self._has_inputs = False # for model with input quantity self._simulated = False # True if the model has already been simulated self._csvFile: Optional[pathlib.Path] = None # for storing inputs condition - self._resultfile: Optional[pathlib.Path] = None # for storing result file + self._result_file: Optional[pathlib.Path] = None # for storing result file self._variableFilter = variableFilter if self._file_name is not None and not self._file_name.is_file(): # if file does not exist @@ -942,13 +942,13 @@ def simulate(self, if resultfile is None: # default result file generated by OM - self._resultfile = self._tempdir / f"{self._model_name}_res.mat" + self._result_file = self._tempdir / f"{self._model_name}_res.mat" elif os.path.exists(resultfile): - self._resultfile = pathlib.Path(resultfile) + self._result_file = pathlib.Path(resultfile) else: - self._resultfile = self._tempdir / resultfile + self._result_file = self._tempdir / resultfile # always define the resultfile to use - om_cmd.arg_set(key="r", val=self._resultfile.as_posix()) + om_cmd.arg_set(key="r", val=self._result_file.as_posix()) # allow runtime simulation flags from user input if simflags is not None: @@ -985,17 +985,17 @@ def simulate(self, om_cmd.arg_set(key="csvInput", val=self._csvFile.as_posix()) # delete resultfile ... - if self._resultfile.is_file(): - self._resultfile.unlink() + if self._result_file.is_file(): + self._result_file.unlink() # ... run simulation ... returncode = om_cmd.run() # and check returncode *AND* resultfile - if returncode != 0 and self._resultfile.is_file(): + if returncode != 0 and self._result_file.is_file(): # check for an empty (=> 0B) result file which indicates a crash of the model executable # see: https://github.com/OpenModelica/OMPython/issues/261 # https://github.com/OpenModelica/OpenModelica/issues/13829 - if self._resultfile.stat().st_size == 0: - self._resultfile.unlink() + if self._result_file.stat().st_size == 0: + self._result_file.unlink() raise ModelicaSystemError("Empty result file - this indicates a crash of the model executable!") logger.warning(f"Return code = {returncode} but result file exists!") @@ -1035,9 +1035,9 @@ def getSolutions(self, varList: Optional[str | list[str]] = None, resultfile: Op [-1. , -0.90483742, -0.81873075]]) """ if resultfile is None: - if self._resultfile is None: + if self._result_file is None: raise ModelicaSystemError("No result file found. Run simulate() first.") - result_file = self._resultfile + result_file = self._result_file else: result_file = pathlib.Path(resultfile) From 9f63e658c3ed6b380e37f154921ace835440f6f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Sluka?= Date: Wed, 2 Jul 2025 15:09:58 +0200 Subject: [PATCH 66/66] Rename _variableFilter to _variable_filter --- OMPython/ModelicaSystem.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py index 183f6384..2f02b710 100644 --- a/OMPython/ModelicaSystem.py +++ b/OMPython/ModelicaSystem.py @@ -391,7 +391,7 @@ def __init__( self._simulated = False # True if the model has already been simulated self._csvFile: Optional[pathlib.Path] = None # for storing inputs condition self._result_file: Optional[pathlib.Path] = None # for storing result file - self._variableFilter = variableFilter + self._variable_filter = variableFilter if self._file_name is not None and not self._file_name.is_file(): # if file does not exist raise IOError(f"{self._file_name} does not exist!") @@ -472,10 +472,10 @@ def getWorkDirectory(self) -> pathlib.Path: def buildModel(self, variableFilter: Optional[str] = None): if variableFilter is not None: - self._variableFilter = variableFilter + self._variable_filter = variableFilter - if self._variableFilter is not None: - varFilter = f'variableFilter="{self._variableFilter}"' + if self._variable_filter is not None: + varFilter = f'variableFilter="{self._variable_filter}"' else: varFilter = 'variableFilter=".*"'