10925879936

Committed 18 Sep 2024 04:01PM UTC coverage: 88.352% (+0.2%) from 88.111%

Build # 10925879936

Build Type

Pull #644

github

Committed by

vtnate

Commit Message

remove TN output that isn't necessary for our tests

Pull Request Pull Request #644: Support multiple GHEs in a single district

Run Details

1010 of 1226 branches covered (82.38%)

Branch coverage included in aggregate %.

138 of 150 new or added lines in 10 files covered. (92.0%)

3 existing lines in 1 file now uncovered.

2775 of 3058 relevant lines covered (90.75%)

1.81 hits per line

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

86.49

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

import pandas as pd
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 GroundCoupling(NetworkBase):
    model_name = "GroundCoupling"

    def __init__(self, system_parameters):
        super().__init__(system_parameters)
        self.id = "groCou_" + simple_uuid()
        self.ground_coupling_name = "GroundCoupling_" + simple_uuid()

        self.required_mo_files.append(os.path.join(self.template_dir, "UndisturbedSoilTemperature.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"
            ),
            "weather": self.system_parameters.get_param("$.weather"),
            "num_buildings": len(self.system_parameters.get_param("$.buildings")),
            "loop_order": {
                "number_of_loops": len(self.loop_order),
                "data": self.loop_order,
            },
        }

        # 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

        # get weather station name from weather file
        parts = template_data["weather"].split("/")[-1].split("_")
        if len(parts) == 4:
            station_name = parts[2]
        elif len(parts) == 3:
            station_name = parts[1]
        station_name = re.sub(r"\d+", "", station_name).replace(".", " ")

        # search for coefficients for calculating soil temperature based on station
        coefs = pd.read_csv(Path(__file__).parent / "data" / "Soil_temp_coefficients.csv")
        matching_rows = coefs[coefs.apply(lambda row: row.astype(str).str.contains(station_name).any(), axis=1)]
        if len(matching_rows) == 0:
            raise ValueError(
                "No matching weather station has been found. Please check your weather file name format."
                "(e.g., USA_NY_Buffalo-Greater.Buffalo.Intl.AP.725280_TMY3.mos)"
            )
        else:
            template_data["surface_temp"] = matching_rows["Ts,avg, C"].iloc[0] + 273.15
            template_data["first_amplitude"] = matching_rows["Ts,amplitude,1, C"].iloc[0]
            template_data["second_amplitude"] = matching_rows["Ts,amplitude,2, C"].iloc[0]
            template_data["first_phase_lag"] = matching_rows["PL1"].iloc[0]
            template_data["second_phase_lag"] = matching_rows["PL2"].iloc[0]

        # create horizontal piping package paths
        b_modelica_path = ModelicaPath(self.ground_coupling_name, scaffold.networks_path.files_dir, True)

        # load templates
        coupling_template = self.template_env.get_template("GroundCoupling.mot")

        self.run_template(
            coupling_template,
            os.path.join(b_modelica_path.files_dir, "GroundCoupling.mo"),
            project_name=scaffold.project_name,
            model_name=self.ground_coupling_name,
            piping_data=template_data,
        )

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

        # GroundCoupling_ package
        subpackage_models = ["GroundCoupling"]
        ground_coupling_package = PackageParser.new_from_template(
            path=b_modelica_path.files_dir,
            name=self.ground_coupling_name,
            order=subpackage_models,
            within=f"{scaffold.project_name}.Networks",
        )
        ground_coupling_package.save()

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

        package_models = [self.ground_coupling_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:
                networks_package.add_model(model_name)
        networks_package.save()

    def get_modelica_type(self, scaffold):
        return f"Networks.{self.ground_coupling_name}.GroundCoupling"

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 re	2✔
7	from pathlib import Path	2✔
8
9	import pandas as pd	2✔
10	from modelica_builder.package_parser import PackageParser	2✔
11
12	from geojson_modelica_translator.model_connectors.networks.network_base import NetworkBase	2✔
13	from geojson_modelica_translator.utils import ModelicaPath, simple_uuid	2✔
14
15	logger = logging.getLogger(__name__)	2✔
16
17
18	class GroundCoupling(NetworkBase):	2✔
19	model_name = "GroundCoupling"	2✔
20
21	def __init__(self, system_parameters):	2✔
22	super().__init__(system_parameters)	2✔
23	self.id = "groCou_" + simple_uuid()	2✔
24	self.ground_coupling_name = "GroundCoupling_" + simple_uuid()	2✔
25
26	self.required_mo_files.append(os.path.join(self.template_dir, "UndisturbedSoilTemperature.mo"))	2✔
27
28	def to_modelica(self, scaffold):	2✔
29	"""
30	Create timeSeries models based on the data in the buildings and geojsons
31
32	:param scaffold: Scaffold object, Scaffold of the entire directory of the project.
33	"""
34
35	template_data = {	2✔
36	"hydraulic_diameter": self.system_parameters.get_param(
37	"$.district_system.fifth_generation.horizontal_piping_parameters.hydraulic_diameter"
38	),
39	"insulation_thickness": self.system_parameters.get_param(
40	"$.district_system.fifth_generation.horizontal_piping_parameters.insulation_thickness"
41	),
42	"insulation_conductivity": self.system_parameters.get_param(
43	"$.district_system.fifth_generation.horizontal_piping_parameters.insulation_conductivity"
44	),
45	"diameter_ratio": self.system_parameters.get_param(
46	"$.district_system.fifth_generation.horizontal_piping_parameters.diameter_ratio"
47	),
48	"roughness": self.system_parameters.get_param(
49	"$.district_system.fifth_generation.horizontal_piping_parameters.roughness"
50	),
51	"rho_cp": self.system_parameters.get_param(
52	"$.district_system.fifth_generation.horizontal_piping_parameters.rho_cp"
53	),
54	"number_of_segments": self.system_parameters.get_param(
55	"$.district_system.fifth_generation.horizontal_piping_parameters.number_of_segments"
56	),
57	"buried_depth": self.system_parameters.get_param(
58	"$.district_system.fifth_generation.horizontal_piping_parameters.buried_depth"
59	),
60	"weather": self.system_parameters.get_param("$.weather"),
61	"num_buildings": len(self.system_parameters.get_param("$.buildings")),
62	"loop_order": {
63	"number_of_loops": len(self.loop_order),
64	"data": self.loop_order,
65	},
66	}
67
68	# process pipe wall thickness
69	if template_data["hydraulic_diameter"] and template_data["diameter_ratio"]:	2!
70	template_data["pipe_wall_thickness"] = template_data["hydraulic_diameter"] / (	2✔
71	template_data["diameter_ratio"] - 2
72	)
73	else:
74	template_data["pipe_wall_thickness"] = None	×
75
76	# get weather station name from weather file
77	parts = template_data["weather"].split("/")[-1].split("_")	2✔
78	if len(parts) == 4:	2✔
79	station_name = parts[2]	2✔
80	elif len(parts) == 3:	2!
81	station_name = parts[1]	2✔
82	station_name = re.sub(r"\d+", "", station_name).replace(".", " ")	2✔
83
84	# search for coefficients for calculating soil temperature based on station
85	coefs = pd.read_csv(Path(__file__).parent / "data" / "Soil_temp_coefficients.csv")	2✔
86	matching_rows = coefs[coefs.apply(lambda row: row.astype(str).str.contains(station_name).any(), axis=1)]	2✔
87	if len(matching_rows) == 0:	2!
88	raise ValueError(	×
89	"No matching weather station has been found. Please check your weather file name format."
90	"(e.g., USA_NY_Buffalo-Greater.Buffalo.Intl.AP.725280_TMY3.mos)"
91	)
92	else:
93	template_data["surface_temp"] = matching_rows["Ts,avg, C"].iloc[0] + 273.15	2✔
94	template_data["first_amplitude"] = matching_rows["Ts,amplitude,1, C"].iloc[0]	2✔
95	template_data["second_amplitude"] = matching_rows["Ts,amplitude,2, C"].iloc[0]	2✔
96	template_data["first_phase_lag"] = matching_rows["PL1"].iloc[0]	2✔
97	template_data["second_phase_lag"] = matching_rows["PL2"].iloc[0]	2✔
98
99	# create horizontal piping package paths
100	b_modelica_path = ModelicaPath(self.ground_coupling_name, scaffold.networks_path.files_dir, True)	2✔
101
102	# load templates
103	coupling_template = self.template_env.get_template("GroundCoupling.mot")	2✔
104
105	self.run_template(	2✔
106	coupling_template,
107	os.path.join(b_modelica_path.files_dir, "GroundCoupling.mo"),
108	project_name=scaffold.project_name,
109	model_name=self.ground_coupling_name,
110	piping_data=template_data,
111	)
112
113	# generate Modelica package
114	self.copy_required_mo_files(	2✔
115	dest_folder=scaffold.networks_path.files_dir, within=f"{scaffold.project_name}.Networks"
116	)
117
118	# GroundCoupling_ package
119	subpackage_models = ["GroundCoupling"]	2✔
120	ground_coupling_package = PackageParser.new_from_template(	2✔
121	path=b_modelica_path.files_dir,
122	name=self.ground_coupling_name,
123	order=subpackage_models,
124	within=f"{scaffold.project_name}.Networks",
125	)
126	ground_coupling_package.save()	2✔
127
128	# Networks package
129	package = PackageParser(scaffold.project_path)	2✔
130	if "Networks" not in package.order:	2!
UNCOV 131	package.add_model("Networks")	×
UNCOV 132	package.save()	×
133
134	package_models = [self.ground_coupling_name] + [Path(mo).stem for mo in self.required_mo_files]	2✔
135	networks_package = PackageParser(scaffold.networks_path.files_dir)	2✔
136	if networks_package.order_data is None:	2!
UNCOV 137	networks_package = PackageParser.new_from_template(	×
138	path=scaffold.networks_path.files_dir,
139	name="Networks",
140	order=package_models,
141	within=scaffold.project_name,
142	)
143	else:
144	for model_name in package_models:	2✔
145	networks_package.add_model(model_name)	2✔
146	networks_package.save()	2✔
147
148	def get_modelica_type(self, scaffold):	2✔
149	return f"Networks.{self.ground_coupling_name}.GroundCoupling"	2✔

urbanopt / geojson-modelica-translator / 10925879936

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