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

reV/generation/output_attributes/lcoe_fcr_inputs.json

@@ -4,7 +4,7 @@
     "dtype": "float32",
     "scale_factor": 1,
     "type": "scalar",
-    "units": "dollars"
+    "units": "usd"
   },
   "fixed_charge_rate": {
     "chunks": null,
@@ -18,13 +18,48 @@
     "dtype": "float32",
     "scale_factor": 1,
     "type": "scalar",
-    "units": "dollars"
+    "units": "usd"
   },
   "variable_operating_cost": {
     "chunks": null,
     "dtype": "float32",
     "scale_factor": 1,
     "type": "scalar",
-    "units": "dol/kWh"
+    "units": "usd/kWh"
+  },
+  "base_capital_cost": {
+    "chunks": null,
+    "dtype": "float32",
+    "scale_factor": 1,
+    "type": "scalar",
+    "units": "usd"
+  },
+  "base_fixed_operating_cost": {
+    "chunks": null,
+    "dtype": "float32",
+    "scale_factor": 1,
+    "type": "scalar",
+    "units": "usd"
+  },
+  "base_variable_operating_cost": {
+    "chunks": null,
+    "dtype": "float32",
+    "scale_factor": 1,
+    "type": "scalar",
+    "units": "usd/kWh"
+  },
+  "capital_cost_multiplier": {
+    "chunks": null,
+    "dtype": "float32",
+    "scale_factor": 1,
+    "type": "scalar",
+    "units": "unitless"
+  },
+  "system_capacity": {
+    "chunks": null,
+    "dtype": "float32",
+    "scale_factor": 1,
+    "type": "scalar",
+    "units": "kW"
   }
 }

reV/handlers/__init__.py

@@ -3,5 +3,4 @@
 Sub-package of data handlers
 """
 from .exclusions import ExclusionLayers
-from .multi_year import MultiYear
 from .outputs import Outputs

reV/handlers/exclusions.py

@@ -2,17 +2,18 @@
 """
 Exclusion layers handler
 """
-import logging
 import json
+import logging
+
 import numpy as np
+from rex.multi_file_resource import MultiFileResource
+from rex.resource import Resource
+from rex.utilities.parse_keys import parse_keys
 
 from reV.utilities.exceptions import HandlerKeyError, MultiFileExclusionError
 
-from rex.utilities.parse_keys import parse_keys
-from rex.resource import Resource
-from rex.multi_file_resource import MultiFileResource
-
 logger = logging.getLogger(__name__)
+LATITUDE, LONGITUDE = "latitude", "longitude"
 
 
 class ExclusionLayers:
@@ -81,8 +82,8 @@ class ExclusionLayers:
 
     def _preflight_multi_file(self):
         """Run simple multi-file exclusion checks."""
-        lat_shape = self.h5.shapes['latitude']
-        lon_shape = self.h5.shapes['longitude']
+        lat_shape = self.h5.shapes[LATITUDE]
+        lon_shape = self.h5.shapes[LONGITUDE]
         for layer in self.layers:
             lshape = self.h5.shapes[layer]
             lshape = lshape[1:] if len(lshape) > 2 else lshape
@@ -231,7 +232,7 @@ class ExclusionLayers:
         """
         shape = self.h5.attrs.get('shape', None)
         if shape is None:
-            shape = self.h5.shapes['latitude']
+            shape = self.h5.shapes[LATITUDE]
 
         return tuple(shape)
 
@@ -247,7 +248,7 @@ class ExclusionLayers:
         """
         chunks = self.h5.attrs.get('chunks', None)
         if chunks is None:
-            chunks = self.h5.chunks['latitude']
+            chunks = self.h5.chunks[LATITUDE]
 
         return chunks
 
@@ -260,7 +261,7 @@ class ExclusionLayers:
         -------
         ndarray
         """
-        return self['latitude']
+        return self[LATITUDE]
 
     @property
     def longitude(self):
@@ -271,7 +272,7 @@ class ExclusionLayers:
         -------
         ndarray
         """
-        return self['longitude']
+        return self[LONGITUDE]
 
     def get_layer_profile(self, layer):
         """
