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

{nrel_rev-0.14.4.dist-info → nrel_rev-0.14.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NREL-reV
-Version: 0.14.4
+Version: 0.14.5
 Summary: National Renewable Energy Laboratory's (NREL's) Renewable Energy Potential(V) Model: reV
 Author-email: Galen Maclaurin <galen.maclaurin@nrel.gov>
 Maintainer-email: Grant Buster <gbuster@nrel.gov>, Paul Pinchuk <ppinchuk@nrel.gov>

{nrel_rev-0.14.4.dist-info → nrel_rev-0.14.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
-nrel_rev-0.14.4.dist-info/licenses/LICENSE,sha256=hDwoTANtan2ZpufBlXm5C3W_PJ-mCqItvlcobgjxL7k,1526
+nrel_rev-0.14.5.dist-info/licenses/LICENSE,sha256=hDwoTANtan2ZpufBlXm5C3W_PJ-mCqItvlcobgjxL7k,1526
 reV/__init__.py,sha256=tXTpWu_qVo3uotfSw_TJ-gNbidGaIPPfUTwBlpCMJ-g,856
-reV/cli.py,sha256=u7G5M5moA7q8fCgC_1MB30Z7R14GNcngVf6eVNkfQU8,1682
-reV/version.py,sha256=oIdidsSwDY_HSSZ-2OPfa9VlyBv1QAecZqvfdONcImU,51
+reV/cli.py,sha256=tkJzwkGNz0h7PfKpjUAv6aM-Jpn_z8jUbXyjb5GCFBM,1792
+reV/version.py,sha256=DNYUQmgQgGdiJDrMQAgH6IJ-51uB5WIunyqwp0YBFMM,51
 reV/SAM/SAM.py,sha256=3NK9rRaJzqH6wz7CU_5XguKCRhmoilOpDdFFsFgOaxQ,33163
 reV/SAM/__init__.py,sha256=LJqoncyKDY5ZP5WA4kboh561bce11F9Ge645Izah0EY,240
 reV/SAM/defaults.py,sha256=JQMJomX7wsbMzxKjx_IMnA_9QFsV2yWCyl_JToDVSJo,6703
@@ -16,11 +16,11 @@ reV/SAM/defaults/WY Southern-Flat Lands.srw,sha256=oSlFI7nnycW7SMnTXEXBXYkoh8rhV
 reV/SAM/defaults/geothermal.json,sha256=gnlxOBxxkbDDacIw6B9yP9iRkfmwj0WTWs8Zb71ytCo,7119
 reV/SAM/defaults/i_pvwattsv5.json,sha256=sF8rSe1bcqsKLXchvRxlp25dXOVe_q7rPJTf_vWR20Y,312
 reV/bespoke/__init__.py,sha256=vpXbyBUrUsTgK8UP_LafMjLiDg2CRG9WZLHPsOJoxek,109
-reV/bespoke/bespoke.py,sha256=PLs42cTGRrCihBZRO_6VR6eByGgTRBwLOEiXwPiz7dg,114863
+reV/bespoke/bespoke.py,sha256=fZvNpNeKf8LYQbDDhX4I8iOgm_3MGdCf0aq-wzQcflo,116916
 reV/bespoke/cli_bespoke.py,sha256=b6Xu0GKpXqPX3qVJ6-z0FrO97uCsH_1dVOa4r6IvesQ,2911
 reV/bespoke/gradient_free.py,sha256=URWV1yiO2jyWk3_GOpfpLV_wlgJhXXGmTUwCB3WTV0Y,12015
 reV/bespoke/pack_turbs.py,sha256=Dcd9F8obF8LPztzeycB5kxa5hXKSCiz3jC1WeAFUx28,3508
-reV/bespoke/place_turbines.py,sha256=f1Or9X1b2_XOkhUgRNXZwpF_xZQTw1LFL2O2SRe1p1E,25883
+reV/bespoke/place_turbines.py,sha256=pc5JofO9LAwwsQDGbxauGOoMeO6TXVr9uXABgVAADw0,27121
 reV/config/__init__.py,sha256=oqFNU4JESU_fPxFmPyQNFAXLDAdzmTlPuabXTe3Rf2Y,92
 reV/config/base_analysis_config.py,sha256=NvA3g5zQz8mIrV8ZSENLq0XBZGXa6RTGkwpZ76TVZj8,5615
 reV/config/base_config.py,sha256=a748VQ3CRs9RVi5sSEPcaWOyH6R3t5tssaFqZntHyaE,10075
@@ -28,7 +28,7 @@ reV/config/cli_project_points.py,sha256=6edOlLNOG-ZEbcpNS2MPfu-DXjcOTEh_MEvKOvQS
 reV/config/curtailment.py,sha256=1bH7xzxOmD4PwLKcXFNotMAa9iCfGBUm2DKTOXViCJg,5548
 reV/config/execution.py,sha256=hyf8W7XYUXE6tXBXs-4En7h_aDTYu8FzbslgBsKLJkQ,5046
 reV/config/output_request.py,sha256=cww5MxOUnXE_HwwLYitsFSwwUT8mWkctSElq9-zUl_8,4725
-reV/config/project_points.py,sha256=CSq7lHgWfJ1pq1XlWJ5eykmGGhumkxVcg__Ln9RR4-Y,41886
+reV/config/project_points.py,sha256=BdLwWrESsDZDQJ59rki-1Z0xXF4QUXZkbB8nsPrtOEA,42147
 reV/config/sam_config.py,sha256=xvvx2FTuliq0Sk-BjRE3I9zdDmIdwHVBnWtXCcsoc40,7998
 reV/econ/__init__.py,sha256=UId1LNaAP9lErCEXVce6JZf0qVRUvwNFOPrajdRevGo,130
 reV/econ/cli_econ.py,sha256=2KNy3JQD0EKjStaoD2r6nv3ELFw88h2E_up-UKj_sfE,4286
@@ -75,25 +75,25 @@ reV/rep_profiles/cli_rep_profiles.py,sha256=i3fRolT7HTzTQePXpNLDyxwgpRa7FEfHO1mO
 reV/rep_profiles/rep_profiles.py,sha256=dJ2jcklbelYYNS3IUXIYHg8E0poXLOWrwdqeBBnqYIE,48271
 reV/supply_curve/__init__.py,sha256=dbf0cO0qmt1VhV8dnDddztrcpnwua9T2HBhM6tLKaP8,274
 reV/supply_curve/aggregation.py,sha256=DvIUmj0PbZ8NxgOSmpXvzn9wJnOiQO2Xm2w_WCRVK-U,40908
-reV/supply_curve/cli_sc_aggregation.py,sha256=iDBHlUUPg-Ce4N4Rqb4scn8A_Ygq2q4i9v_ypbH-krs,3387
+reV/supply_curve/cli_sc_aggregation.py,sha256=fJwhOixN3VlzImHStWfcB8Bum_POY-RRgkhWi8Slgao,4633
 reV/supply_curve/cli_supply_curve.py,sha256=e-XrHQIe4OqWTL6u-TUAyHrw7Alk7vkXQ2HoLbE3zTM,2163
 reV/supply_curve/cli_tech_mapping.py,sha256=Dirn4JOmu_3BIP7WgcRLAepsreKqmDhChHLPEUqcDAo,1735
 reV/supply_curve/competitive_wind_farms.py,sha256=eOjM72-4oWtsqxB7Wh2gnB2zVAt4LY3iPE_DqWdXbQ4,15795
-reV/supply_curve/exclusions.py,sha256=4-ZxTO5Vlu03vie0V_74uvdajQfCuC8FE96Pg8I4U_c,42950
+reV/supply_curve/exclusions.py,sha256=dzwgcXyDg5_MrcxKohW-j5YX7tWW6JlQimkUwLlhz2k,44056
 reV/supply_curve/extent.py,sha256=168Vcr2XQNkoLLn3xCLfvE3udi39wbtQ7GAbvw1yys0,17917
-reV/supply_curve/points.py,sha256=d3dPZio1PAbc0qvLJ1CqzqbcUwqsKMQK2wxbek4_CJ8,93937
-reV/supply_curve/sc_aggregation.py,sha256=l7uXs-grLb0enblPNsEDKccSP11WZ2Pah5baWtgtvzE,68067
+reV/supply_curve/points.py,sha256=dl518Bv_i2jOM1N-BAVZcK3chmv23BphvHO47zcbTxU,94142
+reV/supply_curve/sc_aggregation.py,sha256=VaFKS_EIPqlxlpFlxUiZiI8q_mJWdamh9fSuF6LXm28,70843
 reV/supply_curve/supply_curve.py,sha256=9zhAA_9XSxE18j1Z9FuC71Wr3I0VuakfR5mt1_gHYuU,69931
-reV/supply_curve/tech_mapping.py,sha256=WP-o5Sk5q1Jz_F9Rpe77_fvTYGH8R4GnYDfRMSTuHB8,17804
-reV/utilities/__init__.py,sha256=ii0xiebw0PNg5Eq9kYcLrX9M3yVglyxnn9_fP_w4ILA,10871
+reV/supply_curve/tech_mapping.py,sha256=xP8j2KMY58kZ5MSH13nIs8IoDtFhNCzGY4hQeKxW33w,17878
+reV/utilities/__init__.py,sha256=b99Su_feREbuKkP71W_NrlO7GH9vQRsH7TrP7f4-Eg0,22703
 reV/utilities/_clean_readme.py,sha256=IFI9wGPX5nnLTNVLJzH8IOHq9unQlAlHRu4Namib0LA,709
-reV/utilities/cli_functions.py,sha256=1_T_sXz0Ct8lW-vOk3mMRcpD6NYsc9cGI7dEujIi9z4,3864
+reV/utilities/cli_functions.py,sha256=3q7d0MHNpb6vnzWSxQMPNXH176nGp_CHMgHCLknmv1k,5154
 reV/utilities/curtailment.py,sha256=As902-2aLGnCiVEutYfAFIOwuV--_rCQhxGNOY9RB-4,5241
 reV/utilities/exceptions.py,sha256=f7sRGsbFLpmL6Caq_H1cD4GfVhnLMyvYUsLPA1UVDDE,3974
 reV/utilities/pytest_utils.py,sha256=spCw9yQ8KEYOkQZpCi9IEmaWIvIqHqbUPDXXNQJJ68U,3241
 reV/utilities/slots.py,sha256=xsw-JuUVZ0YeoCNuwP_HxGNxFMA4xRs1tuImXHIJqaU,2618
-nrel_rev-0.14.4.dist-info/METADATA,sha256=3lCV-lrlcYrhrUEtJbAKsj5e8kTahxjDhLujt2-XXqQ,10718
-nrel_rev-0.14.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nrel_rev-0.14.4.dist-info/entry_points.txt,sha256=4IfJtZm2iMJwrbC8J0Or7VjZWnFpvCaHYVpvSWfIwDA,616
-nrel_rev-0.14.4.dist-info/top_level.txt,sha256=S6YF2ZYgXUB6n28SY0K2H8YB9tMJdXQ9CyQbo6VC89M,4
-nrel_rev-0.14.4.dist-info/RECORD,,
+nrel_rev-0.14.5.dist-info/METADATA,sha256=UCWoXqsoas-MeRXDg1ytuva-qI6B3XDpY1MhGb3ew_g,10718
+nrel_rev-0.14.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nrel_rev-0.14.5.dist-info/entry_points.txt,sha256=4IfJtZm2iMJwrbC8J0Or7VjZWnFpvCaHYVpvSWfIwDA,616
+nrel_rev-0.14.5.dist-info/top_level.txt,sha256=S6YF2ZYgXUB6n28SY0K2H8YB9tMJdXQ9CyQbo6VC89M,4
+nrel_rev-0.14.5.dist-info/RECORD,,

reV/bespoke/bespoke.py

@@ -310,7 +310,24 @@ class BespokeSinglePlant:
                   cost ($) as evaluated by
                   `balance_of_system_cost_function`
                 - ``self.wind_plant``: the SAM wind plant object,
-                  through which all SAM variables can be accessed
+                  through which all SAM variables can be accessed.
+
+                  .. IMPORTANT::
+                     When using the `self.wind_plant` variable,
+                     DO NOT include quotes around variable names (keys).
+
+                        - ❌ Wrong: ``self.wind_plant["annual_energy"]``
+                        - ✅ Correct: ``self.wind_plant[annual_energy]``
+
+                  .. IMPORTANT::
+                     It's possible for SAM wind plant variables to be
+                     ``None``, especially if something went wrong while
+                     optimizing the wind plant layout. In this case,
+                     your objective function may fail to evaluate and
+                     terminate the program entirely. To avoid this, add
+                     a default value for the variable in your objective
+                     function, like so:
+                     ``(self.wind_plant[annual_energy] or 0)``
 
         capital_cost_function : str
             The plant capital cost function as a string, must return the total
@@ -1265,6 +1282,14 @@ class BespokeSinglePlant:
             for k, v in plant.outputs.items():
                 self._outputs[k + "-{}".format(year)] = v
 
+        self._compute_output_means()
+        self._add_extra_meta_columns()
+        logger.debug("Timeseries analysis complete!")
+
+        return self.outputs
+
+    def _compute_output_means(self):
+        """Compute time series means and store them in the outputs dict"""
         means = {}
         for k1, v1 in self._outputs.items():
             if isinstance(v1, Number) and parse_year(k1, option="boolean"):
@@ -1277,6 +1302,9 @@ class BespokeSinglePlant:
 
         self._outputs.update(means)
 
+    def _add_extra_meta_columns(self):
+        """Copy over some non-temporal datasets to meta"""
+
         self._meta[SupplyCurveField.MEAN_RES] = self.res_df["windspeed"].mean()
         self._meta[SupplyCurveField.MEAN_CF_DC] = np.nan
         self._meta[SupplyCurveField.MEAN_CF_AC] = np.nan
@@ -1302,10 +1330,6 @@ class BespokeSinglePlant:
                 self.outputs["annual_wake_loss_internal_percent-means"]
             )
 
