Merge pull request #131 from RWTH-EBC/130-add-option-to-dymolaapi-to-start-with-no-model_name [PYPI-RELEASE]

130 add option to dymolaapi to start with no model name

Author: FWuellhorst

CHANGELOG.md

@@ -100,3 +100,7 @@
   - Preprocessing functions now copy the input 
   DataFrame by default with the new inplace argument (default False). #125
   - Add inplace option to TimeSeriesData function (default True)
+- v0.4.1
+  - fix reproduction with modifiers #82
+  - enable model_name=None upon startup of DymolaAPI #130
+  - Only create logger handler if not already done by root-logger

ebcpy/__init__.py

@@ -8,4 +8,4 @@
 from .optimization import Optimizer
 
 
-__version__ = '0.4.0'
+__version__ = '0.4.1'

ebcpy/simulationapi/__init__.py

@@ -196,6 +196,7 @@ def __init__(self, working_directory: Union[Path, str], model_name: str, **kwarg
         self.parameters: Dict[str, Variable] = {}   # Parameter of model
         self.states: Dict[str, Variable] = {}       # States of model
         self.result_names = []
+        self._model_name = None
         self.model_name = model_name
 
     # MP-Functions
@@ -448,13 +449,13 @@ def model_name(self) -> str:
         return self._model_name
 
     @model_name.setter
-    def model_name(self, model_name):
+    def model_name(self, model_name: str):
         """
         Set new model_name and trigger further functions
         to load parameters etc.
         """
         # Only update if the model_name actually changes
-        if hasattr(self, "_model_name") and self._model_name == model_name:
+        if self._model_name == model_name:
             return
         self._model_name = model_name
         # Only update model if it's the first setup. On multiprocessing,

ebcpy/simulationapi/dymola_api.py

@@ -4,7 +4,7 @@
 import sys
 import os
 import shutil
-import pathlib
+import uuid
 import warnings
 import atexit
 import json
@@ -49,7 +49,8 @@ class DymolaAPI(SimulationAPI):
     :param str,Path working_directory:
         Dirpath for the current working directory of dymola
     :param str model_name:
-        Name of the model to be simulated
+        Name of the model to be simulated.
+        If None, it has to be provided prior to or when calling simulate().
     :param list packages:
         List with path's to the packages needed to simulate the model
     :keyword Boolean show_window:
@@ -156,7 +157,7 @@ class DymolaAPI(SimulationAPI):
     def __init__(
             self,
             working_directory: Union[Path, str],
-            model_name: str,
+            model_name: str = None,
             packages: List[Union[Path, str]] = None,
             **kwargs
     ):
@@ -223,8 +224,9 @@ def __init__(
                         "Thus, not able to find the `dymola_exe_path` and `dymola_interface_path`. "
                         "Either specify both or pass an existing `dymola_path`."
                     )
+        self.dymola_path = dymola_path
         if self.dymola_exe_path is None:
-            self.dymola_exe_path = self.get_dymola_path(dymola_path)
+            self.dymola_exe_path = self.get_dymola_exe_path(dymola_path)
         self.logger.info("Using dymola.exe: %s", self.dymola_exe_path)
         if self.dymola_interface_path is None:
             self.dymola_interface_path = self.get_dymola_interface_path(dymola_path)
@@ -271,10 +273,14 @@ def __init__(
             )
         # For translation etc. always setup a default dymola instance
         self.dymola = self._setup_dymola_interface(dict(use_mp=False))
+        if not self.license_is_available():
+            warnings.warn("You have no licence to use Dymola. "
+                          "Hence you can only simulate models with 8 or less equations.")
 
         self.fully_initialized = True
         # Trigger on init.
-        self._update_model()
+        if model_name is not None:
+            self._update_model()
         # Set result_names to output variables.
         self.result_names = list(self.outputs.keys())
 
@@ -407,6 +413,13 @@ def _single_simulation(self, kwargs):
                     " ,".join(list(set(_res_names).difference(self.result_names)))
                 )
 
+        if self.model_name is None:
+            raise ValueError(
+                "You neither passed a model_name when "
+                "starting DymolaAPI, nor when calling simulate. "
+                "Can't simulate no model."
+            )
+
         # Handle parameters:
         if parameters is None:
             parameters = {}
@@ -824,14 +837,18 @@ def _setup_dymola_interface(self, kwargs: dict):
             # Events can also cause errors in the shape.
             dymola.experimentSetupOutput(equidistant=True,
                                          events=False)