@@ -384,13 +385,13 @@ class ExclusionLayers:
         lat : ndarray
             Latitude coordinates
         """
-        if 'latitude' not in self.h5:
+        if LATITUDE not in self.h5:
             msg = ('"latitude" is missing from {}'
                    .format(self.h5_file))
             logger.error(msg)
             raise HandlerKeyError(msg)
 
-        ds_slice = ('latitude', ) + ds_slice
+        ds_slice = (LATITUDE, ) + ds_slice
 
         lat = self.h5[ds_slice]
 
@@ -410,13 +411,13 @@ class ExclusionLayers:
         lon : ndarray
             Longitude coordinates
         """
-        if 'longitude' not in self.h5:
+        if LONGITUDE not in self.h5:
             msg = ('"longitude" is missing from {}'
                    .format(self.h5_file))
             logger.error(msg)
             raise HandlerKeyError(msg)
 
-        ds_slice = ('longitude', ) + ds_slice
+        ds_slice = (LONGITUDE, ) + ds_slice
 
         lon = self.h5[ds_slice]
 

reV/handlers/multi_year.py

@@ -3,22 +3,26 @@
 Classes to collect reV outputs from multiple annual files.
 """
 import glob
-import time
 import logging
-import numpy as np
 import os
-import pandas as pd
+import time
 from warnings import warn
 
-from rex import Resource
-from rex.utilities.utilities import (get_class_properties, parse_year,
-                                     get_lat_lon_cols)
+import numpy as np
+import pandas as pd
 from gaps.pipeline import parse_previous_status
+from rex import Resource
+from rex.utilities.utilities import (
+    get_class_properties,
+    get_lat_lon_cols,
+    parse_year,
+)
 
-from reV.handlers.outputs import Outputs
+from reV.generation.base import LCOE_REQUIRED_OUTPUTS
 from reV.config.output_request import SAMOutputRequest
-from reV.utilities.exceptions import HandlerRuntimeError, ConfigError
-from reV.utilities import log_versions, ModuleName
+from reV.handlers.outputs import Outputs
+from reV.utilities import ModuleName, log_versions
+from reV.utilities.exceptions import ConfigError, HandlerRuntimeError
 
 logger = logging.getLogger(__name__)
 
@@ -57,8 +61,12 @@ class MultiYearGroup:
             source files. This takes priority over `source_dir` and
             `source_prefix` but is not used if `source_files` are
             specified explicitly. By default, ``None``.
-        dsets : list | tuple, optional
-            List of datasets to collect. By default, ``('cf_mean',)``.
+        dsets : str | list | tuple, optional
+            List of datasets to collect. This can be set to
+            ``"PIPELINE"`` if running from the command line as part of a
+            reV pipeline. In this case, all the datasets from the
+            previous pipeline step will be collected.
+            By default, ``('cf_mean',)``.
         pass_through_dsets : list | tuple, optional
             Optional list of datasets that are identical in the
             multi-year files (e.g. input datasets that don't vary from
@@ -73,10 +81,35 @@ class MultiYearGroup:
         self._source_prefix = source_prefix
         self._source_pattern = source_pattern
         self._pass_through_dsets = None
-        if pass_through_dsets is not None:
-            self._pass_through_dsets = SAMOutputRequest(pass_through_dsets)
+        self._dsets = None
+
+        self._parse_pass_through_dsets(dsets, pass_through_dsets or [])
+        self._parse_dsets(dsets)
 
-        self._dsets = self._parse_dsets(dsets)
+    def _parse_pass_through_dsets(self, dsets, pass_through_dsets):
+        """Parse a multi-year pass-through dataset collection request.
+
+        Parameters
+        ----------
+        dsets : str | list
+            One or more datasets to collect, or "PIPELINE"
+        pass_through_dsets : list
+            List of pass through datasets.
+        """
+        if isinstance(dsets, str) and dsets == 'PIPELINE':
+            files = parse_previous_status(self._dirout, ModuleName.MULTI_YEAR)
+            with Resource(files[0]) as res:
+                dsets = res.datasets
+
+        if "lcoe_fcr" in dsets:
+            for dset in LCOE_REQUIRED_OUTPUTS:
+                if dset not in pass_through_dsets:
+                    pass_through_dsets.append(dset)
+        if "dc_ac_ratio" in dsets:
+            if "dc_ac_ratio" not in pass_through_dsets:
+                pass_through_dsets.append("dc_ac_ratio")
+
+        self._pass_through_dsets = SAMOutputRequest(pass_through_dsets)
 
     def _parse_dsets(self, dsets):
         """Parse a multi-year dataset collection request. Can handle PIPELINE