-        logger.debug("Timeseries analysis complete!")
-
-        return self.outputs
-
     def run_plant_optimization(self):
         """Run the wind plant layout optimization and export outputs
         to outputs property.
@@ -1626,7 +1650,24 @@ class BespokeWindPlants(BaseAggregation):
                   cost ($) as evaluated by
                   `balance_of_system_cost_function`
                 - ``self.wind_plant``: the SAM wind plant object,
-                  through which all SAM variables can be accessed
+                  through which all SAM variables can be accessed.
+
+                  .. IMPORTANT::
+                     When using the `self.wind_plant` variable,
+                     DO NOT include quotes around variable names (keys).
+
+                        - ❌ Wrong: ``self.wind_plant["annual_energy"]``
+                        - ✅ Correct: ``self.wind_plant[annual_energy]``
+
+                  .. IMPORTANT::
+                     It's possible for SAM wind plant variables to be
+                     ``None``, especially if something went wrong while
+                     optimizing the wind plant layout. In this case,
+                     your objective function may fail to evaluate and
+                     terminate the program entirely. To avoid this, add
+                     a default value for the variable in your objective
+                     function, like so:
+                     ``(self.wind_plant[annual_energy] or 0)``
 
         capital_cost_function : str
             The plant capital cost function written out as a string.

reV/bespoke/place_turbines.py

@@ -3,6 +3,7 @@
 """
 place turbines for bespoke wind plants
 """
+import re
 from functools import wraps
 
 import numpy as np
@@ -96,7 +97,24 @@ class PlaceTurbines:
                   cost ($) as evaluated by
                   `balance_of_system_cost_function`
                 - ``self.wind_plant``: the SAM wind plant object,
-                  through which all SAM variables can be accessed
+                  through which all SAM variables can be accessed.
+
+                  .. IMPORTANT::
+                     When using the `self.wind_plant` variable,
+                     DO NOT include quotes around variable names (keys).
+
+                        - ❌ Wrong: ``self.wind_plant["annual_energy"]``
+                        - ✅ Correct: ``self.wind_plant[annual_energy]``
+
+                  .. IMPORTANT::
+                     It's possible for SAM wind plant variables to be
+                     ``None``, especially if something went wrong while
+                     optimizing the wind plant layout. In this case,
+                     your objective function may fail to evaluate and
+                     terminate the program entirely. To avoid this, add
+                     a default value for the variable in your objective
+                     function, like so:
+                     ``(self.wind_plant[annual_energy] or 0)``
 
         capital_cost_function : str
             The plant capital cost function as a string, must return the
@@ -133,13 +151,15 @@ class PlaceTurbines:
         # inputs
         self.wind_plant = wind_plant
 
-        self.capital_cost_function = capital_cost_function
-        self.fixed_operating_cost_function = fixed_operating_cost_function
-        self.variable_operating_cost_function = \
-            variable_operating_cost_function
-        self.balance_of_system_cost_function = balance_of_system_cost_function
+        self.capital_cost_function = _fix_wp_keys(capital_cost_function)
+        self.fixed_operating_cost_function = _fix_wp_keys(
+            fixed_operating_cost_function)
+        self.variable_operating_cost_function = _fix_wp_keys(
+            variable_operating_cost_function)
+        self.balance_of_system_cost_function = _fix_wp_keys(
+            balance_of_system_cost_function)
 
-        self.objective_function = objective_function
+        self.objective_function = _fix_wp_keys(objective_function)
         self.include_mask = include_mask
         self.pixel_side_length = pixel_side_length
         self.min_spacing = min_spacing
@@ -158,7 +178,6 @@ class PlaceTurbines:
         self.safe_polygons = None
         self._optimized_nn_conn_dist_m = None
 
-        self.ILLEGAL = ('import ', 'os.', 'sys.', '.__', '__.', 'eval', 'exec')
         self._preflight(self.objective_function)
         self._preflight(self.capital_cost_function)
         self._preflight(self.fixed_operating_cost_function)
@@ -167,7 +186,10 @@ class PlaceTurbines:
 
     def _preflight(self, eqn):
         """Run preflight checks on the equation string."""
-        for substr in self.ILLEGAL:
+        _illegal_substr = ('import ', 'os.', 'sys.', '.__', '__.', 'eval',
+                           'exec')
+
+        for substr in _illegal_substr:
             if substr in str(eqn):
                 msg = ('Will not evaluate string which contains "{}": {}'
                        .format(substr, eqn))
@@ -656,3 +678,10 @@ def _compute_nn_conn_dist(x_coords, y_coords):
         left_to_connect.mask[next_connection] = 1
 
     return total_dist
+
+
+def _fix_wp_keys(eqn):
+    """Surround key of `self.wind_plant` in quotes"""
+    pattern = r'(self\.wind_plant\[\s*)([^\]]+?)(\s*\])'
+    replacement = r'\1"\2"\3'
+    return re.sub(pattern, replacement, str(eqn))

reV/cli.py

@@ -10,7 +10,8 @@ from reV.generation.cli_gen import gen_command
 from reV.econ.cli_econ import econ_command
 from reV.handlers.cli_collect import collect_command
 from reV.handlers.cli_multi_year import my_command
-from reV.supply_curve.cli_sc_aggregation import sc_agg_command
+from reV.supply_curve.cli_sc_aggregation import (sc_agg_command,
+                                                 sc_col_descriptions)
 from reV.supply_curve.cli_supply_curve import sc_command
 from reV.supply_curve.cli_tech_mapping import tm_command
 from reV.rep_profiles.cli_rep_profiles import rep_profiles_command
@@ -31,6 +32,7 @@ commands = [bespoke_command, gen_command, econ_command, collect_command,
 main = make_cli(commands, info={"name": "reV", "version": __version__})
 main.add_command(qa_qc_extra)
 main.add_command(project_points)
+main.add_command(sc_col_descriptions)
 
 # export GAPs commands to namespace for documentation
 batch = main.commands["batch"]

reV/config/project_points.py

@@ -627,10 +627,14 @@ class ProjectPoints:
         # pylint: disable=no-member
         if SiteDataField.CONFIG not in df.columns:
             df[SiteDataField.CONFIG] = None
+        df[SiteDataField.CONFIG] = (df[SiteDataField.CONFIG]
+                                    .replace({np.nan: None}))
 
         # pylint: disable=no-member
         if SiteDataField.CURTAILMENT not in df.columns:
             df[SiteDataField.CURTAILMENT] = None
+        df[SiteDataField.CURTAILMENT] = (df[SiteDataField.CURTAILMENT]
+                                         .replace({np.nan: None}))
 
         gids = df[SiteDataField.GID].values
         if not np.array_equal(np.sort(gids), gids):

reV/supply_curve/cli_sc_aggregation.py

@@ -2,16 +2,21 @@
 """
 reV Supply Curve Aggregation CLI utility functions.
 """
-import os
 import logging
+from pathlib import Path
 
+import click
+import pandas as pd
+from rex import init_logger
 from rex.multi_file_resource import MultiFileResource
 from rex.utilities.utilities import check_res_file
 from gaps.cli import as_click_command, CLICommandFromClass
 
+from reV import __version__
 from reV.supply_curve.sc_aggregation import SupplyCurveAggregation
 from reV.utilities import ModuleName
-from reV.utilities.cli_functions import parse_from_pipeline
+from reV.utilities.cli_functions import (parse_from_pipeline,
+                                         compile_descriptions)
 from reV.utilities.exceptions import ConfigError
 
 
@@ -103,6 +108,38 @@ sc_agg_command = CLICommandFromClass(SupplyCurveAggregation, method="run",
 main = as_click_command(sc_agg_command)
 
 
+@click.command()
+@click.version_option(version=__version__)
+@click.option('--sc_fpath', '-sc', type=click.Path(), default=None,
+              help='Supply curve CSV file path used to subset the columns')
+@click.option('--out_fp', '-of', default=None, type=click.Path(),
+              help='Output CSV file for the column descriptions')
+@click.pass_context
+def sc_col_descriptions(ctx, sc_fpath, out_fp):
+    """Generate reV supply curve column descriptions"""
+    if ctx.obj.get('VERBOSE', False):
+        log_level = 'DEBUG'
+    else:
+        log_level = 'INFO'
+
+    init_logger('reV', log_level=log_level)
+
+    cols = []
+    if sc_fpath:
+        cols = pd.read_csv(sc_fpath, nrows=0).columns.tolist()
+
+    if not out_fp:
+        if sc_fpath:
+            sc_name = Path(sc_fpath).stem
+            out_fp = Path(sc_fpath).parent / f"{sc_name}_column_lookup.csv"
+        else:
+            out_fp = "rev_supply_curve_column_lookup.csv"
+
+    columns = compile_descriptions(cols)
+    columns.to_csv(out_fp, index=False)
+    logger.info("Column descriptions saved to %s", out_fp)
+
+
 if __name__ == '__main__':
     try:
         main(obj={})

reV/supply_curve/exclusions.py

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

reV/supply_curve/points.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# pylint: disable=anomalous-backslash-in-string
 """
 reV supply curve points frameworks.
 """
@@ -1452,8 +1453,12 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
     """Supply curve point summary framework that ties a reV SC point to its
     respective generation and resource data."""
 
-    # technology-dependent power density estimates in MW/km2
     POWER_DENSITY = {"pv": 36, "wind": 3}
+    """Technology-dependent power density estimates (in MW/km\ :sup:`2`).
+
+    The PV power density is a \**DC power density*\*, while the wind power
+    density is an \**AC power density*\*.
+    """
 
     def __init__(
         self,
@@ -2116,7 +2121,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             `None` for solar runs with "dc_ac_ratio" dataset in the
             generation file
         """