-        if not dymola.RequestOption("Standard"):
-            warnings.warn("You have no licence to use Dymola. "
-                          "Hence you can only simulate models with 8 or less equations.")
         if use_mp:
             DymolaAPI.dymola = dymola
             return None
         return dymola
 
+    def license_is_available(self, option: str = "Standard"):
+        """Check if license is available"""
+        if self.dymola is None:
+            warnings.warn("You want to check the license before starting dymola, this is not supported.")
+            return False
+        return self.dymola.RequestOption(option)
+
     def _open_dymola_interface(self, port):
         """Open an instance of dymola and return the API-Object"""
         if self.dymola_interface_path not in sys.path:
@@ -968,9 +985,27 @@ def save_for_reproduction(
             _total_model_name = f"Dymola/{self.model_name.replace('.', '_')}_total.mo"
             _total_model = Path(self.cd).joinpath(_total_model_name)
             os.makedirs(_total_model.parent, exist_ok=True)  # Create to ensure model can be saved.
+            if "(" in self.model_name:
+                # Create temporary model:
+                temp_model_file = Path(self.cd).joinpath(f"temp_total_model_{uuid.uuid4()}.mo")
+                temp_mode_name = f"{self.model_name.split('(')[0].split('.')[-1]}WithModifier"
+                with open(temp_model_file, "w") as file:
+                    file.write(f"model {temp_mode_name}\n  extends {self.model_name};\nend {temp_mode_name};")
+                res = self.dymola.openModel(str(temp_model_file), changeDirectory=False)
+                if not res:
+                    self.logger.error(
+                        "Could not create separate model for model with modifiers: %s",
+                        self.model_name
+                    )
+                    model_name_to_save = self.model_name
+                else:
+                    model_name_to_save = temp_mode_name
+                os.remove(temp_model_file)
+            else:
+                model_name_to_save = self.model_name
             res = self.dymola.saveTotalModel(
                 fileName=str(_total_model),
-                modelName=self.model_name
+                modelName=model_name_to_save
             )
             if res:
                 files.append(ReproductionFile(
@@ -1061,7 +1096,7 @@ def get_dymola_interface_path(dymola_install_dir):
         return egg_file
 
     @staticmethod
-    def get_dymola_path(dymola_install_dir, dymola_name=None):
+    def get_dymola_exe_path(dymola_install_dir, dymola_name=None):
         """
         Function to get the path of the dymola exe-file
         on the current used machine.

ebcpy/utils/__init__.py

@@ -31,12 +31,13 @@ def setup_logger(name: str,
     # Check if logger was already instantiated. If so, return already.
     if logger.handlers:
         return logger
-    # Add handlers
+    # Add handlers if not set already by logging.basicConfig and if path is specified
     formatter = logging.Formatter(fmt='%(asctime)s %(levelname)s %(name)s: %(message)s',
                                   datefmt='%d.%m.%Y-%H:%M:%S')
-    console = logging.StreamHandler()
-    console.setFormatter(fmt=formatter)
-    logger.addHandler(hdlr=console)
+    if not logging.getLogger().hasHandlers():
+        console = logging.StreamHandler()
+        console.setFormatter(fmt=formatter)
+        logger.addHandler(hdlr=console)
     if working_directory is not None:
         os.makedirs(working_directory, exist_ok=True)
         file_handler = logging.FileHandler(filename=working_directory.joinpath(f"{name}.log"))

examples/e5_modifier_example.py

@@ -10,25 +10,19 @@
 
 
 def main(
-        aixlib_mo,
-        ibpsa_mo,
-        besmod_mo,
+        besmod_startup_mos,
         ext_model_name,
         working_directory=None,
-        n_cpu=1,
-        with_plot=True
+        n_cpu=1
 ):
     """
     Arguments of this example:
-    :param str aixlib_mo:
-        Path to the package.mo of the AixLib.
-        This example was tested for AixLib version 1.3.2.
-    :param str ibpsa_mo:
-        Path to the package.mo of the IBSPA.
-        This example was tested for IBSPA version 3.0.0.
-    :param str besmod_mo:
-        Path to the package.mo of the BESMod.
+
+    :param str besmod_startup_mos:
+        Path to the startup.mos of the BESMod.
         This example was tested for BESMod version 0.4.0.
+        This example was tested for IBSPA version 3.0.0.
+        This example was tested for AixLib version 1.3.2.
     :param list ext_model_name:
         Executable model name with redeclared subsystems and modifiers.
     :param str working_directory:
@@ -50,7 +44,7 @@ def main(
         model_name=ext_model_name,
         working_directory=working_directory,
         n_cpu=n_cpu,
-        packages=[aixlib_mo, ibpsa_mo, besmod_mo],
+        mos_script_pre=besmod_startup_mos,
         show_window=False,
         # Only necessary if you need a specific dymola version
         dymola_path=r"C:\Program Files\Dymola 2023x",
@@ -77,33 +71,33 @@ def main(
     # You can also simulate a list of different `model_names` (or modified versions of the same model)
     # by passing a list to the `simulate` function in `DymolaAPI`:
     model_names_to_simulate = [
+        "BESMod.Examples.DesignOptimization.BES",
         "BESMod.Examples.GasBoilerBuildingOnly(redeclare BESMod.Systems.Control.DHWSuperheating control(dTDHW=10))",
         "BESMod.Examples.GasBoilerBuildingOnly(redeclare BESMod.Systems.Control.DHWSuperheating control(dTDHW=5))",
-        "BESMod.Examples.DesignOptimization.BES",
     ]
     results = dym_api.simulate(
         return_option="time_series",
         model_names=model_names_to_simulate
     )
     print(results)
-
+    dym_api.save_for_reproduction(
+        title="FMUTest",
+        log_message="This is just an example."
+    )
     # ######################### Closing ##########################
     # Close Dymola. If you forget to do so,
     # we call this function at the exit of your script.
     dym_api.close()
 
 
 if __name__ == '__main__':
-    # TODO-User: Change the AixLib and BESMod path!
-
+    # TODO-User: Change the BESMod path!
     # call function main
     # - External libraries AixLib, IBSPA and BESMod will be loaded
     # - Model ext_model_name will be called. Subsystem for controller will be exchanged from NoControl to DHWSuperheating.
     #   Additional to the new subsystem, the parameter dTDHW will be set from 5 K to 10 K.
     # Furthermore, inside the main function, a method for simulating multiple models at one call is shown.
     main(
-        aixlib_mo=r"D:\900_repository\000_general\AixLib-1.3.2\AixLib\package.mo",
-        ibpsa_mo=r"D:\900_repository\000_general\modelica-ibpsa-master\IBPSA\package.mo",
-        besmod_mo=r"D:\900_repository\000_general\BESMod\BESMod\package.mo",
+        besmod_startup_mos=r"D:\04_git\BESMod\startup.mos",
         ext_model_name='BESMod.Examples.GasBoilerBuildingOnly(redeclare BESMod.Systems.Control.DHWSuperheating control(dTDHW=10))'
     )

tests/test_simulationapi.py

@@ -169,7 +169,7 @@ def setUp(self) -> None:
         if self.__class__ == PartialTestDymolaAPI:
             self.skipTest("Just a partial class")
         ebcpy_test_package_dir = self.data_dir.joinpath("TestModelVariables.mo")
-        packages = [ebcpy_test_package_dir]
+        self.packages = [ebcpy_test_package_dir]
         model_name = "TestModelVariables"
         self.parameters = {"test_real": 10.0,
                            "test_int": 5,
@@ -182,7 +182,11 @@ def setUp(self) -> None:
         }
         # Mos script
         mos_script = self.data_dir.joinpath("mos_script_test.mos")
+        self._start_dymola_api(
+            model_name=model_name, mos_script=mos_script
+        )
 
+    def _start_dymola_api(self, model_name: str, mos_script):
         # Just for tests in the gitlab-ci:
         if "linux" in sys.platform:
             dymola_exe_path = "/usr/local/bin/dymola"
@@ -192,7 +196,7 @@ def setUp(self) -> None:
             self.sim_api = dymola_api.DymolaAPI(
                 working_directory=self.example_sim_dir,
                 model_name=model_name,
-                packages=packages,
+                packages=self.packages,
                 dymola_exe_path=dymola_exe_path,
                 n_cpu=self.n_cpu,
                 mos_script_pre=mos_script,
@@ -202,6 +206,15 @@ def setUp(self) -> None:
             self.skipTest(f"Could not load the dymola interface "
                           f"on this machine. Error message: {error}")
 
+    def test_no_model_none(self):
+        self.sim_api.close()
+        self._start_dymola_api(
+            mos_script=None, model_name=None,
+        )
+        with self.assertRaises(ValueError):
+            self.sim_api.simulate()
+        self.sim_api.simulate(model_names=["TestModelVariables"], parameters=self.parameters)
+
     def test_close(self):
         """Test close functionality of dymola api"""
         self.sim_api.close()