Merge branch 'ModelicaSystemDoE_use_OMCPath' into merge_all

Author: syntron

OMPython/ModelicaSystem.py

@@ -36,8 +36,9 @@
  CONDITIONS OF OSMC-PL.
 """
 
-from OMPython.ModelicaSystem import LinearizationResult, ModelicaSystem, ModelicaSystemCmd, ModelicaSystemError
-from OMPython.OMCSession import (OMCSessionCmd, OMCSessionException, OMCSessionZMQ,
+from OMPython.ModelicaSystem import (LinearizationResult, ModelicaSystem, ModelicaSystemCmd, ModelicaSystemDoE,
+                                     ModelicaSystemError)
+from OMPython.OMCSession import (OMCSessionCmd, OMCSessionException, OMCSessionRunData, OMCSessionZMQ,
                                  OMCProcessPort, OMCProcessLocal, OMCProcessDocker, OMCProcessDockerContainer,
                                  OMCProcessWSL)
 
@@ -46,10 +47,12 @@
     'LinearizationResult',
     'ModelicaSystem',
     'ModelicaSystemCmd',
+    'ModelicaSystemDoE',
     'ModelicaSystemError',
 
     'OMCSessionCmd',
     'OMCSessionException',
+    'OMCSessionRunData',
     'OMCSessionZMQ',
     'OMCProcessPort',
     'OMCProcessLocal',

OMPython/OMCSession.py

@@ -1,12 +1,13 @@
 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()
+    tmp = pathlib.Path(mod.getWorkDirectory())
     try:
         fmu = mod.convertMo2Fmu(fileNamePrefix="CauerLowPassAnalog")
         assert os.path.exists(fmu)
@@ -16,7 +17,7 @@ def test_CauerLowPassAnalog():
 
 def test_DrumBoiler():
     mod = OMPython.ModelicaSystem(modelName="Modelica.Fluid.Examples.DrumBoiler.DrumBoiler", lmodel=["Modelica"])
-    tmp = mod.getWorkDirectory()
+    tmp = pathlib.Path(mod.getWorkDirectory())
     try:
         fmu = mod.convertMo2Fmu(fileNamePrefix="DrumBoiler")
         assert os.path.exists(fmu)

OMPython/__init__.py

@@ -2,20 +2,36 @@
 import os
 import pathlib
 import pytest
+import sys
 import tempfile
 import numpy as np
 
+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_firstorder(tmp_path):
-    mod = tmp_path / "M.mo"
-    mod.write_text("""model M
+def model_firstorder_content():
+    return ("""model M
   Real x(start = 1, fixed = true);
   parameter Real a = -1;
 equation
   der(x) = x*a;
 end M;
 """)
+
+
+@pytest.fixture
+def model_firstorder(tmp_path, model_firstorder_content):
+    mod = tmp_path / "M.mo"
+    mod.write_text(model_firstorder_content)
     return mod
 
 
@@ -106,16 +122,40 @@ def test_customBuildDirectory(tmp_path, model_firstorder):
     tmpdir = tmp_path / "tmpdir1"
     tmpdir.mkdir()
     m = OMPython.ModelicaSystem(filePath, "M", customBuildDirectory=tmpdir)
-    assert m.getWorkDirectory().resolve() == tmpdir.resolve()
+    assert pathlib.Path(m.getWorkDirectory()).resolve() == tmpdir.resolve()
     result_file = tmpdir / "a.mat"
     assert not result_file.exists()
     m.simulate(resultfile="a.mat")
     assert result_file.is_file()
 
 
+@skip_on_windows
+@skip_python_older_312
+def test_getSolutions_docker(model_firstorder_content):
+    omcp = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
+    omc = OMPython.OMCSessionZMQ(omc_process=omcp)
+
+    modelpath = omc.omcpath_tempdir() / 'M.mo'
+    modelpath.write_text(model_firstorder_content)
+
+    file_path = pathlib.Path(modelpath)
+    mod = OMPython.ModelicaSystem(
+        fileName=file_path,
+        modelName="M",
+        omc_process=omc.omc_process,
+    )
+
+    _run_getSolutions(mod)
+
+
 def test_getSolutions(model_firstorder):
     filePath = model_firstorder.as_posix()
     mod = OMPython.ModelicaSystem(filePath, "M")
+
+    _run_getSolutions(mod)
+
+
+def _run_getSolutions(mod):
     x0 = 1
     a = -1
     tau = -1 / a