-        if self.power_density_ac is None:
+        if "dc_ac_ratio" not in self.gen.datasets:
             return None
 
         return self.area * self.power_density_ac
@@ -2138,7 +2143,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             `None` for solar runs with "dc_ac_ratio" dataset in the
             generation file
         """
-        if self.power_density_ac is None:
+        if "dc_ac_ratio" not in self.gen.datasets:
             return None
 
         return self.area * self.power_density

reV/supply_curve/sc_aggregation.py

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

reV/supply_curve/tech_mapping.py

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

reV/utilities/__init__.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 """reV utilities."""
-from enum import Enum
+import ast
+import inspect
+from enum import Enum, EnumMeta
 
 import PySAM
 from rex.utilities.loggers import log_versions as rex_log_versions
@@ -8,7 +10,50 @@ from rex.utilities.loggers import log_versions as rex_log_versions
 from reV.version import __version__
 
 
-class FieldEnum(str, Enum):
+class _DocstringEnumMeta(EnumMeta):
+    """Metaclass to assign docstrings to Enum members"""
+
+    def __new__(metacls, clsname, bases, clsdict):
+        cls = super().__new__(metacls, clsname, bases, clsdict)
+
+        try:
+            source = inspect.getsource(cls)
+        except TypeError:
+            return cls  # source not available (e.g., in interactive shell)
+
+        module = ast.parse(source)
+
+        for node in ast.iter_child_nodes(module):
+            if isinstance(node, ast.ClassDef) and node.name == cls.__name__:
+                prev = None
+                for body_item in node.body:
+                    if isinstance(body_item, ast.Assign):
+                        target = body_item.targets[0]
+                        if isinstance(target, ast.Name):
+                            name = target.id
+                            prev = body_item
+                    elif (isinstance(body_item, ast.Expr)
+                          and isinstance(body_item.value, ast.Constant)):
+                        if prev:
+                            doc = body_item.value.s
+                            member = cls.__members__.get(name)
+                            if member:
+                                member._description = (doc.strip()
+                                                       .replace("\n    ", " "))
+                            prev = None
+        return cls
+
+
+class DocEnum(Enum, metaclass=_DocstringEnumMeta):
+    """Base Enum class with docstring support"""
+
+    @property
+    def description(self):
+        """Description of enum member pulled from docstring"""
+        return getattr(self, '_description', None)
+
+
+class FieldEnum(str, DocEnum):
     """Base Field enum with some mapping methods."""
 
     @classmethod
@@ -118,90 +163,373 @@ class SupplyCurveField(FieldEnum):
 
     Not all of these columns are guaranteed in every supply-curve like
     output (e.g. "convex_hull_area" is a bespoke-only output).
+
+    The docstrings for each field are used as a description when
+    exporting metadata information about supply curve columns. See
+    TBA for details.
     """
 
