11113713598

Committed 30 Sep 2024 08:33PM UTC coverage: 88.358% (-0.002%) from 88.36%

Build # 11113713598

Build Type

Pull #646

github

Committed by

tanushree04

Commit Message

run pre-commit

Pull Request Pull Request #646: Adds method to process modelica results

Run Details

1044 of 1263 branches covered (82.66%)

Branch coverage included in aggregate %.

64 of 74 new or added lines in 2 files covered. (86.49%)

2 existing lines in 1 file now uncovered.

2842 of 3135 relevant lines covered (90.65%)

1.81 hits per line

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

93.84

/management/uo_des.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

from pathlib import Path
from shutil import rmtree

import click

from geojson_modelica_translator.geojson_modelica_translator import GeoJsonModelicaTranslator
from geojson_modelica_translator.modelica.modelica_runner import ModelicaRunner
from geojson_modelica_translator.results_ghp import ResultsModelica
from geojson_modelica_translator.system_parameters.system_parameters import SystemParameters

CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}


@click.group(context_settings=CONTEXT_SETTINGS)
def cli():
    """URBANopt District Energy Systems"""


@cli.command(short_help="Create sys-param file")
@click.argument(
    "sys_param_filename",
    type=click.Path(file_okay=True, dir_okay=False),
)
@click.argument(
    "scenario_file",
    type=click.Path(exists=True, file_okay=True, dir_okay=False),
)
@click.argument(
    "feature_file",
    type=click.Path(exists=True, file_okay=True, dir_okay=False),
)
@click.argument(
    "district_type",
    default="4G",
)
@click.argument(
    "model_type",
    default="time_series",
)
@click.option(
    "-o",
    "--overwrite",
    is_flag=True,
    help="Delete and replace any existing file of the same name & location",
    default=False,
)
@click.option(
    "-m",
    "--microgrid",
    is_flag=True,
    help="If specified, microgrid inputs will be added to system parameters file",
    default=False,
)
def build_sys_param(
    model_type: str,
    sys_param_filename: Path,
    scenario_file: Path,
    feature_file: Path,
    district_type: str,
    overwrite: bool,
    microgrid: bool,
):
    """Create system parameters file using uo_sdk output
    #FIXME: Formatting of the args...

    SYS_PARAM_FILENAME: Path/name to sys-param file be created. Be sure to include the ".json" suffix.

    SCENARIO_FILE: Path to sdk scenario file.

    FEATURE_FILE: Path to sdk json feature file with data about the buildings.

    DISTRICT_TYPE: selection for which kind of simulation this sys-param file will support.
    Available options are: ['steam', '4G', '5G', '5G_ghe']

    \b
    MODEL_TYPE: selection for which kind of simulation this sys-param file will support.
    Available options are: "time_series"

    \f
    :param model_type: string, selection of which model type to use in the GMT
    :param sys_param_filename: Path, location & name of json output file to save
    :param scenario_file: Path, location of SDK scenario_file
    :param feature_file: Path, location of SDK feature_file
    :param district_type: string, district type to model
    :param overwrite: Boolean, flag to overwrite an existing file of the same name/location
    :param microgrid: Boolean, flag to add Microgrid properties to System Parameter File
    """

    # Use scenario_file to be consistent with sdk
    scenario_name = Path(scenario_file).stem
    scenario_dir = Path(scenario_file).parent / "run" / scenario_name
    sp = SystemParameters()
    sp.csv_to_sys_param(
        model_type=model_type,
        sys_param_filename=Path(sys_param_filename),
        scenario_dir=Path(scenario_dir),
        feature_file=Path(feature_file),
        district_type=district_type,
        overwrite=overwrite,
        microgrid=microgrid,
    )

    if Path(sys_param_filename).exists():
        print(f"\nSystem parameters file {sys_param_filename} successfully created.")
    else:
        raise SystemExit(f"{sys_param_filename} failed. Please check your inputs and try again.")