tests/test_FMIExport.py

@@ -18,7 +18,11 @@ 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._model_name)
+    mscmd = OMPython.ModelicaSystemCmd(
+        session=mod._getconn,
+        runpath=mod.getWorkDirectory(),
+        modelname=mod._model_name,
+    )
     return mscmd
 
 
@@ -32,8 +36,7 @@ def test_simflags(mscmd_firstorder):
     with pytest.deprecated_call():
         mscmd.args_set(args=mscmd.parse_simflags(simflags="-noEventEmit -noRestart -override=a=1,x=3"))
 
-    assert mscmd.get_cmd() == [
-        mscmd.get_exe().as_posix(),
+    assert mscmd.get_cmd_args() == [
         '-noEventEmit',
         '-noRestart',
         '-override=a=1,b=2,x=3',

tests/test_ModelicaSystem.py

@@ -0,0 +1,148 @@
+import numpy as np
+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;
+  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
+
+
+@pytest.fixture
+def param_doe() -> dict[str, list]:
+    param = {
+        # structural
+        'p': [1, 2],
+        'q': [3, 4],
+        # simple
+        'a': [5, 6],
+        'b': [7, 8],
+    }
+    return param
+
+
+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)
+
+    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)
+
+
+def _run_ModelicaSystemDoe(doe_mod):
+    doe_count = doe_mod.prepare()
+    assert doe_count == 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_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_def:
+        row = doe_def[resultfilename]
+
+        assert resultfilename in doe_sol
+        sol = doe_sol[resultfilename]
+
+        var_dict = {
+            # simple / non-structural parameters
+            'a': float(row['a']),
+            'b': float(row['b']),
+            # structural parameters
+            'p': float(row['p']),
+            'q': float(row['q']),
+            # variables using the structural parameters
+            f"x[{row['p']}]": float(row['a']),
+            f"y[{row['p']}]": float(row['b']),
+        }
+
+        for var in var_dict:
+            assert var in sol['data']
+            assert np.isclose(sol['data'][var][-1], var_dict[var])

tests/test_ModelicaSystemCmd.py

@@ -0,0 +1,78 @@
+import sys
+import OMPython
+import pytest
+
+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.",
+)
+
+
+def test_OMCPath_OMCSessionZMQ():
+    om = OMPython.OMCSessionZMQ()
+
+    _run_OMCPath_checks(om)
+
+    del om
+
+
+def test_OMCPath_OMCProcessLocal():
+    omp = OMPython.OMCProcessLocal()
+    om = OMPython.OMCSessionZMQ(omc_process=omp)
+
+    _run_OMCPath_checks(om)
+
+    del om
+
+
+@skip_on_windows
+@skip_python_older_312
+def test_OMCPath_OMCProcessDocker():
+    omcp = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
+    om = OMPython.OMCSessionZMQ(omc_process=omcp)
+    assert om.sendExpression("getVersion()") == "OpenModelica 1.25.0"
+
+    _run_OMCPath_checks(om)
+
+    del omcp
+    del om
+
+
+@pytest.mark.skip(reason="Not able to run WSL on github")
+@skip_python_older_312
+def test_OMCPath_OMCProcessWSL():
+    omcp = OMPython.OMCProcessWSL(
+        wsl_omc='omc',
+        wsl_user='omc',
+        timeout=30.0,
+    )
+    om = OMPython.OMCSessionZMQ(omc_process=omcp)
+
+    _run_OMCPath_checks(om)
+
+    del omcp
+    del om
+
+
+def _run_OMCPath_checks(om: OMPython.OMCSessionZMQ):
+    p1 = om.omcpath_tempdir()
+    p2 = p1 / 'test'
+    p2.mkdir()
+    assert p2.is_dir()
+    p3 = p2 / '..' / p2.name / 'test.txt'
+    assert p3.is_file() is False
+    assert p3.write_text('test')
+    assert p3.is_file()
+    assert p3.size() > 0
+    p3 = p3.resolve().absolute()
+    assert str(p3) == str((p2 / 'test.txt').resolve().absolute())
+    assert p3.read_text() == "test"
+    assert p3.is_file()
+    assert p3.parent.is_dir()
+    p3.unlink()
+    assert p3.is_file() is False

tests/test_ModelicaSystemDoE.py

@@ -50,7 +50,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)