+    # ############## #
+    # Shared outputs #
+    # ############## #
+
     SC_GID = "sc_gid"
+    """Supply curve GID (Specific to this particular supply curve output)"""
+
     LATITUDE = "latitude"
+    """Centroid latitude of the supply curve grid-cell"""
+
     LONGITUDE = "longitude"
+    """Centroid longitude of the supply curve grid-cell"""
+
     COUNTRY = "country"
+    """Country of the supply curve grid-cell"""
+
     STATE = "state"
+    """State of the supply curve grid-cell"""
+
     COUNTY = "county"
+    """County of the supply curve grid-cell"""
+
     ELEVATION = "elevation_m"
+    """Mean elevation of the supply curve grid-cell"""
+
     TIMEZONE = "timezone"
+    """
+    Timezone of supply curve grid-cell, expressed as an hourly offset from UTC
+    """
+
     SC_POINT_GID = "sc_point_gid"
+    """
+    Unique ID that can be used to match supply curve grid-cells across reV
+    supply curves at the same resolution
+    """
+
     SC_ROW_IND = "sc_row_ind"
+    """Supply curve grid-cell row ID (Invariant across supply curves)"""
+
     SC_COL_IND = "sc_col_ind"
+    """Supply curve grid-cell column ID (Invariant across supply curves)"""
+
     SOURCE_GIDS = "source_gids"
