8159741944

Committed 05 Mar 2024 04:33PM UTC coverage: 88.963% (+0.2%) from 88.716%

Build # 8159741944

Build Type

push

github

Committed by

web-flow

Commit Message

Update tooling to use ruff for linting & formatting (#619)

* use ruff for linting & formatting

* make the sys-param schema file not executable

* gitignore ruff_cache

* update ruff versions, use new mofmt repo

* remove autopep8 from dev dependencies

* remove isort config from pyproject

* first pass of ruff formatting & linting

* more formatting & linting

* fix SystemExit text after change to keep matching test

* restore correct if-statement nesting

* make both mypy and formatting happy for these assertions

* upgrade ruff to v0.2.1

* move `fix` out of `tool.ruff.lint`

* more ruff config tweaking

* cleaner use of ruff in pre-commit-config

* ruff auto-formatting in cli

* remove formatting from a block of code

* different style of building template_data dict

* update dependencies

* bump ruff version via `pre-commit autoupdate`

* formatting change from new ruff version

Run Details

922 of 1105 branches covered (83.44%)

Branch coverage included in aggregate %.

704 of 791 new or added lines in 50 files covered. (89.0%)

6 existing lines in 5 files now uncovered.

2568 of 2818 relevant lines covered (91.13%)

1.82 hits per line

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

77.32

/geojson_modelica_translator/model_connectors/plants/borefield.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 math
import os
from pathlib import Path

import pandas as pd
import scipy.io as sio
from modelica_builder.package_parser import PackageParser

from geojson_modelica_translator.model_connectors.plants.plant_base import PlantBase
from geojson_modelica_translator.utils import ModelicaPath, simple_uuid

logger = logging.getLogger(__name__)
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s: %(message)s",
    datefmt="%d-%b-%y %H:%M:%S",
)


