WIP - calculate Royalty Holder NPV

Author: softwareengineerprogrammer

src/geophires_x/Economics.py

@@ -968,7 +968,7 @@ def __init__(self, model: Model):
         )
 
         self.royalty_rate = self.ParameterDict[self.royalty_rate.Name] = floatParameter(
-            "Royalty Rate",
+            'Royalty Rate',
             DefaultValue=0.,
             Min=0.0,
             Max=1.0,
@@ -978,6 +978,18 @@ def __init__(self, model: Model):
             ToolTipText="Royalty rate used in SAM Economic Models."  # FIXME WIP TODO documentation
         )
 
+        self.royalty_holder_discount_rate = self.ParameterDict[self.royalty_holder_discount_rate.Name] = floatParameter(
+            'Royalty Holder Discount Rate',
+            DefaultValue=0.05,
+            Min=0.0,
+            Max=1.0,
+            UnitType=Units.PERCENT,
+            PreferredUnits=PercentUnit.TENTH,
+            CurrentUnits=PercentUnit.TENTH,
+            ToolTipText="Royalty holder discount rate used in SAM Economic Models."  # FIXME WIP TODO documentation
+        )
+
+
         self.discount_initial_year_cashflow = self.ParameterDict[self.discount_initial_year_cashflow.Name] = boolParameter(
             'Discount Initial Year Cashflow',
             DefaultValue=False,
@@ -2134,6 +2146,33 @@ def __init__(self, model: Model):
             UnitType=Units.NONE,
         )
 
+        # Results for the Royalty Holder
+        self.royalty_holder_npv = self.OutputParameterDict[self.royalty_holder_npv.Name] = OutputParameter(
+            'Royalty Holder NPV',
+            UnitType=Units.CURRENCY,
+            PreferredUnits=CurrencyUnit.MDOLLARS,
+            CurrentUnits=CurrencyUnit.MDOLLARS,
+            ToolTipText="Net Present Value (NPV) of the royalty holder's cash flow stream."
+        )
+        self.royalty_holder_annual_revenue = self.OutputParameterDict[
+            self.royalty_holder_annual_revenue.Name
+        ] = OutputParameter(
+            'Royalty Holder Annual Revenue',
+            UnitType=Units.CURRENCYFREQUENCY,
+            PreferredUnits=CurrencyFrequencyUnit.MDOLLARSPERYEAR,
+            CurrentUnits=CurrencyFrequencyUnit.MDOLLARSPERYEAR,
+            ToolTipText="The royalty holder's annual revenue stream from the royalty agreement."
+        )
+        self.royalty_holder_total_revenue = self.OutputParameterDict[
+            self.royalty_holder_total_revenue.Name
+        ] = OutputParameter(
+            'Royalty Holder Total Revenue',
+            UnitType=Units.CURRENCY,
+            PreferredUnits=CurrencyUnit.MDOLLARS,
+            CurrentUnits=CurrencyUnit.MDOLLARS,
+            ToolTipText='The total (undiscounted) revenue received by the royalty holder over the project lifetime.'
+        )
+
         model.logger.info(f'Complete {__class__!s}: {sys._getframe().f_code.co_name}')
 
     def read_parameters(self, model: Model) -> None:
@@ -2504,38 +2543,8 @@ def Calculate(self, model: Model) -> None:
                 self.discount_initial_year_cashflow.value
             )
 
-        non_calculated_output_placeholder_val = -1
         if self.econmodel.value == EconomicModel.SAM_SINGLE_OWNER_PPA:
-            self.sam_economics_calculations = calculate_sam_economics(model)
-
-            # Setting capex_total distinguishes capex from CCap's display name of 'Total capital costs',
-            # since SAM Economic Model doesn't subtract ITC from this value.
-            self.capex_total.value = (self.sam_economics_calculations.capex.quantity()
-                               .to(self.capex_total.CurrentUnits.value).magnitude)
-            self.CCap.value = (self.sam_economics_calculations.capex.quantity()
-                               .to(self.CCap.CurrentUnits.value).magnitude)
-
-            average_annual_royalties = np.average(
-                self.sam_economics_calculations.royalties_opex.value[1:]  # ignore pre-revenue year(s) (Year 0)
-            )
-            if average_annual_royalties > 0:
-                self.royalties_average_annual_cost.value = average_annual_royalties
-                self.Coam.value += self.royalties_average_annual_cost.quantity().to(self.Coam.CurrentUnits.value).magnitude
-
-            self.wacc.value = self.sam_economics_calculations.wacc.value
-            self.nominal_discount_rate.value = self.sam_economics_calculations.nominal_discount_rate.value
-            self.ProjectNPV.value = self.sam_economics_calculations.project_npv.quantity().to(
-                convertible_unit(self.ProjectNPV.CurrentUnits)).magnitude
-
-            self.ProjectIRR.value = non_calculated_output_placeholder_val  # SAM calculates After-Tax IRR instead
-            self.after_tax_irr.value = self.sam_economics_calculations.after_tax_irr.quantity().to(
-                convertible_unit(self.ProjectIRR.CurrentUnits)).magnitude
-
-            self.ProjectMOIC.value = self.sam_economics_calculations.moic.value
-            self.ProjectVIR.value = self.sam_economics_calculations.project_vir.value
-
-            # TODO remove or clarify project payback period: https://github.com/NREL/GEOPHIRES-X/issues/413
-            self.ProjectPaybackPeriod.value = self.sam_economics_calculations.project_payback_period.value
+            self._calculate_sam_economics(model)
 
         # Calculate the project payback period
         if self.econmodel.value != EconomicModel.SAM_SINGLE_OWNER_PPA:
@@ -3267,6 +3276,51 @@ def calculate_cashflow(self, model: Model) -> None:
             for i in range(1, model.surfaceplant.plant_lifetime.value + model.surfaceplant.construction_years.value, 1):
                 self.TotalCummRevenue.value[i] = self.TotalCummRevenue.value[i-1] + self.TotalRevenue.value[i]
 
+    def _calculate_sam_economics(self, model: Model) -> None:
+        non_calculated_output_placeholder_val = -1
+        self.sam_economics_calculations = calculate_sam_economics(model)
+
+        # Setting capex_total distinguishes capex from CCap's display name of 'Total capital costs',
+        # since SAM Economic Model doesn't subtract ITC from this value.
+        self.capex_total.value = (self.sam_economics_calculations.capex.quantity()
+                                  .to(self.capex_total.CurrentUnits.value).magnitude)
+        self.CCap.value = (self.sam_economics_calculations.capex.quantity()
+                           .to(self.CCap.CurrentUnits.value).magnitude)
+
+
+        if self.royalty_rate.Provided:
+            average_annual_royalties = np.average(
+                self.sam_economics_calculations.royalties_opex.value[1:]  # ignore pre-revenue year(s) (Year 0)
+            )
+
+            self.royalties_average_annual_cost.value = average_annual_royalties
+            self.Coam.value += self.royalties_average_annual_cost.quantity().to(self.Coam.CurrentUnits.value).magnitude
+
+            self.royalty_holder_npv.value = calculate_npv(
+                self.royalty_holder_discount_rate.value,
+                self.sam_economics_calculations.royalties_opex.value,
+                self.discount_initial_year_cashflow.value
+            )
+            # FIXME WIP
+            # self.royalty_holder_annual_revenue
+            # self.royalty_holder_total_revenue
+
+
+        self.wacc.value = self.sam_economics_calculations.wacc.value
+        self.nominal_discount_rate.value = self.sam_economics_calculations.nominal_discount_rate.value
+        self.ProjectNPV.value = self.sam_economics_calculations.project_npv.quantity().to(
+            convertible_unit(self.ProjectNPV.CurrentUnits)).magnitude
+
+        self.ProjectIRR.value = non_calculated_output_placeholder_val  # SAM calculates After-Tax IRR instead
+        self.after_tax_irr.value = self.sam_economics_calculations.after_tax_irr.quantity().to(
+            convertible_unit(self.ProjectIRR.CurrentUnits)).magnitude
+
+        self.ProjectMOIC.value = self.sam_economics_calculations.moic.value
+        self.ProjectVIR.value = self.sam_economics_calculations.project_vir.value
+
+        # TODO remove or clarify project payback period: https://github.com/NREL/GEOPHIRES-X/issues/413
+        self.ProjectPaybackPeriod.value = self.sam_economics_calculations.project_payback_period.value
+
     # noinspection SpellCheckingInspection
     def _calculate_derived_outputs(self, model: Model) -> None:
         """

src/geophires_x/EconomicsSam.py

@@ -417,7 +417,7 @@ def _get_single_owner_parameters(model: Model) -> dict[str, Any]:
     )
     ret['ppa_price_input'] = ppa_price_schedule_per_kWh
 
-    if hasattr(econ, 'royalty_rate') and econ.royalty_rate.value > 0.0:
+    if hasattr(econ, 'royalty_rate') and econ.royalty_rate.Provided:
         royalty_rate_fraction = econ.royalty_rate.quantity().to(convertible_unit('dimensionless')).magnitude
 
         # For each year, calculate the royalty as a $/MWh variable cost.

src/geophires_x/Outputs.py

@@ -324,6 +324,11 @@ def PrintOutputs(self, model: Model):
                 if model.surfaceplant.enduse_option.value in [EndUseOptions.ELECTRICITY]:
                     f.write(f'      Estimated Jobs Created:                                 {model.economics.jobs_created.value}\n')
 
+                if econ.royalty_rate.Provided:
+                    royalty_holder_npv_label = Outputs._field_label(econ.royalty_holder_npv.display_name, 49)
+                    f.write(
+                        f'         {royalty_holder_npv_label}{econ.royalty_holder_npv.value:10.2f} {econ.royalty_holder_npv.CurrentUnits.value}\n')
+
 
                 f.write(NL)
                 f.write('                          ***ENGINEERING PARAMETERS***\n')
@@ -555,7 +560,7 @@ def PrintOutputs(self, model: Model):
                         aoc_label = Outputs._field_label(model.addeconomics.AddOnOPEXTotalPerYear.display_name, 47)
                         f.write(f'         {aoc_label}{model.addeconomics.AddOnOPEXTotalPerYear.value:10.2f} {model.addeconomics.AddOnOPEXTotalPerYear.CurrentUnits.value}\n')
 
-                    if econ.royalty_rate.value > 0.0:
+                    if econ.royalty_rate.Provided:
                         royalties_label = Outputs._field_label(econ.royalties_average_annual_cost.display_name, 47)
                         f.write(f'         {royalties_label}{econ.royalties_average_annual_cost.value:10.2f} {econ.royalties_average_annual_cost.CurrentUnits.value}\n')
 

src/geophires_x_client/geophires_x_result.py

@@ -93,6 +93,7 @@ class GeophiresXResult:
                 'Project Payback Period',
                 'CHP: Percent cost allocation for electrical plant',
                 'Estimated Jobs Created',
+                'Royalty Holder NPV',
             ],
             'EXTENDED ECONOMICS': [
                 'Adjusted Project LCOE (after incentives, grants, AddOns,etc)',

tests/test_geophires_x.py

@@ -1025,7 +1025,7 @@ def _get_result(
                 'Number of Injection Wells': doublets,
 
                 # offset contingency
-                'Reservoir Stimulation Capital Cost Adjustment Factor': 1/default_contingency_factor,
+                'Reservoir Stimulation Capital Cost Adjustment Factor': 1 / default_contingency_factor,
             }
         )
         # fmt:on
@@ -1285,13 +1285,15 @@ def test_redrilling_costs(self):
             capex_field_suffix = (
                 '' if result_capex.get('Drilling and completion costs') is not None else ' (for redrilling)'
             )
+            # @formatter:off
             expected_annual_redrilling_cost = (
                 (
                     result_capex[f'Drilling and completion costs{capex_field_suffix}']['value']
                     + result_capex[f'Stimulation costs{capex_field_suffix}']['value']
                 )
                 * result_redrills
             ) / result.result['ECONOMIC PARAMETERS']['Project lifetime']['value']
+            # @formatter:on
 
             self.assertAlmostEqual(expected_annual_redrilling_cost, result_opex['Redrilling costs']['value'], places=2)
 
@@ -1308,22 +1310,29 @@ def test_royalty_rate(self):
                 )
             )
             opex_result = result.result['OPERATING AND MAINTENANCE COSTS (M$/yr)']
-            if royalty_rate > 0.0:
-                self.assertIsNotNone(opex_result[royalties_output_name])
-                self.assertEqual(58.88, opex_result[royalties_output_name]['value'])
-                self.assertEqual('MUSD/yr', opex_result[royalties_output_name]['unit'])
 
-                total_opex_MUSD = opex_result['Total operating and maintenance costs']['value']
+            self.assertIsNotNone(opex_result[royalties_output_name])
+            self.assertEqual('MUSD/yr', opex_result[royalties_output_name]['unit'])
 
-                opex_line_item_sum = 0
-                for line_item_names in [
-                    'Wellfield maintenance costs',
-                    'Power plant maintenance costs',
-                    'Water costs',
-                    royalties_output_name,
-                ]:
-                    opex_line_item_sum += opex_result[line_item_names]['value']
+            total_opex_MUSD = opex_result['Total operating and maintenance costs']['value']
 
-                self.assertEqual(opex_line_item_sum, total_opex_MUSD)
+            opex_line_item_sum = 0
+            for line_item_names in [
+                'Wellfield maintenance costs',
+                'Power plant maintenance costs',
+                'Water costs',
+                royalties_output_name,
+            ]:
+                opex_line_item_sum += opex_result[line_item_names]['value']
+
+            self.assertEqual(opex_line_item_sum, total_opex_MUSD)
+
+            econ_result = result.result['ECONOMIC PARAMETERS']
+            royalty_holder_npv_MUSD = econ_result['Royalty Holder NPV']['value']
+
+            if royalty_rate > 0.0:
+                self.assertEqual(58.88, opex_result[royalties_output_name]['value'])
+                self.assertGreater(royalty_holder_npv_MUSD, 0)  # FIXME WIP
             else:
-                self.assertIsNone(opex_result[royalties_output_name])
+                self.assertEqual(0, opex_result[royalties_output_name]['value'])
+                self.assertEqual(0, royalty_holder_npv_MUSD)