NREL-reV 0.14.2__py3-none-any.whl → 0.14.5__py3-none-any.whl

reV/supply_curve/exclusions.py

@@ -3,6 +3,7 @@
 Generate reV inclusion mask from exclusion layers
 """
 import logging
+import fnmatch
 from warnings import warn
 
 import numpy as np
@@ -132,10 +133,10 @@ class LayerMask:
             layer is equal to 1, 2, 3, 4, or 5**. Outside of these
             regions (i.e. outside of federal park regions), the viewshed
             exclusion is **NOT** applied. If the extent mask created by
-            these options is not boolean, an error is thrown (i.e. do
-            not specify `weight` or `use_as_weights`).
-            By default ``None``, which applies the original layer mask
-            to the full extent.
+            these options is not boolean, an error is thrown (in other
+            words, do not specify `weight` or `use_as_weights` or else
+            you will run into errors). By default ``None``, which
+            applies the original layer mask to the full extent.
         **kwargs
             Optional inputs to maintain legacy kwargs of ``inclusion_*``
             instead of ``include_*``.
@@ -600,19 +601,7 @@ class ExclusionMask:
         self._check_layers = check_layers
 
         if layers is not None:
-            if not isinstance(layers, list):
-                layers = [layers]
-
-            missing = [layer.name for layer in layers
-                       if layer.name not in self.excl_layers]
-            if any(missing):
-                msg = ("ExclusionMask layers {} are missing from: {}"
-                       .format(missing, self._excl_h5))
-                logger.error(msg)
-                raise KeyError(msg)
-
-            for layer in layers:
-                self.add_layer(layer)
+            self._add_many_layers(layers)
 
         if kernel in ["queen", "rook"]:
             self._min_area = min_area
@@ -623,6 +612,22 @@ class ExclusionMask:
         else:
             raise KeyError('kernel must be "queen" or "rook"')
 
+    def _add_many_layers(self, layers):
+        """Add multiple layers (with check for missing layers)"""
+        if not isinstance(layers, list):
+            layers = [layers]
+
+        missing = [layer.name for layer in layers
+                   if layer.name not in self.excl_layers]
+        if any(missing):
+            msg = ("ExclusionMask layers {} are missing from: {}"
+                   .format(missing, self._excl_h5))
+            logger.error(msg)
+            raise KeyError(msg)
+
+        for layer in layers:
+            self.add_layer(layer)
+
     def __enter__(self):
         return self
 
@@ -1113,7 +1118,7 @@ class ExclusionMaskFromDict(ExclusionMask):
         excl_h5 : str | list | tuple
             Path to one or more exclusions .h5 files
         layers_dict : dict | NoneType
-            Dictionary of LayerMask arugments {layer: {kwarg: value}}
+            Dictionary of LayerMask arguments {layer: {kwarg: value}}
         min_area : float | NoneType
             Minimum required contiguous area in sq-km
         kernel : str
@@ -1125,16 +1130,34 @@ class ExclusionMaskFromDict(ExclusionMask):
             Run a pre-flight check on each layer to ensure they contain
             un-excluded values
         """