@cli.command(short_help="Create Modelica model")
@click.argument(
    "sys_param_file",
    type=click.Path(exists=True, file_okay=True, dir_okay=False),
)
@click.argument(
    "geojson_feature_file",
    type=click.Path(exists=True, file_okay=True, dir_okay=False),
)
@click.argument(
    "project_path",
    default="model_from_sdk",
    type=click.Path(exists=False, file_okay=False, dir_okay=True),
)
@click.option(
    "-o",
    "--overwrite",
    is_flag=True,
    help="Delete and replace any existing folder of the same name & location",
    default=False,
)
def create_model(sys_param_file: Path, geojson_feature_file: Path, project_path: Path, overwrite: bool):
    """Build Modelica model from user data

    SYS_PARAM_FILE: Path/name to sys-param file, possibly created with this CLI.

    GEOJSON_FEATURE_FILE: Path to sdk json feature file with data about the buildings.

    PROJECT_PATH: Path for Modelica project directory created with this command

    \f
    :param sys_param_file: Path, location and name of file created with this cli
    :param geojson_feature_file: Path, location and name of sdk feature_file
    :param project_path: Path, location and name of Modelica model dir to be created
    :param overwrite: Boolean, flag to overwrite an existing file of the same name/location
    """
    project_path = Path(project_path)
    if project_path.exists():
        if overwrite:
            rmtree(project_path, ignore_errors=True)
        else:
            raise SystemExit(f"Output dir '{project_path}' already exists and overwrite flag is not given")
    if len(project_path.name.split()) > 1:  # Modelica can't handle spaces in project name
        raise SystemExit(
            f"\n'{project_path}' failed. Modelica does not support spaces in project names or paths. "
            "Please choose a different 'project_path'"
        )

    gmt = GeoJsonModelicaTranslator(geojson_feature_file, sys_param_file, project_path.parent, project_path.name)

    gmt.to_modelica()


@cli.command(short_help="Run Modelica model")
@click.argument(
    "modelica_project",
    default="./model_from_sdk",
    required=True,
    type=click.Path(exists=True, file_okay=False, dir_okay=True),
)
@click.option(
    "-a",
    "--start_time",
    default=17280000,
    help="Start time of the simulation (seconds of a year)",
    type=int,
)
@click.option(
    "-z",
    "--stop_time",
    default=31536000,
    help="Stop time of the simulation (seconds of a year)",
    type=int,
)
@click.option(
    "-x",
    "--step_size",
    default=900,
    help="Step size of the simulation (seconds)",
    type=int,
)
@click.option(
    "-i",
    "--intervals",
    default=35050,
    help="Number of intervals to divide the simulation into (alternative to step_size)",
    type=int,
)
def run_model(modelica_project: Path, start_time: int, stop_time: int, step_size: int, intervals: int):
    """Run the model
    \b
    Run the Modelica project in a docker-based environment.
    Results are saved at the same level as the project path that is passed.
    The model that runs is hard coded to be the Districts/DistrictEnergySystem.mo within the package.

    MODELICA_PROJECT: Path to the Modelica project, possibly created by this cli
        default = ./model_from_sdk

    \f
    :param sys_param_file: Path, location and name of file created with this cli
    :param modelica_project: Path, name & location of modelica project, possibly created with this cli
    :param start_time (int): start time of the simulation (seconds of a year)
    :param stop_time (int): stop time of the simulation (seconds of a year)
    :param step_size (int): step size of the simulation (seconds)
    :param number_of_intervals (int): number of intervals to run the simulation
    """
    run_path = Path(modelica_project).resolve()
    project_name = run_path.stem

    if len(str(run_path).split()) > 1:  # Modelica can't handle spaces in project name or path
        raise SystemExit(
            f"\n'{run_path}' failed. Modelica does not support spaces in project names or paths. "
            "Please update your directory tree to not include spaces in any name"
        )
    # setup modelica runner
    mr = ModelicaRunner()
    mr.run_in_docker(
        "compile_and_run",
        f"{project_name}.Districts.DistrictEnergySystem",
        file_to_load=run_path / "package.mo",
        run_path=run_path,
        start_time=start_time,
        stop_time=stop_time,
        step_size=step_size,
        number_of_intervals=intervals,
    )

    run_location = run_path.parent / project_name / f"{project_name}.Districts.DistrictEnergySystem_results"
    if (run_location / f"{project_name}.Districts.DistrictEnergySystem_res.mat").exists():
        print(f"\nModelica model {project_name} ran successfully and can be found in {run_location}")
    else:
        raise SystemExit(f"\n{project_name} failed. Check the error log at {run_location}/stdout.log for more info.")


