NREL-reV 0.8.7__py3-none-any.whl → 0.8.9__py3-none-any.whl

reV/supply_curve/tech_mapping.py

@@ -8,21 +8,21 @@ Created on Fri Jun 21 16:05:47 2019
 
 @author: gbuster
 """
-from concurrent.futures import as_completed
-import h5py
 import logging
-from math import ceil
-import numpy as np
 import os
-from scipy.spatial import cKDTree
+from concurrent.futures import as_completed
+from math import ceil
 from warnings import warn
 
-from reV.supply_curve.extent import SupplyCurveExtent
-from reV.utilities.exceptions import FileInputWarning, FileInputError
-
+import h5py
+import numpy as np
 from rex.resource import Resource
 from rex.utilities.execution import SpawnProcessPool
 from rex.utilities.utilities import res_dist_threshold
+from scipy.spatial import cKDTree
+
+from reV.supply_curve.extent import SupplyCurveExtent, LATITUDE, LONGITUDE
+from reV.utilities.exceptions import FileInputError, FileInputWarning
 
 logger = logging.getLogger(__name__)
 
@@ -30,8 +30,9 @@ logger = logging.getLogger(__name__)
 class TechMapping:
     """Framework to create map between tech layer (exclusions), res, and gen"""
 
-    def __init__(self, excl_fpath, res_fpath, sc_resolution=2560,
-                 dist_margin=1.05):
+    def __init__(
+        self, excl_fpath, res_fpath, sc_resolution=2560, dist_margin=1.05
+    ):
         """
         Parameters
         ----------
@@ -51,11 +52,13 @@ class TechMapping:
         self._excl_fpath = excl_fpath
         self._check_fout()
 
-        self._tree, self._dist_thresh = \
-            self._build_tree(res_fpath, dist_margin=dist_margin)
+        self._tree, self._dist_thresh = self._build_tree(
+            res_fpath, dist_margin=dist_margin
+        )
 
-        with SupplyCurveExtent(self._excl_fpath,
-                               resolution=sc_resolution) as sc:
+        with SupplyCurveExtent(
+            self._excl_fpath, resolution=sc_resolution
+        ) as sc:
             self._sc_resolution = sc.resolution
             self._gids = np.array(list(range(len(sc))), dtype=np.uint32)
             self._excl_shape = sc.exclusions.shape
@@ -64,9 +67,12 @@ class TechMapping:
             self._sc_col_indices = sc.col_indices
             self._excl_row_slices = sc.excl_row_slices
             self._excl_col_slices = sc.excl_col_slices
-            logger.info('Initialized TechMapping object with {} calc chunks '
-                        'for {} tech exclusion points'
-                        .format(len(self._gids), self._n_excl))
+            logger.info(
+                "Initialized TechMapping object with {} calc chunks "
+                "for {} tech exclusion points".format(
+                    len(self._gids), self._n_excl
+                )
+            )
 
     @property
     def distance_threshold(self):
@@ -110,8 +116,9 @@ class TechMapping:
         # pylint: disable=not-callable
         tree = cKDTree(lat_lons)
 
-        dist_thresh = res_dist_threshold(lat_lons, tree=tree,
-                                         margin=dist_margin)
+        dist_thresh = res_dist_threshold(
+            lat_lons, tree=tree, margin=dist_margin
+        )
 
         return tree, dist_thresh
 
@@ -135,8 +142,9 @@ class TechMapping:
         return iarr.reshape(shape)
 
     @staticmethod
-    def _get_excl_slices(gid, sc_row_indices, sc_col_indices, excl_row_slices,
-                         excl_col_slices):
+    def _get_excl_slices(
+        gid, sc_row_indices, sc_col_indices, excl_row_slices, excl_col_slices
+    ):
         """
         Get the row and column slices of the exclusions grid corresponding
         to the supply curve point gid.
@@ -175,7 +183,7 @@ class TechMapping:
     @classmethod
     def _get_excl_coords(cls, excl_fpath, gids, sc_row_indices, sc_col_indices,
                          excl_row_slices, excl_col_slices,
-                         coord_labels=('latitude', 'longitude')):
+                         coord_labels=(LATITUDE, LONGITUDE)):
         """
         Extract the exclusion coordinates for teh desired gids for TechMapping.
 