-        if layers_dict is not None:
-            layers = []
-            for layer, kwargs in layers_dict.items():
-                layers.append(LayerMask(layer, **kwargs))
-        else:
-            layers = None
-
-        super().__init__(excl_h5, layers=layers, min_area=min_area,
+        super().__init__(excl_h5, layers=layers_dict, min_area=min_area,
                          kernel=kernel, hsds=hsds, check_layers=check_layers)
 
+    def _add_many_layers(self, layers):
+        """Add multiple layers (with check for missing layers)"""
+        missing = set()
+        final_layers = {}
+
+        # sort pattern-first so that users can overwrite specific layers
+        sorted_layers = sorted(layers, key=_unix_patterns_first)
+        for layer_pattern in sorted_layers:
+            kwargs = layers[layer_pattern]
+            layer_names = fnmatch.filter(self.excl_layers, layer_pattern)
+            if not layer_names:
+                missing.add(layer_pattern)
+
+            for layer in layer_names:
+                final_layers[layer] = LayerMask(layer, **kwargs)
+
+        if any(missing):
+            msg = ("ExclusionMask layers {} are missing from: {}"
+                   .format(missing, self._excl_h5))
+            logger.error(msg)
+            raise KeyError(msg)
+
+        for layer in final_layers.values():
+            self.add_layer(layer)
+
     @classmethod
     def extract_inclusion_mask(cls, excl_fpath, tm_dset, excl_dict=None,
                                area_filter_kernel='queen', min_area=None):
@@ -1295,3 +1318,9 @@ class FrictionMask(ExclusionMask):
             mask = f.mask
 
         return mask
+
+
+def _unix_patterns_first(layer_name):
+    """Key that will put layer names with unix patterns first"""
+    special_chars = {"?", "*", "!", "[", "]"}
+    return -1 * any(char in layer_name for char in special_chars), layer_name

reV/supply_curve/extent.py

@@ -10,7 +10,6 @@ import pandas as pd
 from rex.utilities.utilities import get_chunk_ranges
 
 from reV.handlers.exclusions import LATITUDE, LONGITUDE, ExclusionLayers
-from reV.utilities import SupplyCurveField
 from reV.utilities.exceptions import SupplyCurveError, SupplyCurveInputError
 
 logger = logging.getLogger(__name__)
@@ -297,14 +296,19 @@ class SupplyCurveExtent:
             lats = []
             lons = []
 
+            max_center = self.resolution // 2 + 1
+            min_center = max_center - 2 + self.resolution % 2
+
             sc_cols, sc_rows = np.meshgrid(
                 np.arange(self.n_cols), np.arange(self.n_rows)
             )
             for r, c in zip(sc_rows.flatten(), sc_cols.flatten()):
-                r = self.excl_row_slices[r]
-                c = self.excl_col_slices[c]
-                lats.append(self.exclusions[LATITUDE, r, c].mean())
-                lons.append(self.exclusions[LONGITUDE, r, c].mean())
+                r = slice(r * self.resolution + min_center,
+                          r * self.resolution + max_center)
+                c = slice(c * self.resolution + min_center,
+                          c * self.resolution + max_center)
+                lats.append(np.median(self.exclusions[LATITUDE, r, c]))
+                lons.append(np.median(self.exclusions[LONGITUDE, r, c]))
 
             self._latitude = np.array(lats, dtype="float32")
             self._longitude = np.array(lons, dtype="float32")
@@ -324,14 +328,19 @@ class SupplyCurveExtent:
             lats = []
             lons = []
 
+            max_center = self.resolution // 2 + 1
+            min_center = max_center - 2 + self.resolution % 2
+
             sc_cols, sc_rows = np.meshgrid(
                 np.arange(self.n_cols), np.arange(self.n_rows)
             )
             for r, c in zip(sc_rows.flatten(), sc_cols.flatten()):
-                r = self.excl_row_slices[r]
-                c = self.excl_col_slices[c]
-                lats.append(self.exclusions[LATITUDE, r, c].mean())
-                lons.append(self.exclusions[LONGITUDE, r, c].mean())
+                r = slice(r * self.resolution + min_center,
+                          r * self.resolution + max_center)
+                c = slice(c * self.resolution + min_center,
+                          c * self.resolution + max_center)
+                lats.append(np.median(self.exclusions[LATITUDE, r, c]))
+                lons.append(np.median(self.exclusions[LONGITUDE, r, c]))
 
             self._latitude = np.array(lats, dtype="float32")
             self._longitude = np.array(lons, dtype="float32")

reV/supply_curve/points.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# pylint: disable=anomalous-backslash-in-string
 """
 reV supply curve points frameworks.
 """
@@ -1452,8 +1453,12 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
     """Supply curve point summary framework that ties a reV SC point to its
     respective generation and resource data."""
 
-    # technology-dependent power density estimates in MW/km2
     POWER_DENSITY = {"pv": 36, "wind": 3}
+    """Technology-dependent power density estimates (in MW/km\ :sup:`2`).
+
+    The PV power density is a \**DC power density*\*, while the wind power
+    density is an \**AC power density*\*.
+    """
 
     def __init__(
         self,
@@ -1856,6 +1861,15 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
 
         return None
 
+    @property
+    def mean_wake_losses(self):
+        """float: Mean wake losses, if applicable."""
+        if "annual_wake_loss_internal_percent-means" not in self.gen.datasets:
+            return None
+
+        wakes = self.gen["annual_wake_loss_internal_percent-means"]
+        return self.exclusion_weighted_mean(wakes)
+
     @property
     def mean_lcoe(self):
         """Get the mean LCOE for the non-excluded data.
@@ -2107,7 +2121,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             `None` for solar runs with "dc_ac_ratio" dataset in the
             generation file
         """
-        if self.power_density_ac is None:
+        if "dc_ac_ratio" not in self.gen.datasets:
             return None
 
         return self.area * self.power_density_ac
@@ -2129,7 +2143,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             `None` for solar runs with "dc_ac_ratio" dataset in the
             generation file
         """
-        if self.power_density_ac is None:
+        if "dc_ac_ratio" not in self.gen.datasets:
             return None
 
         return self.area * self.power_density
@@ -2368,6 +2382,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             SupplyCurveField.MEAN_CF_DC: self.mean_cf_dc,
             SupplyCurveField.MEAN_LCOE: self.mean_lcoe,
             SupplyCurveField.MEAN_RES: self.mean_res,
+            SupplyCurveField.WAKE_LOSSES: self.mean_wake_losses,
             SupplyCurveField.AREA_SQ_KM: self.area,
             SupplyCurveField.CAPACITY_AC_MW: (
                 self.capacity if self.capacity_ac is None else self.capacity_ac

reV/supply_curve/sc_aggregation.py

@@ -245,6 +245,7 @@ class SupplyCurveAggFileHandler(AbstractAggFileHandler):
 class SupplyCurveAggregation(BaseAggregation):
     """SupplyCurveAggregation"""
 
+    # pylint: disable=line-too-long
     def __init__(self, excl_fpath, tm_dset, econ_fpath=None,
                  excl_dict=None, area_filter_kernel='queen', min_area=None,
                  resolution=64, excl_area=None, res_fpath=None, gids=None,
@@ -334,6 +335,12 @@ class SupplyCurveAggregation(BaseAggregation):
                         "exclude_nodata": True,
                         "nodata_value": -1
                     },
+                    "wildcard*exclusion": {
+                        "exclude_values": 1,
+                    },
+                    "wildcard_unique_exclusion": {
+                        "exclude_values": [1, 2, 3],
+                    },
                     "partial_setback": {
                         "use_as_weights": True
                     },
@@ -359,9 +366,24 @@ class SupplyCurveAggregation(BaseAggregation):
                     ...
                 }
 
-            Note that all the keys given in this dictionary should be
-            datasets of the `excl_fpath` file. If ``None`` or empty
-            dictionary, no exclusions are applied. By default, ``None``.
+            Note that all the keys given in this dictionary must be
+            datasets of the `excl_fpath` file or you will get an error.
+            You *may* include Unix-style wildcards (i.e. ``*``, ``?``,
+            or ``[]``) in the keys, but note that the same exclusion
+            configuration will be applied to **all** datasets that match
+            the wildcard pattern unless you explicitly override it for a
+            specific layer. For example, in the configuration above,
+            **all** of the layers matching the pattern
+            ``wildcard*exclusion`` will be used as exclusions where the
+            respective layer values equal ``1``, **except** for the
+            ``wildcard_unique_exclusion`` layer, which will be used as
+            an exclusion wherever that particular layer values equal
+            ``1``, ``2``, or ``3``. You can use this strategy to
+            "exclude" layers from the wildcard match - simply set the
+            ``exclude_values`` key to a value that does not exist in
+            that layer and it will be effectively ignored. If ``None``
+            or empty dictionary, no exclusions are applied.
+            By default, ``None``.
         area_filter_kernel : {"queen", "rook"}, optional
             Contiguous area filter method to use on final exclusions
             mask. The filters are defined as::
@@ -484,16 +506,36 @@ class SupplyCurveAggregation(BaseAggregation):
             The ``"output_layer_name"`` is the column name under which
             the aggregated data will appear in the output CSV file. The
             ``"output_layer_name"`` does not have to match the ``dset``
-            input value. The latter should match the layer name in the
+            input value. The ``dset`` should match the layer name in the
             HDF5 from which the data to aggregate should be pulled. The
-            ``method`` should be one of
-            ``{"mode", "mean", "min", "max", "sum", "category"}``,
-            describing how the high-resolution data should be aggregated
-            for each supply curve point. ``fpath`` is an optional key
-            that can point to an HDF5 file containing the layer data. If
-            left out, the data is assumed to exist in the file(s)
-            specified by the `excl_fpath` input. If ``None``, no data
-            layer aggregation is performed. By default, ``None``
+            ``method`` key should be one of the following:
+
+                - ``"mode"``: Output values will be the numerical mode
+                  of the non-excluded high resolution data layer cell
+                  values
+                - ``"mean"``: Output values will be the arithmetic mean
+                  of the non-excluded high resolution data layer cell
+                  values
+                - ``"min"``: Output values will be the numerical minimum
+                  value of the non-excluded high resolution data layer
+                  cell values
+                - ``"max"``: Output values will be the numerical maximum
+                  value of the non-excluded high resolution data layer
+                  cell values
+                - ``"sum"``: Output values will be the sum of the
+                  non-excluded high resolution data layer cell values
+                - ``"category"``: Output values will be a string
+                  representation of a dictionary where the keys are the
+                  unique values of the non-excluded high resolution data
+                  layer cells and the values are the *total
+                  high-resolution pixel area* corresponding to that data
+                  layer value
+
+            ``fpath`` is an optional key that can point to an HDF5 file
+            containing the layer data. If left out, the data is assumed
+            to exist in the file(s) specified by the `excl_fpath` input.
+            If ``None``, no data layer aggregation is performed.
+            By default, ``None``
         power_density : float | str, optional
             Power density value (in MW/km\ :sup:`2`) or filepath to
             variable power density CSV file containing the following
@@ -503,8 +545,15 @@ class SupplyCurveAggregation(BaseAggregation):
                 - ``power_density`` : power density value (in
                   MW/km\ :sup:`2`)
 
-            If ``None``, a constant power density is inferred from the
-            generation meta data technology. By default, ``None``.
+            If you are running reV for PV (more specifically, you have a
+            `dc_ac_ratio` in your generation file), then this input
+            should represent the \**DC power density*\*. For all other
+            technologies (wind, geothermal, etc), this input should
+            represent the \**AC power density*\*. If ``None``, a
+            constant power density value is pulled from
+            :obj:`~reV.supply_curve.points.GenerationSupplyCurvePoint.POWER_DENSITY`
+            by looking up the technology from the generation meta data.
+            By default, ``None``.
         friction_fpath : str, optional
             Filepath to friction surface data (cost based exclusions).
             Must be paired with the `friction_dset` input below. The
@@ -1218,7 +1267,7 @@ class SupplyCurveAggregation(BaseAggregation):
                                          .format(gid, zone_id))
                         else:
                             pointsum['res_class'] = ri
-                            pointsum['zone_id'] = zone_id
+                            pointsum[SupplyCurveField.ZONE_ID] = zone_id
 
                             summary.append(pointsum)
                             logger.debug(

reV/supply_curve/tech_mapping.py

@@ -32,6 +32,7 @@ class TechMapping:
 
     def __init__(self, excl_fpath, sc_resolution=1200):
         """
+
         Parameters
         ----------
         excl_fpath : str
@@ -44,9 +45,9 @@ class TechMapping:
             map the exclusion pixels in 1200x1200 pixel chunks.
 
             .. Note:: This parameter does not affect the exclusion to resource
-            (tech) mapping, which deviates from how the effect of the
-            ``sc_resolution`` parameter works in other functionality within
-            ``reV``.
+                      (tech) mapping, which deviates from how the effect of the
+                      ``sc_resolution`` parameter works in other functionality
+                      within ``reV``.
 
         """
         self._excl_fpath = excl_fpath
@@ -433,7 +434,7 @@ class TechMapping:
             techmap (exclusions-to-resource mapping data) will be saved.
 
             .. Important:: If this dataset already exists in the h5 file,
-              it will be overwritten.
+                           it will be overwritten.
 
         sc_resolution : int | None, optional
             Defines how many exclusion pixels are mapped at a time. Units
@@ -442,9 +443,9 @@ class TechMapping:
             map the exclusion pixels in 1200x1200 pixel chunks.
 
             .. Note:: This parameter does not affect the exclusion to resource
-            (tech) mapping, which deviates from how the effect of the
-            ``sc_resolution`` parameter works in other functionality within
-            ``reV``.
+                      (tech) mapping, which deviates from how the effect of the
+                      ``sc_resolution`` parameter works in other functionality
+                      within ``reV``.
 
         dist_margin : float, optional
             Extra margin to multiply times the computed distance between