+
     RES_GIDS = "res_gids"
+    """List of resource GID's mapped to this supply curve grid-cells"""
+
     GEN_GIDS = "gen_gids"
+    """List of generation GID's mapped to this supply curve point"""
+
     GID_COUNTS = "gid_counts"
+    """
+    Number of high-resolution cells corresponding to each generation GID
+    for this supply curve point
+    """
+
     N_GIDS = "n_gids"
+    """
+    Total number of not fully excluded pixels associated with the available
+    resource/generation gids
+    """
+
     ZONE_ID = "zone_id"
+    """Zone ID of the supply curve grid-cell, if applicable. Defaults to 1."""
+
     MEAN_RES = "resource"
+    """
+    Mean resource (e.g. wind speed, gha, temperature, etc.) across the supply
+    curve grid-cell
+    """
+
     MEAN_CF_AC = "capacity_factor_ac"
+    """Mean capacity factor (AC) across supply curve grid-cell"""
+
     MEAN_CF_DC = "capacity_factor_dc"
+    """Mean capacity factor (DC) across supply curve grid-cell"""
+
     WAKE_LOSSES = "losses_wakes_pct"
+    """Mean wake losses across supply curve grid-cell"""
+
     MEAN_LCOE = "lcoe_site_usd_per_mwh"
+    """
+    Mean power plant levelized cost of energy across supply curve grid-cell
+    """
+
     CAPACITY_AC_MW = "capacity_ac_mw"
