[ModelicaSystemDoE] update variable handling / remove variables not needed

Author: syntron

OMPython/ModelicaSystem.py

@@ -1800,52 +1800,52 @@ def run_doe():
 
     def __init__(
             self,
-            fileName: Optional[str | os.PathLike | pathlib.Path] = None,
+            # data to be used for ModelicaSystem
+            fileName: Optional[str | os.PathLike] = None,
             modelName: Optional[str] = None,
             lmodel: Optional[list[str | tuple[str, str]]] = None,
             commandLineOptions: Optional[list[str]] = None,
             variableFilter: Optional[str] = None,
-            customBuildDirectory: Optional[str | os.PathLike | pathlib.Path] = None,
+            customBuildDirectory: Optional[str | os.PathLike] = None,
             omhome: Optional[str] = None,
-
+            omc_process: Optional[OMCProcess] = None,  # TODO: use omc session
+            # simulation specific input
+            # TODO: add more settings (simulation options, input options, ...)
             simargs: Optional[dict[str, Optional[str | dict[str, str] | numbers.Number]]] = None,
             timeout: Optional[int] = None,
-
-            resultpath: Optional[pathlib.Path] = None,
+            # DoE specific inputs
+            resultpath: Optional[str | os.PathLike] = None,
             parameters: Optional[dict[str, list[str] | list[int] | list[float]]] = None,
     ) -> None:
         """
         Initialisation of ModelicaSystemDoE. The parameters are based on: ModelicaSystem.__init__() and
         ModelicaSystem.simulate(). Additionally, the path to store the result files is needed (= resultpath) as well as
         a list of parameters to vary for the Doe (= parameters). All possible combinations are considered.
         """
-        self._lmodel = lmodel
-        self._modelName = modelName
-        self._fileName = fileName
-
-        self._CommandLineOptions = commandLineOptions
-        self._variableFilter = variableFilter
-        self._customBuildDirectory = customBuildDirectory
-        self._omhome = omhome
 
-        # reference for the model; not used for any simulations but to evaluate parameters, etc.
         self._mod = ModelicaSystem(
-            fileName=self._fileName,
-            modelName=self._modelName,
-            lmodel=self._lmodel,
-            commandLineOptions=self._CommandLineOptions,
-            variableFilter=self._variableFilter,
-            customBuildDirectory=self._customBuildDirectory,
-            omhome=self._omhome,
+            fileName=fileName,
+            modelName=modelName,
+            lmodel=lmodel,
+            commandLineOptions=commandLineOptions,
+            variableFilter=variableFilter,
+            customBuildDirectory=customBuildDirectory,
+            omhome=omhome,
+            omc_process=omc_process,
         )
 
+        self._model_name = modelName
+
         self._simargs = simargs
         self._timeout = timeout
 
-        if isinstance(resultpath, pathlib.Path):
-            self._resultpath = resultpath
+        if resultpath is None:
+            self._resultpath = self._mod._getconn.omcpath_tempdir()
         else:
-            self._resultpath = pathlib.Path('.')
+            self._resultpath = self._mod._getconn.omcpath(resultpath)
+        if not self._resultpath.is_dir():
+            raise ModelicaSystemError("Argument resultpath must be set to a valid path within the environment used "
+                                      f"for the OpenModelica session: {resultpath}!")
 
         if isinstance(parameters, dict):
             self._parameters = parameters
@@ -1892,15 +1892,15 @@ def prepare(self) -> int:
 
                 pk_value = pc_structure[idx_structure]
                 if isinstance(pk_value, str):
-                    expression = f"setParameterValue({self._modelName}, {pk_structure}, \"{pk_value}\")"
+                    expression = f"setParameterValue({self._model_name}, {pk_structure}, \"{pk_value}\")"
                 elif isinstance(pk_value, bool):
                     pk_value_bool_str = "true" if pk_value else "false"
-                    expression = f"setParameterValue({self._modelName}, {pk_structure}, {pk_value_bool_str});"
+                    expression = f"setParameterValue({self._model_name}, {pk_structure}, {pk_value_bool_str});"
                 else:
-                    expression = f"setParameterValue({self._modelName}, {pk_structure}, {pk_value})"
-                res = mod_structure.sendExpression(expression)
+                    expression = f"setParameterValue({self._model_name}, {pk_structure}, {pk_value})"
+                res = self._mod.sendExpression(expression)
                 if not res:
-                    raise ModelicaSystemError(f"Cannot set structural parameter {self._modelName}.{pk_structure} "
+                    raise ModelicaSystemError(f"Cannot set structural parameter {self._model_name}.{pk_structure} "
                                               f"to {pk_value} using {repr(expression)}")
 
             self._mod.buildModel()