@@ -210,21 +218,25 @@ class TechMapping:
             tech exclusion points. List entries correspond to input gids.
         """
         coords_out = []
-        with h5py.File(excl_fpath, 'r') as f:
+        with h5py.File(excl_fpath, "r") as f:
             for gid in gids:
-                row_slice, col_slice = cls._get_excl_slices(gid,
-                                                            sc_row_indices,
-                                                            sc_col_indices,
-                                                            excl_row_slices,
-                                                            excl_col_slices)
+                row_slice, col_slice = cls._get_excl_slices(
+                    gid,
+                    sc_row_indices,
+                    sc_col_indices,
+                    excl_row_slices,
+                    excl_col_slices,
+                )
                 try:
                     lats = f[coord_labels[0]][row_slice, col_slice]
                     lons = f[coord_labels[1]][row_slice, col_slice]
                     emeta = np.vstack((lats.flatten(), lons.flatten())).T
                 except Exception as e:
-                    m = ('Could not unpack coordinates for gid {} with '
-                         'row/col slice {}/{}. Received the following '
-                         'error:\n{}'.format(gid, row_slice, col_slice, e))
+                    m = (
+                        "Could not unpack coordinates for gid {} with "
+                        "row/col slice {}/{}. Received the following "
+                        "error:\n{}".format(gid, row_slice, col_slice, e)
+                    )
                     logger.error(m)
                     raise e
 
@@ -233,9 +245,17 @@ class TechMapping:
         return coords_out
 
     @classmethod
-    def map_resource_gids(cls, gids, excl_fpath, sc_row_indices,
-                          sc_col_indices, excl_row_slices, excl_col_slices,
-                          tree, dist_thresh):
+    def map_resource_gids(
+        cls,
+        gids,
+        excl_fpath,
+        sc_row_indices,
+        sc_col_indices,
+        excl_row_slices,
+        excl_col_slices,
+        tree,
+        dist_thresh,
+    ):
         """Map exclusion gids to the resource meta.
 
         Parameters
@@ -272,15 +292,26 @@ class TechMapping:
             List of arrays of index values from the NN. List entries correspond
             to input gids.
         """
-        logger.debug('Getting tech map coordinates for chunks {} through {}'
-                     .format(gids[0], gids[-1]))
+        logger.debug(
+            "Getting tech map coordinates for chunks {} through {}".format(
+                gids[0], gids[-1]
+            )
+        )
         ind_out = []
-        coords_out = cls._get_excl_coords(excl_fpath, gids, sc_row_indices,
-                                          sc_col_indices, excl_row_slices,
-                                          excl_col_slices)
-
-        logger.debug('Running tech mapping for chunks {} through {}'
-                     .format(gids[0], gids[-1]))
+        coords_out = cls._get_excl_coords(
+            excl_fpath,
+            gids,
+            sc_row_indices,
+            sc_col_indices,
+            excl_row_slices,
+            excl_col_slices,
+        )
+
+        logger.debug(
+            "Running tech mapping for chunks {} through {}".format(
+                gids[0], gids[-1]
+            )
+        )
         for i, _ in enumerate(gids):
             dist, ind = tree.query(coords_out[i])
             ind[(dist >= dist_thresh)] = -1
@@ -289,8 +320,14 @@ class TechMapping:
         return ind_out
 
     @staticmethod
-    def save_tech_map(excl_fpath, dset, indices, distance_threshold=None,
-                      res_fpath=None, chunks=(128, 128)):
+    def save_tech_map(
+        excl_fpath,
+        dset,
+        indices,
+        distance_threshold=None,
+        res_fpath=None,
+        chunks=(128, 128),
+    ):
         """Save tech mapping indices and coordinates to an h5 output file.
 
         Parameters