+    """
+    Capacity of system based on area_sq_km * AC capacity density assumption
+    """
+
     CAPACITY_DC_MW = "capacity_dc_mw"
+    """
+    Capacity of system based on area_sq_km * DC capacity density assumption
+    """
+
     OFFSHORE = "offshore"
+    """
+    Flag value indicating if the supply curve grid-cell is offshore (1)
+    or not (0)
+    """
+
     AREA_SQ_KM = "area_developable_sq_km"
+    """Developable area after spatial exclusions applied"""
+
     MEAN_FRICTION = "friction_site"
+
     MEAN_LCOE_FRICTION = "lcoe_friction_usd_per_mwh"
+
     RAW_LCOE = "lcoe_raw_usd_per_mwh"
+    """
+    Mean power plant levelized cost of energy across supply curve grid-cell
+    without any multipliers or economies of scale applied
+    """
+
     EOS_MULT = "multiplier_cc_eos"
+    """
+    Capital cost economies of Scale (EOS) multiplier value (defaults to `1`
+    if no EOS curve was specified)
+    """
+
     FIXED_EOS_MULT = "multiplier_foc_eos"
+    """
+    Fixed operating cost economies of Scale (EOS) multiplier value (defaults
+    to `1` if no EOS curve was specified)
+    """
+
     VAR_EOS_MULT = "multiplier_voc_eos"
+    """
+    Variable operating cost economies of Scale (EOS) multiplier value
+    (defaults to `1` if no EOS curve was specified)
+    """
+
     REG_MULT = "multiplier_cc_regional"
+    """
+    Regional capital cost multiplier to capture taxes, labor, land lease
+    regional differences
+    """
+
     SC_POINT_ANNUAL_ENERGY_MWH = "annual_energy_site_mwh"
+    """
+    Total annual energy for supply curve grid-cell (computed using
+    "capacity_ac_mw" and "capacity_factor_ac")
+    """
+
     COST_BASE_CC_USD_PER_AC_MW = "cost_base_cc_usd_per_ac_mw"
+    """
+    Included-area weighted capital cost for supply curve grid-cell with no
+    multipliers or economies of scale applied (defaults to `None` for
+    non-LCOE runs)
+    """
+
     COST_SITE_CC_USD_PER_AC_MW = "cost_site_cc_usd_per_ac_mw"
+    """
+    Included-area weighted capital cost for supply curve grid-cell
+    (defaults to `None` for non-LCOE runs)
+    """
+
     COST_BASE_FOC_USD_PER_AC_MW = "cost_base_foc_usd_per_ac_mw"
+    """
+    Included-area weighted fixed operating cost for supply curve grid-cell
+    with no multipliers or economies of scale applied (defaults to `None` for
+    non-LCOE runs)
+    """
+
     COST_SITE_FOC_USD_PER_AC_MW = "cost_site_foc_usd_per_ac_mw"
+    """
+    Included-area weighted fixed operating cost for supply curve grid-cell
+    (defaults to `None` for non-LCOE runs)
+    """
+
     COST_BASE_VOC_USD_PER_AC_MWH = "cost_base_voc_usd_per_ac_mwh"
+    """
+    Included-area weighted variable operating cost for supply curve grid-cell
+    with no multipliers or economies of scale applied (defaults to `None` for
+    non-LCOE runs)
+    """
+
     COST_SITE_VOC_USD_PER_AC_MWH = "cost_site_voc_usd_per_ac_mwh"
+    """
+    Included-area weighted variable operating cost for supply curve grid-cell
+    (defaults to `None` for non-LCOE runs)
+    """
+
     FIXED_CHARGE_RATE = "fixed_charge_rate"
+    """
+    Fixed charge rate used for LCOE computation
+    (defaults to `None` for non-LCOE runs)
+    """
+
+    # ############### #
+    # Bespoke outputs #
+    # ############### #
 
-    # Bespoke outputs
     POSSIBLE_X_COORDS = "possible_x_coords"
+    """
+    List of turbine x coordinates considered during layout optimization
+    (in meters relative to grid-cell)
+    """
+
     POSSIBLE_Y_COORDS = "possible_y_coords"
+    """
+    List of turbine y coordinates considered during layout optimization
+    (in meters relative to grid-cell)
+    """
+
     TURBINE_X_COORDS = "turbine_x_coords"
+    """
+    List of optimized layout turbine x coordinates
+    (in meters relative to grid-cell)
+    """
+
     TURBINE_Y_COORDS = "turbine_y_coords"
+    """
+    List of optimized layout turbine y coordinates
+    (in meters relative to grid-cell)
+    """
+
     N_TURBINES = "n_turbines"
+    """
+    Number of turbines in the optimized layout for this supply curve
+    grid-cell
+    """
+
     INCLUDED_AREA = "area_included_sq_km"
+    """Area available for wind turbine layout optimization"""
+
     INCLUDED_AREA_CAPACITY_DENSITY = (
         "capacity_density_included_area_mw_per_km2"
     )
+    """
+    Capacity density of the optimized wind plant layout defined using the
+    area available after removing the exclusions
+    """
+
     CONVEX_HULL_AREA = "area_convex_hull_sq_km"
+    """Area of the convex hull of the optimized wind plant layout"""
+
     CONVEX_HULL_CAPACITY_DENSITY = "capacity_density_convex_hull_mw_per_km2"
+    """
+    Capacity density of the optimized wind plant layout defined using the
+    convex hull area of the layout
+    """
+
     FULL_CELL_CAPACITY_DENSITY = "capacity_density_full_cell_mw_per_km2"
+    """
+    Capacity density of the optimized wind plant layout defined using the full
+    non-excluded area of the supply curve grid-cell
+    """
+
     BESPOKE_AEP = "optimized_plant_aep"
+    """
+    Annual energy production of the optimized wind plant layout computed using
+    wind speed/direction joint probability distribution (as opposed to
+    historical weather data)
+    """
+
     BESPOKE_OBJECTIVE = "optimized_plant_objective"
