NREL-reV 0.9.7__py3-none-any.whl → 0.12.2__py3-none-any.whl

reV/supply_curve/points.py

@@ -221,6 +221,7 @@ class SupplyCurvePoint(AbstractSupplyCurvePoint):
         excl_area=None,
         exclusion_shape=None,
         close=True,
+        zone_mask=None,
     ):
         """
         Parameters
@@ -254,6 +255,11 @@ class SupplyCurvePoint(AbstractSupplyCurvePoint):
             will speed things up considerably.
         close : bool
             Flag to close object file handlers on exit.
+        zone_mask : np.ndarray | None, optional
+            2D array defining zone within the supply curve to be evaluated,
+            where values of 0 or False will be excluded. The shape of this
+            array will be checked against the input resolution. If not
+            specified, no zone mask will be applied.
         """
 
         self._excl_dict = excl_dict
@@ -282,6 +288,18 @@ class SupplyCurvePoint(AbstractSupplyCurvePoint):
             assert inclusion_mask.size == len(self._gids), msg
             self._incl_mask = inclusion_mask.copy()
 
+        self._zone_mask = zone_mask
+        if zone_mask is not None:
+            msg = (
+                "Bad zone mask input shape of {} with stated "
+                "resolution of {}".format(zone_mask.shape, resolution)
+            )
+            assert len(zone_mask.shape) == 2, msg
+            assert zone_mask.shape[0] <= resolution, msg
+            assert zone_mask.shape[1] <= resolution, msg
+            assert zone_mask.size == len(self._gids), msg
+            self._zone_mask = zone_mask.copy()
+
         self._centroid = None
         self._excl_area = excl_area
         self._check_excl()
@@ -454,6 +472,17 @@ class SupplyCurvePoint(AbstractSupplyCurvePoint):
 
         return n_gids
 
+    @property
+    def zone_mask(self):
+        """
+        Get the 2D zone mask, where 1 is included and 0 is excluded.
+
+        Returns
+        -------
+        np.ndarray
+        """
+        return self._zone_mask
+
     @property
     def include_mask(self):
         """Get the 2D inclusion mask (normalized with expected range: [0, 1]
@@ -481,6 +510,10 @@ class SupplyCurvePoint(AbstractSupplyCurvePoint):
                 logger.warning(w)
                 warn(w)
 
+        if self.zone_mask is not None:
+            out_of_zone = self.zone_mask == 0
+            self._incl_mask[out_of_zone] = 0.0
+
         return self._incl_mask
 
     @property
@@ -955,6 +988,7 @@ class AggregationSupplyCurvePoint(SupplyCurvePoint):
         close=True,
         gen_index=None,
         apply_exclusions=True,
+        zone_mask=None,
     ):
         """
         Parameters
@@ -997,6 +1031,11 @@ class AggregationSupplyCurvePoint(SupplyCurvePoint):
         apply_exclusions : bool
             Flag to apply exclusions to the resource / generation gid's on
             initialization.
+        zone_mask : np.ndarray | None, optional
+            2D array defining zone within the supply curve to be evaluated,
+            where values of 0 or False will be excluded. The shape of this
+            array will be checked against the input resolution. If not
+            specified, no zone mask will be applied.
         """
         super().__init__(
             gid,
@@ -1008,6 +1047,7 @@ class AggregationSupplyCurvePoint(SupplyCurvePoint):
             excl_area=excl_area,
             exclusion_shape=exclusion_shape,
             close=close,
+            zone_mask=zone_mask,
         )
 
         self._h5_fpath, self._h5 = self._parse_h5_file(agg_h5)
@@ -1435,6 +1475,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
         friction_layer=None,
         recalc_lcoe=True,
         apply_exclusions=True,
+        zone_mask=None,
     ):
         """
         Parameters
@@ -1510,6 +1551,11 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
         apply_exclusions : bool
             Flag to apply exclusions to the resource / generation gid's on
             initialization.