@@ -315,31 +352,40 @@ class TechMapping:
         shape = indices.shape
         chunks = (np.min((shape[0], chunks[0])), np.min((shape[1], chunks[1])))
 
-        with h5py.File(excl_fpath, 'a') as f:
+        with h5py.File(excl_fpath, "a") as f:
             if dset in list(f):
-                wmsg = ('TechMap results dataset "{}" is being replaced '
-                        'in pre-existing Exclusions TechMapping file "{}"'
-                        .format(dset, excl_fpath))
+                wmsg = (
+                    'TechMap results dataset "{}" is being replaced '
+                    'in pre-existing Exclusions TechMapping file "{}"'.format(
+                        dset, excl_fpath
+                    )
+                )
                 logger.warning(wmsg)
                 warn(wmsg, FileInputWarning)
                 f[dset][...] = indices
             else:
-                f.create_dataset(dset, shape=shape, dtype=indices.dtype,
-                                 data=indices, chunks=chunks)
+                f.create_dataset(
+                    dset,
+                    shape=shape,
+                    dtype=indices.dtype,
+                    data=indices,
+                    chunks=chunks,
+                )
 
             if distance_threshold:
-                f[dset].attrs['distance_threshold'] = distance_threshold
+                f[dset].attrs["distance_threshold"] = distance_threshold
 
             if res_fpath:
-                f[dset].attrs['src_res_fpath'] = res_fpath
+                f[dset].attrs["src_res_fpath"] = res_fpath
 
-        logger.info('Successfully saved tech map "{}" to {}'
-                    .format(dset, excl_fpath))
+        logger.info(
+            'Successfully saved tech map "{}" to {}'.format(dset, excl_fpath)
+        )
 
     def _check_fout(self):
         """Check the TechMapping output file for cached data."""
         with h5py.File(self._excl_fpath, 'r') as f:
-            if 'latitude' not in f or 'longitude' not in f:
+            if LATITUDE not in f or LONGITUDE not in f:
                 emsg = ('Datasets "latitude" and/or "longitude" not in '
                         'pre-existing Exclusions TechMapping file "{}". '
                         'Cannot proceed.'
@@ -370,33 +416,36 @@ class TechMapping:
         gid_chunks = np.array_split(self._gids, gid_chunks)
 
         # init full output arrays
-        indices = -1 * np.ones((self._n_excl, ), dtype=np.int32)
+        indices = -1 * np.ones((self._n_excl,), dtype=np.int32)
         iarr = self._make_excl_iarr(self._excl_shape)
 
         futures = {}
-        loggers = [__name__, 'reV']
-        with SpawnProcessPool(max_workers=max_workers,
-                              loggers=loggers) as exe:
-
+        loggers = [__name__, "reV"]
+        with SpawnProcessPool(max_workers=max_workers, loggers=loggers) as exe:
             # iterate through split executions, submitting each to worker
             for i, gid_set in enumerate(gid_chunks):
                 # submit executions and append to futures list
-                futures[exe.submit(self.map_resource_gids,
-                                   gid_set,
-                                   self._excl_fpath,
-                                   self._sc_row_indices,
-                                   self._sc_col_indices,
-                                   self._excl_row_slices,
-                                   self._excl_col_slices,
-                                   self._tree,
-                                   self.distance_threshold)] = i
+                futures[
+                    exe.submit(
+                        self.map_resource_gids,
+                        gid_set,
+                        self._excl_fpath,
+                        self._sc_row_indices,
+                        self._sc_col_indices,
+                        self._excl_row_slices,
+                        self._excl_col_slices,
+                        self._tree,
+                        self.distance_threshold,
+                    )
+                ] = i
 
             n_finished = 0
             for future in as_completed(futures):
                 n_finished += 1
-                logger.info('Parallel TechMapping futures collected: '
-                            '{} out of {}'
-                            .format(n_finished, len(futures)))
+                logger.info(
+                    "Parallel TechMapping futures collected: "
+                    "{} out of {}".format(n_finished, len(futures))
+                )
 
                 i = futures[future]
                 result = future.result()
@@ -407,7 +456,8 @@ class TechMapping:
                         self._sc_row_indices,
                         self._sc_col_indices,
                         self._excl_row_slices,
-                        self._excl_col_slices)
+                        self._excl_col_slices,
+                    )
                     ind_slice = iarr[row_slice, col_slice].flatten()
                     indices[ind_slice] = result[j]
 
@@ -416,8 +466,16 @@ class TechMapping:
         return indices
 
     @classmethod
-    def run(cls, excl_fpath, res_fpath, dset=None, sc_resolution=2560,
-            dist_margin=1.05, max_workers=None, points_per_worker=10):
+    def run(
+        cls,
+        excl_fpath,
+        res_fpath,
+        dset=None,
+        sc_resolution=2560,
+        dist_margin=1.05,
+        max_workers=None,
+        points_per_worker=10,
+    ):
         """Run parallel mapping and save to h5 file.
 
         Parameters
@@ -450,15 +508,19 @@ class TechMapping:
             Index values of the NN resource point. -1 if no res point found.
             2D integer array with shape equal to the exclusions extent shape.
         """
-        kwargs = {"dist_margin": dist_margin,
-                  "sc_resolution": sc_resolution}
+        kwargs = {"dist_margin": dist_margin, "sc_resolution": sc_resolution}
         mapper = cls(excl_fpath, res_fpath, **kwargs)
-        indices = mapper.map_resource(max_workers=max_workers,
-                                      points_per_worker=points_per_worker)
+        indices = mapper.map_resource(
+            max_workers=max_workers, points_per_worker=points_per_worker
+        )
 
         if dset:
-            mapper.save_tech_map(excl_fpath, dset, indices,
-                                 distance_threshold=mapper.distance_threshold,
-                                 res_fpath=res_fpath)
+            mapper.save_tech_map(
+                excl_fpath,
+                dset,
+                indices,
+                distance_threshold=mapper.distance_threshold,
+                res_fpath=res_fpath,
+            )
 
         return indices

reV/utilities/__init__.py

@@ -1,13 +1,196 @@
 # -*- coding: utf-8 -*-
-"""
-reV utilities.
-"""
+"""reV utilities."""
 from enum import Enum
+
 import PySAM
 from rex.utilities.loggers import log_versions as rex_log_versions
+
 from reV.version import __version__
 
 