@@ -87,11 +120,6 @@ class MultiYearGroup:
         ----------
         dsets : str | list
             One or more datasets to collect, or "PIPELINE"
-
-        Returns
-        -------
-        dsets : SAMOutputRequest
-            Dataset list object.
         """
         if isinstance(dsets, str) and dsets == 'PIPELINE':
             files = parse_previous_status(self._dirout, ModuleName.MULTI_YEAR)
@@ -101,9 +129,7 @@ class MultiYearGroup:
                          and d != 'meta'
                          and d not in self.pass_through_dsets]
 
-        dsets = SAMOutputRequest(dsets)
-
-        return dsets
+        self._dsets = SAMOutputRequest(dsets)
 
     @property
     def name(self):
@@ -812,10 +838,15 @@ def my_collect_groups(out_fpath, groups, clobber=True):
                 MultiYear.collect_means(out_fpath, group['source_files'],
                                         dset, group=group['group'])
 
-        if group.get('pass_through_dsets', None) is not None:
-            for dset in group['pass_through_dsets']:
-                MultiYear.pass_through(out_fpath, group['source_files'],
-                                       dset, group=group['group'])
+        pass_through_dsets = group.get('pass_through_dsets') or []
+        if "lcoe_fcr" in group['dsets']:
+            for dset in LCOE_REQUIRED_OUTPUTS:
+                if dset not in pass_through_dsets:
+                    pass_through_dsets.append(dset)
+
+        for dset in pass_through_dsets:
+            MultiYear.pass_through(out_fpath, group['source_files'],
+                                   dset, group=group['group'])
 
         runtime = (time.time() - t0) / 60
         logger.info('- {} collection completed in: {:.2f} min.'

reV/handlers/outputs.py

@@ -2,15 +2,16 @@
 """
 Classes to handle reV h5 output files.
 """
+import json
 import logging
+import sys
+
 import NRWAL
 import PySAM
 import rex
-import sys
-import json
+from rex.outputs import Outputs as rexOutputs
 
 from reV.version import __version__
-from rex.outputs import Outputs as rexOutputs
 
 logger = logging.getLogger(__name__)
 
@@ -28,8 +29,8 @@ class Outputs(rexOutputs):
     >>> import pandas as pd
     >>> import numpy as np
     >>>
-    >>> meta = pd.DataFrame({'latitude': np.ones(100),
-    >>>                      'longitude': np.ones(100)})
+    >>> meta = pd.DataFrame({SupplyCurveField.LATITUDE: np.ones(100),
+    >>>                      SupplyCurveField.LONGITUDE: np.ones(100)})
     >>>
     >>> time_index = pd.date_range('20210101', '20220101', freq='1h',
     >>>                            closed='right')

reV/handlers/transmission.py

@@ -9,6 +9,7 @@ import os
 import pandas as pd
 from warnings import warn
 
+from reV.utilities import SupplyCurveField
 from reV.utilities.exceptions import (HandlerWarning, HandlerKeyError,
                                       HandlerRuntimeError)
 
@@ -153,12 +154,17 @@ class TransmissionFeatures:
             raise
 
         trans_table = \
-            trans_table.rename(columns={'trans_line_gid': 'trans_gid',
-                                        'trans_gids': 'trans_line_gids'})
-
-        if 'dist_mi' in trans_table and 'dist_km' not in trans_table:
-            trans_table = trans_table.rename(columns={'dist_mi': 'dist_km'})
-            trans_table['dist_km'] *= 1.60934
+            trans_table.rename(
+                columns={'trans_line_gid': SupplyCurveField.TRANS_GID,
+                         'trans_gids': 'trans_line_gids'})
+
+        contains_dist_in_miles = "dist_mi" in trans_table
+        missing_km_dist = SupplyCurveField.DIST_SPUR_KM not in trans_table
+        if contains_dist_in_miles and missing_km_dist:
+            trans_table = trans_table.rename(
+                columns={"dist_mi": SupplyCurveField.DIST_SPUR_KM}
+            )
+            trans_table[SupplyCurveField.DIST_SPUR_KM] *= 1.60934
 
         return trans_table
 
@@ -184,23 +190,28 @@ class TransmissionFeatures:
         features = {}
 
         cap_frac = self._avail_cap_frac
-        trans_features = trans_table.groupby('trans_gid').first()
+        trans_features = trans_table.groupby(SupplyCurveField.TRANS_GID)
+        trans_features = trans_features.first()
 
         for gid, feature in trans_features.iterrows():
-            name = feature['category'].lower()
+            name = feature[SupplyCurveField.TRANS_TYPE].lower()
             feature_dict = {'type': name}
 
             if name == 'transline':
-                feature_dict['avail_cap'] = feature['ac_cap'] * cap_frac
+                feature_dict[SupplyCurveField.TRANS_CAPACITY] = (
+                    feature['ac_cap'] * cap_frac
+                )
 
             elif name == 'substation':
                 feature_dict['lines'] = json.loads(feature['trans_line_gids'])
 
             elif name == 'loadcen':
-                feature_dict['avail_cap'] = feature['ac_cap'] * cap_frac
+                feature_dict[SupplyCurveField.TRANS_CAPACITY] = (
+                    feature['ac_cap'] * cap_frac
+                )
 
             elif name == 'pcaloadcen':
-                feature_dict['avail_cap'] = None
+                feature_dict[SupplyCurveField.TRANS_CAPACITY] = None
 
             else:
                 msg = ('Cannot not recognize feature type "{}" '
@@ -297,7 +308,8 @@ class TransmissionFeatures:
             Substation available capacity
         """
         try:
