NREL-reV 0.13.1__py3-none-any.whl → 0.14.1__py3-none-any.whl

reV/supply_curve/points.py

@@ -11,7 +11,7 @@ import numpy as np
 import pandas as pd
 from rex.multi_time_resource import MultiTimeResource
 from rex.resource import BaseResource, Resource
-from rex.utilities.utilities import jsonify_dict
+from rex.utilities.utilities import jsonify_dict, check_res_file
 
 from reV.econ.economies_of_scale import EconomiesOfScale
 from reV.econ.utilities import lcoe_fcr
@@ -1169,9 +1169,11 @@ class AggregationSupplyCurvePoint(SupplyCurvePoint):
             Resource h5 handler object.
         """
         if self._h5 is None and "*" in self._h5_fpath:
-            self._h5 = MultiTimeResource(self._h5_fpath)
+            __, hsds = check_res_file(self._h5_fpath)
+            self._h5 = MultiTimeResource(self._h5_fpath, hsds=hsds)
         elif self._h5 is None:
-            self._h5 = Resource(self._h5_fpath)
+            __, hsds = check_res_file(self._h5_fpath)
+            self._h5 = Resource(self._h5_fpath, hsds=hsds)
 
         return self._h5
 
@@ -1643,7 +1645,8 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             reV generation Resource object
         """
         if self._gen is None:
-            self._gen = Resource(self._gen_fpath, str_decode=False)
+            __, hsds = check_res_file(self._gen_fpath)
+            self._gen = Resource(self._gen_fpath, str_decode=False, hsds=hsds)
 
         return self._gen
 
@@ -2249,6 +2252,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 +2378,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 +2390,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 +2424,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 +2471,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 +2526,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 +2599,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 +2677,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
@@ -543,15 +569,20 @@ class SupplyCurveAggregation(BaseAggregation):
             generation HDF5 output, or if `recalc_lcoe` is set to
             ``False``, the mean LCOE will be computed from the data
             stored under the `lcoe_dset` instead. By default, ``True``.
-        zones_dset: str, optional
-            Dataset name in `excl_fpath` containing the zones to be applied.
-            If specified, supply curve aggregation will be performed separately
-            for each discrete zone within each supply curve site. This option
-            can be used for uses cases such as subdividing sites by parcel,
-            such that each parcel within each site is output to a separate
-            sc_gid. The input data layer should consist of unique integer
-            values for each zone. Values of zero will be treated as excluded
-            areas.
+        zones_dset : str, optional
+            Dataset name in `excl_fpath` containing the zones to be
+            applied. If specified, supply curve aggregation will be
+            performed separately for each discrete zone within each
+            supply curve site. This option can be used for uses cases
+            such as subdividing sites by parcel, such that each parcel
+            within each site is output to a separate ``sc_gid``. The
+            input data layer should consist of unique integer values for
+            each zone. Values of zero will be treated as excluded areas.
+            This functionality works best of you have on the order of
+            ~100,000 zones or less. If you have significantly more zones
+            than that, the supply curve aggregation computation may take
+            too long to run; consider performing an alternative
+            analysis. By default, ``None``.
 
         Examples
         --------
@@ -711,6 +742,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 +991,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 +1076,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 +1207,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 +1328,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 +1469,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,
             )