@cli.command(short_help="Process Modelica model")
@click.argument(
    "modelica_project",
    default="./model_from_sdk",
    required=True,
    type=click.Path(exists=True, file_okay=False, dir_okay=True),
)
def des_process(modelica_project: Path):
    """Post Process the model
    \b
    Post process results from Modelica project run previously, for GHP LCCA analysis
    \b
    MODELICA_PROJECT: Path to the Modelica project, possibly created by this cli
        default = ./model_from_sdk

    \f
    :param modelica_project: Path, name & location of modelica project, possibly created with this cli
    """
    modelica_path = Path(modelica_project).resolve()
    result = ResultsModelica(modelica_path)
    result.calculate_results()

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	from pathlib import Path	2✔
5	from shutil import rmtree	2✔
6
7	import click	2✔
8
9	from geojson_modelica_translator.geojson_modelica_translator import GeoJsonModelicaTranslator	2✔
10	from geojson_modelica_translator.modelica.modelica_runner import ModelicaRunner	2✔
11	from geojson_modelica_translator.results_ghp import ResultsModelica	2✔
12	from geojson_modelica_translator.system_parameters.system_parameters import SystemParameters	2✔
13
14	CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}	2✔
15
16
17	@click.group(context_settings=CONTEXT_SETTINGS)	2✔
18	def cli():	2✔
19	"""URBANopt District Energy Systems"""
20
21
22	@cli.command(short_help="Create sys-param file")	2✔
23	@click.argument(	2✔
24	"sys_param_filename",
25	type=click.Path(file_okay=True, dir_okay=False),
26	)
27	@click.argument(	2✔
28	"scenario_file",
29	type=click.Path(exists=True, file_okay=True, dir_okay=False),
30	)
31	@click.argument(	2✔
32	"feature_file",
33	type=click.Path(exists=True, file_okay=True, dir_okay=False),
34	)
35	@click.argument(	2✔
36	"district_type",
37	default="4G",
38	)
39	@click.argument(	2✔
40	"model_type",
41	default="time_series",
42	)
43	@click.option(	2✔
44	"-o",
45	"--overwrite",
46	is_flag=True,
47	help="Delete and replace any existing file of the same name & location",
48	default=False,
49	)
50	@click.option(	2✔
51	"-m",
52	"--microgrid",
53	is_flag=True,
54	help="If specified, microgrid inputs will be added to system parameters file",
55	default=False,
56	)
57	def build_sys_param(	2✔
58	model_type: str,
59	sys_param_filename: Path,
60	scenario_file: Path,
61	feature_file: Path,
62	district_type: str,
63	overwrite: bool,
64	microgrid: bool,
65	):
66	"""Create system parameters file using uo_sdk output
67	#FIXME: Formatting of the args...
68
69	SYS_PARAM_FILENAME: Path/name to sys-param file be created. Be sure to include the ".json" suffix.
70
71	SCENARIO_FILE: Path to sdk scenario file.
72
73	FEATURE_FILE: Path to sdk json feature file with data about the buildings.
74
75	DISTRICT_TYPE: selection for which kind of simulation this sys-param file will support.
76	Available options are: ['steam', '4G', '5G', '5G_ghe']
77
78	\b
79	MODEL_TYPE: selection for which kind of simulation this sys-param file will support.
80	Available options are: "time_series"
81
82	\f
83	:param model_type: string, selection of which model type to use in the GMT
84	:param sys_param_filename: Path, location & name of json output file to save
85	:param scenario_file: Path, location of SDK scenario_file
86	:param feature_file: Path, location of SDK feature_file
87	:param district_type: string, district type to model
88	:param overwrite: Boolean, flag to overwrite an existing file of the same name/location
89	:param microgrid: Boolean, flag to add Microgrid properties to System Parameter File
90	"""
91
92	# Use scenario_file to be consistent with sdk
93	scenario_name = Path(scenario_file).stem	2✔
94	scenario_dir = Path(scenario_file).parent / "run" / scenario_name	2✔
95	sp = SystemParameters()	2✔
96	sp.csv_to_sys_param(	2✔
97	model_type=model_type,
98	sys_param_filename=Path(sys_param_filename),
99	scenario_dir=Path(scenario_dir),
100	feature_file=Path(feature_file),
101	district_type=district_type,
102	overwrite=overwrite,
103	microgrid=microgrid,
104	)
105
106	if Path(sys_param_filename).exists():	2!
107	print(f"\nSystem parameters file {sys_param_filename} successfully created.")	2✔
108	else:
109	raise SystemExit(f"{sys_param_filename} failed. Please check your inputs and try again.")	×
110
111
112	@cli.command(short_help="Create Modelica model")	2✔
113	@click.argument(	2✔
114	"sys_param_file",
115	type=click.Path(exists=True, file_okay=True, dir_okay=False),
116	)
117	@click.argument(	2✔
118	"geojson_feature_file",
119	type=click.Path(exists=True, file_okay=True, dir_okay=False),
120	)
121	@click.argument(	2✔
122	"project_path",
123	default="model_from_sdk",
124	type=click.Path(exists=False, file_okay=False, dir_okay=True),
125	)
126	@click.option(	2✔
127	"-o",
128	"--overwrite",
129	is_flag=True,
130	help="Delete and replace any existing folder of the same name & location",
131	default=False,
132	)
133	def create_model(sys_param_file: Path, geojson_feature_file: Path, project_path: Path, overwrite: bool):	2✔
134	"""Build Modelica model from user data
135
136	SYS_PARAM_FILE: Path/name to sys-param file, possibly created with this CLI.
137
138	GEOJSON_FEATURE_FILE: Path to sdk json feature file with data about the buildings.
139
140	PROJECT_PATH: Path for Modelica project directory created with this command
141
142	\f
143	:param sys_param_file: Path, location and name of file created with this cli
144	:param geojson_feature_file: Path, location and name of sdk feature_file
145	:param project_path: Path, location and name of Modelica model dir to be created
146	:param overwrite: Boolean, flag to overwrite an existing file of the same name/location
147	"""
148	project_path = Path(project_path)	2✔
149	if project_path.exists():	2✔
150	if overwrite:	2✔
151	rmtree(project_path, ignore_errors=True)	2✔
152	else:
153	raise SystemExit(f"Output dir '{project_path}' already exists and overwrite flag is not given")	2✔
154	if len(project_path.name.split()) > 1: # Modelica can't handle spaces in project name	2✔
155	raise SystemExit(	2✔
156	f"\n'{project_path}' failed. Modelica does not support spaces in project names or paths. "
157	"Please choose a different 'project_path'"
158	)
159
160	gmt = GeoJsonModelicaTranslator(geojson_feature_file, sys_param_file, project_path.parent, project_path.name)	2✔
161
162	gmt.to_modelica()	2✔
163
164
165	@cli.command(short_help="Run Modelica model")	2✔
166	@click.argument(	2✔
167	"modelica_project",
168	default="./model_from_sdk",
169	required=True,
170	type=click.Path(exists=True, file_okay=False, dir_okay=True),
171	)
172	@click.option(	2✔
173	"-a",
174	"--start_time",
175	default=17280000,
176	help="Start time of the simulation (seconds of a year)",
177	type=int,
178	)
179	@click.option(	2✔
180	"-z",
181	"--stop_time",
182	default=31536000,
183	help="Stop time of the simulation (seconds of a year)",
184	type=int,
185	)
186	@click.option(	2✔
187	"-x",
188	"--step_size",
189	default=900,
190	help="Step size of the simulation (seconds)",
191	type=int,
192	)
193	@click.option(	2✔
194	"-i",
195	"--intervals",
196	default=35050,
197	help="Number of intervals to divide the simulation into (alternative to step_size)",
198	type=int,
199	)
200	def run_model(modelica_project: Path, start_time: int, stop_time: int, step_size: int, intervals: int):	2✔
201	"""Run the model
202	\b
203	Run the Modelica project in a docker-based environment.
204	Results are saved at the same level as the project path that is passed.
205	The model that runs is hard coded to be the Districts/DistrictEnergySystem.mo within the package.
206
207	MODELICA_PROJECT: Path to the Modelica project, possibly created by this cli
208	default = ./model_from_sdk
209
210	\f
211	:param sys_param_file: Path, location and name of file created with this cli
212	:param modelica_project: Path, name & location of modelica project, possibly created with this cli
213	:param start_time (int): start time of the simulation (seconds of a year)
214	:param stop_time (int): stop time of the simulation (seconds of a year)
215	:param step_size (int): step size of the simulation (seconds)
216	:param number_of_intervals (int): number of intervals to run the simulation
217	"""
218	run_path = Path(modelica_project).resolve()	2✔
219	project_name = run_path.stem	2✔
220
221	if len(str(run_path).split()) > 1: # Modelica can't handle spaces in project name or path	2!
UNCOV 222	raise SystemExit(	×
223	f"\n'{run_path}' failed. Modelica does not support spaces in project names or paths. "
224	"Please update your directory tree to not include spaces in any name"
225	)
226	# setup modelica runner
227	mr = ModelicaRunner()	2✔
228	mr.run_in_docker(	2✔
229	"compile_and_run",
230	f"{project_name}.Districts.DistrictEnergySystem",
231	file_to_load=run_path / "package.mo",
232	run_path=run_path,
233	start_time=start_time,
234	stop_time=stop_time,
235	step_size=step_size,
236	number_of_intervals=intervals,
237	)
238
239	run_location = run_path.parent / project_name / f"{project_name}.Districts.DistrictEnergySystem_results"	2✔
240	if (run_location / f"{project_name}.Districts.DistrictEnergySystem_res.mat").exists():	2!
241	print(f"\nModelica model {project_name} ran successfully and can be found in {run_location}")	2✔
242	else:
UNCOV 243	raise SystemExit(f"\n{project_name} failed. Check the error log at {run_location}/stdout.log for more info.")	×
244
245
246	@cli.command(short_help="Process Modelica model")	2✔
247	@click.argument(	2✔
248	"modelica_project",
249	default="./model_from_sdk",
250	required=True,
251	type=click.Path(exists=True, file_okay=False, dir_okay=True),
252	)
253	def des_process(modelica_project: Path):	2✔
254	"""Post Process the model
255	\b
256	Post process results from Modelica project run previously, for GHP LCCA analysis
257	\b
258	MODELICA_PROJECT: Path to the Modelica project, possibly created by this cli
259	default = ./model_from_sdk
260
261	\f
262	:param modelica_project: Path, name & location of modelica project, possibly created with this cli
263	"""
NEW 264	modelica_path = Path(modelica_project).resolve()	×
NEW 265	result = ResultsModelica(modelica_path)	×
NEW 266	result.calculate_results()	×

urbanopt / geojson-modelica-translator / 11113713598

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