+    """
+    Objective function value of the optimized wind plant layout. This is
+    typically the LCOE computed using wind speed/direction joint probability
+    distribution (as opposed to historical weather data)
+    """
+
     BESPOKE_CAPITAL_COST = "optimized_plant_capital_cost"
+    """Capital cost of the optimized wind plant layout"""
+
     BESPOKE_FIXED_OPERATING_COST = "optimized_plant_fixed_operating_cost"
+    """Annual fixed operating cost of the optimized wind plant layout"""
+
     BESPOKE_VARIABLE_OPERATING_COST = "optimized_plant_variable_operating_cost"
+    """Variable operating cost of the optimized wind plant layout"""
+
     BESPOKE_BALANCE_OF_SYSTEM_COST = "optimized_plant_balance_of_system_cost"
+    """Balance of system cost of the optimized wind plant layout"""
+
+    # #################### #
+    # Transmission outputs #
+    # #################### #
 
-    # Transmission outputs
     TRANS_GID = "trans_gid"
+    """Transmission connection feature GID"""
+
     TRANS_TYPE = "trans_type"
+    """Transmission connection feature type"""
+
     TOTAL_LCOE_FRICTION = "lcoe_total_friction_usd_per_mwh"
     TRANS_CAPACITY = "trans_capacity"
+
     DIST_SPUR_KM = "dist_spur_km"
+    """
+    Distance between the grid-cell centroid and cheapest available electrical
+    substation. Used in lcot calculations.
+    """
+
     DIST_EXPORT_KM = "dist_export_km"
+    """Length of the offshore export cable"""
+
     REINFORCEMENT_DIST_KM = "dist_reinforcement_km"
-    TIE_LINE_COST_PER_MW = "cost_spur_usd_per_mw"
-    CONNECTION_COST_PER_MW = "cost_poi_usd_per_mw"
-    EXPORT_COST_PER_MW = "cost_export_usd_per_mw"
-    REINFORCEMENT_COST_PER_MW = "cost_reinforcement_usd_per_mw"
-    TOTAL_TRANS_CAP_COST_PER_MW = "cost_total_trans_usd_per_mw"
+    """
+    Distance between the connected substation and nearest regional load
+    center. Used in lcot calculations.
+    """
+
+    TIE_LINE_COST_PER_MW = "cost_spur_usd_per_mw_ac"
+    """
+    Cost of the spur line used to connect the grid-cell centroid with the
+    cheapest available electrical substation
+    """
+
+    CONNECTION_COST_PER_MW = "cost_poi_usd_per_mw_ac"
+    """Substation connection/upgrade/installation cost"""
+
+    EXPORT_COST_PER_MW = "cost_export_usd_per_mw_ac"
+    """Cost of the offshore export cable """
+
+    REINFORCEMENT_COST_PER_MW = "cost_reinforcement_usd_per_mw_ac"
+    """Non-levelized reinforcement transmission capital costs"""
+
+    TOTAL_TRANS_CAP_COST_PER_MW = "cost_total_trans_usd_per_mw_ac"
+    """
+    Non-levelized spur and point-of-interconnection transmission capital costs
+    """
+
     LCOT = "lcot_usd_per_mwh"
+    """
+    Levelized cost of transmission. Includes spur-transmission,
+    point-of-interconnection, and reinforcement costs.
+    """
+
     TOTAL_LCOE = "lcoe_all_in_usd_per_mwh"
+    """All-in LCOE. Includes site-lcoe + lcot"""
+
     N_PARALLEL_TRANS = "count_num_parallel_trans"
+    """
+    Number of parallel transmission lines connecting the grid-cell centroid
+    with the cheapest available electrical substation
+    """
+
     POI_LAT = "latitude_poi"
+    """
+    Latitude of the cheapest available electrical substation for the supply
+    curve grid-cell
+    """
+
     POI_LON = "longitude_poi"
+    """
+    Longitude of the cheapest available electrical substation for the supply
+    curve grid-cell
+    """
+
     REINFORCEMENT_POI_LAT = "latitude_reinforcement_poi"
+    """
+    Latitude of the nearest regional load center for the supply curve
+    grid-cell
+    """
+
     REINFORCEMENT_POI_LON = "longitude_reinforcement_poi"
+    """
+    Longitude of the nearest regional load center for the supply curve
+    grid-cell
+    """
 
     @classmethod
     def map_from_legacy(cls):
@@ -222,6 +550,11 @@ class SupplyCurveField(FieldEnum):
 
         return legacy_map
 
