test_royalty_rate_escalation

Author: softwareengineerprogrammer

src/geophires_x/Economics.py

@@ -3222,14 +3222,20 @@ def get_royalty_rate_schedule(self, model: Model) -> list[float]:
         :return: schedule: A list of rates as fractions (e.g., 0.05 for 5%).
         """
 
+        def r(x: float) -> float:
+            """Ignore apparent float precision issue"""
+            _precision = 8
+            return round(x, _precision)
+
         plant_lifetime = model.surfaceplant.plant_lifetime.value
 
-        escalation_rate = self.royalty_escalation_rate.value
-        max_rate = self.maximum_royalty_rate.value
+        escalation_rate = r(self.royalty_escalation_rate.value)
+        max_rate = r(self.maximum_royalty_rate.value)
 
         schedule = []
-        current_rate = self.royalty_rate.value
+        current_rate = r(self.royalty_rate.value)
         for _ in range(plant_lifetime):
+            current_rate = r(current_rate)
             schedule.append(min(current_rate, max_rate))
             current_rate += escalation_rate
 

src/geophires_x/EconomicsSam.py

@@ -423,13 +423,13 @@ def _get_single_owner_parameters(model: Model) -> dict[str, Any]:
         # The royalty is a percentage of revenue (MWh * $/MWh). By setting the
         # variable O&M rate to (PPA Price * Royalty Rate), SAM's calculation
         # (Rate * MWh) will correctly yield the total royalty payment.
-        variable_om_schedule_per_mwh = [
+        variable_om_schedule_per_MWh = [
             (price_kwh * 1000) * royalty_fraction  # TODO use pint unit conversion instead
             for price_kwh, royalty_fraction in zip(ppa_price_schedule_per_kWh, royalty_rate_schedule)
         ]
 
         # The PySAM parameter for variable operating cost in $/MWh is 'om_production'.
-        ret['om_production'] = variable_om_schedule_per_mwh
+        ret['om_production'] = variable_om_schedule_per_MWh
 
     # Debt/equity ratio ('Fraction of Investment in Bonds' parameter)
     ret['debt_percent'] = _pct(econ.FIB)

tests/test_geophires_x.py

@@ -1309,6 +1309,7 @@ def test_redrilling_costs(self):
     def test_royalty_rate(self):
         royalties_output_name = 'Average Annual Royalty Cost'
 
+        zero_royalty_npv = None
         for royalty_rate in [0, 0.1]:
             result = GeophiresXClient().get_geophires_result(
                 ImmutableGeophiresInputParameters(
@@ -1345,6 +1346,9 @@ def test_royalty_rate(self):
                 self.assertEqual(58.88, opex_result[royalties_output_name]['value'])
                 self.assertGreater(royalty_holder_npv_MUSD, 0)
 
+                # Owner NPV is lower when royalty rate is non-zero
+                self.assertGreater(zero_royalty_npv, result.result['ECONOMIC PARAMETERS']['Project NPV']['value'])
+
                 royalties_cash_flow_MUSD = [
                     it * 1e-6
                     for it in _cash_flow_profile_row(
@@ -1362,3 +1366,65 @@ def test_royalty_rate(self):
             if royalty_rate == 0.0:
                 self.assertEqual(0, opex_result[royalties_output_name]['value'])
                 self.assertEqual(0, royalty_holder_npv_MUSD)
+                zero_royalty_npv = result.result['ECONOMIC PARAMETERS']['Project NPV']['value']
+
+    def test_royalty_rate_escalation(self):
+        royalties_output_name = 'Average Annual Royalty Cost'
+
+        base_royalty_rate = 0.05
+        escalation_rate = 0.01
+
+        for max_rate in [0.08, 1.0]:
+            result = GeophiresXClient().get_geophires_result(
+                ImmutableGeophiresInputParameters(
+                    from_file_path=self._get_test_file_path(
+                        'geophires_x_tests/generic-egs-case-2_sam-single-owner-ppa.txt'
+                    ),
+                    params={
+                        'Royalty Rate': base_royalty_rate,
+                        'Royalty Rate Escalation': escalation_rate,
+                        'Royalty Rate Maximum': max_rate,
+                    },
+                )
+            )
+            opex_result = result.result['OPERATING AND MAINTENANCE COSTS (M$/yr)']
+
+            self.assertIsNotNone(opex_result[royalties_output_name])
+            self.assertEqual('MUSD/yr', opex_result[royalties_output_name]['unit'])
+
+            total_opex_MUSD = opex_result['Total operating and maintenance costs']['value']
+
+            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.assertAlmostEqual(opex_line_item_sum, total_opex_MUSD, places=4)
+
+            project_lifetime_yrs = result.result['ECONOMIC PARAMETERS']['Project lifetime']['value']
+
+            royalties_cash_flow_MUSD = [
+                it * 1e-6
+                for it in _cash_flow_profile_row(
+                    result.result['SAM CASH FLOW PROFILE'], 'O&M production-based expense ($)'
+                )
+            ][1:]
+
+            ppa_revenue_MUSD = [
+                it * 1e-6 for it in _cash_flow_profile_row(result.result['SAM CASH FLOW PROFILE'], 'PPA revenue ($)')
+            ][1:]
+
+            actual_royalty_rate = [None] * len(ppa_revenue_MUSD)
+            for i in range(len(ppa_revenue_MUSD)):
+                actual_royalty_rate[i] = royalties_cash_flow_MUSD[i] / ppa_revenue_MUSD[i]
+
+            max_expected_rate = (
+                max_rate if max_rate < 1.0 else base_royalty_rate + escalation_rate * (project_lifetime_yrs - 1)
+            )
+
+            expected_last_year_revenue = ppa_revenue_MUSD[-1] * max_expected_rate
+            self.assertAlmostEqual(expected_last_year_revenue, royalties_cash_flow_MUSD[-1], places=3)