11042210834

Committed 25 Sep 2024 10:39PM UTC coverage: 88.36% (+0.2%) from 88.111%

Build # 11042210834

Build Type

push

github

Committed by

web-flow

Commit Message

Support multiple GHEs in a single district (#644)

* update borefield.py to accept a ghe_id when instantiated

* add debug logging to get_param_by_id method

* pass the list of ghes to borefield when instantiating in single_ghe test

* WIP new test for multi-ghe

* improve error message for missing g-function file

* additional g-function files to match the test sys-param files

* update borefield test to work in the multi-ghe paradigm

* improve help text in CLI

* more explicitly process different types of district sys-params

* clean up generation call, load loop order, load multiple ghes

* use new parameter for district_type argument

* load ghe loop order in the correct place

* move soil parameters out of ghe-specific and into all 5G parameters

* use new location of soil parameters

* don't require soil in the incorrect place, duh

* use new fifth_generation tag properly in 5G tests

* fix test sys-param files for 5G districts

* add graceful error message when sizing output from TN is not found

* remove outdated TODO message

* remove unused test sys-param file

* comment noisy debug log lines

* update geojson and sys_param paths

* add project folder for testing multi-ghe

* update building load profiles

* modify paths pointing to mos files and ghe_dir

* add ghe sizing results to ghe_dir

* move soil and add horizontal piping parameters

* pre-commit formatting

* read the loop order file for later use

* py file for new distribution template

* new distribution template file

* new distribution template instance file

* correct name

* correct name

* take out dis and temp sensors

* move dis and sensor connections elsewhere

* coupling no longer needed

* new distribution couplings

* read loop_order in district.py for use in couplings

* remove accidental `endraw` tag in jinja template

* new placeholder coupling templates

* WIP: first steps in reading ... (continued)

Run Details

1010 of 1226 branches covered (82.38%)

Branch coverage included in aggregate %.

140 of 152 new or added lines in 10 files covered. (92.11%)

3 existing lines in 1 file now uncovered.

2778 of 3061 relevant lines covered (90.75%)

1.82 hits per line

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

96.15

/geojson_modelica_translator/model_connectors/networks/unidirectional_series.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
from pathlib import Path

from modelica_builder.package_parser import PackageParser

from geojson_modelica_translator.model_connectors.networks.network_base import NetworkBase
from geojson_modelica_translator.utils import ModelicaPath, simple_uuid

logger = logging.getLogger(__name__)


class UnidirectionalSeries(NetworkBase):
    model_name = "UnidirectionalSeries"

    def __init__(self, system_parameters):
        super().__init__(system_parameters)
        self.id = "dis_" + simple_uuid()
        self.unidirectional_series_name = "UnidirectionalSeries_" + simple_uuid()

        self.required_mo_files.append(os.path.join(self.template_dir, "ConnectionSeriesAutosize.mo"))

    def to_modelica(self, scaffold):
        """
        Create timeSeries models based on the data in the buildings and geojsons

        :param scaffold: Scaffold object, Scaffold of the entire directory of the project.
        """

        template_data = {
            "hydraulic_diameter": self.system_parameters.get_param(
                "$.district_system.fifth_generation.horizontal_piping_parameters.hydraulic_diameter"
            ),
            "insulation_thickness": self.system_parameters.get_param(
                "$.district_system.fifth_generation.horizontal_piping_parameters.insulation_thickness"
            ),
            "insulation_conductivity": self.system_parameters.get_param(
                "$.district_system.fifth_generation.horizontal_piping_parameters.insulation_conductivity"
            ),
            "diameter_ratio": self.system_parameters.get_param(
                "$.district_system.fifth_generation.horizontal_piping_parameters.diameter_ratio"
            ),
            "roughness": self.system_parameters.get_param(
                "$.district_system.fifth_generation.horizontal_piping_parameters.roughness"
            ),
            "rho_cp": self.system_parameters.get_param(
                "$.district_system.fifth_generation.horizontal_piping_parameters.rho_cp"
            ),
            "number_of_segments": self.system_parameters.get_param(
                "$.district_system.fifth_generation.horizontal_piping_parameters.number_of_segments"
            ),
            "buried_depth": self.system_parameters.get_param(
                "$.district_system.fifth_generation.horizontal_piping_parameters.buried_depth"
            ),
        }

        # process pipe wall thickness
        if template_data["hydraulic_diameter"] and template_data["diameter_ratio"]:
            template_data["pipe_wall_thickness"] = template_data["hydraulic_diameter"] / (
                template_data["diameter_ratio"] - 2
            )
        else:
            template_data["pipe_wall_thickness"] = None

        # create distribution network package paths
        b_modelica_path = ModelicaPath(self.unidirectional_series_name, scaffold.networks_path.files_dir, True)

        # load templates
        distribution_template = self.template_env.get_template("UnidirectionalSeries.mot")

        self.run_template(
            distribution_template,
            os.path.join(b_modelica_path.files_dir, "UnidirectionalSeries.mo"),
            project_name=scaffold.project_name,
            model_name=self.unidirectional_series_name,
            distribution_data=template_data,
        )

        # generate Modelica package
        self.copy_required_mo_files(
            dest_folder=scaffold.networks_path.files_dir, within=f"{scaffold.project_name}.Networks"
        )

        # UnidirectionalSeries_ package
        subpackage_models = ["UnidirectionalSeries"]
        distribution_package = PackageParser.new_from_template(
            path=b_modelica_path.files_dir,
            name=self.unidirectional_series_name,
            order=subpackage_models,
            within=f"{scaffold.project_name}.Networks",
        )
        distribution_package.save()

        # Networks package
        package = PackageParser(scaffold.project_path)
        if "Networks" not in package.order:
            package.add_model("Networks")
            package.save()

        package_models = [self.unidirectional_series_name] + [Path(mo).stem for mo in self.required_mo_files]
        networks_package = PackageParser(scaffold.networks_path.files_dir)
        if networks_package.order_data is None:
            networks_package = PackageParser.new_from_template(
                path=scaffold.networks_path.files_dir,
                name="Networks",
                order=package_models,
                within=scaffold.project_name,
            )
        else:
            for model_name in package_models:
                # We only want a single model named ConnectionSeriesAutosize to be included, so we skip adding
                # (One was included when the Networks package order_data was first created just above)
                if model_name != "ConnectionSeriesAutosize":
                    networks_package.add_model(model_name)
        networks_package.save()

    def get_modelica_type(self, scaffold):
        return f"Networks.{self.unidirectional_series_name}.UnidirectionalSeries"

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	from pathlib import Path	2✔
7
8	from modelica_builder.package_parser import PackageParser	2✔
9
10	from geojson_modelica_translator.model_connectors.networks.network_base import NetworkBase	2✔
11	from geojson_modelica_translator.utils import ModelicaPath, simple_uuid	2✔
12
13	logger = logging.getLogger(__name__)	2✔
14
15
16	class UnidirectionalSeries(NetworkBase):	2✔
17	model_name = "UnidirectionalSeries"	2✔
18
19	def __init__(self, system_parameters):	2✔
20	super().__init__(system_parameters)	2✔
21	self.id = "dis_" + simple_uuid()	2✔
22	self.unidirectional_series_name = "UnidirectionalSeries_" + simple_uuid()	2✔
23
24	self.required_mo_files.append(os.path.join(self.template_dir, "ConnectionSeriesAutosize.mo"))	2✔
25
26	def to_modelica(self, scaffold):	2✔
27	"""
28	Create timeSeries models based on the data in the buildings and geojsons
29
30	:param scaffold: Scaffold object, Scaffold of the entire directory of the project.
31	"""
32
33	template_data = {	2✔
34	"hydraulic_diameter": self.system_parameters.get_param(
35	"$.district_system.fifth_generation.horizontal_piping_parameters.hydraulic_diameter"
36	),
37	"insulation_thickness": self.system_parameters.get_param(
38	"$.district_system.fifth_generation.horizontal_piping_parameters.insulation_thickness"
39	),
40	"insulation_conductivity": self.system_parameters.get_param(
41	"$.district_system.fifth_generation.horizontal_piping_parameters.insulation_conductivity"
42	),
43	"diameter_ratio": self.system_parameters.get_param(
44	"$.district_system.fifth_generation.horizontal_piping_parameters.diameter_ratio"
45	),
46	"roughness": self.system_parameters.get_param(
47	"$.district_system.fifth_generation.horizontal_piping_parameters.roughness"
48	),
49	"rho_cp": self.system_parameters.get_param(
50	"$.district_system.fifth_generation.horizontal_piping_parameters.rho_cp"
51	),
52	"number_of_segments": self.system_parameters.get_param(
53	"$.district_system.fifth_generation.horizontal_piping_parameters.number_of_segments"
54	),
55	"buried_depth": self.system_parameters.get_param(
56	"$.district_system.fifth_generation.horizontal_piping_parameters.buried_depth"
57	),
58	}
59
60	# process pipe wall thickness
61	if template_data["hydraulic_diameter"] and template_data["diameter_ratio"]:	2!
62	template_data["pipe_wall_thickness"] = template_data["hydraulic_diameter"] / (	2✔
63	template_data["diameter_ratio"] - 2
64	)
65	else:
NEW 66	template_data["pipe_wall_thickness"] = None	×
67
68	# create distribution network package paths
69	b_modelica_path = ModelicaPath(self.unidirectional_series_name, scaffold.networks_path.files_dir, True)	2✔
70
71	# load templates
72	distribution_template = self.template_env.get_template("UnidirectionalSeries.mot")	2✔
73
74	self.run_template(	2✔
75	distribution_template,
76	os.path.join(b_modelica_path.files_dir, "UnidirectionalSeries.mo"),
77	project_name=scaffold.project_name,
78	model_name=self.unidirectional_series_name,
79	distribution_data=template_data,
80	)
81
82	# generate Modelica package
83	self.copy_required_mo_files(	2✔
84	dest_folder=scaffold.networks_path.files_dir, within=f"{scaffold.project_name}.Networks"
85	)
86
87	# UnidirectionalSeries_ package
88	subpackage_models = ["UnidirectionalSeries"]	2✔
89	distribution_package = PackageParser.new_from_template(	2✔
90	path=b_modelica_path.files_dir,
91	name=self.unidirectional_series_name,
92	order=subpackage_models,
93	within=f"{scaffold.project_name}.Networks",
94	)
95	distribution_package.save()	2✔
96
97	# Networks package
98	package = PackageParser(scaffold.project_path)	2✔
99	if "Networks" not in package.order:	2✔
100	package.add_model("Networks")	2✔
101	package.save()	2✔
102
103	package_models = [self.unidirectional_series_name] + [Path(mo).stem for mo in self.required_mo_files]	2✔
104	networks_package = PackageParser(scaffold.networks_path.files_dir)	2✔
105	if networks_package.order_data is None:	2✔
106	networks_package = PackageParser.new_from_template(	2✔
107	path=scaffold.networks_path.files_dir,
108	name="Networks",
109	order=package_models,
110	within=scaffold.project_name,
111	)
112	else:
113	for model_name in package_models:	2✔
114	# We only want a single model named ConnectionSeriesAutosize to be included, so we skip adding
115	# (One was included when the Networks package order_data was first created just above)
116	if model_name != "ConnectionSeriesAutosize":	2✔
117	networks_package.add_model(model_name)	2✔
118	networks_package.save()	2✔
119
120	def get_modelica_type(self, scaffold):	2✔
121	return f"Networks.{self.unidirectional_series_name}.UnidirectionalSeries"	2✔

urbanopt / geojson-modelica-translator / 11042210834

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