NREL-reV 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

reV/supply_curve/cli_tech_mapping.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""
+reV Tech Mapping CLI utility functions.
+"""
+import logging
+
+from gaps.cli import as_click_command, CLICommandFromClass
+
+from reV.supply_curve.tech_mapping import TechMapping
+from reV.utilities import ModuleName
+from reV.utilities.exceptions import ConfigError
+from reV.supply_curve.cli_sc_aggregation import _format_res_fpath
+
+logger = logging.getLogger(__name__)
+
+
+def _preprocessor(config):
+    """Preprocess tech mapping config user input.
+
+    Parameters
+    ----------
+    config : dict
+        User configuration file input as (nested) dict.
+
+    Returns
+    -------
+    dict
+        Updated config file.
+    """
+    _validate_excl_fpath(config)
+    config = _format_res_fpath(config)
+    _validate_dset(config)
+
+    return config
+
+
+def _validate_excl_fpath(config):
+    paths = config["excl_fpath"]
+    if isinstance(paths, list):
+        raise ConfigError(
+            "Multiple exclusion file paths passed via excl_fpath. "
+            "Cannot run tech mapping with arbitrary multiple exclusion. "
+            "Specify a single exclusion file path to write to."
+        )
+
+
+def _validate_dset(config):
+    if config.get("dset") is None:
+        raise ConfigError(
+            "dset must be specified to run tech mapping."
+        )
+
+
+tm_command = CLICommandFromClass(TechMapping, method="run",
+                                 name=str(ModuleName.TECH_MAPPING),
+                                 add_collect=False, split_keys=None,
+                                 config_preprocessor=_preprocessor)
+main = as_click_command(tm_command)
+
+
+if __name__ == '__main__':
+    try:
+        main(obj={})
+    except Exception:
+        logger.exception('Error running reV Tech Mapping CLI.')
+        raise

reV/supply_curve/points.py

@@ -2249,6 +2249,13 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
                   else self.capacity_ac)
         return sc_point_cost / ac_cap
 
+    def _compute_voc_per_ac_mwh(self, dset):
+        """Compute variable operating cost per MWh """
+        if dset not in self.gen.datasets:
+            return None
+
+        return self.exclusion_weighted_mean(self.gen[dset]) * 1000  # to $/MWh
+
     @property
     def mean_h5_dsets_data(self):
         """Get the mean supplemental h5 datasets data (optional)
@@ -2368,10 +2375,10 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             SupplyCurveField.SC_POINT_ANNUAL_ENERGY_MWH: (
                 self.sc_point_annual_energy
             ),