+class FieldEnum(str, Enum):
+    """Base Field enum with some mapping methods."""
+
+    @classmethod
+    def map_to(cls, other):
+        """Return a rename map from this enum to another.
+
+        Mapping is performed on matching enum names. In other words, if
+        both enums have a `ONE` attribute, this will be mapped from one
+        enum to another.
+
+        Parameters
+        ----------
+        other : :class:`Enum`
+            ``Enum`` subclass with ``__members__`` attribute.
+
+        Returns
+        -------
+        dict
+            Dictionary mapping matching values from one enum to another.
+
+        Examples
+        --------
+        >>> class Test1(FieldEnum):
+        >>>     ONE = "one_x"
+        >>>     TWO = "two"
+        >>>
+        >>> class Test2(Enum):
+        >>>     ONE = "one_y"
+        >>>     THREE = "three"
+        >>>
+        >>> Test1.map_to(Test2)
+        {<Test1.ONE: 'one_x'>: <Test2.ONE: 'one_y'>}
+        """
+        return {
+            cls[mem]: other[mem]
+            for mem in cls.__members__
+            if mem in other.__members__
+        }
+
+    @classmethod
+    def map_from(cls, other):
+        """Map from a dictionary of name / member pairs to this enum.
+
+        Parameters
+        ----------
+        other : dict
+            Dictionary mapping key values (typically old aliases) to
+            enum values. For example, ``{'sc_gid': 'SC_GID'}`` would
+            return a dictionary that maps ``'sc_gid'`` to the ``SC_GID``
+            member of this enum.
+
+        Returns
+        -------
+        dict
+            Mapping of input dictionary keys to member values of this
+            enum.
+
+        Examples
+        --------
+        >>> class Test(FieldEnum):
+        >>>     ONE = "one_x"
+        >>>     TWO = "two_y"
+        >>>
+        >>> Test.map_from({1: "ONE", 2: "TWO"})
+        {1: <Test.ONE: 'one_x'>, 2: <Test.TWO: 'two_y'>}
+        """
+        return {name: cls[mem] for name, mem in other.items()}
+
+    def __str__(self):
+        return self.value
+
+    def __format__(self, format_spec):
+        return str.__format__(self.value, format_spec)
+
+
+class SiteDataField(FieldEnum):
+    """An enumerated map to site data column names."""
+
+    GID = "gid"
+    CONFIG = "config"
+
+
+class ResourceMetaField(FieldEnum):
+    """An enumerated map to resource meta column names.
+
+    Each output name should match the name of a key the resource file
+    meta table.
+    """
+
+    GID = "gid"
+    LATITUDE = "latitude"
+    LONGITUDE = "longitude"
+    ELEVATION = "elevation"
+    TIMEZONE = "timezone"
+    COUNTY = "county"
+    STATE = "state"
+    COUNTRY = "country"
+    OFFSHORE = "offshore"
+
+
+class SupplyCurveField(FieldEnum):
+    """An enumerated map to supply curve summary/meta keys.
+
+    Each output name should match the name of a key in
+    meth:`AggregationSupplyCurvePoint.summary` or
+    meth:`GenerationSupplyCurvePoint.point_summary` or
+    meth:`BespokeSinglePlant.meta`
+    """
+
+    SC_POINT_GID = "sc_point_gid"
+    SOURCE_GIDS = "source_gids"
+    SC_GID = "sc_gid"
+    GID_COUNTS = "gid_counts"
+    GID = "gid"
+    N_GIDS = "n_gids"
+    RES_GIDS = "res_gids"
+    GEN_GIDS = "gen_gids"
+    AREA_SQ_KM = "area_sq_km"
+    LATITUDE = "latitude"
+    LONGITUDE = "longitude"
+    ELEVATION = "elevation"
+    TIMEZONE = "timezone"
+    COUNTY = "county"
+    STATE = "state"
+    COUNTRY = "country"
+    MEAN_CF = "mean_cf"
+    MEAN_LCOE = "mean_lcoe"
+    MEAN_RES = "mean_res"
+    CAPACITY = "capacity"
+    OFFSHORE = "offshore"
+    SC_ROW_IND = "sc_row_ind"
+    SC_COL_IND = "sc_col_ind"
+    CAPACITY_AC = "capacity_ac"
+    CAPITAL_COST = "capital_cost"
+    FIXED_OPERATING_COST = "fixed_operating_cost"
+    VARIABLE_OPERATING_COST = "variable_operating_cost"
+    FIXED_CHARGE_RATE = "fixed_charge_rate"
+    SC_POINT_CAPITAL_COST = "sc_point_capital_cost"
+    SC_POINT_FIXED_OPERATING_COST = "sc_point_fixed_operating_cost"
+    SC_POINT_ANNUAL_ENERGY = "sc_point_annual_energy"
+    SC_POINT_ANNUAL_ENERGY_AC = "sc_point_annual_energy_ac"
+    MEAN_FRICTION = "mean_friction"
+    MEAN_LCOE_FRICTION = "mean_lcoe_friction"
+    TOTAL_LCOE_FRICTION = "total_lcoe_friction"
+    RAW_LCOE = "raw_lcoe"
+    CAPITAL_COST_SCALAR = "capital_cost_scalar"
+    SCALED_CAPITAL_COST = "scaled_capital_cost"
+    SCALED_SC_POINT_CAPITAL_COST = "scaled_sc_point_capital_cost"
+    TURBINE_X_COORDS = "turbine_x_coords"
+    TURBINE_Y_COORDS = "turbine_y_coords"
+    EOS_MULT = "eos_mult"
+    REG_MULT = "reg_mult"
+
+
+    @classmethod
+    def map_from_legacy(cls):
+        """Map of legacy names to current values.
+
+        Returns
+        -------
+        dict
+            Dictionary that maps legacy supply curve column names to
+            members of this enum.
+        """
+        legacy_map = {}
+        for current_field, old_field in cls.map_to(_LegacySCAliases).items():
+            aliases = old_field.value
+            if isinstance(aliases, str):
+                aliases = [aliases]
+            legacy_map.update({alias: current_field for alias in aliases})
+
+        return legacy_map
+
+
+class _LegacySCAliases(Enum):
+    """Legacy supply curve column names.
+
+    Enum values can be either a single string or an iterable of string
+    values where each string value represents a previously known alias.
+    """
+
+
 class ModuleName(str, Enum):
     """A collection of the module names available in reV.
 
@@ -22,17 +205,17 @@ class ModuleName(str, Enum):
     click name conversions: https://tinyurl.com/4rehbsvf
     """
 
