7425403093

Committed 05 Jan 2024 06:28PM UTC coverage: 85.732% (-2.9%) from 88.672%

Build # 7425403093

Build Type

Pull #581

github

Committed by

vtnate

Commit Message

hard-code the district pump head pressure. Fix later

Pull Request Pull Request #581: Mblv10

Run Details

892 of 1091 branches covered (0.0%)

Branch coverage included in aggregate %.

18 of 35 new or added lines in 9 files covered. (51.43%)

81 existing lines in 3 files now uncovered.

2473 of 2834 relevant lines covered (87.26%)

1.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.59

/geojson_modelica_translator/modelica/modelica_runner.py

# :copyright (c) URBANopt, Alliance for Sustainable Energy, LLC, and other contributors.
# See also https://github.com/urbanopt/geojson-modelica-translator/blob/develop/LICENSE.md

import logging
import os
import shutil
import subprocess
from pathlib import Path
from typing import Union

from buildingspy.simulate.Dymola import Simulator
from jinja2 import Environment, FileSystemLoader, StrictUndefined

from geojson_modelica_translator.jinja_filters import ALL_CUSTOM_FILTERS

logger = logging.getLogger(__name__)
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s: %(message)s',
    datefmt='%d-%b-%y %H:%M:%S',
)


class ModelicaRunner(object):
    """
    Class to run Modelica models.
    """
    ACTION_LOG_MAP = {
        'compile': 'Compiling mo file',  # creates an FMU
        'compile_and_run': 'Compile and run the mo file',
        'run': 'Running FMU',
    }

    def __init__(self):
        """
        Initialize the runner with data needed for simulation
        """

        # Verify that docker is up and running, if needed.
        r = subprocess.call(['docker', 'ps'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        self.docker_configured = r == 0

    def _verify_docker_run_capability(self, file_to_load: Union[str, Path, None]):
        """Verify that docker is configured on the host computer correctly before running

        Args:
            file_to_load (Union[str, Path]): Can be a file path or a modelica path

        Raises:
            SystemExit: _description_
            SystemExit: _description_
        """
        if not self.docker_configured:
            raise SystemExit('Docker not configured on host computer, unable to run')

        # If there is a file to load (meaning that we aren't loading from the library),
        # then check that it exists
        if file_to_load and not Path(file_to_load).exists():
            raise SystemExit(f'File not found to run {file_to_load}')

    def _verify_run_path_for_docker(self, run_path: Union[str, Path, None], file_to_run: Union[str, Path, None]) -> Path:
        """If there is no run_path, then run it in the same directory as the
        file being run. This works fine for simple Modelica projects but typically
        the run_path needs to be a few levels higher in order to include other
        project dependencies (e.g., multiple mo files).

        Args:
            run_path (str): directory of where to run the simulation
            file_to_run (str): the name of the file to run. This should be the fully
                               qualified path to the file.

        Raises:
            SystemExit: Throw an exception if the run_path or file_to_run has spaces in it

        Returns:
            Path: Return the run_path as a Path object
        """
        if not run_path:
            run_path = Path(file_to_run).parent  # type: ignore
        new_run_path = Path(run_path)

        # Modelica can't handle spaces in project name or path
        if (len(str(new_run_path).split()) > 1) or (len(str(file_to_run).split()) > 1):
            raise SystemExit(
                f"\nModelica does not support spaces in project names or paths. "
                f"You used '{new_run_path}' for run path and {file_to_run} for model project name. "
                "Please update your directory path or model name to not include spaces anywhere.")
        return new_run_path

    def _copy_over_docker_resources(self, run_path: Path, filename: Union[str, Path, None], model_name: str, **kwargs) -> None:
        """Copy over files needed to run the simulation, this includes
        the generation of the OpenModelica scripts to load and compile/run
        the simulation.

        Must pass start_time, stop_time, and either step_size or number_of_intervals.

        Args:
            run_path (Path): Path where the model will be run, this is where the files will be copied.
            filename (str): name of the file that will be loaded (e.g., BouncingBall.mo, package.mo)
            model_name (str): name of the model to run (e.g., BouncingBall, Districts.DistrictModel)
            **kwargs: Arbitrary keyword arguments.
                project_in_library (bool): If True, then the file_to_load is in the library, otherwise it is a file
                                             on the local file system.
                start_time (int): start time of the simulation, in seconds
                stop_time (int): stop time of the simulation, in seconds
                step_size (int): step size of the simulation, in seconds
                number_of_intervals (int): number of intervals to run the simulation
        """
        # read in the start, stop, and step times
        project_in_library = kwargs.get('project_in_library', False)
        start_time = kwargs.get('start_time', None)
        stop_time = kwargs.get('stop_time', None)
        step_size = kwargs.get('step_size', None)
        number_of_intervals = kwargs.get('number_of_intervals', None)

        # initialize the templating framework (Jinja2)
        template_env = Environment(
            loader=FileSystemLoader(searchpath=Path(__file__).parent.resolve() / 'lib' / 'runner'),
            undefined=StrictUndefined
        )
        template_env.filters.update(ALL_CUSTOM_FILTERS)
        template = template_env.get_template('simulate.most')
        model_data = {
            "project_in_library": project_in_library,
            "file_to_load": Path(filename).name if filename else None,
            "model_name": model_name,
            "use_default_time_params": False if start_time is not None and stop_time is not None else True,
            "start_time": start_time,
            "stop_time": stop_time,
            "step_size": step_size,
            "number_of_intervals": number_of_intervals,
        }
        with open(run_path / 'simulate.mos', 'w') as f:
            f.write(template.render(**model_data))
        template = template_env.get_template('compile_fmu.most')
        with open(run_path / 'compile_fmu.mos', 'w') as f:
            f.write(template.render(**model_data))

    def _subprocess_call_to_docker(self, run_path: Path, action: str) -> int:
        """Call out to a subprocess to run the command in docker

        Args:
            run_path (Path): local path where the Modelica simulation or compilation will start
            action (str):  action to run either compile_and_run, compile, or run

        Returns:
            int: exit code of the subprocess
        """
        # Set up the run content
        curdir = Path.cwd()
        os.chdir(run_path)
        stdout_log = open('stdout.log', 'w')
        model_name = run_path.parts[-1]
        image_name = 'nrel/gmt-om-runner:v2.0.0'
        mo_script = 'compile_fmu' if action == 'compile' else 'simulate'
        try:
            # create the command to call the open modelica compiler inside the docker image
            exec_call = ['docker', 'run', '-v', f'{run_path}:/mnt/shared/{model_name}', f'{image_name}',
                         '/bin/bash', '-c', f"cd mnt/shared/{model_name} && omc {mo_script}.mos"]
            # execute the command that calls docker
            logger.debug(f"Calling {exec_call}")
            completed_process = subprocess.run(
                exec_call,  # type: ignore
                stdout=stdout_log,
                stderr=subprocess.STDOUT,
                cwd=run_path
            )
            # Uncomment this section and rebuild the container in order to pause the container
            # to inspect the container and test commands.
            # import time
            # time.sleep(10000)  # wait for the subprocess to start
            logger.debug(f"Subprocess command executed, waiting for completion... \nArgs used: {completed_process.args}")
        except KeyboardInterrupt:
            # List all containers and their images
            docker_containers_cmd = ['docker', 'ps', '--format', '{{.ID}} {{.Image}}']
            containers_list = subprocess.check_output(docker_containers_cmd, text=True).rstrip().split('\n')

            # Find containers from our image
            for container_line in containers_list:
                container_id, container_image = container_line.split()
                if container_image == image_name:
                    logger.debug(f"Killing container: {container_id} (Image: {container_image})")
                    # Kill the container
                    kill_command = f"docker kill {container_id}"
                    subprocess.run(kill_command.split(), check=True, text=True)
            # Remind user why the simulation didn't complete
            raise SystemExit("Simulation stopped by user KeyboardInterrupt")
        finally:
            os.chdir(curdir)
            stdout_log.close()
            logger.debug('Closed stdout.log')

        return completed_process.returncode

    def run_in_docker(self, action: str, model_name: str, file_to_load: Union[str, Path, None] = None,
                      run_path: Union[str, Path, None] = None, **kwargs) -> tuple[bool, Union[str, Path]]:
        """Run the Modelica project in a docker-based environment. The action will determine
        what type of run will be conducted. This method supports either a file path pointing to the package to load, or a modelica path which is a period separated path. Results are saved into run_path.

        stdout.log will store both stdout and stderr of the simulations

        Args:
            action (str): The action to run, must be one of compile_and_run, compile, or run
            model_name (str): The name of the model to be simulated (this is the name within Modelica)
            file_to_load (str, Path): The file path or a modelica path to be simulated
            run_path (str, optional): location where the Modelica simulation will start. Defaults to None.
            kwargs: additional arguments to pass to the runner which can include
                project_in_library (bool): whether the project is in a library or not
                start_time (float): start time of the simulation
                stop_time (float): stop time of the simulation
                step_size (float): step size of the simulation
                number_of_intervals (int): number of intervals to run the simulation
                debug (bool): whether to run in debug mode or not, prevents files from being deleted.

        Returns:
            tuple[bool, str]: success status and path to the results directory
        """
        # Verify that the action is in the list of valid actions
        if action not in ModelicaRunner.ACTION_LOG_MAP:
            raise SystemExit(f'Invalid action {action}, must be one of {list(ModelicaRunner.ACTION_LOG_MAP.keys())}')

        self._verify_docker_run_capability(file_to_load)
        verified_run_path = self._verify_run_path_for_docker(run_path, file_to_load)

        self._copy_over_docker_resources(
            verified_run_path, file_to_load, model_name, **kwargs
        )

        exitcode = self._subprocess_call_to_docker(verified_run_path, action)

        logger.debug('Checking stdout.log for errors')
        with open(verified_run_path / 'stdout.log', 'r') as f:
            stdout_log = f.read()
            if 'Failed to build model' in stdout_log:
                logger.error('Model failed to build')
                exitcode = 1
            elif 'Killed' in stdout_log:
                logger.error('Model is too large for the Docker resources available.'
                             ' Increase Docker resources, decrease number of buildings simulated, or both')
            elif 'division by zero at time' and 'Simulation execution failed for model:' in stdout_log:
                logger.error('Model failed to run due to division by zero')
                exitcode = 1
            elif 'The simulation finished successfully' in stdout_log:
                logger.info('Model ran successfully')
                exitcode = 0
            elif action == 'compile':
                logger.info('Model compiled successfully -- no errors')
                exitcode = 0
            else:
                logger.error('Model failed to run -- unknown error')
                exitcode = 1

        # Cleanup all of the temporary files that get created
        self.cleanup_path(verified_run_path, model_name, debug=kwargs.get('debug', False))

        logger.debug('Moving results to results directory')
        # get the location of the results path
        results_path = Path(verified_run_path / f'{model_name}_results')
        self.move_results(verified_run_path, results_path, model_name)
        return (exitcode == 0, results_path)

    def run_in_dymola(self, action: str, model_name: str, file_to_load: Union[str, Path], run_path: Union[str, Path], **kwargs) -> tuple[bool, Union[str, Path]]:
        """If running on Windows or Linux, you can run Dymola (assuming you have a license),
        using the BuildingsPy library. This is not supported on Mac.

        For using Dymola with the GMT, you need to ensure that MSL v4.0 are loaded correctly and that the
        Buildings library is in the MODELICAPATH. I added the MSL openModel via appending it to the Dymola's
        /opt/<install>/install/dymola.mos file on Linux.

        Args:
            action (str): compile (translate) or simulate
            model_name (str): Name of the model to translate or simulate
            package_path (Union[str, Path]): Name of the package to also load
            kwargs: additional arguments to pass to the runner which can include
                start_time (float): start time of the simulation
                stop_time (float): stop time of the simulation, in seconds
                step_size (float): step size of the simulation, in seconds
                debug (bool): whether to run in debug mode or not, prevents files from being deleted.

        Returns:
            tuple[bool, Union[str, Path]]:  success status and path to the results directory
        """
        run_path = str(run_path)
        current_dir = Path.cwd()
        try:
            os.chdir(run_path)
            print(run_path)
            if file_to_load is None:
                # This occurs when the model is already in a library that is loaded (e.g., MSL, Buildings)
                # Dymola does check the MODELICAPATH for any libraries that need to be loaded automatically.
                dymola_simulator = Simulator(
                    modelName=model_name,
                    outputDirectory=run_path,
                )
            else:
                file_to_load = str(file_to_load)
                dymola_simulator = Simulator(
                    modelName=model_name,
                    outputDirectory=run_path,
                    packagePath=file_to_load,
                )

            # TODO: add in passing of parameters
            # dymola_simulator.addParameters({'PI.k': 10.0, 'PI.Ti': 0.1})
            dymola_simulator.setSolver("dassl")

            start_time = kwargs.get('start_time', 0)
            stop_time = kwargs.get('stop_time', 300)
            step_size = kwargs.get('step_size', 5)

            # calculate the number of intervals based on the step size
            number_of_intervals = int((stop_time - start_time) / step_size)

            dymola_simulator.setStartTime(start_time)
            dymola_simulator.setStopTime(stop_time)
            dymola_simulator.setNumberOfIntervals(number_of_intervals)

            # Do not show progressbar! -- It will cause an "elapsed time used before assigned" error.
            # dymola_simulator.showProgressBar(show=True)

            if kwargs.get('debug', False):
                dymola_simulator.showGUI(show=True)
                dymola_simulator.exitSimulator(False)

            # BuildingPy throws an exception if the model errs
            try:
                if action == 'compile':
                    dymola_simulator.translate()
                    # the results of this does not create an FMU, just
                    # the status of the translation/compilation.
                elif action == 'simulate':
                    dymola_simulator.simulate()
            except Exception as e:
                logger.error(f"Exception running Dymola: {e}")
                return False, run_path

            # remove some of the unneeded results
            self.cleanup_path(Path(run_path), model_name, debug=kwargs.get('debug', False))
        finally:
            os.chdir(current_dir)

        return True, run_path

    def move_results(self, from_path: Path, to_path: Path, model_name: Union[str, None] = None) -> None:
        """This method moves the results of the simulation that are known for now.
        This method moves only specific files (stdout.log for now), plus all files and folders beginning
        with the "{project_name}_" name.

        If there are results, they will simply be overwritten (for now).

        Args:
            from_path (Path): where the files will move from
            to_path (Path): where the files will be saved. Will be created if does not exist.
            model_name (Union[str, None], optional): name of the project ran in run_in_docker method. Defaults to None.
        """
        to_path.mkdir(parents=True, exist_ok=True)

        files_to_move = [
            'stdout.log',
        ]
        if model_name is not None:
            files_to_move.append(f'{model_name}.log',)
            files_to_move.append(f'{model_name}.fmu',)
            files_to_move.append(f"{model_name.replace('.', '_')}.log",)
            files_to_move.append(f"{model_name.replace('.', '_')}_FMU.log",)

        for to_move in from_path.iterdir():
            if not to_move == to_path:
                if (to_move.name in files_to_move) or to_move.name.startswith(f'{model_name}_'):
                    # typecast back to strings for the shutil method.
                    shutil.move(str(to_move), str(to_path / to_move.name))

    def cleanup_path(self, path: Path, model_name: str, **kwargs: dict) -> None:
        """Clean up the files in the path that was presumably used to run the simulation.
        If debug is passed, then simulation running files will not be removed, but the
        intermediate simulation files will be removed (e.g., .c, .h, .o, .bin)

        Args:
            path (Path): Path of the folder to clean
            model_name (str): Name of the model, used to remove model-specific intermediate files
            kwargs: additional arguments to pass to the runner which can include
                debug (bool): whether to remove all files or not
        """
        # list of files to always remove
        files_to_remove = [
            'dsin.txt',
            'dsmodel.c',
            'dymosim',
            'request.',
            f'{model_name}',
            f'{model_name}.makefile',
            f'{model_name}.libs',
            f"{model_name.replace('.', '_')}_info.json",
            f"{model_name.replace('.', '_')}_FMU.makefile",
            f"{model_name.replace('.', '_')}_FMU.libs",
        ]

        conditional_remove_files = [
            'compile_fmu.mos',
            'simulate.mos',
            'run.mos',
            'run_translate.mos',
        ]

        logger.debug('Removing temporary files')

        if not kwargs.get('debug', False):
            logger.debug('...and removing intermediate files')
            files_to_remove.extend(conditional_remove_files)

        for f in files_to_remove:
            (path / f).unlink(missing_ok=True)

        # The other files below will always be removed, debug or not

        # glob for the .c, .h, .o, .bin files to remove
        remove_files_glob = [
            f'{model_name}*.c',
            f'{model_name}*.h',
            f'{model_name}*.o',
            f'{model_name}*.bin',
        ]
        for pattern in remove_files_glob:
            for f in path.glob(pattern):  # type: ignore
                Path(f).unlink(missing_ok=True)

        # Remove the 'tmp' folder that was created by 5G simulations
        # Dir won't exist for 4G simulations, so ignoring errors
        shutil.rmtree(path / 'tmp', ignore_errors=True)

1	# :copyright (c) URBANopt, Alliance for Sustainable Energy, LLC, and other contributors.
2	# See also https://github.com/urbanopt/geojson-modelica-translator/blob/develop/LICENSE.md
3
4	import logging	2✔
5	import os	2✔
6	import shutil	2✔
7	import subprocess	2✔
8	from pathlib import Path	2✔
9	from typing import Union	2✔
10
11	from buildingspy.simulate.Dymola import Simulator	2✔
12	from jinja2 import Environment, FileSystemLoader, StrictUndefined	2✔
13
14	from geojson_modelica_translator.jinja_filters import ALL_CUSTOM_FILTERS	2✔
15
16	logger = logging.getLogger(__name__)	2✔
17	logging.basicConfig(	2✔
18	level=logging.INFO,
19	format='%(asctime)s - %(levelname)s: %(message)s',
20	datefmt='%d-%b-%y %H:%M:%S',
21	)
22
23
24	class ModelicaRunner(object):	2✔
25	"""
26	Class to run Modelica models.
27	"""
28	ACTION_LOG_MAP = {	2✔
29	'compile': 'Compiling mo file', # creates an FMU
30	'compile_and_run': 'Compile and run the mo file',
31	'run': 'Running FMU',
32	}
33
34	def __init__(self):	2✔
35	"""
36	Initialize the runner with data needed for simulation
37	"""
38
39	# Verify that docker is up and running, if needed.
40	r = subprocess.call(['docker', 'ps'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)	2✔
41	self.docker_configured = r == 0	2✔
42
43	def _verify_docker_run_capability(self, file_to_load: Union[str, Path, None]):	2✔
44	"""Verify that docker is configured on the host computer correctly before running
45
46	Args:
47	file_to_load (Union[str, Path]): Can be a file path or a modelica path
48
49	Raises:
50	SystemExit: _description_
51	SystemExit: _description_
52	"""
53	if not self.docker_configured:	2!
54	raise SystemExit('Docker not configured on host computer, unable to run')	×
55
56	# If there is a file to load (meaning that we aren't loading from the library),
57	# then check that it exists
58	if file_to_load and not Path(file_to_load).exists():	2✔
59	raise SystemExit(f'File not found to run {file_to_load}')	2✔
60
61	def _verify_run_path_for_docker(self, run_path: Union[str, Path, None], file_to_run: Union[str, Path, None]) -> Path:	2✔
62	"""If there is no run_path, then run it in the same directory as the
63	file being run. This works fine for simple Modelica projects but typically
64	the run_path needs to be a few levels higher in order to include other
65	project dependencies (e.g., multiple mo files).
66
67	Args:
68	run_path (str): directory of where to run the simulation
69	file_to_run (str): the name of the file to run. This should be the fully
70	qualified path to the file.
71
72	Raises:
73	SystemExit: Throw an exception if the run_path or file_to_run has spaces in it
74
75	Returns:
76	Path: Return the run_path as a Path object
77	"""
78	if not run_path:	2✔
79	run_path = Path(file_to_run).parent # type: ignore	2✔
80	new_run_path = Path(run_path)	2✔
81
82	# Modelica can't handle spaces in project name or path
83	if (len(str(new_run_path).split()) > 1) or (len(str(file_to_run).split()) > 1):	2!
84	raise SystemExit(	×
85	f"\nModelica does not support spaces in project names or paths. "
86	f"You used '{new_run_path}' for run path and {file_to_run} for model project name. "
87	"Please update your directory path or model name to not include spaces anywhere.")
88	return new_run_path	2✔
89
90	def _copy_over_docker_resources(self, run_path: Path, filename: Union[str, Path, None], model_name: str, **kwargs) -> None:	2✔
91	"""Copy over files needed to run the simulation, this includes
92	the generation of the OpenModelica scripts to load and compile/run
93	the simulation.
94
95	Must pass start_time, stop_time, and either step_size or number_of_intervals.
96
97	Args:
98	run_path (Path): Path where the model will be run, this is where the files will be copied.
99	filename (str): name of the file that will be loaded (e.g., BouncingBall.mo, package.mo)
100	model_name (str): name of the model to run (e.g., BouncingBall, Districts.DistrictModel)
101	**kwargs: Arbitrary keyword arguments.
102	project_in_library (bool): If True, then the file_to_load is in the library, otherwise it is a file
103	on the local file system.
104	start_time (int): start time of the simulation, in seconds
105	stop_time (int): stop time of the simulation, in seconds
106	step_size (int): step size of the simulation, in seconds
107	number_of_intervals (int): number of intervals to run the simulation
108	"""
109	# read in the start, stop, and step times
110	project_in_library = kwargs.get('project_in_library', False)	2✔
111	start_time = kwargs.get('start_time', None)	2✔
112	stop_time = kwargs.get('stop_time', None)	2✔
113	step_size = kwargs.get('step_size', None)	2✔
114	number_of_intervals = kwargs.get('number_of_intervals', None)	2✔
115
116	# initialize the templating framework (Jinja2)
117	template_env = Environment(	2✔
118	loader=FileSystemLoader(searchpath=Path(__file__).parent.resolve() / 'lib' / 'runner'),
119	undefined=StrictUndefined
120	)
121	template_env.filters.update(ALL_CUSTOM_FILTERS)	2✔
122	template = template_env.get_template('simulate.most')	2✔
123	model_data = {	2✔
124	"project_in_library": project_in_library,
125	"file_to_load": Path(filename).name if filename else None,
126	"model_name": model_name,
127	"use_default_time_params": False if start_time is not None and stop_time is not None else True,
128	"start_time": start_time,
129	"stop_time": stop_time,
130	"step_size": step_size,
131	"number_of_intervals": number_of_intervals,
132	}
133	with open(run_path / 'simulate.mos', 'w') as f:	2✔
134	f.write(template.render(**model_data))	2✔
135	template = template_env.get_template('compile_fmu.most')	2✔
136	with open(run_path / 'compile_fmu.mos', 'w') as f:	2✔
137	f.write(template.render(**model_data))	2✔
138
139	def _subprocess_call_to_docker(self, run_path: Path, action: str) -> int:	2✔
140	"""Call out to a subprocess to run the command in docker
141
142	Args:
143	run_path (Path): local path where the Modelica simulation or compilation will start
144	action (str): action to run either compile_and_run, compile, or run
145
146	Returns:
147	int: exit code of the subprocess
148	"""
149	# Set up the run content
150	curdir = Path.cwd()	2✔
151	os.chdir(run_path)	2✔
152	stdout_log = open('stdout.log', 'w')	2✔
153	model_name = run_path.parts[-1]	2✔
154	image_name = 'nrel/gmt-om-runner:v2.0.0'	2✔
155	mo_script = 'compile_fmu' if action == 'compile' else 'simulate'	2✔
156	try:	2✔
157	# create the command to call the open modelica compiler inside the docker image
158	exec_call = ['docker', 'run', '-v', f'{run_path}:/mnt/shared/{model_name}', f'{image_name}',	2✔
159	'/bin/bash', '-c', f"cd mnt/shared/{model_name} && omc {mo_script}.mos"]
160	# execute the command that calls docker
161	logger.debug(f"Calling {exec_call}")	2✔
162	completed_process = subprocess.run(	2✔
163	exec_call, # type: ignore
164	stdout=stdout_log,
165	stderr=subprocess.STDOUT,
166	cwd=run_path
167	)
168	# Uncomment this section and rebuild the container in order to pause the container
169	# to inspect the container and test commands.
170	# import time
171	# time.sleep(10000) # wait for the subprocess to start
172	logger.debug(f"Subprocess command executed, waiting for completion... \nArgs used: {completed_process.args}")	2✔
173	except KeyboardInterrupt:	×
174	# List all containers and their images
175	docker_containers_cmd = ['docker', 'ps', '--format', '{{.ID}} {{.Image}}']	×
176	containers_list = subprocess.check_output(docker_containers_cmd, text=True).rstrip().split('\n')	×
177
178	# Find containers from our image
179	for container_line in containers_list:	×
180	container_id, container_image = container_line.split()	×
181	if container_image == image_name:	×
182	logger.debug(f"Killing container: {container_id} (Image: {container_image})")	×
183	# Kill the container
184	kill_command = f"docker kill {container_id}"	×
185	subprocess.run(kill_command.split(), check=True, text=True)	×
186	# Remind user why the simulation didn't complete
187	raise SystemExit("Simulation stopped by user KeyboardInterrupt")	×
188	finally:
189	os.chdir(curdir)	2✔
190	stdout_log.close()	2✔
191	logger.debug('Closed stdout.log')	2!
192
193	return completed_process.returncode	2✔
194
195	def run_in_docker(self, action: str, model_name: str, file_to_load: Union[str, Path, None] = None,	2✔
196	run_path: Union[str, Path, None] = None, **kwargs) -> tuple[bool, Union[str, Path]]:
197	"""Run the Modelica project in a docker-based environment. The action will determine
198	what type of run will be conducted. This method supports either a file path pointing to the package to load, or a modelica path which is a period separated path. Results are saved into run_path.
199
200	stdout.log will store both stdout and stderr of the simulations
201
202	Args:
203	action (str): The action to run, must be one of compile_and_run, compile, or run
204	model_name (str): The name of the model to be simulated (this is the name within Modelica)
205	file_to_load (str, Path): The file path or a modelica path to be simulated
206	run_path (str, optional): location where the Modelica simulation will start. Defaults to None.
207	kwargs: additional arguments to pass to the runner which can include
208	project_in_library (bool): whether the project is in a library or not
209	start_time (float): start time of the simulation
210	stop_time (float): stop time of the simulation
211	step_size (float): step size of the simulation
212	number_of_intervals (int): number of intervals to run the simulation
213	debug (bool): whether to run in debug mode or not, prevents files from being deleted.
214
215	Returns:
216	tuple[bool, str]: success status and path to the results directory
217	"""
218	# Verify that the action is in the list of valid actions
219	if action not in ModelicaRunner.ACTION_LOG_MAP:	2✔
220	raise SystemExit(f'Invalid action {action}, must be one of {list(ModelicaRunner.ACTION_LOG_MAP.keys())}')	2✔
221
222	self._verify_docker_run_capability(file_to_load)	2✔
223	verified_run_path = self._verify_run_path_for_docker(run_path, file_to_load)	2✔
224
225	self._copy_over_docker_resources(	2✔
226	verified_run_path, file_to_load, model_name, **kwargs
227	)
228
229	exitcode = self._subprocess_call_to_docker(verified_run_path, action)	2✔
230
231	logger.debug('Checking stdout.log for errors')	2✔
232	with open(verified_run_path / 'stdout.log', 'r') as f:	2✔
233	stdout_log = f.read()	2✔
234	if 'Failed to build model' in stdout_log:	2!
235	logger.error('Model failed to build')	×
236	exitcode = 1	×
237	elif 'Killed' in stdout_log:	2!
NEW 238	logger.error('Model is too large for the Docker resources available.'	×
239	' Increase Docker resources, decrease number of buildings simulated, or both')
240	elif 'division by zero at time' and 'Simulation execution failed for model:' in stdout_log:	2✔
241	logger.error('Model failed to run due to division by zero')	2✔
242	exitcode = 1	2✔
243	elif 'The simulation finished successfully' in stdout_log:	2✔
244	logger.info('Model ran successfully')	2✔
245	exitcode = 0	2✔
246	elif action == 'compile':	2!
247	logger.info('Model compiled successfully -- no errors')	2✔
248	exitcode = 0	2✔
249	else:
250	logger.error('Model failed to run -- unknown error')	×
251	exitcode = 1	×
252
253	# Cleanup all of the temporary files that get created
254	self.cleanup_path(verified_run_path, model_name, debug=kwargs.get('debug', False))	2✔
255
256	logger.debug('Moving results to results directory')	2✔
257	# get the location of the results path
258	results_path = Path(verified_run_path / f'{model_name}_results')	2✔
259	self.move_results(verified_run_path, results_path, model_name)	2✔
260	return (exitcode == 0, results_path)	2✔
261
262	def run_in_dymola(self, action: str, model_name: str, file_to_load: Union[str, Path], run_path: Union[str, Path], **kwargs) -> tuple[bool, Union[str, Path]]:	2✔
263	"""If running on Windows or Linux, you can run Dymola (assuming you have a license),
264	using the BuildingsPy library. This is not supported on Mac.
265
266	For using Dymola with the GMT, you need to ensure that MSL v4.0 are loaded correctly and that the
267	Buildings library is in the MODELICAPATH. I added the MSL openModel via appending it to the Dymola's
268	/opt/<install>/install/dymola.mos file on Linux.
269
270	Args:
271	action (str): compile (translate) or simulate
272	model_name (str): Name of the model to translate or simulate
273	package_path (Union[str, Path]): Name of the package to also load
274	kwargs: additional arguments to pass to the runner which can include
275	start_time (float): start time of the simulation
276	stop_time (float): stop time of the simulation, in seconds
277	step_size (float): step size of the simulation, in seconds
278	debug (bool): whether to run in debug mode or not, prevents files from being deleted.
279
280	Returns:
281	tuple[bool, Union[str, Path]]: success status and path to the results directory
282	"""
283	run_path = str(run_path)	×
284	current_dir = Path.cwd()	×
285	try:	×
286	os.chdir(run_path)	×
287	print(run_path)	×
288	if file_to_load is None:	×
289	# This occurs when the model is already in a library that is loaded (e.g., MSL, Buildings)
290	# Dymola does check the MODELICAPATH for any libraries that need to be loaded automatically.
291	dymola_simulator = Simulator(	×
292	modelName=model_name,
293	outputDirectory=run_path,
294	)
295	else:
296	file_to_load = str(file_to_load)	×
297	dymola_simulator = Simulator(	×
298	modelName=model_name,
299	outputDirectory=run_path,
300	packagePath=file_to_load,
301	)
302
303	# TODO: add in passing of parameters
304	# dymola_simulator.addParameters({'PI.k': 10.0, 'PI.Ti': 0.1})
305	dymola_simulator.setSolver("dassl")	×
306
307	start_time = kwargs.get('start_time', 0)	×
308	stop_time = kwargs.get('stop_time', 300)	×
309	step_size = kwargs.get('step_size', 5)	×
310
311	# calculate the number of intervals based on the step size
312	number_of_intervals = int((stop_time - start_time) / step_size)	×
313
314	dymola_simulator.setStartTime(start_time)	×
315	dymola_simulator.setStopTime(stop_time)	×
316	dymola_simulator.setNumberOfIntervals(number_of_intervals)	×
317
318	# Do not show progressbar! -- It will cause an "elapsed time used before assigned" error.
319	# dymola_simulator.showProgressBar(show=True)
320
321	if kwargs.get('debug', False):	×
322	dymola_simulator.showGUI(show=True)	×
323	dymola_simulator.exitSimulator(False)	×
324
325	# BuildingPy throws an exception if the model errs
326	try:	×
327	if action == 'compile':	×
328	dymola_simulator.translate()	×
329	# the results of this does not create an FMU, just
330	# the status of the translation/compilation.
331	elif action == 'simulate':	×
332	dymola_simulator.simulate()	×
333	except Exception as e:	×
334	logger.error(f"Exception running Dymola: {e}")	×
335	return False, run_path	×
336
337	# remove some of the unneeded results
338	self.cleanup_path(Path(run_path), model_name, debug=kwargs.get('debug', False))	×
339	finally:
340	os.chdir(current_dir)	×
341
342	return True, run_path	×
343
344	def move_results(self, from_path: Path, to_path: Path, model_name: Union[str, None] = None) -> None:	2✔
345	"""This method moves the results of the simulation that are known for now.
346	This method moves only specific files (stdout.log for now), plus all files and folders beginning
347	with the "{project_name}_" name.
348
349	If there are results, they will simply be overwritten (for now).
350
351	Args:
352	from_path (Path): where the files will move from
353	to_path (Path): where the files will be saved. Will be created if does not exist.
354	model_name (Union[str, None], optional): name of the project ran in run_in_docker method. Defaults to None.
355	"""
356	to_path.mkdir(parents=True, exist_ok=True)	2✔
357
358	files_to_move = [	2✔
359	'stdout.log',
360	]
361	if model_name is not None:	2!
362	files_to_move.append(f'{model_name}.log',)	2✔
363	files_to_move.append(f'{model_name}.fmu',)	2✔
364	files_to_move.append(f"{model_name.replace('.', '_')}.log",)	2✔
365	files_to_move.append(f"{model_name.replace('.', '_')}_FMU.log",)	2✔
366
367	for to_move in from_path.iterdir():	2✔
368	if not to_move == to_path:	2✔
369	if (to_move.name in files_to_move) or to_move.name.startswith(f'{model_name}_'):	2✔
370	# typecast back to strings for the shutil method.
371	shutil.move(str(to_move), str(to_path / to_move.name))	2✔
372
373	def cleanup_path(self, path: Path, model_name: str, **kwargs: dict) -> None:	2✔
374	"""Clean up the files in the path that was presumably used to run the simulation.
375	If debug is passed, then simulation running files will not be removed, but the
376	intermediate simulation files will be removed (e.g., .c, .h, .o, .bin)
377
378	Args:
379	path (Path): Path of the folder to clean
380	model_name (str): Name of the model, used to remove model-specific intermediate files
381	kwargs: additional arguments to pass to the runner which can include
382	debug (bool): whether to remove all files or not
383	"""
384	# list of files to always remove
385	files_to_remove = [	2✔
386	'dsin.txt',
387	'dsmodel.c',
388	'dymosim',
389	'request.',
390	f'{model_name}',
391	f'{model_name}.makefile',
392	f'{model_name}.libs',
393	f"{model_name.replace('.', '_')}_info.json",
394	f"{model_name.replace('.', '_')}_FMU.makefile",
395	f"{model_name.replace('.', '_')}_FMU.libs",
396	]
397
398	conditional_remove_files = [	2✔
399	'compile_fmu.mos',
400	'simulate.mos',
401	'run.mos',
402	'run_translate.mos',
403	]
404
405	logger.debug('Removing temporary files')	2✔
406
407	if not kwargs.get('debug', False):	2!
408	logger.debug('...and removing intermediate files')	2✔
409	files_to_remove.extend(conditional_remove_files)	2✔
410
411	for f in files_to_remove:	2✔
412	(path / f).unlink(missing_ok=True)	2✔
413
414	# The other files below will always be removed, debug or not
415
416	# glob for the .c, .h, .o, .bin files to remove
417	remove_files_glob = [	2✔
418	f'{model_name}*.c',
419	f'{model_name}*.h',
420	f'{model_name}*.o',
421	f'{model_name}*.bin',
422	]
423	for pattern in remove_files_glob:	2✔
424	for f in path.glob(pattern): # type: ignore	2✔
425	Path(f).unlink(missing_ok=True)	2✔
426
427	# Remove the 'tmp' folder that was created by 5G simulations
428	# Dir won't exist for 4G simulations, so ignoring errors
429	shutil.rmtree(path / 'tmp', ignore_errors=True)	2✔

urbanopt / geojson-modelica-translator / 7425403093

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous