7434300214

Committed 06 Jan 2024 10:25PM UTC coverage: 85.736% (-2.9%) from 88.675%

Build # 7434300214

Build Type

Pull #581

github

Committed by

nllong

Commit Message

Merge remote-tracking branch 'origin/develop' into mblv10

Pull Request Pull Request #581: Mblv10

Run Details

892 of 1091 branches covered (0.0%)

Branch coverage included in aggregate %.

19 of 36 new or added lines in 9 files covered. (52.78%)

81 existing lines in 3 files now uncovered.

2474 of 2835 relevant lines covered (87.27%)

1.75 hits per line

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

17.74

/geojson_modelica_translator/modelica/GMT_Lib/DHC/DHC_5G_waste_heat_GHX.py

import shutil
from pathlib import Path

from modelica_builder.modelica_mos_file import ModelicaMOS
from modelica_builder.package_parser import PackageParser

from geojson_modelica_translator.modelica.simple_gmt_base import SimpleGMTBase
from geojson_modelica_translator.scaffold import Scaffold
from geojson_modelica_translator.utils import mbl_version


class DHC5GWasteHeatAndGHX(SimpleGMTBase):
    """Generates a full Modelica package with the DHC 5G waste heat and GHX model."""

    def __init__(self, system_parameters):
        self.system_parameters = system_parameters
        self.template_dir = Path(__file__).parent
        super().__init__(self.system_parameters, self.template_dir)

    def build_from_template(self, output_dir: Path, project_name: str) -> None:
        """This is a bit past being a simple template as it is exporting an entire scaffolded package
        that can be loaded and simulated in Modelica. The scaffold is very specific to DES.

        Args:
            output_dir (Path): directory to save the package to (without the project name)
            project_name (str, optional): The name of the project which is used in the Scaffold object.
        """
        template_data = {
            'project_name': project_name,
            'save_file_name': 'district',
            'building_load_files': []
        }

        # create the directory structure
        scaffold = Scaffold(output_dir, project_name=project_name)
        scaffold.create(ignore_paths=['Loads', 'Networks', 'Plants', 'Substations'])

        # create the root package
        package = PackageParser.new_from_template(
            scaffold.project_path,
            project_name,
            order=[],
            mbl_version=mbl_version(),
        )
        package.add_model('Districts')

        # create the district package with the template_data from above
        files_to_copy = []

        # 1: grab all of the time series files and place them in the proper location
        for building in self.system_parameters.get_param("$.buildings[?load_model=time_series]"):
            building_load_file = Path(building['load_model_parameters']['time_series']['filepath'])
            files_to_copy.append({
                "orig_file": building_load_file,
                "geojson_id": building['geojson_id'],
                "save_path": f"{scaffold.districts_path.resources_dir}/{building['geojson_id']}",
                "save_filename": building_load_file.name
            })

        # 2: Copy the files to the appropriate location and ensure uniqueness by putting into a unique directory
        #    (since OpenStudio creates all files with modelica.mos)
        total_heating_load = 0
        total_cooling_load = 0
        total_swh_load = 0
        for file_to_copy in files_to_copy:
            # create the path if it doesn't exist
            Path(file_to_copy['save_path']).mkdir(parents=True, exist_ok=True)
            save_filename = f"{file_to_copy['save_path']}/{file_to_copy['save_filename']}"
            shutil.copy(file_to_copy['orig_file'], save_filename)

            # 3: If the file is an MOS file, and it has the Peak water heating load set to zero, then set it to a minimum value
            #    Also, store the total heating, cooling, and water loads which will be used for sizing.
            mos_file = ModelicaMOS(save_filename)
            total_heating_load += mos_file.retrieve_header_variable_value('Peak space heating load', cast_type=float)
            total_cooling_load += mos_file.retrieve_header_variable_value('Peak space cooling load', cast_type=float)
            peak_water = mos_file.retrieve_header_variable_value('Peak water heating load', cast_type=float)
            total_swh_load += peak_water
            if peak_water == 0:
                peak_heat = mos_file.retrieve_header_variable_value('Peak space heating load', cast_type=float)
                peak_swh = max(peak_heat / 10, 5000)

                mos_file.replace_header_variable_value('Peak water heating load', peak_swh)
                mos_file.save()

            # 4: Add the path to the param data with Modelica friendly path names
            rel_path_name = f"{project_name}/{scaffold.districts_path.resources_relative_dir}/{file_to_copy['geojson_id']}/{file_to_copy['save_filename']}"  # noqa: E501
            template_data['building_load_files'].append(f"modelica://{rel_path_name}")  # type: ignore

        # 5: Calculate the mass flow rates (kg/s) for the heating and cooling networks peak load (in Watts)
        #    (assuming 5C delta T [since 5G] and 4.18 Cp (kJ/kgK)). Add 1.5x the peak for oversizing
        delta_t = 5
        heating_flow_rate = 1.5 * total_heating_load / (1000 * delta_t * 4.18)
        cooling_flow_rate = 1.5 * total_cooling_load / (1000 * delta_t * 4.18)
        swh_flow_rate = 1.5 * total_swh_load / (1000 * delta_t * 4.18)

        template_data['max_flow_rate'] = round(max(heating_flow_rate, cooling_flow_rate, swh_flow_rate), 3)  # type: ignore

        nbuildings = len(template_data['building_load_files'])
        template_data['lDis'] = self.build_string("lDis = {", "0.5, ", nbuildings)
        template_data['lCon'] = self.build_string("lCon = {", "0.5, ", nbuildings)
        template_data['dhDis'] = self.build_string("dhDis = {", "0.5, ", nbuildings)
        template_data['dhCon'] = self.build_string("dhCon = {", "0.6, ", nbuildings)

        # 6: generate the modelica files from the template
        self.to_modelica(output_dir=Path(scaffold.districts_path.files_dir),
                         model_name='DHC_5G_waste_heat_GHX',
                         param_data=template_data,
                         save_file_name='district.mo',
                         generate_package=True,
                         partial_files={'DHC_5G_partial': 'PartialSeries'})

        # 7: save the root package.mo
        package.save()

    def build_string(self, base_text: str, value: str, iterations: int) -> str:
        """Builds a string with a comma separated list of values.

        This is used to build 5G districts with arbitrary number of buildings.
        It's ugly because of the Jinja/Modelica templating system.
        This is a bit of a hack but it works.

        Example output: lDis = { 0.5, 0.5, 0.5 }

        Args:
            base_text (str): The text to start the string with.
            value (str): The value to add multiple times.
            iterations (int): The number of values to add to the string."""
        text = f"{base_text} {value * iterations}"
        return text.removesuffix(", ") + " }"

1	import shutil	2✔
2	from pathlib import Path	2✔
3
4	from modelica_builder.modelica_mos_file import ModelicaMOS	2✔
5	from modelica_builder.package_parser import PackageParser	2✔
6
7	from geojson_modelica_translator.modelica.simple_gmt_base import SimpleGMTBase	2✔
8	from geojson_modelica_translator.scaffold import Scaffold	2✔
9	from geojson_modelica_translator.utils import mbl_version	2✔
10
11
12	class DHC5GWasteHeatAndGHX(SimpleGMTBase):	2✔
13	"""Generates a full Modelica package with the DHC 5G waste heat and GHX model."""
14
15	def __init__(self, system_parameters):	2✔
UNCOV 16	self.system_parameters = system_parameters	×
UNCOV 17	self.template_dir = Path(__file__).parent	×
UNCOV 18	super().__init__(self.system_parameters, self.template_dir)	×
19
20	def build_from_template(self, output_dir: Path, project_name: str) -> None:	2✔
21	"""This is a bit past being a simple template as it is exporting an entire scaffolded package
22	that can be loaded and simulated in Modelica. The scaffold is very specific to DES.
23
24	Args:
25	output_dir (Path): directory to save the package to (without the project name)
26	project_name (str, optional): The name of the project which is used in the Scaffold object.
27	"""
UNCOV 28	template_data = {	×
29	'project_name': project_name,
30	'save_file_name': 'district',
31	'building_load_files': []
32	}
33
34	# create the directory structure
UNCOV 35	scaffold = Scaffold(output_dir, project_name=project_name)	×
UNCOV 36	scaffold.create(ignore_paths=['Loads', 'Networks', 'Plants', 'Substations'])	×
37
38	# create the root package
NEW 39	package = PackageParser.new_from_template(	×
40	scaffold.project_path,
41	project_name,
42	order=[],
43	mbl_version=mbl_version(),
44	)
UNCOV 45	package.add_model('Districts')	×
46
47	# create the district package with the template_data from above
UNCOV 48	files_to_copy = []	×
49
50	# 1: grab all of the time series files and place them in the proper location
UNCOV 51	for building in self.system_parameters.get_param("$.buildings[?load_model=time_series]"):	×
UNCOV 52	building_load_file = Path(building['load_model_parameters']['time_series']['filepath'])	×
UNCOV 53	files_to_copy.append({	×
54	"orig_file": building_load_file,
55	"geojson_id": building['geojson_id'],
56	"save_path": f"{scaffold.districts_path.resources_dir}/{building['geojson_id']}",
57	"save_filename": building_load_file.name
58	})
59
60	# 2: Copy the files to the appropriate location and ensure uniqueness by putting into a unique directory
61	# (since OpenStudio creates all files with modelica.mos)
UNCOV 62	total_heating_load = 0	×
UNCOV 63	total_cooling_load = 0	×
UNCOV 64	total_swh_load = 0	×
UNCOV 65	for file_to_copy in files_to_copy:	×
66	# create the path if it doesn't exist
UNCOV 67	Path(file_to_copy['save_path']).mkdir(parents=True, exist_ok=True)	×
UNCOV 68	save_filename = f"{file_to_copy['save_path']}/{file_to_copy['save_filename']}"	×
UNCOV 69	shutil.copy(file_to_copy['orig_file'], save_filename)	×
70
71	# 3: If the file is an MOS file, and it has the Peak water heating load set to zero, then set it to a minimum value
72	# Also, store the total heating, cooling, and water loads which will be used for sizing.
UNCOV 73	mos_file = ModelicaMOS(save_filename)	×
UNCOV 74	total_heating_load += mos_file.retrieve_header_variable_value('Peak space heating load', cast_type=float)	×
UNCOV 75	total_cooling_load += mos_file.retrieve_header_variable_value('Peak space cooling load', cast_type=float)	×
UNCOV 76	peak_water = mos_file.retrieve_header_variable_value('Peak water heating load', cast_type=float)	×
UNCOV 77	total_swh_load += peak_water	×
UNCOV 78	if peak_water == 0:	×
UNCOV 79	peak_heat = mos_file.retrieve_header_variable_value('Peak space heating load', cast_type=float)	×
UNCOV 80	peak_swh = max(peak_heat / 10, 5000)	×
81
UNCOV 82	mos_file.replace_header_variable_value('Peak water heating load', peak_swh)	×
UNCOV 83	mos_file.save()	×
84
85	# 4: Add the path to the param data with Modelica friendly path names
UNCOV 86	rel_path_name = f"{project_name}/{scaffold.districts_path.resources_relative_dir}/{file_to_copy['geojson_id']}/{file_to_copy['save_filename']}" # noqa: E501	×
UNCOV 87	template_data['building_load_files'].append(f"modelica://{rel_path_name}") # type: ignore	×
88
89	# 5: Calculate the mass flow rates (kg/s) for the heating and cooling networks peak load (in Watts)
90	# (assuming 5C delta T [since 5G] and 4.18 Cp (kJ/kgK)). Add 1.5x the peak for oversizing
UNCOV 91	delta_t = 5	×
UNCOV 92	heating_flow_rate = 1.5 * total_heating_load / (1000 * delta_t * 4.18)	×
UNCOV 93	cooling_flow_rate = 1.5 * total_cooling_load / (1000 * delta_t * 4.18)	×
UNCOV 94	swh_flow_rate = 1.5 * total_swh_load / (1000 * delta_t * 4.18)	×
95
UNCOV 96	template_data['max_flow_rate'] = round(max(heating_flow_rate, cooling_flow_rate, swh_flow_rate), 3) # type: ignore	×
97
NEW 98	nbuildings = len(template_data['building_load_files'])	×
NEW 99	template_data['lDis'] = self.build_string("lDis = {", "0.5, ", nbuildings)	×
NEW 100	template_data['lCon'] = self.build_string("lCon = {", "0.5, ", nbuildings)	×
NEW 101	template_data['dhDis'] = self.build_string("dhDis = {", "0.5, ", nbuildings)	×
NEW 102	template_data['dhCon'] = self.build_string("dhCon = {", "0.6, ", nbuildings)	×
103
104	# 6: generate the modelica files from the template
UNCOV 105	self.to_modelica(output_dir=Path(scaffold.districts_path.files_dir),	×
106	model_name='DHC_5G_waste_heat_GHX',
107	param_data=template_data,
108	save_file_name='district.mo',
109	generate_package=True,
110	partial_files={'DHC_5G_partial': 'PartialSeries'})
111
112	# 7: save the root package.mo
UNCOV 113	package.save()	×
114
115	def build_string(self, base_text: str, value: str, iterations: int) -> str:	2✔
116	"""Builds a string with a comma separated list of values.
117
118	This is used to build 5G districts with arbitrary number of buildings.
119	It's ugly because of the Jinja/Modelica templating system.
120	This is a bit of a hack but it works.
121
122	Example output: lDis = { 0.5, 0.5, 0.5 }
123
124	Args:
125	base_text (str): The text to start the string with.
126	value (str): The value to add multiple times.
127	iterations (int): The number of values to add to the string."""
NEW 128	text = f"{base_text} {value * iterations}"	×
NEW 129	return text.removesuffix(", ") + " }"	×

urbanopt / geojson-modelica-translator / 7434300214

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