8239561917

Committed 11 Mar 2024 08:51PM UTC coverage: 89.093% (+0.1%) from 88.963%

Build # 8239561917

Build Type

Pull #626

github

Committed by

vtnate

Commit Message

implement dhw workaround for MBLv10 bug

Pull Request Pull Request #626: Force a dummy value for SHW in modelica loads even if not present

Run Details

942 of 1125 branches covered (83.73%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 2 files covered. (100.0%)

87 existing lines in 6 files now uncovered.

2595 of 2845 relevant lines covered (91.21%)

1.82 hits per line

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

95.29

/geojson_modelica_translator/model_connectors/districts/district.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 jinja2 import Environment, FileSystemLoader, StrictUndefined
from modelica_builder.package_parser import PackageParser

from geojson_modelica_translator.jinja_filters import ALL_CUSTOM_FILTERS
from geojson_modelica_translator.model_connectors.couplings.diagram import Diagram
from geojson_modelica_translator.model_connectors.load_connectors.load_base import LoadBase
from geojson_modelica_translator.scaffold import Scaffold
from geojson_modelica_translator.utils import _add_water_heating_patch, mbl_version


def render_template(template_name, template_params):
    """Helper for rendering a template

    :param template_name: string, name of template (relative to templates directory)
    :param template_params: dict, template parameters
    :return: string, templated result
    """
    template_dir = Path(__file__).parent / "templates"
    template_env = Environment(loader=FileSystemLoader(searchpath=template_dir), undefined=StrictUndefined)
    template_env.filters.update(ALL_CUSTOM_FILTERS)
    template = template_env.get_template(template_name)
    return template.render(template_params)


class District:
    """
    Class for modeling entire district energy systems
    """

    def __init__(self, root_dir, project_name, system_parameters, coupling_graph):
        self._scaffold = Scaffold(root_dir, project_name)
        self.system_parameters = system_parameters
        self._coupling_graph = coupling_graph
        self.district_model_filepath = None
        # Modelica can't handle spaces in project name or path
        if (len(str(root_dir).split()) > 1) or (len(str(project_name).split()) > 1):
            raise SystemExit(
                f"\nModelica does not support spaces in project names or paths. "
                f"You used '{root_dir}' for run path and {project_name} for model project name. "
                "Please update your directory path or model name to not include spaces anywhere."
            )

    def to_modelica(self):
        """Generate modelica files for the models as well as the modelica file for
        the entire district system.
        """
        # scaffold the project
        self._scaffold.create()
        self.district_model_filepath = Path(self._scaffold.districts_path.files_dir) / "DistrictEnergySystem.mo"

        # create the root package
        root_package = PackageParser.new_from_template(
            self._scaffold.project_path,
            self._scaffold.project_name,
            order=[],
            mbl_version=mbl_version(),
        )
        root_package.save()

        # generate model modelica files
        for model in self._coupling_graph.models:
            model.to_modelica(self._scaffold)

        # construct graph of visual components
        diagram = Diagram(self._coupling_graph)

        district_template_params = {
            "district_within_path": ".".join([self._scaffold.project_name, "Districts"]),
            "diagram": diagram,
            "couplings": [],
            "models": [],
            "is_ghe_district": self.system_parameters.get_param("$.district_system.fifth_generation.ghe_parameters"),
        }
        common_template_params = {
            "globals": {
                "medium_w": "MediumW",
                "delChiWatTemBui": "delChiWatTemBui",
                "delChiWatTemDis": "delChiWatTemDis",
                "delHeaWatTemBui": "delHeaWatTemBui",
                "delHeaWatTemDis": "delHeaWatTemDis",
            },
            "graph": self._coupling_graph,
            "sys_params": {
                "district_system": self.system_parameters.get_param("$.district_system"),
                # num_buildings counts the ports required for 5G systems
                "num_buildings": len(self.system_parameters.get_param("$.buildings")),
            },
        }

        # render each coupling
        load_num = 1
        for coupling in self._coupling_graph.couplings:
            template_context = {
                "diagram": diagram.to_dict(coupling.id, is_coupling=True),
            }
            template_context.update(**common_template_params)

            coupling_load = coupling.get_load()
            if coupling_load is not None:
                # read sys params file for the load
                building_sys_params = self.system_parameters.get_param_by_id(coupling_load.building_id, "$")
                template_context["sys_params"]["building"] = building_sys_params
                # Note which load is being used, so ports connect properly in couplings/5G_templates/ConnectStatements
                template_context["sys_params"]["load_num"] = load_num
                load_num += 1

            templated_result = coupling.render_templates(template_context)
            district_template_params["couplings"].append(
                {
                    "id": coupling.id,
                    "component_definitions": templated_result["component_definitions"],
                    "connect_statements": templated_result["connect_statements"],
                    "coupling_definitions_template_path": templated_result["component_definitions_template_path"],
                    "connect_statements_template_path": templated_result["connect_statements_template_path"],
                }
            )

        # render each model instance
        for model in self._coupling_graph.models:
            template_params = {
                "model": model.to_dict(self._scaffold),
                "couplings": self._coupling_graph.couplings_by_type(model.id),
                "diagram": diagram.to_dict(model.id, is_coupling=False),
            }
            template_params.update(**common_template_params)

            if issubclass(type(model), LoadBase):
                building_sys_params = self.system_parameters.get_param_by_id(model.building_id, "$")
                template_params["sys_params"]["building"] = building_sys_params

            templated_instance, instance_template_path = model.render_instance(template_params)
            district_template_params["models"].append(
                {"id": model.id, "instance_template_path": instance_template_path, "instance": templated_instance}
            )

        # render the full district file
        if "fifth_generation" in common_template_params["sys_params"]["district_system"]:
            final_result = render_template("DistrictEnergySystem5G.mot", district_template_params)
        elif "fourth_generation" in common_template_params["sys_params"]["district_system"]:
            final_result = render_template("DistrictEnergySystem.mot", district_template_params)
        with open(self.district_model_filepath, "w") as f:
            f.write(final_result)

        districts_package = PackageParser.new_from_template(
            self._scaffold.districts_path.files_dir,
            "Districts",
            ["DistrictEnergySystem"],
            within=f"{self._scaffold.project_name}",
        )
        districts_package.save()

        root_package = PackageParser(self._scaffold.project_path)
        if "Districts" not in root_package.order:
            root_package.add_model("Districts")
            root_package.save()

        # Hack workaround for MBLv10.0.0 bug that requires DHW in the loads even if it's not used
        # This hack runs after the scaffold is created and before the simulation is run.
        _add_water_heating_patch(self._scaffold.project_path)

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
6	from jinja2 import Environment, FileSystemLoader, StrictUndefined	2✔
7	from modelica_builder.package_parser import PackageParser	2✔
8
9	from geojson_modelica_translator.jinja_filters import ALL_CUSTOM_FILTERS	2✔
10	from geojson_modelica_translator.model_connectors.couplings.diagram import Diagram	2✔
11	from geojson_modelica_translator.model_connectors.load_connectors.load_base import LoadBase	2✔
12	from geojson_modelica_translator.scaffold import Scaffold	2✔
13	from geojson_modelica_translator.utils import _add_water_heating_patch, mbl_version	2✔
14
15
16	def render_template(template_name, template_params):	2✔
17	"""Helper for rendering a template
18
19	:param template_name: string, name of template (relative to templates directory)
20	:param template_params: dict, template parameters
21	:return: string, templated result
22	"""
23	template_dir = Path(__file__).parent / "templates"	2✔
24	template_env = Environment(loader=FileSystemLoader(searchpath=template_dir), undefined=StrictUndefined)	2✔
25	template_env.filters.update(ALL_CUSTOM_FILTERS)	2✔
26	template = template_env.get_template(template_name)	2✔
27	return template.render(template_params)	2✔
28
29
30	class District:	2✔
31	"""
32	Class for modeling entire district energy systems
33	"""
34
35	def __init__(self, root_dir, project_name, system_parameters, coupling_graph):	2✔
36	self._scaffold = Scaffold(root_dir, project_name)	2✔
37	self.system_parameters = system_parameters	2✔
38	self._coupling_graph = coupling_graph	2✔
39	self.district_model_filepath = None	2✔
40	# Modelica can't handle spaces in project name or path
41	if (len(str(root_dir).split()) > 1) or (len(str(project_name).split()) > 1):	2!
UNCOV 42	raise SystemExit(	×
43	f"\nModelica does not support spaces in project names or paths. "
44	f"You used '{root_dir}' for run path and {project_name} for model project name. "
45	"Please update your directory path or model name to not include spaces anywhere."
46	)
47
48	def to_modelica(self):	2✔
49	"""Generate modelica files for the models as well as the modelica file for
50	the entire district system.
51	"""
52	# scaffold the project
53	self._scaffold.create()	2✔
54	self.district_model_filepath = Path(self._scaffold.districts_path.files_dir) / "DistrictEnergySystem.mo"	2✔
55
56	# create the root package
57	root_package = PackageParser.new_from_template(	2✔
58	self._scaffold.project_path,
59	self._scaffold.project_name,
60	order=[],
61	mbl_version=mbl_version(),
62	)
63	root_package.save()	2✔
64
65	# generate model modelica files
66	for model in self._coupling_graph.models:	2✔
67	model.to_modelica(self._scaffold)	2✔
68
69	# construct graph of visual components
70	diagram = Diagram(self._coupling_graph)	2✔
71
72	district_template_params = {	2✔
73	"district_within_path": ".".join([self._scaffold.project_name, "Districts"]),
74	"diagram": diagram,
75	"couplings": [],
76	"models": [],
77	"is_ghe_district": self.system_parameters.get_param("$.district_system.fifth_generation.ghe_parameters"),
78	}
79	common_template_params = {	2✔
80	"globals": {
81	"medium_w": "MediumW",
82	"delChiWatTemBui": "delChiWatTemBui",
83	"delChiWatTemDis": "delChiWatTemDis",
84	"delHeaWatTemBui": "delHeaWatTemBui",
85	"delHeaWatTemDis": "delHeaWatTemDis",
86	},
87	"graph": self._coupling_graph,
88	"sys_params": {
89	"district_system": self.system_parameters.get_param("$.district_system"),
90	# num_buildings counts the ports required for 5G systems
91	"num_buildings": len(self.system_parameters.get_param("$.buildings")),
92	},
93	}
94
95	# render each coupling
96	load_num = 1	2✔
97	for coupling in self._coupling_graph.couplings:	2✔
98	template_context = {	2✔
99	"diagram": diagram.to_dict(coupling.id, is_coupling=True),
100	}
101	template_context.update(**common_template_params)	2✔
102
103	coupling_load = coupling.get_load()	2✔
104	if coupling_load is not None:	2✔
105	# read sys params file for the load
106	building_sys_params = self.system_parameters.get_param_by_id(coupling_load.building_id, "$")	2✔
107	template_context["sys_params"]["building"] = building_sys_params	2✔
108	# Note which load is being used, so ports connect properly in couplings/5G_templates/ConnectStatements
109	template_context["sys_params"]["load_num"] = load_num	2✔
110	load_num += 1	2✔
111
112	templated_result = coupling.render_templates(template_context)	2✔
113	district_template_params["couplings"].append(	2✔
114	{
115	"id": coupling.id,
116	"component_definitions": templated_result["component_definitions"],
117	"connect_statements": templated_result["connect_statements"],
118	"coupling_definitions_template_path": templated_result["component_definitions_template_path"],
119	"connect_statements_template_path": templated_result["connect_statements_template_path"],
120	}
121	)
122
123	# render each model instance
124	for model in self._coupling_graph.models:	2✔
125	template_params = {	2✔
126	"model": model.to_dict(self._scaffold),
127	"couplings": self._coupling_graph.couplings_by_type(model.id),
128	"diagram": diagram.to_dict(model.id, is_coupling=False),
129	}
130	template_params.update(**common_template_params)	2✔
131
132	if issubclass(type(model), LoadBase):	2✔
133	building_sys_params = self.system_parameters.get_param_by_id(model.building_id, "$")	2✔
134	template_params["sys_params"]["building"] = building_sys_params	2✔
135
136	templated_instance, instance_template_path = model.render_instance(template_params)	2✔
137	district_template_params["models"].append(	2✔
138	{"id": model.id, "instance_template_path": instance_template_path, "instance": templated_instance}
139	)
140
141	# render the full district file
142	if "fifth_generation" in common_template_params["sys_params"]["district_system"]:	2✔
143	final_result = render_template("DistrictEnergySystem5G.mot", district_template_params)	2✔
144	elif "fourth_generation" in common_template_params["sys_params"]["district_system"]:	2!
145	final_result = render_template("DistrictEnergySystem.mot", district_template_params)	2✔
146	with open(self.district_model_filepath, "w") as f:	2✔
147	f.write(final_result)	2✔
148
149	districts_package = PackageParser.new_from_template(	2✔
150	self._scaffold.districts_path.files_dir,
151	"Districts",
152	["DistrictEnergySystem"],
153	within=f"{self._scaffold.project_name}",
154	)
155	districts_package.save()	2✔
156
157	root_package = PackageParser(self._scaffold.project_path)	2✔
158	if "Districts" not in root_package.order:	2!
159	root_package.add_model("Districts")	2✔
160	root_package.save()	2✔
161
162	# Hack workaround for MBLv10.0.0 bug that requires DHW in the loads even if it's not used
163	# This hack runs after the scaffold is created and before the simulation is run.
164	_add_water_heating_patch(self._scaffold.project_path)	2✔

urbanopt / geojson-modelica-translator / 8239561917

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