Merge branch 'enum-numerical-vals'

Author: softwareengineerprogrammer

src/geophires_x/AGSOutputs.py

@@ -61,7 +61,7 @@ def PrintOutputs(self, model: Model):
                     f = scipy.interpolate.interp1d(np.arange(0, len(model.wellbores.PumpingPower.value)),
                                                    model.wellbores.PumpingPower.value, fill_value="extrapolate")
                     model.wellbores.PumpingPower.value = f(np.arange(0, len(model.wellbores.ProducedTemperature.value), 1.0))
-                if model.surfaceplant.enduse_option.value != EndUseOptions.HEAT:
+                if model.surfaceplant.enduse_option.value is not EndUseOptions.HEAT:
                     if len(model.wellbores.PumpingPower.value) != len(model.wellbores.ProducedTemperature.value):
                         f = scipy.interpolate.interp1d(np.arange(0, len(model.wellbores.PumpingPower.value)),
                                                        model.wellbores.PumpingPower.value, fill_value="extrapolate")

src/geophires_x/EconomicsAddOns.py

@@ -279,10 +279,10 @@ def Calculate(self, model: Model) -> None:
         # so we need to update them here so when they get used in the final economic calculation (below),
         # the new values reflect the addition of the AddOns
         for i in range(0, model.surfaceplant.plant_lifetime.value):
-            if model.surfaceplant.enduse_option.value != EndUseOptions.HEAT:  # all these end-use options have an electricity generation component
+            if model.surfaceplant.enduse_option.value is not EndUseOptions.HEAT:  # all these end-use options have an electricity generation component
                 model.surfaceplant.TotalkWhProduced.value[i] = model.surfaceplant.TotalkWhProduced.value[i] + self.AddOnElecGainedTotalPerYear.value
                 model.surfaceplant.NetkWhProduced.value[i] = model.surfaceplant.NetkWhProduced.value[i] + self.AddOnElecGainedTotalPerYear.value
-                if model.surfaceplant.enduse_option.value != EndUseOptions.ELECTRICITY:
+                if model.surfaceplant.enduse_option.value is not EndUseOptions.ELECTRICITY:
                     model.surfaceplant.HeatkWhProduced.value[i] = model.surfaceplant.HeatkWhProduced.value[i] + self.AddOnHeatGainedTotalPerYear.value
             else:
                 # all the end-use option of direct-use only components have a heat generation component

src/geophires_x/EconomicsS_DAC_GT.py

@@ -654,13 +654,13 @@ def Calculate(self, model: Model) -> None:
         # some (all) of it to do the capture, so when they get used in the final economic calculation (below),
         # the new values reflect the impact of S-DAC-GT
         for i in range(0, model.surfaceplant.plant_lifetime.value):
-            if model.surfaceplant.enduse_option.value != EndUseOptions.HEAT:
+            if model.surfaceplant.enduse_option.value is not EndUseOptions.HEAT:
                 # all these end-use options have an electricity generation component
                 model.surfaceplant.TotalkWhProduced.value[i] = model.surfaceplant.TotalkWhProduced.value[i] - (
                     self.CarbonExtractedAnnually.value[i] * self.elec.value)
                 model.surfaceplant.NetkWhProduced.value[i] = model.surfaceplant.NetkWhProduced.value[i] - (
                     self.CarbonExtractedAnnually.value[i] * self.elec.value)
-                if model.surfaceplant.enduse_option.value != EndUseOptions.ELECTRICITY:
+                if model.surfaceplant.enduse_option.value is not EndUseOptions.ELECTRICITY:
                     model.surfaceplant.HeatkWhProduced.value[i] = model.surfaceplant.HeatkWhProduced.value[i] - (
                         self.CarbonExtractedAnnually.value[i] * self.therm.value)
             else:

src/geophires_x/OptionList.py

@@ -3,40 +3,37 @@
 
 
 class EndUseOptions(str, Enum):
