Potential API for PyGFunction

pygfunction/api.py

@@ -0,0 +1,80 @@
+from pygfunction.gfunction import gFunction
+from pygfunction.boreholes import Borehole
+
+from typing import Union, List, Tuple, Dict
+
+
+class BHFieldParams(object):
+    def __init__(self, xy_coord_pairs: Union[List[Tuple[float, float]], List[List[float]]],
+                 height: Union[float, List[float]], depth: Union[float, List[float]],
+                 borehole_radius: Union[float, List[float]], tilt_angle: Union[float, List[float]] = 0,
+                 orientation_angle: Union[float, List[float]] = 0):
+
+        self.xy_coords = xy_coord_pairs
+        self.x_coords = [xy_pair[0] for xy_pair in xy_coord_pairs]
+        self.y_coords = [xy_pair[1] for xy_pair in xy_coord_pairs]
+        self.num_bh = len(xy_coord_pairs)
+        self.height = height
+        self.height_list = []
+        self.depth = depth
+        self.depth_list = []
+        self.bh_radius = borehole_radius
+        self.bh_radius_list = []
+        self.tilt_angle = tilt_angle
+        self.tilt_angle_list = []
+        self.orientation_angle = orientation_angle
+        self.orientation_angle_list = []
+
+    def setup_list(self, user_value):
+        if type(user_value) == list:
+            if len(user_value) != self.num_bh:
+                assert False
+            return user_value
+        else:
+            return [user_value] * self.num_bh
+
+    def as_config(self):
+        self.height_list = self.setup_list(self.height)
+        self.depth_list = self.setup_list(self.depth)
+        self.bh_radius_list = self.setup_list(self.bh_radius)
+        self.tilt_angle_list = self.setup_list(self.tilt_angle)
+        self.orientation_angle_list = self.setup_list(self.orientation_angle)
+
+        all_bh_configs = zip(self.height_list,
+                             self.depth_list,
+                             self.bh_radius_list,
+                             self.x_coords,
+                             self.y_coords,
+                             self.tilt_angle_list,
+                             self.orientation_angle_list)
+
+        return [Borehole(*cfg) for cfg in all_bh_configs]
+
+
+class GFunctionGenerator(object):
+
+    def __init__(self, borehole_field: BHFieldParams,
+                 alpha: float,
+                 time: List[float],
+                 options: Union[Dict[str, str], None] = None,
+                 solver_method: str = "equivalent",
+                 boundary_condition: str = "UHTR"):
+        """
+        Borehole config parameters are defined in the Borehole class
+        All other parameters are defined in the PyGFunction class
+        """
+
+        if options is None:
+            options = {}
+
+        self.gfunc = gFunction(
+            borehole_field.as_config(),
+            alpha,
+            time=time,
+            boundary_condition=boundary_condition,
+            options=options,
+            method=solver_method,
+        )
+
+    def to_list(self):
+        return self.gfunc.gFunc.tolist()

pygfunction/gfunction.py

@@ -65,11 +65,11 @@ class gFunction(object):
         of
 
             - 'UHTR' :
-                **Uniform heat transfer rate**. This is corresponds to boundary
+                **Uniform heat transfer rate**. This corresponds to boundary
                 condition *BC-I* as defined by Cimmino and Bernier (2014)
                 [#gFunction-CimBer2014]_.
             - 'UBWT' :
-                **Uniform borehole wall temperature**. This is corresponds to
+                **Uniform borehole wall temperature**. This corresponds to
                 boundary condition *BC-III* as defined by Cimmino and Bernier
                 (2014) [#gFunction-CimBer2014]_.
             - 'MIFT' :

tests/test_api.py

@@ -0,0 +1,67 @@
+import numpy as np
+
+from unittest import TestCase
+from pygfunction.api import GFunctionGenerator, BHFieldParams
+
+
+class TestAPI(TestCase):
+
+    def setUp(self):
+        self.height = 150
+        self.depth = 4
+        self.bh_radius = 0.075
+
+        # g-function config
+        self.alpha = 1e-6  # Ground thermal diffusivity [m2/s]
+        ts = self.height ** 2 / (9 * self.alpha)
+        self.time = np.array([0.1, 1., 10.]) * ts
+
+    def test_compute_vertical_g_functions_from_api(self):
+        # bh locations
+        xy_coords = [(0, 5), (0, 10), (0, 15), (0, 20)]
+
+        # compute g-functions
+        bh_field_params = BHFieldParams(xy_coords, self.height, self.depth, self.bh_radius)
+        GFunctionGenerator(bh_field_params, self.alpha, self.time)
+
+    def test_compute_inclined_g_functions_from_api(self):
+        # borehole config
+        self.height = 150.  # Borehole length [m]
+        self.depth = 4.  # Borehole buried self.depth [m]
+        self.bh_radius = 0.075  # Borehole radius [m]
+
+        # bh locations
+        xy_coords = [(0, 5), (0, 10), (0, 15), (0, 20)]
+
+        # compute g-functions
+        bh_field_params = BHFieldParams(xy_coords, self.height, self.depth, self.bh_radius, tilt_angle=20,
+                                        orientation_angle=20)
+        GFunctionGenerator(bh_field_params, self.alpha, self.time, solver_method="detailed")
+
+    # # Set up initial borehole config values
+    # complete_borehole_config = [self.height, self.depth, self.bh_radius, x, y, tilt, orientation]
+    # # print(f"{complete_borehole_config=}=")
+    # simple_borehole_config = [self.height, self.depth, self.bh_radius, x, y]
+    # # print(f"{simple_borehole_config=}")
+    #
+    # number_of_boreholes = 6
+    # # only change x, y coordinates between boreholes
+    # increment_indices = [3, 4]
+    # # Generate list of lists of borehole configs. Increment each value by 1 to avoid duplicates
+    # complete_borefield_config = [
+    #     [x + i if idx in increment_indices else x for idx, x in enumerate(complete_borehole_config)] for i in
+    #     range(number_of_boreholes)]
+    # # pprint(f"{complete_borefield_config=}=")
+    # simple_borefield_config = [
+    #     [x + i if idx in increment_indices else x for idx, x in enumerate(simple_borehole_config)] for i in
+    #     range(number_of_boreholes)]
+    # # pprint(f"{simple_borefield_config=}=")
+    #
+    # # -- Act
+    # # TODO: submit various options and test the output
+    # pyg_1 = GFunctionGenerator(complete_borefield_config, alpha, time, solver_method="detailed")
+    # pyg_2 = GFunctionGenerator(simple_borefield_config, alpha, time)
+
+    # -- Assert
+    # assert isinstance(pyg_1.to_list(), list)
+    # assert isinstance(pyg_2.to_list(), list)