class Borefield(PlantBase):
    model_name = "Borefield"

    def __init__(self, system_parameters):
        super().__init__(system_parameters)
        self.id = "borFie_" + simple_uuid()
        self.borefield_name = "Borefield_" + simple_uuid()

        self.required_mo_files.append(os.path.join(self.template_dir, "GroundTemperatureResponse.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 = {
            "gfunction": {
                "input_path": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.ghe_dir"
                ),
                "ghe_id": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].ghe_id"
                ),
            },
            "soil": {
                "initial_ground_temperature": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.soil.undisturbed_temp"
                ),
                "conductivity": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.soil.conductivity"
                ),
                "volumetric_heat_capacity": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.soil.rho_cp"
                ),
            },
            "fill": {
                "conductivity": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.grout.conductivity"
                ),
                "volumetric_heat_capacity": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.grout.rho_cp"
                ),
            },
            "configuration": {
                "borehole_configuration": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.pipe.arrangement"
                ),
                "nominal_mass_flow_per_borehole": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.design.flow_rate"
                ),
                "flow_type": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.design.flow_type"
                ),
                "borehole_height": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].borehole.length_of_boreholes"
                ),
                "borehole_diameter": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].borehole.diameter"
                ),
                "borehole_buried_depth": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].borehole.buried_depth"
                ),
                "number_of_boreholes": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].borehole.number_of_boreholes"
                ),
            },
            "tube": {
                "outer_diameter": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.pipe.outer_diameter"
                ),
                "inner_diameter": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.pipe.inner_diameter"
                ),
                "conductivity": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.pipe.conductivity"
                ),
                "shank_spacing": self.system_parameters.get_param(
                    "$.district_system.fifth_generation.ghe_parameters.pipe.shank_spacing"
                ),
            },
        }

        # process g-function file
        if Path(template_data["gfunction"]["input_path"]).expanduser().is_absolute():
            gfunction = pd.read_csv(
                Path(template_data["gfunction"]["input_path"]) / template_data["gfunction"]["ghe_id"] / "Gfunction.csv",
                header=0,
                usecols=[0, 2],
            )
        else:
            sys_param_dir = Path(self.system_parameters.filename).parent.resolve()
            try:
                gfunction = pd.read_csv(
                    sys_param_dir
                    / template_data["gfunction"]["input_path"]
                    / template_data["gfunction"]["ghe_id"]
                    / "Gfunction.csv",
                    header=0,
                    usecols=[0, 2],
                )
            except FileNotFoundError:
                raise SystemExit(
                    'When using a relative path to your ghe_dir, your path '
                    f' \'{template_data["gfunction"]["input_path"]}\' must be relative to the dir your '
                    'sys-param file is in.'
                )
        template_data["gfunction"]["gfunction_file_rows"] = gfunction.shape[0] + 1

        # convert the values to match Modelica gfunctions
        for i in range(len(gfunction)):
            gfunction[gfunction.columns[0]].iloc[i] = (
                math.exp(gfunction[gfunction.columns[0]].iloc[i])
                * template_data["configuration"]["borehole_height"] ** 2
                / (9 * template_data["soil"]["conductivity"] / template_data["soil"]["volumetric_heat_capacity"])
            )
            gfunction[gfunction.columns[1]].iloc[i] = gfunction[gfunction.columns[1]].iloc[i] / (
                template_data["configuration"]["number_of_boreholes"]
                * 2
                * math.pi
                * template_data["configuration"]["borehole_height"]
                * template_data["soil"]["conductivity"]
            )

        # add zeros to the first row
        new_row = pd.Series({gfunction.columns[0]: 0, gfunction.columns[1]: 0})
        gfunction = pd.concat([gfunction.iloc[:0], pd.DataFrame([new_row]), gfunction.iloc[0:]]).reset_index(drop=True)

        # create borefield package paths
        b_modelica_path = ModelicaPath(self.borefield_name, scaffold.plants_path.files_dir, True)

        # add to dict and save MAT file to the borefield's resources folder
        data_dict = {"TStep": gfunction.to_numpy()}
        gfunction_path = os.path.join(b_modelica_path.resources_dir, "Gfunction.mat")
        sio.savemat(gfunction_path, data_dict)
        template_data["gfunction"]["gfunction_file_path"] = b_modelica_path.resources_relative_dir + "/Gfunction.mat"

        # process nominal mass flow rate
        if template_data["configuration"]["flow_type"] == "system":
            template_data["configuration"]["nominal_mass_flow_per_borehole"] = (
                template_data["configuration"]["nominal_mass_flow_per_borehole"]
                / template_data["configuration"]["number_of_boreholes"]
            )

        # process tube thickness
        if template_data["tube"]["outer_diameter"] and template_data["tube"]["inner_diameter"]:
            template_data["tube"]["thickness"] = (
                template_data["tube"]["outer_diameter"] - template_data["tube"]["inner_diameter"]
            ) / 2
        else:
            template_data["tube"]["thickness"] = None

        # process shank spacing
        if template_data["tube"]["shank_spacing"] and template_data["tube"]["outer_diameter"]:
            template_data["tube"]["shank_spacing"] = (
                template_data["tube"]["shank_spacing"] + template_data["tube"]["outer_diameter"]
            ) / 2
        else:
            template_data["tube"]["shank_spacing"] = None

        # load templates
        oneutube_template = self.template_env.get_template("BorefieldOneUTube.mot")
        twoutube_template = self.template_env.get_template("BorefieldTwoUTubes.mot")

        if template_data["configuration"]["borehole_configuration"] == "singleutube":
            plant_template = oneutube_template
            template_data["configuration"]["borehole_configuration"] = (
                "Buildings.Fluid.Geothermal.Borefields.Types.BoreholeConfiguration.SingleUTube"
            )
            template_data["configuration"]["borehole_type"] = (
                "Buildings.Fluid.Geothermal.Borefields.BaseClasses.Boreholes.OneUTube"
            )
        elif template_data["configuration"]["borehole_configuration"] == "doubleutube":
            plant_template = twoutube_template
            template_data["configuration"]["borehole_configuration"] = (
                "Buildings.Fluid.Geothermal.Borefields.Types.BoreholeConfiguration.DoubleUTubeSeries"
            )
            template_data["configuration"]["borehole_type"] = (
                "Buildings.Fluid.Geothermal.Borefields.BaseClasses.Boreholes.TwoUTube"
            )
        else:
            raise ValueError("The type of geothermal heat exchanger pipe arrangement is not supported.")

        self.run_template(
            plant_template,
            os.path.join(b_modelica_path.files_dir, "Borefield.mo"),
            project_name=scaffold.project_name,
            model_name=self.borefield_name,
            ghe_data=template_data,
        )

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

        # Borefield_ package
        subpackage_models = ["Borefield"]
        borefield_package = PackageParser.new_from_template(
            path=b_modelica_path.files_dir,
            name=self.borefield_name,
            order=subpackage_models,
            within=f"{scaffold.project_name}.Plants",
        )
        borefield_package.save()

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

        package_models = [self.borefield_name] + [Path(mo).stem for mo in self.required_mo_files]
        plants_package = PackageParser(scaffold.plants_path.files_dir)
        if plants_package.order_data is None:
            plants_package = PackageParser.new_from_template(
                path=scaffold.plants_path.files_dir, name="Plants", order=package_models, within=scaffold.project_name
            )
        else:
            for model_name in package_models:
                plants_package.add_model(model_name)
        plants_package.save()

    def get_modelica_type(self, scaffold):
        return f"Plants.{self.borefield_name}.Borefield"

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 math	2✔
6	import os	2✔
7	from pathlib import Path	2✔
8
9	import pandas as pd	2✔
10	import scipy.io as sio	2✔
11	from modelica_builder.package_parser import PackageParser	2✔
12
13	from geojson_modelica_translator.model_connectors.plants.plant_base import PlantBase	2✔
14	from geojson_modelica_translator.utils import ModelicaPath, simple_uuid	2✔
15
16	logger = logging.getLogger(__name__)	2✔
17	logging.basicConfig(	2✔
18	level=logging.INFO,
19	format="%(asctime)s - %(levelname)s: %(message)s",
20	datefmt="%d-%b-%y %H:%M:%S",
21	)
22
23
24	class Borefield(PlantBase):	2✔
25	model_name = "Borefield"	2✔
26
27	def __init__(self, system_parameters):	2✔
28	super().__init__(system_parameters)	2✔
29	self.id = "borFie_" + simple_uuid()	2✔
30	self.borefield_name = "Borefield_" + simple_uuid()	2✔
31
32	self.required_mo_files.append(os.path.join(self.template_dir, "GroundTemperatureResponse.mo"))	2✔
33
34	def to_modelica(self, scaffold):	2✔
35	"""
36	Create timeSeries models based on the data in the buildings and geojsons
37
38	:param scaffold: Scaffold object, Scaffold of the entire directory of the project.
39	"""
40
41	template_data = {	2✔
42	"gfunction": {
43	"input_path": self.system_parameters.get_param(
44	"$.district_system.fifth_generation.ghe_parameters.ghe_dir"
45	),
46	"ghe_id": self.system_parameters.get_param(
47	"$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].ghe_id"
48	),
49	},
50	"soil": {
51	"initial_ground_temperature": self.system_parameters.get_param(
52	"$.district_system.fifth_generation.ghe_parameters.soil.undisturbed_temp"
53	),
54	"conductivity": self.system_parameters.get_param(
55	"$.district_system.fifth_generation.ghe_parameters.soil.conductivity"
56	),
57	"volumetric_heat_capacity": self.system_parameters.get_param(
58	"$.district_system.fifth_generation.ghe_parameters.soil.rho_cp"
59	),
60	},
61	"fill": {
62	"conductivity": self.system_parameters.get_param(
63	"$.district_system.fifth_generation.ghe_parameters.grout.conductivity"
64	),
65	"volumetric_heat_capacity": self.system_parameters.get_param(
66	"$.district_system.fifth_generation.ghe_parameters.grout.rho_cp"
67	),
68	},
69	"configuration": {
70	"borehole_configuration": self.system_parameters.get_param(
71	"$.district_system.fifth_generation.ghe_parameters.pipe.arrangement"
72	),
73	"nominal_mass_flow_per_borehole": self.system_parameters.get_param(
74	"$.district_system.fifth_generation.ghe_parameters.design.flow_rate"
75	),
76	"flow_type": self.system_parameters.get_param(
77	"$.district_system.fifth_generation.ghe_parameters.design.flow_type"
78	),
79	"borehole_height": self.system_parameters.get_param(
80	"$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].borehole.length_of_boreholes"
81	),
82	"borehole_diameter": self.system_parameters.get_param(
83	"$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].borehole.diameter"
84	),
85	"borehole_buried_depth": self.system_parameters.get_param(
86	"$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].borehole.buried_depth"
87	),
88	"number_of_boreholes": self.system_parameters.get_param(
89	"$.district_system.fifth_generation.ghe_parameters.ghe_specific_params[0].borehole.number_of_boreholes"
90	),
91	},
92	"tube": {
93	"outer_diameter": self.system_parameters.get_param(
94	"$.district_system.fifth_generation.ghe_parameters.pipe.outer_diameter"
95	),
96	"inner_diameter": self.system_parameters.get_param(
97	"$.district_system.fifth_generation.ghe_parameters.pipe.inner_diameter"
98	),
99	"conductivity": self.system_parameters.get_param(
100	"$.district_system.fifth_generation.ghe_parameters.pipe.conductivity"
101	),
102	"shank_spacing": self.system_parameters.get_param(
103	"$.district_system.fifth_generation.ghe_parameters.pipe.shank_spacing"
104	),
105	},
106	}
107
108	# process g-function file
109	if Path(template_data["gfunction"]["input_path"]).expanduser().is_absolute():	2✔
110	gfunction = pd.read_csv(	2✔
111	Path(template_data["gfunction"]["input_path"]) / template_data["gfunction"]["ghe_id"] / "Gfunction.csv",
112	header=0,
113	usecols=[0, 2],
114	)
115	else:
116	sys_param_dir = Path(self.system_parameters.filename).parent.resolve()	2✔
117	try:	2✔
118	gfunction = pd.read_csv(	2✔
119	sys_param_dir
120	/ template_data["gfunction"]["input_path"]
121	/ template_data["gfunction"]["ghe_id"]
122	/ "Gfunction.csv",
123	header=0,
124	usecols=[0, 2],
125	)
126	except FileNotFoundError:	×
NEW 127	raise SystemExit(	×
128	'When using a relative path to your ghe_dir, your path '
129	f' \'{template_data["gfunction"]["input_path"]}\' must be relative to the dir your '
130	'sys-param file is in.'
131	)
132	template_data["gfunction"]["gfunction_file_rows"] = gfunction.shape[0] + 1	2✔
133
134	# convert the values to match Modelica gfunctions
135	for i in range(len(gfunction)):	2✔
136	gfunction[gfunction.columns[0]].iloc[i] = (	2✔
137	math.exp(gfunction[gfunction.columns[0]].iloc[i])
138	* template_data["configuration"]["borehole_height"] ** 2
139	/ (9 * template_data["soil"]["conductivity"] / template_data["soil"]["volumetric_heat_capacity"])
140	)
141	gfunction[gfunction.columns[1]].iloc[i] = gfunction[gfunction.columns[1]].iloc[i] / (	2✔
142	template_data["configuration"]["number_of_boreholes"]
143	* 2
144	* math.pi
145	* template_data["configuration"]["borehole_height"]
146	* template_data["soil"]["conductivity"]
147	)
148
149	# add zeros to the first row
150	new_row = pd.Series({gfunction.columns[0]: 0, gfunction.columns[1]: 0})	2✔
151	gfunction = pd.concat([gfunction.iloc[:0], pd.DataFrame([new_row]), gfunction.iloc[0:]]).reset_index(drop=True)	2✔
152
153	# create borefield package paths
154	b_modelica_path = ModelicaPath(self.borefield_name, scaffold.plants_path.files_dir, True)	2✔
155
156	# add to dict and save MAT file to the borefield's resources folder
157	data_dict = {"TStep": gfunction.to_numpy()}	2✔
158	gfunction_path = os.path.join(b_modelica_path.resources_dir, "Gfunction.mat")	2✔
159	sio.savemat(gfunction_path, data_dict)	2✔
160	template_data["gfunction"]["gfunction_file_path"] = b_modelica_path.resources_relative_dir + "/Gfunction.mat"	2✔
161
162	# process nominal mass flow rate
163	if template_data["configuration"]["flow_type"] == "system":	2!
NEW 164	template_data["configuration"]["nominal_mass_flow_per_borehole"] = (	×
165	template_data["configuration"]["nominal_mass_flow_per_borehole"]
166	/ template_data["configuration"]["number_of_boreholes"]
167	)
168
169	# process tube thickness
170	if template_data["tube"]["outer_diameter"] and template_data["tube"]["inner_diameter"]:	2!
171	template_data["tube"]["thickness"] = (	2✔
172	template_data["tube"]["outer_diameter"] - template_data["tube"]["inner_diameter"]
173	) / 2
174	else:
175	template_data["tube"]["thickness"] = None	×
176
177	# process shank spacing
178	if template_data["tube"]["shank_spacing"] and template_data["tube"]["outer_diameter"]:	2!
179	template_data["tube"]["shank_spacing"] = (	2✔
180	template_data["tube"]["shank_spacing"] + template_data["tube"]["outer_diameter"]
181	) / 2
182	else:
183	template_data["tube"]["shank_spacing"] = None	×
184
185	# load templates
186	oneutube_template = self.template_env.get_template("BorefieldOneUTube.mot")	2✔
187	twoutube_template = self.template_env.get_template("BorefieldTwoUTubes.mot")	2✔
188
189	if template_data["configuration"]["borehole_configuration"] == "singleutube":	2!
190	plant_template = oneutube_template	2✔
191	template_data["configuration"]["borehole_configuration"] = (	2✔
192	"Buildings.Fluid.Geothermal.Borefields.Types.BoreholeConfiguration.SingleUTube"
193	)
194	template_data["configuration"]["borehole_type"] = (	2✔
195	"Buildings.Fluid.Geothermal.Borefields.BaseClasses.Boreholes.OneUTube"
196	)
197	elif template_data["configuration"]["borehole_configuration"] == "doubleutube":	×
198	plant_template = twoutube_template	×
NEW 199	template_data["configuration"]["borehole_configuration"] = (	×
200	"Buildings.Fluid.Geothermal.Borefields.Types.BoreholeConfiguration.DoubleUTubeSeries"
201	)
NEW 202	template_data["configuration"]["borehole_type"] = (	×
203	"Buildings.Fluid.Geothermal.Borefields.BaseClasses.Boreholes.TwoUTube"
204	)
205	else:
206	raise ValueError("The type of geothermal heat exchanger pipe arrangement is not supported.")	×
207
208	self.run_template(	2✔
209	plant_template,
210	os.path.join(b_modelica_path.files_dir, "Borefield.mo"),
211	project_name=scaffold.project_name,
212	model_name=self.borefield_name,
213	ghe_data=template_data,
214	)
215
216	# generate Modelica package
217	self.copy_required_mo_files(	2✔
218	dest_folder=scaffold.plants_path.files_dir, within=f"{scaffold.project_name}.Plants"
219	)
220
221	# Borefield_ package
222	subpackage_models = ["Borefield"]	2✔
223	borefield_package = PackageParser.new_from_template(	2✔
224	path=b_modelica_path.files_dir,
225	name=self.borefield_name,
226	order=subpackage_models,
227	within=f"{scaffold.project_name}.Plants",
228	)
229	borefield_package.save()	2✔
230
231	# Plants package
232	package = PackageParser(scaffold.project_path)	2✔
233	if "Plants" not in package.order:	2!
234	package.add_model("Plants")	2✔
235	package.save()	2✔
236
237	package_models = [self.borefield_name] + [Path(mo).stem for mo in self.required_mo_files]	2✔
238	plants_package = PackageParser(scaffold.plants_path.files_dir)	2✔
239	if plants_package.order_data is None:	2!
240	plants_package = PackageParser.new_from_template(	2✔
241	path=scaffold.plants_path.files_dir, name="Plants", order=package_models, within=scaffold.project_name
242	)
243	else:
244	for model_name in package_models:	×
245	plants_package.add_model(model_name)	×
246	plants_package.save()	2✔
247
248	def get_modelica_type(self, scaffold):	2✔
249	return f"Plants.{self.borefield_name}.Borefield"	2✔

urbanopt / geojson-modelica-translator / 8159741944

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