-    ELECTRICITY = "Electricity"  # 1
-    HEAT = "Direct-Use Heat"  # 2
-    COGENERATION_TOPPING_EXTRA_HEAT = "Cogeneration Topping Cycle, Heat sales considered as extra income"  # 31
-    COGENERATION_TOPPING_EXTRA_ELECTRICITY = "Cogeneration Topping Cycle, Electricity sales considered as extra income"  # 32
-    COGENERATION_BOTTOMING_EXTRA_HEAT = "Cogeneration Bottoming Cycle, Heat sales considered as extra income"  # 41
-    COGENERATION_BOTTOMING_EXTRA_ELECTRICITY = "Cogeneration Bottoming Cycle, Electricity sales considered as extra income"  # 42
-    COGENERATION_PARALLEL_EXTRA_HEAT = "Cogeneration Parallel Cycle, Heat sales considered as extra income"  # 51
-    COGENERATION_PARALLEL_EXTRA_ELECTRICITY = "Cogeneration Parallel Cycle, Electricity sales considered as extra income"  # 52
+    ELECTRICITY = 1, "Electricity"
+    HEAT = 2, "Direct-Use Heat"
+    COGENERATION_TOPPING_EXTRA_HEAT = 31, "Cogeneration Topping Cycle, Heat sales considered as extra income"
+    COGENERATION_TOPPING_EXTRA_ELECTRICITY = 32, "Cogeneration Topping Cycle, Electricity sales considered as extra income"
+    COGENERATION_BOTTOMING_EXTRA_HEAT = 41, "Cogeneration Bottoming Cycle, Heat sales considered as extra income"
+    COGENERATION_BOTTOMING_EXTRA_ELECTRICITY = 42, "Cogeneration Bottoming Cycle, Electricity sales considered as extra income"
+    COGENERATION_PARALLEL_EXTRA_HEAT = 51, "Cogeneration Parallel Cycle, Heat sales considered as extra income"
+    COGENERATION_PARALLEL_EXTRA_ELECTRICITY = 52, "Cogeneration Parallel Cycle, Electricity sales considered as extra income"
+
+    def __new__(cls, *args, **kwds):
+        obj = str.__new__(cls)
+        obj._value_ = args[1]
+        return obj
+
+    def __init__(self, numerical_input_value: int, _: str):
+        self._numerical_input_value = numerical_input_value
+
+    def __eq__(self, other):
+        return str(self) == str(other)
 
     @staticmethod
     def get_end_use_option_from_input_string(input_string:str):
         """
         :rtype: EndUseOptions
         """
 
-        if input_string == str(1):
-            return EndUseOptions.ELECTRICITY
-        elif input_string == str(2):
-            return EndUseOptions.HEAT
-            self.plant_type.value = PlantType.INDUSTRIAL
-        elif input_string == str(31):
-            return EndUseOptions.COGENERATION_TOPPING_EXTRA_HEAT
-        elif input_string == str(32):
-            return EndUseOptions.COGENERATION_TOPPING_EXTRA_ELECTRICITY
-        elif input_string == str(41):
-            return EndUseOptions.COGENERATION_BOTTOMING_EXTRA_HEAT
-        elif input_string == str(42):
-            return EndUseOptions.COGENERATION_BOTTOMING_EXTRA_ELECTRICITY
-        elif input_string == str(51):
-            return EndUseOptions.COGENERATION_PARALLEL_EXTRA_HEAT
-        elif input_string == str(52):
-            return EndUseOptions.COGENERATION_PARALLEL_EXTRA_ELECTRICITY
-
-        raise ValueError(f'Unknown End-Use Option value: {input_string}')
+        for option in EndUseOptions:
+            if input_string == str(option._numerical_input_value):
+                return option
+
+        raise ValueError(f'Unknown End-Use Option input value: {input_string}')
 
 
 class PlantType(str, Enum):
@@ -99,22 +96,26 @@ class WellDrillingCostCorrelation(str, Enum):
     VERTICAL_LARGE_IDEAL = 16, "vertical open-hole, large diameter, ideal", -0.00240, 752.93946, 524337.65380
     DEVIATED_LARGE_IDEAL = 17, "deviated liner, large diameter, ideal", 0.00376, 762.52696, 765103.07690
 
+    def calculate_cost_MUSD(self, meters) -> float:
+        return (self._c2 * meters ** 2 + self._c1 * meters + self._c0) * 1E-6
 
     def __new__(cls, *args, **kwds):
         obj = str.__new__(cls)
         obj._value_ = args[1]
         return obj
 
