Use GEOPHIRES PPA pricing model instead of escalation-based approximation

Author: softwareengineerprogrammer

docs/SAM-Economic-Models.md

@@ -1,11 +1,11 @@
 import math
-import os
 import sys
 import numpy as np
 import numpy_financial as npf
 import geophires_x.Model as Model
 from geophires_x import EconomicsSam
 from geophires_x.EconomicsSam import calculate_sam_economics
+from geophires_x.EconomicsUtils import BuildPricingModel
 from geophires_x.OptionList import Configuration, WellDrillingCostCorrelation, EconomicModel, EndUseOptions, PlantType, \
     _WellDrillingCostCorrelationCitation
 from geophires_x.Parameter import intParameter, floatParameter, OutputParameter, ReadParameter, boolParameter, \
@@ -165,37 +165,6 @@ def BuildPTCModel(plantlifetime: int, duration: int, ptc_price: float,
     return Price
 
 
-def BuildPricingModel(plantlifetime: int, StartPrice: float, EndPrice: float,
-                      EscalationStartYear: int, EscalationRate: float, PTCAddition: list) -> list:
-    """
-    BuildPricingModel builds the price model array for the project lifetime.  It is used to calculate the revenue
-    stream for the project.
-    :param plantlifetime: The lifetime of the project in years
-    :type plantlifetime: int
-    :param StartPrice: The price in the first year of the project in $/kWh
-    :type StartPrice: float
-    :param EndPrice: The price in the last year of the project in $/kWh
-    :type EndPrice: float
-    :param EscalationStartYear: The year the price escalation starts in years (not including construction years) in years
-    :type EscalationStartYear: int
-    :param EscalationRate: The rate of price escalation in $/kWh/year
-    :type EscalationRate: float
-    :param PTCAddition: The PTC addition array for the project in $/kWh
-    :type PTCAddition: list
-    :return: Price: The price model array for the project in $/kWh
-    :rtype: list
-    """
-    Price = [0.0] * plantlifetime
-    for i in range(0, plantlifetime, 1):
-        Price[i] = StartPrice
-        if i >= EscalationStartYear:
-            Price[i] = Price[i] + ((i - EscalationStartYear) * EscalationRate)
-        if Price[i] > EndPrice:
-            Price[i] = EndPrice
-        Price[i] = Price[i] + PTCAddition[i]
-    return Price
-
-
 def CalculateTotalRevenue(plantlifetime: int, ConstructionYears: int, CAPEX: float, OPEX: float, AnnualRev):
     """
     CalculateRevenue calculates the revenue stream for the project.  It is used to calculate the revenue
@@ -2761,13 +2730,13 @@ def Calculate(self, model: Model) -> None:
                                                  self.HeatEscalationStart.value, self.HeatEscalationRate.value,
                                                  self.PTCHeatPrice)
         self.CoolingPrice.value = BuildPricingModel(model.surfaceplant.plant_lifetime.value,
-                                                 self.CoolingStartPrice.value, self.CoolingEndPrice.value,
-                                                 self.CoolingEscalationStart.value, self.CoolingEscalationRate.value,
-                                                 self.PTCCoolingPrice)
+                                                    self.CoolingStartPrice.value, self.CoolingEndPrice.value,
+                                                    self.CoolingEscalationStart.value, self.CoolingEscalationRate.value,
+                                                    self.PTCCoolingPrice)
         self.CarbonPrice.value = BuildPricingModel(model.surfaceplant.plant_lifetime.value,
-                                                 self.CarbonStartPrice.value, self.CarbonEndPrice.value,
-                                                 self.CarbonEscalationStart.value, self.CarbonEscalationRate.value,
-                                                 self.PTCCarbonPrice)
+                                                   self.CarbonStartPrice.value, self.CarbonEndPrice.value,
+                                                   self.CarbonEscalationStart.value, self.CarbonEscalationRate.value,
+                                                   self.PTCCarbonPrice)
 
         # do the additional economic calculations first, if needed, so the summaries below work.
         if self.DoAddOnCalculations.value:

src/geophires_x/Economics.py

@@ -26,13 +26,13 @@
 
 from geophires_x import Model as Model
 from geophires_x.EconomicsSamCashFlow import _calculate_sam_economics_cash_flow
+from geophires_x.EconomicsUtils import BuildPricingModel
 from geophires_x.GeoPHIRESUtils import is_float, is_int
 from geophires_x.OptionList import EconomicModel, EndUseOptions
 from geophires_x.Parameter import Parameter
 from geophires_x.Units import convertible_unit
 
 _SAM_CASH_FLOW_PROFILE_KEY = 'Cash Flow'
-_GEOPHIRES_TO_SAM_PRICING_MODEL_RATE_CONVERSION_CONSTANT = 0.745
 
 
 def validate_read_parameters(model: Model):
@@ -129,6 +129,7 @@ def get_sam_cash_flow_profile_tabulated_output(model: Model, **tabulate_kw_args)
         'floatfmt': ',.2f',
         **tabulate_kw_args
     }
+
     # fmt:on
 
     def get_entry_display(entry: Any) -> str:
@@ -222,15 +223,13 @@ def pct(econ_value: Parameter) -> float:
     geophires_ptr_tenths = Decimal(econ.PTR.value)
     ret['property_tax_rate'] = float(geophires_ptr_tenths * Decimal(100))
 
-    ret['ppa_price_input'] = [econ.ElecStartPrice.value]
-    # Approximation of GEOPHIRES rate model into SAM's percent inflation model (TODO - could probably be improved)
-    ppa_escalation_rate_percent = round(
-        econ.ElecEscalationRate.value
-        / econ.ElecStartPrice.value
-        * _GEOPHIRES_TO_SAM_PRICING_MODEL_RATE_CONVERSION_CONSTANT
-        * 100.0
+    ret['ppa_price_input'] = _ppa_pricing_model(
+        model.surfaceplant.plant_lifetime.value,
+        econ.ElecStartPrice.value,
+        econ.ElecEndPrice.value,
+        econ.ElecEscalationStart.value,
+        econ.ElecEscalationRate.value,
     )
-    ret['ppa_escalation'] = ppa_escalation_rate_percent
 
     # Debt/equity ratio ('Fraction of Investment in Bonds' parameter)
     ret['debt_percent'] = pct(econ.FIB)
@@ -249,6 +248,17 @@ def pct(econ_value: Parameter) -> float:
     return ret
 
 
+def _ppa_pricing_model(
+    plant_lifetime: int, start_price: float, end_price: float, escalation_start_year: int, escalation_rate: float
+) -> list:
+    # See relevant comment in geophires_x.EconomicsUtils.BuildPricingModel re:
+    # https://github.com/NREL/GEOPHIRES-X/issues/340?title=Price+Escalation+Start+Year+seemingly+off+by+1.
+    # We use the same utility method here for the sake of consistency despite technical incorrectness.
+    return BuildPricingModel(
+        plant_lifetime, start_price, end_price, escalation_start_year, escalation_rate, [0] * plant_lifetime
+    )
+
+
 def _get_max_net_generation_MW(model: Model) -> float:
     return np.max(model.surfaceplant.NetElectricityProduced.value)
 

src/geophires_x/EconomicsSam.py

@@ -0,0 +1,31 @@
+def BuildPricingModel(plantlifetime: int, StartPrice: float, EndPrice: float,
+                      EscalationStartYear: int, EscalationRate: float, PTCAddition: list) -> list:
+    """
+    BuildPricingModel builds the price model array for the project lifetime.  It is used to calculate the revenue
+    stream for the project.
+    :param plantlifetime: The lifetime of the project in years
+    :type plantlifetime: int
+    :param StartPrice: The price in the first year of the project in $/kWh
+    :type StartPrice: float
+    :param EndPrice: The price in the last year of the project in $/kWh
+    :type EndPrice: float
+    :param EscalationStartYear: The year the price escalation starts in years (not including construction years) in years
+    :type EscalationStartYear: int
+    :param EscalationRate: The rate of price escalation in $/kWh/year
+    :type EscalationRate: float
+    :param PTCAddition: The PTC addition array for the project in $/kWh
+    :type PTCAddition: list
+    :return: Price: The price model array for the project in $/kWh
+    :rtype: list
+    """
+    Price = [0.0] * plantlifetime
+    for i in range(0, plantlifetime, 1):
+        Price[i] = StartPrice
+        if i >= EscalationStartYear:
+            # TODO: This is arguably an unwanted/incorrect interpretation of escalation start year, see
+            # https://github.com/NREL/GEOPHIRES-X/issues/340?title=Price+Escalation+Start+Year+seemingly+off+by+1
+            Price[i] = Price[i] + ((i - EscalationStartYear) * EscalationRate)
+        if Price[i] > EndPrice:
+            Price[i] = EndPrice
+        Price[i] = Price[i] + PTCAddition[i]
+    return Price

src/geophires_x/EconomicsUtils.py

@@ -1,8 +1,8 @@
 import sys, math
 import numpy as np
 import geophires_x.Model as Model
-from .Economics import Economics, calculate_cost_of_one_vertical_well, BuildPTCModel, BuildPricingModel, \
-    CalculateRevenue, CalculateFinancialPerformance, CalculateLCOELCOHLCOC
+from .Economics import Economics, calculate_cost_of_one_vertical_well, BuildPTCModel, CalculateRevenue, CalculateFinancialPerformance, CalculateLCOELCOHLCOC
+from .EconomicsUtils import BuildPricingModel
 from .OptionList import Configuration, WellDrillingCostCorrelation, PlantType
 from geophires_x.Parameter import floatParameter
 from geophires_x.Units import *