?? MSDOE working without clone / one OMCSession

Author: syntron

OMPython/ModelicaSystem.py

@@ -212,7 +212,7 @@ def definition(self) -> OMCSessionRunData:
             cmd_timeout=self._timeout,
         )
 
-        omc_run_data_updated = self._session.omc_run_data_update(omc_run_data)
+        omc_run_data_updated = self._session.omc_run_data_update(omc_run_data=omc_run_data)
 
         return omc_run_data_updated
 
@@ -1808,20 +1808,10 @@ def prepare(self) -> int:
 
         self._doe_def = {}
         for idx_pc_structure, pc_structure in enumerate(param_structure_combinations):
-            mod_structure_dir = self._mod.getWorkDirectory() / f"DOE_{idx_pc_structure:09d}"
-            mod_structure_dir.mkdir()
-
-            mod_structure = ModelicaSystem(
-                fileName=self._file_name,
-                modelName=self._model_name,
-                lmodel=self._lmodel,
-                commandLineOptions=self._command_line_options,
-                variableFilter=self._variable_filter,
-                customBuildDirectory=mod_structure_dir,
-                omhome=self._omhome,
-                omc_process=self._omc_process,
-                build=False,
-            )
+
+            build_dir = self._resultpath / f"DOE_{idx_pc_structure:09d}"
+            build_dir.mkdir()
+            self._mod.setTempDirectory(build_dir)
 
             sim_param_structure = {}
             for idx_structure, pk_structure in enumerate(param_structure.keys()):
@@ -1835,12 +1825,12 @@ def prepare(self) -> int:
                     expression = f"setParameterValue({self._model_name}, {pk_structure}, {pk_value_bool_str});"
                 else:
                     expression = f"setParameterValue({self._model_name}, {pk_structure}, {pk_value})"
-                res = mod_structure.sendExpression(expression)
+                res = self._mod.sendExpression(expression)
                 if not res:
                     raise ModelicaSystemError(f"Cannot set structural parameter {self._model_name}.{pk_structure} "
                                               f"to {pk_value} using {repr(expression)}")
 
-            mod_structure.buildModel(variableFilter=self._variable_filter)
+            self._mod.buildModel(variableFilter=self._variable_filter)
 
             for idx_pc_simple, pc_simple in enumerate(param_simple_combinations):
                 # TODO: check mypy error message / type hints
@@ -1870,9 +1860,9 @@ def prepare(self) -> int:
 
                 self._doe_def[resfilename] = df_data
 
-                mod_structure.setParameters(sim_param_simple)
+                self._mod.setParameters(sim_param_simple)
 
-                mscmd = mod_structure.simulate_cmd(
+                mscmd = self._mod.simulate_cmd(
                     result_file=resultfile,
                     timeout=self._timeout,
                 )
@@ -1882,19 +1872,11 @@ def prepare(self) -> int:
 
                 cmd_definition = mscmd.definition()
 
-                # TODO: fix path to executable; copy it using OMCPath.copy() => no clone; only one OMC!
-                #       exe = exe.parent / (DOE name)- exe.name
-
                 doe_sim[resultfile.name] = cmd_definition
 
                 del mscmd
 
-            logger.info(f'Status OMC: {mod_structure._getconn.sendExpression("getVersion()")}')
-
-            # cleanup; ensure that there is not too much RAM consumption
-            logger.warning("DEL")
-            del mod_structure._getconn
-            del mod_structure
+            logger.info(f'Status OMC: {self._mod._getconn.sendExpression("getVersion()")}')
 
         logger.info(f"Prepared {len(doe_sim)} simulation definitions for the defined DoE.")
 

tools/run_doe.py

@@ -38,13 +38,13 @@ def param_doe() -> dict[str, list]:
     return param
 
 
-def test_ModelicaSystemDoE(tmp_path, model_doe, param_doe):
-    tmpdir = tmp_path / 'DoE'
-    tmpdir.mkdir(exist_ok=True)
+def test_ModelicaSystemDoE(tmp_path, model_doe, param_doe, om):
+    # tmpdir = tmp_path / 'DoE'
+    # tmpdir.mkdir(exist_ok=True)
 
     # om = OMPython.OMCSessionZMQ()
-    omcp = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
-    om = OMPython.OMCSessionZMQ(omc_process=omcp)
+    # omcp = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
+    # om = OMPython.OMCSessionZMQ(omc_process=omcp)
 
     model_path = om.omcpath_tempdir()
     model_file = model_path / 'M.mo'
@@ -64,14 +64,14 @@ def test_ModelicaSystemDoE(tmp_path, model_doe, param_doe):
     doe_count = doe_mod.prepare()
     assert doe_count == 16
 
-    doe_dict = doe_mod.get_doe()
+    doe_dict = doe_mod.get_doe_definition()
     assert isinstance(doe_dict, dict)
     assert len(doe_dict.keys()) == 16
 
     doe_status = doe_mod.simulate()
     assert doe_status is True
 
-    doe_sol = doe_mod.get_solutions()
+    doe_sol = doe_mod.get_doe_solutions()
 
     for resultfilename in doe_dict:
         row = doe_dict[resultfilename]
@@ -93,29 +93,33 @@ def test_ModelicaSystemDoE(tmp_path, model_doe, param_doe):
 
         for var in var_dict:
             assert var in sol['data']
+            # logger.info(f"{resultfilename}:{var} {sol['data'][var][-1]} <> {var_dict[var]}")
             assert np.isclose(sol['data'][var][-1], var_dict[var])
 
+    doe_def = doe_mod.get_doe_definition()
+    doe_cmd = doe_mod.get_doe_command()
+
+    # logger.warning(doe_def)
+    # logger.warning(doe_cmd)
+    # logger.warning(doe_sol)
+
 
 if __name__ == "__main__":
     # om = OMPython.OMCSessionZMQ()
     omcp = OMPython.OMCProcessDocker(docker="openmodelica/openmodelica:v1.25.0-minimal")
     om = OMPython.OMCSessionZMQ(omc_process=omcp)
 
-    tempdir_local = pathlib.Path('.') / 'DoE'
-    tempdir_local = tempdir_local.resolve().absolute()
-    tempdir_local.mkdir(exist_ok=True)
     tempdir_omcpath = om.omcpath_tempdir()
 
-    model_file_local = model_doe(tempdir_local)
-    model_file_omcpath = tempdir_omcpath / 'M.mo'
-    model_file_omcpath.write_text(model_file_local.read_text())
+    model_file_local = model_doe(tempdir_omcpath)
 
     param = param_doe()
 
     test_ModelicaSystemDoE(
         tmp_path=tempdir_omcpath,
-        model_doe=model_file_omcpath,
+        model_doe=model_file_local,
         param_doe=param,
+        om=om,
     )
 
     print("DONE")