-    def __init__(self, idx: int, _: str, c2:float, c1:float, c0:float):
+    def __init__(self, numerical_input_value: int, _: str, c2: float, c1: float, c0: float):
         self._c2 = c2
         self._c1 = c1
         self._c0 = c0
 
+    def __eq__(self, other):
+        return str(self) == str(other)
+
     def calculate_cost_MUSD(self, meters) -> float:
         return (self._c2 * meters ** 2 + self._c1 * meters + self._c0) * 1E-6
 
 
-
 class FractureShape(str, Enum):
     CIRCULAR_AREA = "Circular fracture with known area"
     CIRCULAR_DIAMETER = "Circular fracture with known diameter"

src/geophires_x/Outputs.py

@@ -795,7 +795,7 @@ def PrintOutputs(self, model: Model):
             summary.append(OutputTableItem('Average Net Electricity Production', '{0:10.2f}'.format(
                 np.average(model.surfaceplant.NetElectricityProduced.value)),
                                            model.surfaceplant.NetElectricityProduced.CurrentUnits.value))
-        if model.surfaceplant.enduse_option.value != EndUseOptions.ELECTRICITY:  # there is a direct-use component
+        if model.surfaceplant.enduse_option.value is not EndUseOptions.ELECTRICITY:  # there is a direct-use component
             summary.append(OutputTableItem('Average Direct-Use Heat Production',
                                            '{0:10.2f}'.format(np.average(model.surfaceplant.HeatProduced.value)),
                                            model.surfaceplant.HeatProduced.CurrentUnits.value))
@@ -1567,7 +1567,7 @@ def PrintOutputs(self, model: Model):
                     f.write('      Surface Application: ' + str(model.surfaceplant.plant_type.value.value) + NL)
                 if model.surfaceplant.enduse_option.value in [EndUseOptions.ELECTRICITY, EndUseOptions.COGENERATION_TOPPING_EXTRA_HEAT, EndUseOptions.COGENERATION_TOPPING_EXTRA_ELECTRICITY, EndUseOptions.COGENERATION_BOTTOMING_EXTRA_ELECTRICITY, EndUseOptions.COGENERATION_BOTTOMING_EXTRA_HEAT, EndUseOptions.COGENERATION_PARALLEL_EXTRA_HEAT, EndUseOptions.COGENERATION_PARALLEL_EXTRA_ELECTRICITY]: # there is an electricity component
                     f.write(f'      Average Net Electricity Production:               {np.average(model.surfaceplant.NetElectricityProduced.value):10.2f} ' + model.surfaceplant.NetElectricityProduced.CurrentUnits.value + NL)
-                if model.surfaceplant.enduse_option.value != EndUseOptions.ELECTRICITY:    # there is a direct-use component
+                if model.surfaceplant.enduse_option.value is not EndUseOptions.ELECTRICITY:    # there is a direct-use component
                     f.write(f'      Average Direct-Use Heat Production:               {np.average(model.surfaceplant.HeatProduced.value):10.2f} '+ model.surfaceplant.HeatProduced.CurrentUnits.value + NL)
                 if model.surfaceplant.plant_type.value == PlantType.DISTRICT_HEATING:
                     f.write(f'      Annual District Heating Demand:                   {np.average(model.surfaceplant.annual_heating_demand.value):10.2f} ' + model.surfaceplant.annual_heating_demand.CurrentUnits.value + NL)

src/geophires_x/SurfacePlant.py

@@ -193,7 +193,7 @@ def annual_electricity_pumping_power(self, plant_lifetime: int, enduse_option: E
                                                         dx=1. / timestepsperyear * 365. * 24.) * 1000. * utilization_factor
                 NetkWhProduced[i] = np.trapz(NetElectricityProduced[(0 + i * timestepsperyear):((i + 1) * timestepsperyear) + 1],
                                                         dx=1. / timestepsperyear * 365. * 24.) * 1000. * utilization_factor
-        if enduse_option != EndUseOptions.ELECTRICITY:
+        if enduse_option is not EndUseOptions.ELECTRICITY:
             # all those end-use options have a direct-use component
             HeatkWhProduced = np.zeros(plant_lifetime)
             for i in range(0, plant_lifetime):
@@ -236,15 +236,15 @@ def __init__(self, model: Model):
             AllowableRange=[1, 2, 31, 32, 41, 42, 51, 52],
             UnitType=Units.NONE,
             ErrMessage="assume default end-use option (1: electricity only)",