-    BESPOKE = 'bespoke'
-    COLLECT = 'collect'
-    ECON = 'econ'
-    GENERATION = 'generation'
-    HYBRIDS = 'hybrids'
-    MULTI_YEAR = 'multi-year'
-    NRWAL = 'nrwal'
-    QA_QC = 'qa-qc'
-    REP_PROFILES = 'rep-profiles'
-    SUPPLY_CURVE = 'supply-curve'
-    SUPPLY_CURVE_AGGREGATION = 'supply-curve-aggregation'
+    BESPOKE = "bespoke"
+    COLLECT = "collect"
+    ECON = "econ"
+    GENERATION = "generation"
+    HYBRIDS = "hybrids"
+    MULTI_YEAR = "multi-year"
+    NRWAL = "nrwal"
+    QA_QC = "qa-qc"
+    REP_PROFILES = "rep-profiles"
+    SUPPLY_CURVE = "supply-curve"
+    SUPPLY_CURVE_AGGREGATION = "supply-curve-aggregation"
 
     def __str__(self):
         return self.value
@@ -63,6 +246,6 @@ def log_versions(logger):
     logger : logging.Logger
         Logger object to log memory message to.
     """
-    logger.info('Running with reV version {}'.format(__version__))
+    logger.info("Running with reV version {}".format(__version__))
     rex_log_versions(logger)
-    logger.debug('- PySAM version {}'.format(PySAM.__version__))
+    logger.debug("- PySAM version {}".format(PySAM.__version__))

reV/utilities/pytest_utils.py

@@ -1,12 +1,15 @@
 # -*- coding: utf-8 -*-
 """Functions used for pytests"""
 
-import numpy as np
 import os
+
+import numpy as np
 import pandas as pd
 from packaging import version
 from rex.outputs import Outputs as RexOutputs
 
+from reV.utilities import ResourceMetaField
+
 
 def pd_date_range(*args, **kwargs):
     """A simple wrapper on the pd.date_range() method that handles the closed
@@ -89,9 +92,10 @@ def make_fake_h5_chunks(td, features, shuffle=False):
     for i, s1 in enumerate(s_slices):
         for j, s2 in enumerate(s_slices):
             out_file = out_pattern.format(i=i, j=j)
-            meta = pd.DataFrame({'latitude': lat[s1, s2].flatten(),
-                                 'longitude': lon[s1, s2].flatten(),
-                                 'gid': gids[s1, s2].flatten()})
+            meta = pd.DataFrame(
+                {ResourceMetaField.LATITUDE: lat[s1, s2].flatten(),
+                 ResourceMetaField.LONGITUDE: lon[s1, s2].flatten(),
+                 ResourceMetaField.GID: gids[s1, s2].flatten()})
             write_chunk(meta=meta, times=times, data=data[s1, s2],
                         features=features, out_file=out_file)
 

reV/version.py

@@ -2,4 +2,4 @@
 reV Version number
 """
 
-__version__ = "0.8.7"
+__version__ = "0.8.9"