+        zone_mask : np.ndarray | None, optional
+            2D array defining zone within the supply curve to be evaluated,
+            where values of 0 or False will be excluded. The shape of this
+            array will be checked against the input resolution. If not
+            specified, no zone mask will be applied.
         """
 
         self._res_class_dset = res_class_dset
@@ -1540,6 +1586,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             exclusion_shape=exclusion_shape,
             close=close,
             apply_exclusions=False,
+            zone_mask=zone_mask,
         )
 
         self._res_gid_set = None
@@ -2423,6 +2470,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
         data_layers=None,
         cap_cost_scale=None,
         recalc_lcoe=True,
+        zone_mask=None,
     ):
         """Get a summary dictionary of a single supply curve point.
 
@@ -2504,6 +2552,11 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             datasets to be aggregated in the gen input: system_capacity,
             fixed_charge_rate, capital_cost, fixed_operating_cost,
             and variable_operating_cost.
+        zone_mask : np.ndarray | None, optional
+            2D array defining zone within the supply curve to be evaluated,
+            where values of 0 or False will be excluded. The shape of this
+            array will be checked against the input resolution. If not
+            specified, no zone mask will be applied.
 
         Returns
         -------
@@ -2525,6 +2578,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             "close": close,
             "friction_layer": friction_layer,
             "recalc_lcoe": recalc_lcoe,
+            "zone_mask": zone_mask,
         }
 
         with cls(

reV/supply_curve/sc_aggregation.py

@@ -252,7 +252,7 @@ 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):
+                 cap_cost_scale=None, recalc_lcoe=True, zones_dset=None):
         r"""ReV supply curve points aggregation framework.
 
         ``reV`` supply curve aggregation combines a high-resolution
@@ -297,7 +297,6 @@ class SupplyCurveAggregation(BaseAggregation):
               exclusion HDF5 file is a blocking operation, so you may
               only run a single ``reV`` aggregation step at a time this
               way.
-
         econ_fpath : str, optional
             Filepath to HDF5 file with ``reV`` econ output results
             containing an `lcoe_dset` dataset. If ``None``, `lcoe_dset`
@@ -544,6 +543,15 @@ 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.
 
         Examples
         --------
@@ -708,6 +716,7 @@ class SupplyCurveAggregation(BaseAggregation):
         self._friction_dset = friction_dset
         self._data_layers = data_layers
         self._recalc_lcoe = recalc_lcoe
+        self._zones_dset = zones_dset
 
         logger.debug("Resource class bins: {}".format(self._res_class_bins))
 
@@ -950,6 +959,7 @@ class SupplyCurveAggregation(BaseAggregation):
         excl_area=None,
         cap_cost_scale=None,
         recalc_lcoe=True,
+        zones_dset=None,
     ):
         """Standalone method to create agg summary - can be parallelized.
 
@@ -1043,6 +1053,15 @@ class SupplyCurveAggregation(BaseAggregation):
             datasets to be aggregated in the h5_dsets input: system_capacity,
             fixed_charge_rate, capital_cost, fixed_operating_cost,
             and variable_operating_cost.
+        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.
 
         Returns
         -------
@@ -1093,47 +1112,64 @@ class SupplyCurveAggregation(BaseAggregation):
                     inclusion_mask, gid, slice_lookup, resolution=resolution
                 )
 
-                for ri, res_bin in enumerate(res_class_bins):
-                    try:
-                        pointsum = GenerationSupplyCurvePoint.summarize(
-                            gid,
-                            fh.exclusions,
-                            fh.gen,
-                            tm_dset,
-                            gen_index,
-                            res_class_dset=res_data,
-                            res_class_bin=res_bin,
-                            cf_dset=cf_dset,
-                            lcoe_dset=lcoe_data,
-                            h5_dsets=h5_dsets_data,
-                            data_layers=fh.data_layers,
-                            resolution=resolution,
-                            exclusion_shape=exclusion_shape,
-                            power_density=fh.power_density,
-                            args=args,
-                            excl_dict=excl_dict,
-                            inclusion_mask=gid_inclusions,
-                            excl_area=excl_area,
-                            close=False,
-                            friction_layer=fh.friction_layer,
-                            cap_cost_scale=cap_cost_scale,
-                            recalc_lcoe=recalc_lcoe,
-                        )
+                zones = cls._get_gid_zones(
+                    excl_fpath, zones_dset, gid, slice_lookup
+                )
+                zone_ids = np.unique(zones[zones != 0]).tolist()
 
