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

reV/generation/generation.py

@@ -113,7 +113,7 @@ class Gen(BaseGen):
         allowed and/or required SAM config file inputs. If economic
         parameters are supplied in the SAM config, then you can bundle a
         "follow-on" econ calculation by just adding the desired econ
-        output keys to the `output_request`. You can request ``reV`` to '
+        output keys to the `output_request`. You can request ``reV`` to
         run the analysis for one or more "sites", which correspond to
         the meta indices in the resource data (also commonly called the
         ``gid's``).
@@ -128,7 +128,7 @@ class Gen(BaseGen):
         >>> import os
         >>> from reV import Gen, TESTDATADIR
         >>>
-        >>> sam_tech = 'pvwattsv7'
+        >>> sam_tech = 'pvwattsv8'
         >>> sites = 0
         >>> fp_sam = os.path.join(TESTDATADIR, 'SAM/naris_pv_1axis_inv13.json')
         >>> fp_res = os.path.join(TESTDATADIR, 'nsrdb/ri_100_nsrdb_2013.h5')
@@ -145,15 +145,16 @@ class Gen(BaseGen):
         >>> gen.run()
         >>>
         >>> gen.out
-        {'lcoe_fcr': array([131.39166, 131.31221, 127.54539, 125.49656]),
-         'cf_mean': array([0.17713654, 0.17724372, 0.1824783 , 0.1854574 ]),
-        : array([[0., 0., 0., 0.],
-                [0., 0., 0., 0.],
-                [0., 0., 0., 0.],
-                ...,
-                [0., 0., 0., 0.],
-                [0., 0., 0., 0.],
-                [0., 0., 0., 0.]])}
+        {'fixed_charge_rate': array([0.096, 0.096, 0.096, 0.096],
+         'base_capital_cost': array([39767200, 39767200, 39767200, 39767200],
+         'base_variable_operating_cost': array([0, 0, 0, 0],
+         'base_fixed_operating_cost': array([260000, 260000, 260000, 260000],
+         'capital_cost': array([39767200, 39767200, 39767200, 39767200],
+         'fixed_operating_cost': array([260000, 260000, 260000, 260000],
+         'variable_operating_cost': array([0, 0, 0, 0],
+         'capital_cost_multiplier': array([1, 1, 1, 1],
+         'cf_mean': array([0.17859147, 0.17869979, 0.1834818 , 0.18646291],
+         'lcoe_fcr': array([130.32126, 130.24226, 126.84782, 124.81981]}
 
         Parameters
         ----------
@@ -454,7 +455,7 @@ class Gen(BaseGen):
             Meta data df for sites in project points. Column names are meta
             data variables, rows are different sites. The row index
             does not indicate the site number if the project points are
-            non-sequential or do not start from 0, so a `SupplyCurveField.GID`
+            non-sequential or do not start from 0, so a `SiteDataField.GID`
             column is added.
         """
         if self._meta is None:
@@ -712,6 +713,8 @@ class Gen(BaseGen):
                 for k in site_output.keys():
                     # iterate through variable names in each site's output dict
                     if k in cls.OUT_ATTRS:
+                        if out[site][k] is None:
+                            continue
                         # get dtype and scale for output variable name
                         dtype = cls.OUT_ATTRS[k].get("dtype", "float32")
                         scale_factor = cls.OUT_ATTRS[k].get("scale_factor", 1)
@@ -947,12 +950,20 @@ class Gen(BaseGen):
             Output variables requested from SAM.
         """
 
-        output_request = self._output_request_type_check(req)
+        output_request = super()._parse_output_request(req)
 
         # ensure that cf_mean is requested from output
         if "cf_mean" not in output_request:
             output_request.append("cf_mean")
 
+        if _is_solar_run_with_ac_outputs(self.tech):
+            if "dc_ac_ratio" not in output_request:
+                output_request.append("dc_ac_ratio")
+            for dset in ["cf_mean", "cf_profile"]:
+                ac_dset = f"{dset}_ac"
+                if dset in output_request and ac_dset not in output_request:
+                    output_request.append(ac_dset)
+
         for request in output_request:
             if request not in self.OUT_ATTRS:
                 msg = (
@@ -1097,3 +1108,10 @@ class Gen(BaseGen):
             raise e
 
         return self._out_fpath
+
+
+def _is_solar_run_with_ac_outputs(tech):
+    """True if tech is pvwattsv8+"""
+    if "pvwatts" not in tech.casefold():
+        return False
+    return tech.casefold() not in {f"pvwattsv{i}" for i in range(8)}

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/multi_year.py

@@ -18,6 +18,7 @@ from rex.utilities.utilities import (
     parse_year,
 )
 
+from reV.generation.base import LCOE_REQUIRED_OUTPUTS
 from reV.config.output_request import SAMOutputRequest
 from reV.handlers.outputs import Outputs
 from reV.utilities import ModuleName, log_versions
@@ -60,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
@@ -76,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._dsets = self._parse_dsets(dsets)
+        self._parse_pass_through_dsets(dsets, pass_through_dsets or [])
+        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
@@ -90,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)
@@ -104,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):
@@ -815,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/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

@@ -31,9 +31,9 @@ def aggregate_solar_capacity(h):
     capacity ratio and the solar capacity is copied into this new
     column.
     """
-    if f'hybrid_solar_{SupplyCurveField.CAPACITY}' in h.hybrid_meta:
+    if f'hybrid_solar_{SupplyCurveField.CAPACITY_AC_MW}' in h.hybrid_meta:
         return None
-    return h.hybrid_meta[f'solar_{SupplyCurveField.CAPACITY}']
+    return h.hybrid_meta[f'solar_{SupplyCurveField.CAPACITY_AC_MW}']
 
 
 def aggregate_wind_capacity(h):
@@ -60,9 +60,9 @@ def aggregate_wind_capacity(h):
     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 f'hybrid_wind_{SupplyCurveField.CAPACITY}' in h.hybrid_meta:
+    if f'hybrid_wind_{SupplyCurveField.CAPACITY_AC_MW}' in h.hybrid_meta:
         return None
-    return h.hybrid_meta[f'wind_{SupplyCurveField.CAPACITY}']
+    return h.hybrid_meta[f'wind_{SupplyCurveField.CAPACITY_AC_MW}']
 
 
 def aggregate_capacity(h):
@@ -81,8 +81,8 @@ def aggregate_capacity(h):
         A series of data containing the aggregated capacity, or `None`
         if the capacity columns are missing.
     """
-    sc = f'hybrid_solar_{SupplyCurveField.CAPACITY}'
-    wc = f'hybrid_wind_{SupplyCurveField.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:
@@ -109,10 +109,10 @@ def aggregate_capacity_factor(h):
         if the capacity and/or mean_cf columns are missing.
     """
 
-    sc = f'hybrid_solar_{SupplyCurveField.CAPACITY}'
-    wc = f'hybrid_wind_{SupplyCurveField.CAPACITY}'
-    scf = f'solar_{SupplyCurveField.MEAN_CF}'
-    wcf = f'wind_{SupplyCurveField.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
@@ -130,8 +130,10 @@ def aggregate_capacity_factor(h):
 
 
 HYBRID_METHODS = {
-    f'hybrid_solar_{SupplyCurveField.CAPACITY}': aggregate_solar_capacity,
-    f'hybrid_wind_{SupplyCurveField.CAPACITY}': aggregate_wind_capacity,
-    f'hybrid_{SupplyCurveField.CAPACITY}': aggregate_capacity,
-    f'hybrid_{SupplyCurveField.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
 }

reV/hybrids/hybrids.py

@@ -38,11 +38,11 @@ NON_DUPLICATE_COLS = {
     SupplyCurveField.SC_POINT_GID, SupplyCurveField.SC_ROW_IND,
     SupplyCurveField.SC_COL_IND
 }
-DROPPED_COLUMNS = [SupplyCurveField.GID]
-DEFAULT_FILL_VALUES = {f'solar_{SupplyCurveField.CAPACITY}': 0,
-                       f'wind_{SupplyCurveField.CAPACITY}': 0,
-                       f'solar_{SupplyCurveField.MEAN_CF}': 0,
-                       f'wind_{SupplyCurveField.MEAN_CF}': 0}
+HYBRIDS_GID_COL = "gid"
+DEFAULT_FILL_VALUES = {f'solar_{SupplyCurveField.CAPACITY_AC_MW}': 0,
+                       f'wind_{SupplyCurveField.CAPACITY_AC_MW}': 0,
+                       f'solar_{SupplyCurveField.MEAN_CF_AC}': 0,
+                       f'wind_{SupplyCurveField.MEAN_CF_AC}': 0}
 OUTPUT_PROFILE_NAMES = ['hybrid_profile',
                         'hybrid_solar_profile',
                         'hybrid_wind_profile']
@@ -702,7 +702,7 @@ class MetaHybridizer:
         self._propagate_duplicate_cols(duplicate_cols)
         self._drop_cols(duplicate_cols)
         self._hybrid_meta.rename(self.__col_name_map, inplace=True, axis=1)
-        self._hybrid_meta.index.name = SupplyCurveField.GID
+        self._hybrid_meta.index.name = HYBRIDS_GID_COL
 
     def _propagate_duplicate_cols(self, duplicate_cols):
         """Fill missing column values from outer merge."""
@@ -713,9 +713,9 @@ class MetaHybridizer:
             self._hybrid_meta.loc[null_idx, no_suffix] = non_null_vals
 
     def _drop_cols(self, duplicate_cols):
-        """Drop any remaning duplicate and 'DROPPED_COLUMNS' columns."""
+        """Drop any remaining duplicate and 'HYBRIDS_GID_COL' columns."""
         self._hybrid_meta.drop(
-            duplicate_cols + DROPPED_COLUMNS,
+            duplicate_cols + [HYBRIDS_GID_COL],
             axis=1,
             inplace=True,
             errors="ignore",
@@ -1196,8 +1196,8 @@ class Hybridization:
     def __rep_profile_hybridization_params(self):
         """Zip the rep profile hybridization parameters."""
 
-        cap_col_names = [f"hybrid_solar_{SupplyCurveField.CAPACITY}",
-                         f"hybrid_wind_{SupplyCurveField.CAPACITY}"]
+        cap_col_names = [f"hybrid_solar_{SupplyCurveField.CAPACITY_AC_MW}",
+                         f"hybrid_wind_{SupplyCurveField.CAPACITY_AC_MW}"]
         idx_maps = [
             self.meta_hybridizer.solar_profile_indices_map,
             self.meta_hybridizer.wind_profile_indices_map,

reV/nrwal/nrwal.py

@@ -37,7 +37,7 @@ class RevNrwal:
 
     def __init__(self, gen_fpath, site_data, sam_files, nrwal_configs,
                  output_request, save_raw=True,
-                 meta_gid_col=ResourceMetaField.GID,
+                 meta_gid_col=str(ResourceMetaField.GID),  # str() to fix docs
                  site_meta_cols=None):
         """Framework to handle reV-NRWAL analysis.
 

reV/qa_qc/qa_qc.py

@@ -105,7 +105,7 @@ class QaQc:
             if file.endswith(".csv"):
                 summary_csv = os.path.join(self.out_dir, file)
                 summary = pd.read_csv(summary_csv)
-                has_right_cols = (SupplyCurveField.GID in summary
+                has_right_cols = ("gid" in summary
                                   and SupplyCurveField.LATITUDE in summary
                                   and SupplyCurveField.LONGITUDE in summary)
                 if has_right_cols:

reV/qa_qc/summary.py

@@ -597,11 +597,11 @@ class SummaryPlots(PlotBase):
         sc_df : pandas.DataFrame
             Supply curve data
         """
-        values = [SupplyCurveField.CAPACITY, lcoe]
+        values = [SupplyCurveField.CAPACITY_AC_MW, lcoe]
         self._check_value(self.summary, values, scatter=False)
         sc_df = self.summary[values].sort_values(lcoe)
         sc_df['cumulative_capacity'] = (
-            sc_df[SupplyCurveField.CAPACITY].cumsum()
+            sc_df[SupplyCurveField.CAPACITY_AC_MW].cumsum()
         )
 
         return sc_df
@@ -800,11 +800,11 @@ class SupplyCurvePlot(PlotBase):
         sc_df : pandas.DataFrame
             Supply curve data
         """
-        values = [SupplyCurveField.CAPACITY, lcoe]
+        values = [SupplyCurveField.CAPACITY_AC_MW, lcoe]
         self._check_value(self.sc_table, values, scatter=False)
         sc_df = self.sc_table[values].sort_values(lcoe)
         sc_df['cumulative_capacity'] = (
-            sc_df[SupplyCurveField.CAPACITY].cumsum()
+            sc_df[SupplyCurveField.CAPACITY_AC_MW].cumsum()
         )
 
         return sc_df

reV/rep_profiles/rep_profiles.py

@@ -953,7 +953,7 @@ class RepProfiles(RepProfilesBase):
     def __init__(self, gen_fpath, rev_summary, reg_cols,
                  cf_dset='cf_profile',
                  rep_method='meanoid', err_method='rmse',
-                 weight=SupplyCurveField.GID_COUNTS,
+                 weight=str(SupplyCurveField.GID_COUNTS),  # str() to fix docs
                  n_profiles=1, aggregate_profiles=False):
         """ReV rep profiles class.
 

reV/supply_curve/exclusions.py

@@ -111,7 +111,7 @@ class LayerMask:
             specifications to create a boolean mask that defines the
             extent to which the original mask should be applied.
             For example, suppose you specify the input the following
-            way:
+            way::
 
                 input_dict = {
                     "viewsheds": {

reV/supply_curve/extent.py

@@ -391,7 +391,7 @@ class SupplyCurveExtent:
                 }
             )
 
-            self._points.index.name = SupplyCurveField.GID  # sc_point_gid
+            self._points.index.name = "gid"  # sc_point_gid
 
         return self._points