Merge pull request #394 from wouterpeere/162-size-borefield-configuration-function_new

162 size borefield configuration function

Author: wouterpeere

CHANGELOG.md

@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 
+- Optimise number of boreholes (issue #162).
 - Artificial Neural Network to speed up calculations (issue #322, @tblanke).
 
 ### Changed

GHEtool/Borefield.py

@@ -237,7 +237,6 @@ def set_borefield(self, borefield: gt.borefield.Borefield = None) -> None:
         -------
         None
         """
-        self._borefield_description = None
         self.borefield = borefield
 
     def create_rectangular_borefield(self, N_1: int, N_2: int, B_1: float, B_2: float, H: float, D: float = 1,
@@ -476,6 +475,7 @@ def borefield(self, borefield: gt.borefield.Borefield = None) -> None:
         else:
             self.gfunction_calculation_object.store_previous_values = \
                 self.gfunction_calculation_object._store_previous_values_backup
+        self._borefield_description = None
 
     @borefield.deleter
     def borefield(self):
@@ -1543,7 +1543,7 @@ def _size_based_on_temperature_profile(self, quadrant: int, hourly: bool = False
         while not self._check_convergence(self.H, H_prev, i):
             if H_prev != 0:
                 self.H = self.H * .5 + H_prev * 0.5
-            limit = self.Tf_min if quadrant in (3, 4, 20) else self.Tf_max
+
             if hourly:
                 self._calculate_temperature_profile(self.H, hourly=True, sizing=True)
             else:
@@ -1587,7 +1587,6 @@ def _size_based_on_temperature_profile(self, quadrant: int, hourly: bool = False
                 return 0, False
 
             i += 1
-
         return self.H, (np.max(self.results.peak_injection) <= self.Tf_max + 0.05 or (
                 quadrant == 10 or quadrant == 1 or quadrant == 2)) and (
                                np.min(self.results.peak_extraction) >= self.Tf_min - 0.05 or (
@@ -1760,6 +1759,9 @@ def _calculate_temperature_profile(self, H: float = None, hourly: bool = False,
 
         # reset self.results
         self.results = ResultsMonthly()
+        variable_efficiency = isinstance(self.load, _LoadDataBuilding) and not (
+                isinstance(self.load.cop, SCOP) and isinstance(self.load.cop_dhw, SCOP) and isinstance(
+            self.load.eer, SEER))
 
         def calculate_temperatures(H, hourly=hourly, results_temperature=ResultsMonthly()):
             # set Rb* value
@@ -1769,9 +1771,7 @@ def calculate_temperatures(H, hourly=hourly, results_temperature=ResultsMonthly(
             results = None
 
             def get_rb(temperature, limit=None):
-                variable_efficiency = isinstance(self.load, _LoadDataBuilding) and not (
-                        isinstance(self.load.cop, SCOP) and isinstance(self.load.cop_dhw, SCOP) and isinstance(
-                    self.load.eer, SEER))
+
                 if self.USE_SPEED_UP_IN_SIZING and sizing and not variable_efficiency:
                     # use only extreme temperatures when sizing
                     if limit is not None:
@@ -1901,7 +1901,10 @@ def calculate_difference(results_old: Union[ResultsMonthly, ResultsHourly],
                 self.load.reset_results(self.Tf_min, self.Tf_max)
             results_old = calculate_temperatures(H, hourly=hourly)
             self.load.set_results(results_old)
-            results = calculate_temperatures(H, hourly=hourly, results_temperature=results_old)
+            if sizing and not variable_efficiency and self._calculation_setup.approximate_req_depth:
+                results = results_old
+            else:
+                results = calculate_temperatures(H, hourly=hourly, results_temperature=results_old)
 
             # safety
             i = 0

GHEtool/Examples/optimal_borehole_configuration.py

@@ -0,0 +1,209 @@
+from GHEtool import *
+from GHEtool.Methods.optimise_borefield_configuration import optimise_borefield_configuration
+from GHEtool.Validation.cases import load_case
+
+
+def borefield_case_1():
+    borefield = Borefield(ground_data=GroundConstantTemperature(3.5, 10),
+                          load=MonthlyGeothermalLoadAbsolute(*load_case(1)))
+    borefield.create_rectangular_borefield(10, 6, 6.5, 6.5, 100, 4, 0.075)
+    borefield.calculation_setup(use_neural_network=True)
+
+    # optimise for minimum borehole length
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150)
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal borehole length is: {result[0][0]:.2f}m. '
+        f'There are {result[0][2]} boreholes. The configuration is {result[0][1]}.')
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150, optimise='nb')
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal number of boreholes {result[0][2]}. '
+        f'The total borehole lengths is {result[0][0]:.2f}m. The configuration is {result[0][1]}.')
+
+
+def borefield_case_2():
+    borefield = Borefield(ground_data=GroundConstantTemperature(3.5, 10),
+                          load=MonthlyGeothermalLoadAbsolute(*load_case(2)))
+    borefield.create_rectangular_borefield(10, 6, 6.5, 6.5, 100, 4, 0.075)
+    borefield.calculation_setup(use_neural_network=True)
+
+    # optimise for minimum borehole length
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150)
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal borehole length is: {result[0][0]:.2f}m. '
+        f'There are {result[0][2]} boreholes. The configuration is {result[0][1]}.')
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150, optimise='nb')
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal number of boreholes {result[0][2]}. '
+        f'The total borehole lengths is {result[0][0]:.2f}m. The configuration is {result[0][1]}.')
+
+
+def borefield_case_3():
+    borefield = Borefield(ground_data=GroundConstantTemperature(3.5, 10),
+                          load=MonthlyGeothermalLoadAbsolute(*load_case(3)))
+    borefield.create_rectangular_borefield(10, 6, 6.5, 6.5, 100, 4, 0.075)
+    borefield.calculation_setup(use_neural_network=True)
+
+    # optimise for minimum borehole length
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150)
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal borehole length is: {result[0][0]:.2f}m. '
+        f'There are {result[0][2]} boreholes. The configuration is {result[0][1]}.')
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150, optimise='nb')
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal number of boreholes {result[0][2]}. '
+        f'The total borehole lengths is {result[0][0]:.2f}m. The configuration is {result[0][1]}.')
+
+
+def borefield_case_4():
+    borefield = Borefield(ground_data=GroundConstantTemperature(3.5, 10),
+                          load=MonthlyGeothermalLoadAbsolute(*load_case(4)))
+    borefield.create_rectangular_borefield(10, 6, 6.5, 6.5, 100, 4, 0.075)
+    borefield.calculation_setup(use_neural_network=True)
+
+    # optimise for minimum borehole length
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150)
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal borehole length is: {result[0][0]:.2f}m. '
+        f'There are {result[0][2]} boreholes. The configuration is {result[0][1]}.')
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150, optimise='nb')
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal number of boreholes {result[0][2]}. '
+        f'The total borehole lengths is {result[0][0]:.2f}m. The configuration is {result[0][1]}.')
+
+
+def borefield_office():
+    borefield = Borefield()
+    borefield.create_rectangular_borefield(10, 10, 6, 6, 110, 4, 0.075)
+    borefield.ground_data = GroundFluxTemperature(3, 10)
+    borefield.fluid_data = ConstantFluidData(0.568, 998, 4180, 1e-3)
+    borefield.flow_data = ConstantFlowRate(mfr=0.2)
+    borefield.pipe_data = DoubleUTube(1, 0.015, 0.02, 0.4, 0.05)
+    borefield.calculation_setup(use_constant_Rb=False)
+    borefield.set_max_avg_fluid_temperature(17)
+    borefield.set_min_avg_fluid_temperature(3)
+    hourly_load = HourlyGeothermalLoad()
+    hourly_load.simulation_period = 20
+    hourly_load.load_hourly_profile(FOLDER.joinpath("test\methods\hourly_data\office.csv"), header=True, separator=";",
+                                    col_injection=0, col_extraction=1)
+    borefield.load = hourly_load
+    borefield.calculation_setup(use_neural_network=True)
+
+    # optimise for minimum borehole length
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150)
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal borehole length is: {result[0][0]:.2f}m. '
+        f'There are {result[0][2]} boreholes. The configuration is {result[0][1]}.')
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150, optimise='nb')
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal number of boreholes {result[0][2]}. '
+        f'The total borehole lengths is {result[0][0]:.2f}m. The configuration is {result[0][1]}.')
+
+
+def borefield_auditorium():
+    borefield = Borefield()
+    borefield.create_rectangular_borefield(10, 10, 6, 6, 110, 4, 0.075)
+    borefield.ground_data = GroundFluxTemperature(3, 10)
+    borefield.fluid_data = ConstantFluidData(0.568, 998, 4180, 1e-3)
+    borefield.flow_data = ConstantFlowRate(mfr=0.2)
+    borefield.pipe_data = DoubleUTube(1, 0.015, 0.02, 0.4, 0.05)
+    borefield.calculation_setup(use_constant_Rb=False)
+    borefield.set_max_avg_fluid_temperature(17)
+    borefield.set_min_avg_fluid_temperature(3)
+    hourly_load = HourlyGeothermalLoad()
+    hourly_load.simulation_period = 20
+    hourly_load.load_hourly_profile(FOLDER.joinpath("test\methods\hourly_data\\auditorium.csv"), header=True,
+                                    separator=";", col_injection=0, col_extraction=1)
+    borefield.load = hourly_load
+    borefield.calculation_setup(use_neural_network=True)
+
+    # optimise for minimum borehole length
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150)
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal borehole length is: {result[0][0]:.2f}m. '
+        f'There are {result[0][2]} boreholes. The configuration is {result[0][1]}.')
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150,
+                                              optimise='nb')
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal number of boreholes {result[0][2]}. '
+        f'The total borehole lengths is {result[0][0]:.2f}m. The configuration is {result[0][1]}.')
+
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150, size_L3=False)
+
+
+def borefield_swimming_pool():
+    borefield = Borefield()
+    borefield.create_rectangular_borefield(10, 10, 6, 6, 110, 4, 0.075)
+    borefield.ground_data = GroundFluxTemperature(3, 10)
+    borefield.fluid_data = ConstantFluidData(0.568, 998, 4180, 1e-3)
+    borefield.flow_data = ConstantFlowRate(mfr=0.2)
+    borefield.pipe_data = DoubleUTube(1, 0.015, 0.02, 0.4, 0.05)
+    borefield.calculation_setup(use_constant_Rb=False)
+    borefield.set_max_avg_fluid_temperature(17)
+    borefield.set_min_avg_fluid_temperature(3)
+    hourly_load = HourlyGeothermalLoad()
+    hourly_load.simulation_period = 20
+    hourly_load.load_hourly_profile(FOLDER.joinpath("test\methods\hourly_data\swimming_pool.csv"), header=True,
+                                    separator=";", col_injection=0, col_extraction=1)
+    borefield.load = hourly_load
+    borefield.calculation_setup(use_neural_network=True)
+
+    # optimise for minimum borehole length
+    result = optimise_borefield_configuration(borefield, 200, 200, 5, 7, 0.5, 60, 300)
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal borehole length is: {result[0][0]:.2f}m. '
+        f'There are {result[0][2]} boreholes. The configuration is {result[0][1]}.')
+    result = optimise_borefield_configuration(borefield, 200, 200, 5, 7, 0.5, 60, 300, optimise='nb')
+    borefield.borefield = result[0][-1]
+    print(
+        f'{len(result)} solutions are found. The optimal number of boreholes {result[0][2]}. '
+        f'The total borehole lengths is {result[0][0]:.2f}m. The configuration is {result[0][1]}.')
+
+
+def borefield_case_1_flow_rate():
+    borefield = Borefield(ground_data=GroundConstantTemperature(3.5, 10),
+                          load=MonthlyGeothermalLoadAbsolute(*load_case(1)))
+    borefield.create_rectangular_borefield(10, 6, 6.5, 6.5, 100, 4, 0.075)
+    borefield.ground_data = GroundFluxTemperature(3, 10)
+    borefield.fluid_data = ConstantFluidData(0.568, 998, 4180, 1e-3)
+    borefield.flow_data = ConstantFlowRate(mfr=0.3)
+    borefield.pipe_data = DoubleUTube(1, 0.015, 0.02, 0.4, 0.05)
+    borefield.calculation_setup(use_constant_Rb=False)
+    borefield.calculation_setup(use_neural_network=True)
+
+    # optimise for minimum borehole length
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150)
+    print(
+        f'{len(result)} solutions are found for a constant flow/borehole. The optimal borehole length is: {result[0][0]:.2f}m. '
+        f'There are {result[0][2]} boreholes. The configuration is {result[0][1]}.')
+
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150,
+                                              flow_field=ConstantFlowRate(mfr=10))
+    print(
+        f'{len(result)} solutions are found for a constant flow/borefield. The optimal number of boreholes {result[0][2]}. '
+        f'The total borehole lengths is {result[0][0]:.2f}m. The configuration is {result[0][1]}.')
+    result = optimise_borefield_configuration(borefield, 80, 70, 5, 7, 0.5, 60, 150,
+                                              flow_field=ConstantFlowRate(vfr=10))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    borefield_case_1()
+    borefield_case_2()
+    borefield_case_3()
+    borefield_case_4()
+    borefield_office()
+    borefield_auditorium()
+    borefield_swimming_pool()
+    borefield_case_1_flow_rate()

GHEtool/Examples/optimise_load_profile_extra.py

@@ -10,22 +10,29 @@
 from GHEtool import *
 from GHEtool.Methods import *
 
+import time
+
 
 def optimise():
-    data = GroundFluxTemperature(1.8, 9.7, flux=0.08)
+    data = GroundFluxTemperature(2, 9.6, flux=0.07)
     borefield = Borefield()
     borefield.ground_data = data
-    borefield.Rb = 0.131
-    borefield.create_rectangular_borefield(3, 5, 6, 6, 100, 1, 0.07)
-    load = HourlyBuildingLoad(efficiency_heating=4.5, efficiency_cooling=20)
-    load.load_hourly_profile(FOLDER.joinpath("test\methods\hourly_data\\auditorium.csv"), header=True, separator=";",
-                             col_cooling=0, col_heating=1)
-
-    # optimise the load for a 10x10 field (see data above) and a fixed length of 150m.
-    # first for an optimisation based on the power
+    borefield.pipe_data = DoubleUTube(1.5, 0.013, 0.016, 0.4, 0.035)
+    borefield.fluid_data = TemperatureDependentFluidData('MPG', 25)
+    borefield.flow_data = ConstantFlowRate(mfr=0.3)
+    borefield.borehole.use_constant_Rb = False
+    borefield.create_rectangular_borefield(20, 4, 6, 6, 150, 1, 0.07)
+    load = HourlyBuildingLoad(efficiency_heating=5, efficiency_cooling=20)
+    load.load_hourly_profile(FOLDER.joinpath("test\methods\hourly_data\\hourly_profile.csv"), header=True,
+                             separator=";", col_cooling=1, col_heating=0)
+    load.simulation_period = 10
+    borefield.set_min_avg_fluid_temperature(3)
+    borefield.USE_SPEED_UP_IN_SIZING = False
+    # first optimise with the speed
+    start = time.time()
     building_load, _ = optimise_load_profile_energy(borefield, load)
     borefield.load = building_load
-
+    print(time.time() - start)
     print(f'Max heating power (primary): {borefield.load.max_peak_extraction:,.0f}kW')
     print(f'Max cooling power (primary): {borefield.load.max_peak_injection:,.0f}kW')
 

GHEtool/Methods/__init__.py

@@ -1,2 +1,3 @@
 from .optimise_load_profile import optimise_load_profile_power, optimise_load_profile_energy, \
     optimise_load_profile_balance
+from .optimise_borefield_configuration import *