-            SupplyCurveField.COST_SITE_OCC_USD_PER_AC_MW: (
+            SupplyCurveField.COST_SITE_CC_USD_PER_AC_MW: (
                 self._compute_cost_per_ac_mw("capital_cost")
             ),
-            SupplyCurveField.COST_BASE_OCC_USD_PER_AC_MW: (
+            SupplyCurveField.COST_BASE_CC_USD_PER_AC_MW: (
                 self._compute_cost_per_ac_mw("base_capital_cost")
             ),
             SupplyCurveField.COST_SITE_FOC_USD_PER_AC_MW: (
@@ -2380,11 +2387,11 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             SupplyCurveField.COST_BASE_FOC_USD_PER_AC_MW: (
                 self._compute_cost_per_ac_mw("base_fixed_operating_cost")
             ),
-            SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MW: (
-                self._compute_cost_per_ac_mw("variable_operating_cost")
+            SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MWH: (
+                self._compute_voc_per_ac_mwh("variable_operating_cost")
             ),
-            SupplyCurveField.COST_BASE_VOC_USD_PER_AC_MW: (
-                self._compute_cost_per_ac_mw("base_variable_operating_cost")
+            SupplyCurveField.COST_BASE_VOC_USD_PER_AC_MWH: (
+                self._compute_voc_per_ac_mwh("base_variable_operating_cost")
             ),
             SupplyCurveField.FIXED_CHARGE_RATE: self.fixed_charge_rate,
         }
@@ -2414,19 +2421,46 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
         return summary
 
     @staticmethod
-    def economies_of_scale(cap_cost_scale, summary):
+    def economies_of_scale(summary, cap_cost_scale=None, fixed_cost_scale=None,
+                           var_cost_scale=None):
         """Apply economies of scale to this point summary
 
         Parameters
         ----------
-        cap_cost_scale : str
-            LCOE scaling equation to implement "economies of scale".
-            Equation must be in python string format and return a scalar
-            value to multiply the capital cost by. Independent variables in
-            the equation should match the names of the columns in the reV
-            supply curve aggregation table.
         summary : dict
             Dictionary of summary outputs for this sc point.
+        cap_cost_scale : str, optional
+            Optional capital cost scaling equation to implement
+            "economies of scale". Equations must be in python string
+            format and must return a scalar value to multiply the
+            capital cost by. Independent variables in the equation
+            should match the names of the columns in the ``reV`` supply
+            curve aggregation output table (see the documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the capital cost.
+        fixed_cost_scale : str, optional
+            Optional fixed operating cost scaling equation to implement
+            "economies of scale". Equations must be in python string
+            format and must return a scalar value to multiply the
+            fixed operating cost by. Independent variables in the
+            equation should match the names of the columns in the
+            ``reV`` supply curve aggregation output table (see the
+            documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the fixed operating cost.
+        var_cost_scale : str, optional
+            Optional variable operating cost scaling equation to
+            implement "economies of scale". Equations must be in python
+            string format and must return a scalar value to multiply the
+            variable operating cost by. Independent variables in the
+            equation should match the names of the columns in the
+            ``reV`` supply curve aggregation output table (see the
+            documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the variable operating cost.
 
         Returns
         -------
@@ -2434,15 +2468,35 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             Dictionary of summary outputs for this sc point.
         """
 
-        eos = EconomiesOfScale(cap_cost_scale, summary)
+        eos = EconomiesOfScale(data=summary, cap_eqn=cap_cost_scale,
+                               fixed_eqn=fixed_cost_scale,
+                               var_eqn=var_cost_scale)
         summary[SupplyCurveField.RAW_LCOE] = eos.raw_lcoe
         summary[SupplyCurveField.MEAN_LCOE] = eos.scaled_lcoe
         summary[SupplyCurveField.EOS_MULT] = eos.capital_cost_scalar
-        cost = summary[SupplyCurveField.COST_SITE_OCC_USD_PER_AC_MW]
+        summary[SupplyCurveField.FIXED_EOS_MULT] = (
+            eos.fixed_operating_cost_scalar)
+        summary[SupplyCurveField.VAR_EOS_MULT] = (
+            eos.variable_operating_cost_scalar)
+
+        cost = summary[SupplyCurveField.COST_SITE_CC_USD_PER_AC_MW]
         if cost is not None:
-            summary[SupplyCurveField.COST_SITE_OCC_USD_PER_AC_MW] = (
+            summary[SupplyCurveField.COST_SITE_CC_USD_PER_AC_MW] = (
                 cost * summary[SupplyCurveField.EOS_MULT]
             )
+
+        cost = summary[SupplyCurveField.COST_SITE_FOC_USD_PER_AC_MW]
+        if cost is not None:
+            summary[SupplyCurveField.COST_SITE_FOC_USD_PER_AC_MW] = (
+                cost * summary[SupplyCurveField.FIXED_EOS_MULT]
+            )
+
+        cost = summary[SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MWH]
+        if cost is not None:
+            summary[SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MWH] = (
+                cost * summary[SupplyCurveField.VAR_EOS_MULT]
+            )
+
         return summary
 
     @classmethod
@@ -2469,6 +2523,8 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
         args=None,
         data_layers=None,
         cap_cost_scale=None,
+        fixed_cost_scale=None,
+        var_cost_scale=None,
         recalc_lcoe=True,
         zone_mask=None,
     ):
@@ -2540,12 +2596,41 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             Aggregation data layers. Must be a dictionary keyed by data label
             name. Each value must be another dictionary with "dset", "method",
             and "fpath", by default None
-        cap_cost_scale : str | None
-            Optional LCOE scaling equation to implement "economies of scale".
-            Equations must be in python string format and return a scalar
-            value to multiply the capital cost by. Independent variables in
-            the equation should match the names of the columns in the reV
-            supply curve aggregation table.
+        cap_cost_scale : str, optional
+            Optional capital cost scaling equation to implement
+            "economies of scale". Equations must be in python string
+            format and must return a scalar value to multiply the
+            capital cost by. Independent variables in the equation
+            should match the names of the columns in the ``reV`` supply
+            curve aggregation output table (see the documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the capital cost.
+            By default, ``None``.
+        fixed_cost_scale : str, optional
+            Optional fixed operating cost scaling equation to implement
+            "economies of scale". Equations must be in python string
+            format and must return a scalar value to multiply the
+            fixed operating cost by. Independent variables in the
+            equation should match the names of the columns in the
+            ``reV`` supply curve aggregation output table (see the
+            documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the fixed operating cost.
+            By default, ``None``.
+        var_cost_scale : str, optional
+            Optional variable operating cost scaling equation to
+            implement "economies of scale". Equations must be in python
+            string format and must return a scalar value to multiply the
+            variable operating cost by. Independent variables in the
+            equation should match the names of the columns in the
+            ``reV`` supply curve aggregation output table (see the
+            documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the variable operating cost.
+            By default, ``None``.
         recalc_lcoe : bool
             Flag to re-calculate the LCOE from the multi-year mean capacity
             factor and annual energy production data. This requires several
@@ -2589,8 +2674,10 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             if data_layers is not None:
                 summary = point.agg_data_layers(summary, data_layers)
 
-            if cap_cost_scale is not None:
-                summary = point.economies_of_scale(cap_cost_scale, summary)
+            if any((cap_cost_scale, fixed_cost_scale, var_cost_scale)):
+                summary = point.economies_of_scale(summary, cap_cost_scale,
+                                                   fixed_cost_scale,
+                                                   var_cost_scale)
 
         for arg, val in summary.items():
             if val is None:

reV/supply_curve/sc_aggregation.py

@@ -252,7 +252,8 @@ class SupplyCurveAggregation(BaseAggregation):
                  res_class_bins=None, cf_dset='cf_mean-means',
                  lcoe_dset='lcoe_fcr-means', h5_dsets=None, data_layers=None,
                  power_density=None, friction_fpath=None, friction_dset=None,
-                 cap_cost_scale=None, recalc_lcoe=True, zones_dset=None):
+                 cap_cost_scale=None, fixed_cost_scale=None,
+                 var_cost_scale=None, recalc_lcoe=True, zones_dset=None):
         r"""ReV supply curve points aggregation framework.
 
         ``reV`` supply curve aggregation combines a high-resolution
@@ -518,15 +519,40 @@ class SupplyCurveAggregation(BaseAggregation):
             ``None``, no friction data is aggregated.
             By default, ``None``.
         cap_cost_scale : str, optional
-            Optional LCOE scaling equation to implement "economies of
-            scale". Equations must be in python string format and must
-            return a scalar value to multiply the capital cost by.
-            Independent variables in the equation should match the names
-            of the columns in the ``reV`` supply curve aggregation
-            output table (see the documentation of
+            Optional capital cost scaling equation to implement
+            "economies of scale". Equations must be in python string
+            format and must return a scalar value to multiply the
+            capital cost by. Independent variables in the equation
+            should match the names of the columns in the ``reV`` supply
+            curve aggregation output table (see the documentation of
             :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
             for details on available outputs). If ``None``, no economies
-            of scale are applied. By default, ``None``.
+            of scale are applied to the capital cost.
+            By default, ``None``.
+        fixed_cost_scale : str, optional
+            Optional fixed operating cost scaling equation to implement
+            "economies of scale". Equations must be in python string
+            format and must return a scalar value to multiply the
+            fixed operating cost by. Independent variables in the
+            equation should match the names of the columns in the
+            ``reV`` supply curve aggregation output table (see the
+            documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the fixed operating cost.
+            By default, ``None``.
+        var_cost_scale : str, optional
+            Optional variable operating cost scaling equation to
+            implement "economies of scale". Equations must be in python
+            string format and must return a scalar value to multiply the
+            variable operating cost by. Independent variables in the
+            equation should match the names of the columns in the
+            ``reV`` supply curve aggregation output table (see the
+            documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the variable operating cost.
+            By default, ``None``.
         recalc_lcoe : bool, optional
             Flag to re-calculate the LCOE from the multi-year mean
             capacity factor and annual energy production data. This
@@ -711,6 +737,8 @@ class SupplyCurveAggregation(BaseAggregation):
         self._lcoe_dset = lcoe_dset
         self._h5_dsets = h5_dsets
         self._cap_cost_scale = cap_cost_scale
+        self._fixed_cost_scale = fixed_cost_scale
+        self._var_cost_scale = var_cost_scale
         self._power_density = power_density
         self._friction_fpath = friction_fpath
         self._friction_dset = friction_dset
@@ -958,6 +986,8 @@ class SupplyCurveAggregation(BaseAggregation):
         friction_dset=None,
         excl_area=None,
         cap_cost_scale=None,
+        fixed_cost_scale=None,
+        var_cost_scale=None,
         recalc_lcoe=True,
         zones_dset=None,
     ):
@@ -1041,12 +1071,41 @@ class SupplyCurveAggregation(BaseAggregation):
         excl_area : float | None, optional
             Area of an exclusion pixel in km2. None will try to infer the area
             from the profile transform attribute in excl_fpath, by default None
-        cap_cost_scale : str | None
-            Optional LCOE scaling equation to implement "economies of scale".
-            Equations must be in python string format and return a scalar
-            value to multiply the capital cost by. Independent variables in
-            the equation should match the names of the columns in the reV
-            supply curve aggregation table.
+        cap_cost_scale : str, optional
+            Optional capital cost scaling equation to implement
+            "economies of scale". Equations must be in python string
+            format and must return a scalar value to multiply the
+            capital cost by. Independent variables in the equation
+            should match the names of the columns in the ``reV`` supply
+            curve aggregation output table (see the documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the capital cost.
+            By default, ``None``.
+        fixed_cost_scale : str, optional
+            Optional fixed operating cost scaling equation to implement
+            "economies of scale". Equations must be in python string
+            format and must return a scalar value to multiply the
+            fixed operating cost by. Independent variables in the
+            equation should match the names of the columns in the
+            ``reV`` supply curve aggregation output table (see the
+            documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the fixed operating cost.
+            By default, ``None``.
+        var_cost_scale : str, optional
+            Optional variable operating cost scaling equation to
+            implement "economies of scale". Equations must be in python
+            string format and must return a scalar value to multiply the
+            variable operating cost by. Independent variables in the
+            equation should match the names of the columns in the
+            ``reV`` supply curve aggregation output table (see the
+            documentation of
+            :class:`~reV.supply_curve.sc_aggregation.SupplyCurveAggregation`
+            for details on available outputs). If ``None``, no economies
+            of scale are applied to the variable operating cost.
+            By default, ``None``.
         recalc_lcoe : bool
             Flag to re-calculate the LCOE from the multi-year mean capacity
             factor and annual energy production data. This requires several
@@ -1143,6 +1202,8 @@ class SupplyCurveAggregation(BaseAggregation):
                                 close=False,
                                 friction_layer=fh.friction_layer,
                                 cap_cost_scale=cap_cost_scale,
+                                fixed_cost_scale=fixed_cost_scale,
+                                var_cost_scale=var_cost_scale,
                                 recalc_lcoe=recalc_lcoe,
                                 zone_mask=zone_mask,
                             )
@@ -1262,6 +1323,8 @@ class SupplyCurveAggregation(BaseAggregation):
                         args=args,
                         excl_area=self._excl_area,
                         cap_cost_scale=self._cap_cost_scale,
+                        fixed_cost_scale=self._fixed_cost_scale,
+                        var_cost_scale=self._var_cost_scale,
                         recalc_lcoe=self._recalc_lcoe,
                         zones_dset=self._zones_dset,
                     )
@@ -1401,6 +1464,8 @@ class SupplyCurveAggregation(BaseAggregation):
                 args=args,
                 excl_area=self._excl_area,
                 cap_cost_scale=self._cap_cost_scale,
+                fixed_cost_scale=self._fixed_cost_scale,
+                var_cost_scale=self._var_cost_scale,
                 recalc_lcoe=self._recalc_lcoe,
                 zones_dset=self._zones_dset,
             )