-            line_caps = [self[l_gid]['avail_cap'] for l_gid in line_gids]
+            line_caps = [self[l_gid][SupplyCurveField.TRANS_CAPACITY]
+                         for l_gid in line_gids]
         except HandlerKeyError as e:
             msg = ('Could not find capacities for substation gid {} and '
                    'connected lines: {}'.format(gid, line_gids))
@@ -331,8 +343,8 @@ class TransmissionFeatures:
 
         feature = self[gid]
 
-        if 'avail_cap' in feature:
-            avail_cap = feature['avail_cap']
+        if SupplyCurveField.TRANS_CAPACITY in feature:
+            avail_cap = feature[SupplyCurveField.TRANS_CAPACITY]
 
         elif 'lines' in feature:
             avail_cap = self._substation_capacity(gid, feature['lines'])
@@ -387,7 +399,7 @@ class TransmissionFeatures:
         capacity : float
             Capacity needed in MW
         """
-        avail_cap = self[gid]['avail_cap']
+        avail_cap = self[gid][SupplyCurveField.TRANS_CAPACITY]
 
         if avail_cap < capacity:
             msg = ("Cannot connect to {}: "
@@ -397,7 +409,7 @@ class TransmissionFeatures:
             logger.error(msg)
             raise RuntimeError(msg)
 
-        self[gid]['avail_cap'] -= capacity
+        self[gid][SupplyCurveField.TRANS_CAPACITY] -= capacity
 
     def _fill_lines(self, line_gids, line_caps, capacity):
         """
@@ -471,7 +483,7 @@ class TransmissionFeatures:
             Substation connection is limited by maximum capacity of the
             attached lines
         """
-        line_caps = np.array([self[gid]['avail_cap']
+        line_caps = np.array([self[gid][SupplyCurveField.TRANS_CAPACITY]
                               for gid in line_gids])
         if self._line_limited:
             gid = line_gids[np.argmax(line_caps)]
@@ -603,8 +615,8 @@ class TransmissionFeatures:
             raise
 
         feature_cap = pd.Series(feature_cap)
-        feature_cap.name = 'avail_cap'
-        feature_cap.index.name = 'trans_gid'
+        feature_cap.name = SupplyCurveField.TRANS_CAPACITY
+        feature_cap.index.name = SupplyCurveField.TRANS_GID
         feature_cap = feature_cap.to_frame().reset_index()
 
         return feature_cap
@@ -635,16 +647,20 @@ class TransmissionCosts(TransmissionFeatures):
 
         features = {}
 
-        if 'avail_cap' not in trans_table:
+        if SupplyCurveField.TRANS_CAPACITY not in trans_table:
             kwargs = {'avail_cap_frac': self._avail_cap_frac}
             fc = TransmissionFeatures.feature_capacity(trans_table,
                                                        **kwargs)
-            trans_table = trans_table.merge(fc, on='trans_gid')
+            trans_table = trans_table.merge(fc, on=SupplyCurveField.TRANS_GID)
 
-        trans_features = trans_table.groupby('trans_gid').first()
+        trans_features = trans_table.groupby(SupplyCurveField.TRANS_GID)
+        trans_features = trans_features.first()
         for gid, feature in trans_features.iterrows():
-            name = feature['category'].lower()
-            feature_dict = {'type': name, 'avail_cap': feature['avail_cap']}
+            name = feature[SupplyCurveField.TRANS_TYPE].lower()
+            feature_dict = {'type': name,
+                            SupplyCurveField.TRANS_CAPACITY: (
+                                feature[SupplyCurveField.TRANS_CAPACITY]
+                            )}
             features[gid] = feature_dict
 
         return features
@@ -665,7 +681,7 @@ class TransmissionCosts(TransmissionFeatures):
             default = 100%
         """
 