+    @property
+    def units(self):
+        """Units of the supply curve column, or ``"N/A"`` if not applicable"""
+        return _SC_UNITS.get(self, "N/A")
+
 
 class _LegacySCAliases(Enum):
     """Legacy supply curve column names.
@@ -243,10 +576,13 @@ class _LegacySCAliases(Enum):
     TRANS_CAPACITY = "avail_cap"
     DIST_SPUR_KM = "dist_km"
     REINFORCEMENT_DIST_KM = "reinforcement_dist_km"
-    TIE_LINE_COST_PER_MW = "tie_line_cost_per_mw"
-    CONNECTION_COST_PER_MW = "connection_cost_per_mw"
-    REINFORCEMENT_COST_PER_MW = "reinforcement_cost_per_mw"
-    TOTAL_TRANS_CAP_COST_PER_MW = "trans_cap_cost_per_mw"
+    TIE_LINE_COST_PER_MW = "tie_line_cost_per_mw", "cost_spur_usd_per_mw"
+    CONNECTION_COST_PER_MW = "connection_cost_per_mw", "cost_poi_usd_per_mw"
+    EXPORT_COST_PER_MW = "cost_export_usd_per_mw"
+    REINFORCEMENT_COST_PER_MW = ("reinforcement_cost_per_mw",
+                                 "cost_reinforcement_usd_per_mw")
+    TOTAL_TRANS_CAP_COST_PER_MW = ("trans_cap_cost_per_mw",
+                                   "cost_total_trans_usd_per_mw")
     LCOT = "lcot"
     TOTAL_LCOE = "total_lcoe"
     TOTAL_LCOE_FRICTION = "total_lcoe_friction"
@@ -332,3 +668,55 @@ def log_versions(logger):
     logger.info("Running with reV version {}".format(__version__))
     rex_log_versions(logger)
     logger.debug("- PySAM version {}".format(PySAM.__version__))
+
+
+_SC_UNITS = {
+    SupplyCurveField.ELEVATION: "m",
+    SupplyCurveField.LATITUDE: "degrees",
+    SupplyCurveField.LONGITUDE: "degrees",
+
+    SupplyCurveField.AREA_SQ_KM: "km2",
+    SupplyCurveField.CAPACITY_AC_MW: "MWac",
+    SupplyCurveField.CAPACITY_DC_MW: "MWdc",
+    SupplyCurveField.MEAN_CF_AC: "ratio",
+    SupplyCurveField.MEAN_CF_DC: "ratio",
+    SupplyCurveField.WAKE_LOSSES: "%",
+    SupplyCurveField.MEAN_LCOE: "$/MWh",
+    SupplyCurveField.RAW_LCOE: "$/MWh",
+    SupplyCurveField.SC_POINT_ANNUAL_ENERGY_MWH: "MWh",
+    SupplyCurveField.COST_BASE_CC_USD_PER_AC_MW: "$/MWac",
+    SupplyCurveField.COST_SITE_CC_USD_PER_AC_MW: "$/MWac",
+    SupplyCurveField.COST_BASE_FOC_USD_PER_AC_MW: "$/MWac",
+    SupplyCurveField.COST_SITE_FOC_USD_PER_AC_MW: "$/MWac",
+    SupplyCurveField.COST_BASE_VOC_USD_PER_AC_MWH: "$/MWh",
+    SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MWH: "$/MWh",
+
+    SupplyCurveField.BESPOKE_AEP: "MWh",
+    SupplyCurveField.BESPOKE_CAPITAL_COST: "$",
+    SupplyCurveField.BESPOKE_FIXED_OPERATING_COST: "$/year",
+    SupplyCurveField.BESPOKE_VARIABLE_OPERATING_COST: "$/kWh",
+    SupplyCurveField.BESPOKE_BALANCE_OF_SYSTEM_COST: "$",
+    SupplyCurveField.INCLUDED_AREA: "km2",
+    SupplyCurveField.INCLUDED_AREA_CAPACITY_DENSITY: "MW/km2",
+    SupplyCurveField.CONVEX_HULL_AREA: "km2",
+    SupplyCurveField.CONVEX_HULL_CAPACITY_DENSITY: "MW/km2",
+    SupplyCurveField.FULL_CELL_CAPACITY_DENSITY: "MW/km2",
+
+    SupplyCurveField.LCOT: "$/MWh",
+    SupplyCurveField.MEAN_RES: "varies",
+    SupplyCurveField.REINFORCEMENT_COST_PER_MW: "$/MWac",
+    SupplyCurveField.REINFORCEMENT_DIST_KM: "km",
+    SupplyCurveField.TOTAL_LCOE: "$/MWh",
+    SupplyCurveField.TOTAL_TRANS_CAP_COST_PER_MW: "$/MWac",
+    SupplyCurveField.DIST_SPUR_KM: "km",
+    SupplyCurveField.DIST_EXPORT_KM: "km",
+    SupplyCurveField.TIE_LINE_COST_PER_MW: "$/MWac",
+    SupplyCurveField.CONNECTION_COST_PER_MW: "$/MWac",
+    SupplyCurveField.EXPORT_COST_PER_MW: "$/MWac",
+
+    SupplyCurveField.POI_LAT: "degrees",
+    SupplyCurveField.POI_LON: "degrees",
+    SupplyCurveField.REINFORCEMENT_POI_LAT: "degrees",
+    SupplyCurveField.REINFORCEMENT_POI_LON: "degrees",
+
+}

reV/utilities/cli_functions.py

@@ -5,10 +5,11 @@ General CLI utility functions.
 import logging
 from warnings import warn
 
+import pandas as pd
 from gaps.pipeline import Status
 from rex.utilities.loggers import init_mult
 
-from reV.utilities import ModuleName
+from reV.utilities import ModuleName, SupplyCurveField
 from reV.utilities.exceptions import ConfigWarning, PipelineError
 
 
@@ -115,3 +116,44 @@ def parse_from_pipeline(config, out_dir, config_key, target_modules):
                     .format(config_key, val[0]))
 
     return config
+
+
+def compile_descriptions(cols=None):
+    """Compile a meta table with reV column descriptions.
+
+    Descriptions are pulled from the
+    :class:`~reV.utilities.SupplyCurveField` enum, which
+    contains the known reV supply curve field descriptions. Columns
+    which do not have a known description are excluded from the
+    output.
+
+    Parameters
+    ----------
+    cols : iterable, optional
+        Optional iterable of column names to include in the output.
+        By default, ``None``, which compiles all known reV supply curve
+        field descriptions.
+
+    Returns
+    -------
+    pd.DataFrame
+        Pandas DataFrame containing column names, corresponding units,
+        and descriptions for each column. Only columns that have a known
+        description are included in the output.
+    """
+    if not cols:
+        cols = [c.value for c in SupplyCurveField]
+
+    data = []
+    for col in cols:
+        try:
+            scf = SupplyCurveField(col)
+        except ValueError:
+            continue
+
+        if scf.description is None:
+            continue
+
+        data.append((str(scf), scf.units, scf.description))
+
+    return pd.DataFrame(data, columns=["reV Column", "Units", "Description"])

reV/version.py

@@ -2,4 +2,4 @@
 reV Version number
 """
 
-__version__ = "0.14.4"
+__version__ = "0.14.5"