-                    except EmptySupplyCurvePointError:
-                        logger.debug("SC point {} is empty".format(gid))
-                    else:
-                        pointsum['res_class'] = ri
+                for ri, res_bin in enumerate(res_class_bins):
+                    for zi, zone_id in enumerate(zone_ids, start=1):
+                        zone_mask = zones == zone_id
+                        try:
+                            pointsum = GenerationSupplyCurvePoint.summarize(
+                                gid,
+                                fh.exclusions,
+                                fh.gen,
+                                tm_dset,
+                                gen_index,
+                                res_class_dset=res_data,
+                                res_class_bin=res_bin,
+                                cf_dset=cf_dset,
+                                lcoe_dset=lcoe_data,
+                                h5_dsets=h5_dsets_data,
+                                data_layers=fh.data_layers,
+                                resolution=resolution,
+                                exclusion_shape=exclusion_shape,
+                                power_density=fh.power_density,
+                                args=args,
+                                excl_dict=excl_dict,
+                                inclusion_mask=gid_inclusions,
+                                excl_area=excl_area,
+                                close=False,
+                                friction_layer=fh.friction_layer,
+                                cap_cost_scale=cap_cost_scale,
+                                recalc_lcoe=recalc_lcoe,
+                                zone_mask=zone_mask,
+                            )
 
-                        summary.append(pointsum)
-                        logger.debug(
-                            "Serial aggregation completed gid {}: "
-                            "{} out of {} points complete".format(
-                                gid, n_finished, len(gids)
+                        except EmptySupplyCurvePointError:
+                            logger.debug("SC point {}, zone ID {} is empty"
+                                         .format(gid, zone_id))
+                        else:
+                            pointsum['res_class'] = ri
+                            pointsum['zone_id'] = zone_id
+
+                            summary.append(pointsum)
+                            logger.debug(
+                                "Serial aggregation completed for"
+                                "resource class {}, zone ID {}: "
+                                "{:,d} out of {:,d} zones complete".format(
+                                    ri, zone_id, zi, len(zone_ids)
+                                )
                             )
-                        )
 
                 n_finished += 1
+                logger.debug(
+                    "Serial aggregation completed for gid {}: "
+                    "{:,d} out of {:,d} points complete".format(
+                        gid, n_finished, len(gids)
+                    )
+                )
 
         return summary
 
@@ -1227,6 +1263,7 @@ class SupplyCurveAggregation(BaseAggregation):
                         excl_area=self._excl_area,
                         cap_cost_scale=self._cap_cost_scale,
                         recalc_lcoe=self._recalc_lcoe,
+                        zones_dset=self._zones_dset,
                     )
                 )
 
@@ -1365,6 +1402,7 @@ class SupplyCurveAggregation(BaseAggregation):
                 excl_area=self._excl_area,
                 cap_cost_scale=self._cap_cost_scale,
                 recalc_lcoe=self._recalc_lcoe,
