??? update ... (ModelicaSystemDoE)

Author: syntron

OMPython/ModelicaSystem.py

@@ -42,8 +42,6 @@
 import os
 import pathlib
 import platform
-import psutil
-import pyparsing
 import re
 import shutil
 import signal
@@ -56,6 +54,9 @@
 import warnings
 import zmq
 
+import psutil
+import pyparsing
+
 # TODO: replace this with the new parser
 from OMPython.OMTypedParser import parseString as om_parser_typed
 from OMPython.OMParser import om_parser_basic
@@ -878,7 +879,7 @@ class OMCProcessLocal(OMCProcess):
     def __init__(
             self,
             timeout: float = 10.00,
-            omhome: Optional[str] = None,
+            omhome: Optional[str | os.PathLike] = None,
     ) -> None:
 
         super().__init__(timeout=timeout)
@@ -891,7 +892,7 @@ def __init__(
         self._omc_port = self._omc_port_get()
 
     @staticmethod
-    def _omc_home_get(omhome: Optional[str] = None) -> pathlib.Path:
+    def _omc_home_get(omhome: Optional[str | os.PathLike] = None) -> pathlib.Path:
         # use the provided path
         if omhome is not None:
             return pathlib.Path(omhome)
@@ -1005,7 +1006,7 @@ def __init__(
             self,
             timeout: float = 10.00,
             dockerExtraArgs: Optional[list] = None,
-            dockerOpenModelicaPath: str = "omc",
+            dockerOpenModelicaPath: str | os.PathLike = "omc",
             dockerNetwork: Optional[str] = None,
             port: Optional[int] = None,
     ) -> None:
@@ -1028,7 +1029,7 @@ def _docker_process_get(self, docker_cid: str) -> Optional[DummyPopen]:
             raise NotImplementedError("Docker not supported on win32!")
 
         docker_process = None
-        for idx in range(0, 40):
+        for _ in range(0, 40):
             dockerTop = subprocess.check_output(["docker", "top", docker_cid]).decode().strip()
             docker_process = None
             for line in dockerTop.split("\n"):
@@ -1143,7 +1144,7 @@ def __init__(
             timeout: float = 10.00,
             docker: Optional[str] = None,
             dockerExtraArgs: Optional[list] = None,
-            dockerOpenModelicaPath: str = "omc",
+            dockerOpenModelicaPath: str | os.PathLike = "omc",
             dockerNetwork: Optional[str] = None,
             port: Optional[int] = None,
     ) -> None:
@@ -1253,7 +1254,7 @@ def _docker_omc_start(self) -> Tuple[subprocess.Popen, DummyPopen, str]:
             raise OMCSessionException(f"Invalid content for docker container ID file path: {docker_cid_file}")
 
         docker_cid = None
-        for idx in range(0, 40):
+        for _ in range(0, 40):
             try:
                 with open(file=docker_cid_file, mode="r", encoding="utf-8") as fh:
                     docker_cid = fh.read().strip()
@@ -1286,7 +1287,7 @@ def __init__(
             timeout: float = 10.00,
             dockerContainer: Optional[str] = None,
             dockerExtraArgs: Optional[list] = None,
-            dockerOpenModelicaPath: str = "omc",
+            dockerOpenModelicaPath: str | os.PathLike = "omc",
             dockerNetwork: Optional[str] = None,
             port: Optional[int] = None,
     ) -> None:

OMPython/OMCSession.py

@@ -1,12 +1,14 @@
 import OMPython
 import shutil
 import os
+import pathlib
 
 
 def test_CauerLowPassAnalog():
     mod = OMPython.ModelicaSystem(modelName="Modelica.Electrical.Analog.Examples.CauerLowPassAnalog",
                                   lmodel=["Modelica"])
-    tmp = mod.getWorkDirectory()
+    # TODO [OMCPath]: need to work using OMCPath
+    tmp = pathlib.Path(mod.getWorkDirectory())
     try:
         fmu = mod.convertMo2Fmu(fileNamePrefix="CauerLowPassAnalog")
         assert os.path.exists(fmu)
@@ -16,7 +18,8 @@ def test_CauerLowPassAnalog():
 
 def test_DrumBoiler():
     mod = OMPython.ModelicaSystem(modelName="Modelica.Fluid.Examples.DrumBoiler.DrumBoiler", lmodel=["Modelica"])
-    tmp = mod.getWorkDirectory()
+    # TODO [OMCPath]: need to work using OMCPath
+    tmp = pathlib.Path(mod.getWorkDirectory())
     try:
         fmu = mod.convertMo2Fmu(fileNamePrefix="DrumBoiler")
         assert os.path.exists(fmu)

tests/test_FMIExport.py

@@ -5,13 +5,19 @@
 @pytest.fixture
 def model_firstorder(tmp_path):
     mod = tmp_path / "M.mo"
-    mod.write_text("""model M
-  Real x(start = 1, fixed = true);
-  parameter Real a = -1;
-equation
-  der(x) = x*a;
-end M;
-""")
+    mod.write_text("""
+    model M
+      parameter Integer p=1;
+      parameter Integer q=1;
+      parameter Real a = -1;
+      parameter Real b = -1;
+      Real x[p];
+      Real y[q];
+    equation
+      der(x) = a * fill(1.0, p);
+      der(y) = b * fill(1.0, q);
+    end M;
+    """)
     return mod
 
 
@@ -38,6 +44,16 @@ def test_simflags(mscmd_firstorder):
 
     assert mscmd.get_cmd_args() == [
         '-noEventEmit',
-        '-override=b=2,a=1,x=3',
+        '-override=a=1,b=2,x=3',
+        '-noRestart',
+    ]
+
+    mscmd.args_set({
+        "override": {'b': None},
+    })
+
+    assert mscmd.get_cmd_args() == [
+        '-noEventEmit',
+        '-override=a=1,x=3',
         '-noRestart',
     ]

tests/test_ModelicaSystemCmd.py

@@ -2,12 +2,24 @@
 import OMPython
 import pathlib
 import pytest
+import sys
+
+skip_on_windows = pytest.mark.skipif(
+    sys.platform.startswith("win"),
+    reason="OpenModelica Docker image is Linux-only; skipping on Windows.",
+)
+
+skip_python_older_312 = pytest.mark.skipif(
+    sys.version_info < (3, 12),
+    reason="OMCPath(non-local) only working for Python >= 3.12.",
+)
 
 
 @pytest.fixture
 def model_doe(tmp_path: pathlib.Path) -> pathlib.Path:
     # see: https://trac.openmodelica.org/OpenModelica/ticket/4052
     mod = tmp_path / "M.mo"
+    # TODO: update for bool and string parameters; check if these can be used in DoE
     mod.write_text("""
 model M
   parameter Integer p=1;
@@ -37,7 +49,47 @@ def param_doe() -> dict[str, list]:
     return param
 
 
-def test_ModelicaSystemDoE(tmp_path, model_doe, param_doe):
+# @pytest.mark.skip(reason="No OMC")
+def test_ModelicaSystemDoE_local(tmp_path, model_doe, param_doe):
+    tmpdir = tmp_path / 'DoE'
+    tmpdir.mkdir(exist_ok=True)
+
+    doe_mod = OMPython.ModelicaSystemDoE(
+        fileName=model_doe.as_posix(),
+        modelName="M",
+        parameters=param_doe,
+        resultpath=tmpdir,
+        simargs={"override": {'stopTime': 1.0}},
+    )
+
+    _run_ModelicaSystemDoe(doe_mod=doe_mod)
+
+
+@skip_on_windows
+@skip_python_older_312
+def test_ModelicaSystemDoE_docker(tmp_path, model_doe, param_doe):
+    omcp = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
+    omc = OMPython.OMCSessionZMQ(omc_process=omcp)
+    assert omc.sendExpression("getVersion()") == "OpenModelica 1.25.0"
+
+    modelpath = omc.omcpath_tempdir() / 'M.mo'
+    modelpath.write_text(model_doe.read_text())
+
+    doe_mod = OMPython.ModelicaSystemDoE(
+        fileName=modelpath.as_posix(),
+        modelName="M",
+        parameters=param_doe,
+        omc_process=omcp,
+        resultpath=modelpath.parent,
+        simargs={"override": {'stopTime': 1.0}},
+    )
+
+    _run_ModelicaSystemDoe(doe_mod=doe_mod)
+
+
+@pytest.mark.skip(reason="Not able to run WSL on github")
+@skip_python_older_312
+def test_ModelicaSystemDoE_WSL(tmp_path, model_doe, param_doe):
     tmpdir = tmp_path / 'DoE'
     tmpdir.mkdir(exist_ok=True)
 
@@ -48,20 +100,34 @@ def test_ModelicaSystemDoE(tmp_path, model_doe, param_doe):
         resultpath=tmpdir,
         simargs={"override": {'stopTime': 1.0}},
     )
+
+    _run_ModelicaSystemDoe(doe_mod=doe_mod)
+
+
+def _run_ModelicaSystemDoe(doe_mod):
     doe_count = doe_mod.prepare()
     assert doe_count == 16
 
-    doe_dict = doe_mod.get_doe()
-    assert isinstance(doe_dict, dict)
-    assert len(doe_dict.keys()) == 16
+    doe_def = doe_mod.get_doe_definition()
+    assert isinstance(doe_def, dict)
+    assert len(doe_def.keys()) == doe_count
+
+    doe_cmd = doe_mod.get_doe_command()
+    assert isinstance(doe_cmd, dict)
+    assert len(doe_cmd.keys()) == doe_count
 
     doe_status = doe_mod.simulate()
     assert doe_status is True
 
-    doe_sol = doe_mod.get_solutions()
+    doe_sol = doe_mod.get_doe_solutions()
+    assert isinstance(doe_sol, dict)
+    assert len(doe_sol.keys()) == doe_count
+
+    assert sorted(doe_def.keys()) == sorted(doe_cmd.keys())
+    assert sorted(doe_cmd.keys()) == sorted(doe_sol.keys())
 
-    for resultfilename in doe_dict:
-        row = doe_dict[resultfilename]
+    for resultfilename in doe_def:
+        row = doe_def[resultfilename]
 
         assert resultfilename in doe_sol
         sol = doe_sol[resultfilename]

tests/test_ModelicaSystemDoE.py

@@ -43,6 +43,15 @@ def test_OMCPath_OMCProcessDocker():
     del om
 
 
+@skip_python_older_312
+def test_OMCPath_local():
+    om = OMPython.OMCProcessLocal()
+
+    _run_OMCPath_checks(om)
+
+    del om
+
+
 @pytest.mark.skip(reason="Not able to run WSL on github")
 @skip_python_older_312
 def test_OMCPath_OMCProcessWSL():

tests/test_OMCPath.py

@@ -0,0 +1,34 @@
+import sys
+import pytest
+import OMPython
+
+skip_on_windows = pytest.mark.skipif(
+    sys.platform.startswith("win"),
+    reason="OpenModelica Docker image is Linux-only; skipping on Windows.",
+)
+
+
+@skip_on_windows
+def test_docker():
+    # TODO: test OMCSessionRunData for valid content
+
+    omcp = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
+    om = OMPython.OMCSessionZMQ(omc_process=omcp)
+    assert om.sendExpression("getVersion()") == "OpenModelica 1.25.0"
+
+    omcpInner = OMPython.OMCProcessDockerContainer(dockerContainer=omcp.get_docker_container_id())
+    omInner = OMPython.OMCSessionZMQ(omc_process=omcpInner)
+    assert omInner.sendExpression("getVersion()") == "OpenModelica 1.25.0"
+
+    omcp2 = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal", port=11111)
+    om2 = OMPython.OMCSessionZMQ(omc_process=omcp2)
+    assert om2.sendExpression("getVersion()") == "OpenModelica 1.25.0"
+
+    del omcp2
+    del om2
+
+    del omcpInner
+    del omInner
+
+    del omcp
+    del om

tests/test_OMCSessionRunData.py

@@ -6,8 +6,17 @@
 
 @pytest.fixture
 def model_time_str():
-    return """model M
-  Real r = time;
+    return """
+model M
+  parameter Integer p=1;
+  parameter Integer q=1;
+  parameter Real a = -1;
+  parameter Real b = -1;
+  Real x[p];
+  Real y[q];
+equation
+  der(x) = a * fill(1.0, p);
+  der(y) = b * fill(1.0, q);
 end M;
 """
 

tests/test_ZMQ.py

@@ -47,7 +47,9 @@ def test_optimization_example(tmp_path):
 
     r = mod.optimize()
     # it is necessary to specify resultfile, otherwise it wouldn't find it.
-    time, f, v = mod.getSolutions(["time", "f", "v"], resultfile=r["resultFile"])
+    resultfile_str = r["resultFile"]
+    resultfile_omcpath = mod._getconn.omcpath(resultfile_str)
+    time, f, v = mod.getSolutions(["time", "f", "v"], resultfile=resultfile_omcpath.as_posix())
     assert np.isclose(f[0], 10)
     assert np.isclose(f[-1], -10)