-        return self[gid]['avail_cap']
+        return self[gid][SupplyCurveField.TRANS_CAPACITY]
 
     @classmethod
     def feature_costs(cls, trans_table, capacity=None, line_tie_in_cost=14000,
@@ -722,8 +738,9 @@ class TransmissionCosts(TransmissionFeatures):
             costs = []
             for _, row in trans_table.iterrows():
                 tm = row.get('transmission_multiplier', 1)
-                costs.append(feature.cost(row['trans_gid'],
-                                          row['dist_km'], capacity=capacity,
+                costs.append(feature.cost(row[SupplyCurveField.TRANS_GID],
+                                          row[SupplyCurveField.DIST_SPUR_KM],
+                                          capacity=capacity,
                                           transmission_multiplier=tm))
         except Exception:
             logger.exception("Error computing costs for all connections in {}"

reV/hybrids/hybrid_methods.py

@@ -3,18 +3,12 @@
 
 @author: ppinchuk
 """
+from reV.utilities import SupplyCurveField
 
 
 def aggregate_solar_capacity(h):
     """Compute the total solar capcity allowed in hybridization.
 
-    Note
-    ----
-    No limiting is done on the ratio of wind to solar. This method
-    checks for an existing 'hybrid_solar_capacity'. If one does not exist,
-    it is assumed that there is no limit on the solar to wind capacity
-    ratio and the solar capacity is copied into this new column.
-
     Parameters
     ----------
     h : `reV.hybrids.Hybridization`
@@ -26,27 +20,25 @@ def aggregate_solar_capacity(h):
     -------
     data : Series | None
         A series of data containing the capacity allowed in the hybrid
-        capacity sum, or `None` if 'hybrid_solar_capacity' already exists.
+        capacity sum, or `None` if 'hybrid_solar_capacity' already
+        exists.
 
     Notes
     -----
-
+    No limiting is done on the ratio of wind to solar. This method
+    checks for an existing 'hybrid_solar_capacity'. If one does not
+    exist, it is assumed that there is no limit on the solar to wind
+    capacity ratio and the solar capacity is copied into this new
+    column.
     """
-    if 'hybrid_solar_capacity' in h.hybrid_meta:
+    if f'hybrid_solar_{SupplyCurveField.CAPACITY_AC_MW}' in h.hybrid_meta:
         return None
-    return h.hybrid_meta['solar_capacity']
+    return h.hybrid_meta[f'solar_{SupplyCurveField.CAPACITY_AC_MW}']
 
 
 def aggregate_wind_capacity(h):
     """Compute the total wind capcity allowed in hybridization.
 
-    Note
-    ----
-    No limiting is done on the ratio of wind to solar. This method
-    checks for an existing 'hybrid_wind_capacity'. If one does not exist,
-    it is assumed that there is no limit on the solar to wind capacity
-    ratio and the wind capacity is copied into this new column.
-
     Parameters
     ----------
     h : `reV.hybrids.Hybridization`
@@ -58,15 +50,19 @@ def aggregate_wind_capacity(h):
     -------
     data : Series | None
         A series of data containing the capacity allowed in the hybrid
-        capacity sum, or `None` if 'hybrid_solar_capacity' already exists.
+        capacity sum, or `None` if 'hybrid_solar_capacity' already
+        exists.
 
     Notes
     -----
-
+    No limiting is done on the ratio of wind to solar. This method
+    checks for an existing 'hybrid_wind_capacity'. If one does not
+    exist, it is assumed that there is no limit on the solar to wind
+    capacity ratio and the wind capacity is copied into this new column.
     """
-    if 'hybrid_wind_capacity' in h.hybrid_meta:
+    if f'hybrid_wind_{SupplyCurveField.CAPACITY_AC_MW}' in h.hybrid_meta:
         return None
-    return h.hybrid_meta['wind_capacity']
+    return h.hybrid_meta[f'wind_{SupplyCurveField.CAPACITY_AC_MW}']
 
 
 def aggregate_capacity(h):
@@ -85,8 +81,8 @@ def aggregate_capacity(h):
         A series of data containing the aggregated capacity, or `None`
         if the capacity columns are missing.
     """
-
-    sc, wc = 'hybrid_solar_capacity', 'hybrid_wind_capacity'
+    sc = f'hybrid_solar_{SupplyCurveField.CAPACITY_AC_MW}'
+    wc = f'hybrid_wind_{SupplyCurveField.CAPACITY_AC_MW}'
     missing_solar_cap = sc not in h.hybrid_meta.columns
     missing_wind_cap = wc not in h.hybrid_meta.columns
     if missing_solar_cap or missing_wind_cap:
@@ -113,8 +109,10 @@ def aggregate_capacity_factor(h):
         if the capacity and/or mean_cf columns are missing.
     """
 
-    sc, wc = 'hybrid_solar_capacity', 'hybrid_wind_capacity'
-    scf, wcf = 'solar_mean_cf', 'wind_mean_cf'
+    sc = f'hybrid_solar_{SupplyCurveField.CAPACITY_AC_MW}'
+    wc = f'hybrid_wind_{SupplyCurveField.CAPACITY_AC_MW}'
+    scf = f'solar_{SupplyCurveField.MEAN_CF_AC}'
+    wcf = f'wind_{SupplyCurveField.MEAN_CF_AC}'
     missing_solar_cap = sc not in h.hybrid_meta.columns
     missing_wind_cap = wc not in h.hybrid_meta.columns
     missing_solar_mean_cf = scf not in h.hybrid_meta.columns
@@ -132,8 +130,10 @@ def aggregate_capacity_factor(h):
 
 
 HYBRID_METHODS = {
-    'hybrid_solar_capacity': aggregate_solar_capacity,
-    'hybrid_wind_capacity': aggregate_wind_capacity,
-    'hybrid_capacity': aggregate_capacity,
-    'hybrid_mean_cf': aggregate_capacity_factor
+    f'hybrid_solar_{SupplyCurveField.CAPACITY_AC_MW}': (
+        aggregate_solar_capacity
+    ),
+    f'hybrid_wind_{SupplyCurveField.CAPACITY_AC_MW}': aggregate_wind_capacity,
+    f'hybrid_{SupplyCurveField.CAPACITY_AC_MW}': aggregate_capacity,
+    f'hybrid_{SupplyCurveField.MEAN_CF_AC}': aggregate_capacity_factor
 }