-            ToolTipText="""Select the end-use application of the geofluid heat:
-1: Electricity;
-2: Direct-Use Heat;
-31: Cogeneration Topping Cycle, Heat sales considered as extra income;
-32: Cogeneration Topping Cycle, Electricity sales considered as extra income;
-41: Cogeneration Bottoming Cycle, Heat sales considered as extra income;
-42: Cogeneration Bottoming Cycle, Electricity sales considered as extra income;
-51: Cogeneration Parallel Cycle, Heat sales considered as extra income;
-52: Cogeneration Parallel Cycle, Electricity sales considered as extra income"""
+            ToolTipText="Select the end-use application of the geofluid heat: " +
+                        "1: Electricity; " +
+                        "2: Direct-Use Heat; " +
+                        "31: Cogeneration Topping Cycle, Heat sales considered as extra income; " +
+                        "32: Cogeneration Topping Cycle, Electricity sales considered as extra income; " +
+                        "41: Cogeneration Bottoming Cycle, Heat sales considered as extra income; " +
+                        "42: Cogeneration Bottoming Cycle, Electricity sales considered as extra income; " +
+                        "51: Cogeneration Parallel Cycle, Heat sales considered as extra income; " +
+                        "52: Cogeneration Parallel Cycle, Electricity sales considered as extra income"
         )
         self.plant_type = self.ParameterDict[self.plant_type.Name] = intParameter(
             "Power Plant Type",

src/geophires_x/SurfacePlantAGS.py

@@ -751,7 +751,7 @@ def Calculate(self, model: Model) -> None:
         self.RemainingReservoirHeatContent.value = model.reserv.InitialReservoirHeatContent.value - np.cumsum(
             self.HeatkWhExtracted.value) * 3600 * 1E3 / 1E15
 
-        if self.End_use != EndUseOptions.ELECTRICITY:
+        if self.End_use is not EndUseOptions.ELECTRICITY:
             self.HeatkWhProduced.value = np.zeros(self.plant_lifetime.value)
             for i in range(0, self.plant_lifetime.value):
                 self.HeatkWhProduced.value[i] = np.trapz(self.HeatProduced.value[

tests/geophires_x_tests/test_options_list.py

@@ -0,0 +1,32 @@
+from base_test_case import BaseTestCase
+from geophires_x.OptionList import EndUseOptions
+from geophires_x.OptionList import PlantType
+from geophires_x.OptionList import WellDrillingCostCorrelation
+
+
+class EndUseOptionsTestCase(BaseTestCase):
+    def test_get_end_use_option_from_input_string(self):
+        self.assertEqual(EndUseOptions.get_end_use_option_from_input_string('1'), EndUseOptions.ELECTRICITY)
+
+        with self.assertRaises(ValueError):
+            EndUseOptions.get_end_use_option_from_input_string('2034982309')
+
+    def test_equality(self):
+        self.assertFalse(EndUseOptions.HEAT == EndUseOptions.ELECTRICITY)
+        self.assertTrue(EndUseOptions.HEAT == EndUseOptions.HEAT)
+        self.assertFalse(EndUseOptions.HEAT is None)
+        self.assertTrue(EndUseOptions.HEAT is EndUseOptions.HEAT)
+        # self.assertTrue(EndUseOptions.HEAT == 'HEAT')
+        # self.assertFalse(EndUseOptions.HEAT == 'Electricity')
+
+
+class WellDrillingCostCorrelationTestCase(BaseTestCase):
+    def test_equality(self):
+        self.assertFalse(WellDrillingCostCorrelation.VERTICAL_SMALL == WellDrillingCostCorrelation.DEVIATED_SMALL)
+        self.assertTrue(WellDrillingCostCorrelation.VERTICAL_SMALL == WellDrillingCostCorrelation.VERTICAL_SMALL)
+
+
+class PlantTypeTestCase(BaseTestCase):
+    def test_equality(self):
+        self.assertFalse(PlantType.SUB_CRITICAL_ORC == PlantType.SUPER_CRITICAL_ORC)
+        self.assertTrue(WellDrillingCostCorrelation.VERTICAL_SMALL == WellDrillingCostCorrelation.VERTICAL_SMALL)