+                zones_dset=self._zones_dset,
             )
         else:
             summary = self.run_parallel(

reV/utilities/__init__.py

@@ -89,6 +89,7 @@ class SiteDataField(FieldEnum):
 
     GID = "gid"
     CONFIG = "config"
+    CURTAILMENT = "curtailment"
 
 
 class ResourceMetaField(FieldEnum):
@@ -135,6 +136,7 @@ class SupplyCurveField(FieldEnum):
     GEN_GIDS = "gen_gids"
     GID_COUNTS = "gid_counts"
     N_GIDS = "n_gids"
+    ZONE_ID = "zone_id"
     MEAN_RES = "resource"
     MEAN_CF_AC = "capacity_factor_ac"
     MEAN_CF_DC = "capacity_factor_dc"

reV/utilities/_clean_readme.py

@@ -0,0 +1,28 @@
+import sys
+
+
+PYPI_DISALLOWED_RST = {"raw::", "<p", "</p", "<img", "---------"}
+REMOVE_TEXT = ["A visual summary of this process is given below:", "&nbsp;"]
+
+
+def _clean(fp):
+    """Prep the README file for PyPi distribution"""
+    readme = []
+    with open(fp, encoding="utf-8") as f:
+        for line in f.readlines():
+            if any(substr in line for substr in PYPI_DISALLOWED_RST):
+                continue
+            readme.append(line)
+
+    readme = "".join(readme)
+    for substr in REMOVE_TEXT:
+        readme = readme.replace(substr, "")
+
+    readme = readme.lstrip()
+
+    with open(fp, "w", encoding="utf-8") as f:
+        f.write(readme)
+
+
+if __name__ == "__main__":
+    _clean(*sys.argv[1:])

reV/utilities/curtailment.py

@@ -19,7 +19,7 @@ from rex.utilities.utilities import check_tz, get_lat_lon_cols
 logger = logging.getLogger(__name__)
 
 
-def curtail(resource, curtailment, random_seed=0):
+def curtail(resource, curtailment, sites, random_seed=0):
     """Curtail the SAM wind resource object based on project points.
 
     Parameters
@@ -28,6 +28,8 @@ def curtail(resource, curtailment, random_seed=0):
         SAM resource object for WIND resource.
     curtailment : reV.config.curtailment.Curtailment
         Curtailment config object.
+    sites : list
+        List of GID's to apply this curtailment to.
     random_seed : int | NoneType
         Number to seed the numpy random number generator. Used to generate
         reproducable psuedo-random results if the probability of curtailment
@@ -41,7 +43,8 @@ def curtail(resource, curtailment, random_seed=0):
         where curtailment is in effect.
     """
 
-    shape = resource.shape
+    shape = (resource.shape[0], len(sites))
+    site_pos = [resource.sites.index(id) for id in sites]
 
     # start with curtailment everywhere
     curtail_mult = np.zeros(shape)
@@ -74,10 +77,10 @@ def curtail(resource, curtailment, random_seed=0):
         raise KeyError(msg)
 
     # Curtail resource when curtailment is possible and is nighttime
-    lat_lon_cols = get_lat_lon_cols(resource.meta)
-    solar_zenith_angle = SolarPosition(
-        resource.time_index,
-        resource.meta[lat_lon_cols].values).zenith
+    meta = resource["meta", sites]
+    lat_lon_cols = get_lat_lon_cols(meta)
+    solar_zenith_angle = SolarPosition(resource.time_index,
+                                       meta[lat_lon_cols].values).zenith
     mask = (solar_zenith_angle > curtailment.dawn_dusk)
     curtail_mult = np.where(mask, curtail_mult, 1)
 
@@ -92,28 +95,29 @@ def curtail(resource, curtailment, random_seed=0):
                          list(resource._res_arrays.keys())),
                  HandlerWarning)
         else:
-            mask = (resource._res_arrays['precipitationrate']
+            mask = (resource._res_arrays['precipitationrate'][:, site_pos]
                     < curtailment.precipitation)
             curtail_mult = np.where(mask, curtail_mult, 1)
 
     # Curtail resource when curtailment is possible and temperature is high
     if curtailment.temperature is not None:
-        mask = (resource._res_arrays['temperature']
+        mask = (resource._res_arrays['temperature'][:, site_pos]
                 > curtailment.temperature)
         curtail_mult = np.where(mask, curtail_mult, 1)
 
     # Curtail resource when curtailment is possible and not that windy
     if curtailment.wind_speed is not None:
-        mask = (resource._res_arrays['windspeed']
+        mask = (resource._res_arrays['windspeed'][:, site_pos]
                 < curtailment.wind_speed)
         curtail_mult = np.where(mask, curtail_mult, 1)
 
     if curtailment.equation is not None:
         # pylint: disable=W0123,W0612
-        wind_speed = resource._res_arrays['windspeed']
-        temperature = resource._res_arrays['temperature']
+        wind_speed = resource._res_arrays['windspeed'][:, site_pos]
+        temperature = resource._res_arrays['temperature'][:, site_pos]
         if 'precipitationrate' in resource._res_arrays:
-            precipitation_rate = resource._res_arrays['precipitationrate']
+            precipitation_rate = (
+                resource._res_arrays['precipitationrate'][:, site_pos])
         mask = eval(curtailment.equation)
         curtail_mult = np.where(mask, curtail_mult, 1)
 
@@ -124,6 +128,6 @@ def curtail(resource, curtailment, random_seed=0):
         curtail_mult = np.where(mask, curtail_mult, 1)
 
     # Apply curtailment multiplier directly to resource
-    resource.curtail_windspeed(resource.sites, curtail_mult)
+    resource.curtail_windspeed(sites, curtail_mult)
 
     return resource

reV/version.py

@@ -2,4 +2,4 @@
 reV Version number
 """
 
-__version__ = "0.9.7"
+__version__ = "0.12.2"

reV/bespoke/plotting_functions.py

@@ -1,178 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-functions to plot turbine layouts and boundary polygons
-"""
-import numpy as np
-import matplotlib.pyplot as plt
-
-
-def get_xy(A):
-    """separate polygon exterior coordinates to x and y
-
-    Parameters
-    ----------
-    A : Polygon.exteroir.coords
-        Exterior coordinates from a shapely Polygon
-
-    Outputs
-    ----------
-    x, y : array
-        Boundary polygon x and y coordinates
-    """
-    x = np.zeros(len(A))
-    y = np.zeros(len(A))
-    for i, _ in enumerate(A):
-        x[i] = A[i][0]
-        y[i] = A[i][1]
-    return x, y
-
-
-def plot_poly(geom, ax=None, color="black", linestyle="--", linewidth=0.5):
-    """plot the wind plant boundaries
-
-    Parameters
-    ----------
-    geom : Polygon | MultiPolygon
-        The shapely.Polygon or shapely.MultiPolygon that define the wind
-        plant boundary(ies).
-    ax : :py:class:`matplotlib.pyplot.axes`, optional
-        The figure axes on which the wind rose is plotted.
-        Defaults to :obj:`None`.
-    color : string, optional
-        The color for the wind plant boundaries
-    linestyle : string, optional
-        Style to plot the boundary lines
-    linewidth : float, optional
-        The width of the boundary lines
-    """
-    if ax is None:
-        _, ax = plt.subplots()
-
-    if geom.type == 'Polygon':
-        exterior_coords = geom.exterior.coords[:]
-        x, y = get_xy(exterior_coords)
-        ax.fill(x, y, color="C0", alpha=0.25)
-        ax.plot(x, y, color=color, linestyle=linestyle, linewidth=linewidth)
-
-        for interior in geom.interiors:
-            interior_coords = interior.coords[:]
-            x, y = get_xy(interior_coords)
-            ax.fill(x, y, color="white", alpha=1.0)
-            ax.plot(x, y, "--k", linewidth=0.5)
-
-    elif geom.type == 'MultiPolygon':
-
-        for part in geom:
-            exterior_coords = part.exterior.coords[:]
-            x, y = get_xy(exterior_coords)
-            ax.fill(x, y, color="C0", alpha=0.25)
-            ax.plot(x, y, color=color, linestyle=linestyle,
-                    linewidth=linewidth)
-
-            for interior in part.interiors:
-                interior_coords = interior.coords[:]
-                x, y = get_xy(interior_coords)
-                ax.fill(x, y, color="white", alpha=1.0)
-                ax.plot(x, y, "--k", linewidth=0.5)
-    return ax
-
-
-def plot_turbines(x, y, r, ax=None, color="C0", nums=False):
-    """plot wind turbine locations
-
-    Parameters
-    ----------
-    x, y : array
-        Wind turbine x and y locations
-    r : float
-        Wind turbine radius
-    ax :py:class:`matplotlib.pyplot.axes`, optional
-        The figure axes on which the wind rose is plotted.
-        Defaults to :obj:`None`.
-    color : string, optional
-        The color for the wind plant boundaries
-    nums : bool, optional
-        Option to show the turbine numbers next to each turbine
-    """
-    # Set up figure
-    if ax is None:
-        _, ax = plt.subplots()
-
-    n = len(x)
-    for i in range(n):
-        t = plt.Circle((x[i], y[i]), r, color=color)
-        ax.add_patch(t)
-        if nums is True:
-            ax.text(x[i], y[i], "%s" % (i + 1))
-
-    return ax
-
-
-def plot_windrose(wind_directions, wind_speeds, wind_frequencies, ax=None,
-                  colors=None):
-    """plot windrose
-
-    Parameters
-    ----------
-    wind_directions : 1D array
-        Wind direction samples
-    wind_speeds : 1D array
-        Wind speed samples
-    wind_frequencies : 2D array
-        Frequency of wind direction and speed samples
-    ax :py:class:`matplotlib.pyplot.axes`, optional
-        The figure axes on which the wind rose is plotted.
-        Defaults to :obj:`None`.
-    color : array, optional
-        The color for the different wind speed bins
-    """
-    if ax is None:
-        _, ax = plt.subplots(subplot_kw=dict(polar=True))
-
-    ndirs = len(wind_directions)
-    nspeeds = len(wind_speeds)
-
-    if colors is None:
-        colors = []
-        for i in range(nspeeds):
-            colors = np.append(colors, "C%s" % i)
-
-    for i in range(ndirs):
-        wind_directions[i] = np.deg2rad(90.0 - wind_directions[i])
-
-    width = 0.8 * 2 * np.pi / len(wind_directions)
-
-    for i in range(ndirs):
-        bottom = 0.0
-        for j in range(nspeeds):
-            if i == 0:
-                if j < nspeeds - 1:
-                    ax.bar(wind_directions[i], wind_frequencies[j, i],
-                           bottom=bottom, width=width, edgecolor="black",
-                           color=[colors[j]],
-                           label="%s-%s m/s" % (int(wind_speeds[j]),
-                                                int(wind_speeds[j + 1]))
-                           )
-                else:
-                    ax.bar(wind_directions[i], wind_frequencies[j, i],
-                           bottom=bottom, width=width, edgecolor="black",
-                           color=[colors[j]],
-                           label="%s+ m/s" % int(wind_speeds[j])
-                           )
-            else:
-                ax.bar(wind_directions[i], wind_frequencies[j, i],
-                       bottom=bottom, width=width, edgecolor="black",
-                       color=[colors[j]])
-            bottom = bottom + wind_frequencies[j, i]
-
-    ax.legend(bbox_to_anchor=(1.3, 1), fontsize=10)
-    pi = np.pi
-    ax.set_xticks((0, pi / 4, pi / 2, 3 * pi / 4, pi, 5 * pi / 4,
-                   3 * pi / 2, 7 * pi / 4))
-    ax.set_xticklabels(("E", "NE", "N", "NW", "W", "SW", "S", "SE"),
-                       fontsize=10)
-    plt.yticks(fontsize=10)
-
-    plt.subplots_adjust(left=0.0, right=1.0, top=0.9, bottom=0.1)
-
-    return ax