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

reV/generation/generation.py

@@ -2,6 +2,7 @@
 """
 reV generation module.
 """
+
 import copy
 import json
 import logging
@@ -10,42 +11,46 @@ import pprint
 
 import numpy as np
 import pandas as pd
-
-from reV.generation.base import BaseGen
-from reV.SAM.generation import (Geothermal,
-                                MhkWave,
-                                LinearDirectSteam,
-                                PvSamv1,
-                                PvWattsv5,
-                                PvWattsv7,
-                                PvWattsv8,
-                                SolarWaterHeat,
-                                TcsMoltenSalt,
-                                TroughPhysicalHeat,
-                                WindPower)
-from reV.utilities import ModuleName
-from reV.utilities.exceptions import (ConfigError,
-                                      InputError,
-                                      ProjectPointsValueError)
 from rex.multi_file_resource import MultiFileResource
 from rex.multi_res_resource import MultiResolutionResource
 from rex.resource import Resource
 from rex.utilities.utilities import check_res_file
 
+from reV.generation.base import BaseGen
+from reV.SAM.generation import (
+    Geothermal,
+    LinearDirectSteam,
+    MhkWave,
+    PvSamv1,
+    PvWattsv5,
+    PvWattsv7,
+    PvWattsv8,
+    SolarWaterHeat,
+    TcsMoltenSalt,
+    TroughPhysicalHeat,
+    WindPower,
+)
+from reV.utilities import ModuleName, ResourceMetaField, SupplyCurveField
+from reV.utilities.exceptions import (
+    ConfigError,
+    InputError,
+    ProjectPointsValueError,
+)
+
 logger = logging.getLogger(__name__)
 
 
 ATTR_DIR = os.path.dirname(os.path.realpath(__file__))
-ATTR_DIR = os.path.join(ATTR_DIR, 'output_attributes')
-with open(os.path.join(ATTR_DIR, 'other.json'), 'r') as f:
+ATTR_DIR = os.path.join(ATTR_DIR, "output_attributes")
+with open(os.path.join(ATTR_DIR, "other.json")) as f:
     OTHER_ATTRS = json.load(f)
-with open(os.path.join(ATTR_DIR, 'generation.json'), 'r') as f:
+with open(os.path.join(ATTR_DIR, "generation.json")) as f:
     GEN_ATTRS = json.load(f)
-with open(os.path.join(ATTR_DIR, 'linear_fresnel.json'), 'r') as f:
+with open(os.path.join(ATTR_DIR, "linear_fresnel.json")) as f:
     LIN_ATTRS = json.load(f)
-with open(os.path.join(ATTR_DIR, 'solar_water_heat.json'), 'r') as f:
+with open(os.path.join(ATTR_DIR, "solar_water_heat.json")) as f:
     SWH_ATTRS = json.load(f)
-with open(os.path.join(ATTR_DIR, 'trough_heat.json'), 'r') as f:
+with open(os.path.join(ATTR_DIR, "trough_heat.json")) as f:
     TPPH_ATTRS = json.load(f)
 
 
@@ -53,17 +58,19 @@ class Gen(BaseGen):
     """Gen"""
 
     # Mapping of reV technology strings to SAM generation objects
-    OPTIONS = {'geothermal': Geothermal,
-               'lineardirectsteam': LinearDirectSteam,
-               'mhkwave': MhkWave,
-               'pvsamv1': PvSamv1,
-               'pvwattsv5': PvWattsv5,
-               'pvwattsv7': PvWattsv7,
-               'pvwattsv8': PvWattsv8,
-               'solarwaterheat': SolarWaterHeat,
-               'tcsmoltensalt': TcsMoltenSalt,
-               'troughphysicalheat': TroughPhysicalHeat,
-               'windpower': WindPower}
+    OPTIONS = {
+        "geothermal": Geothermal,
+        "lineardirectsteam": LinearDirectSteam,
+        "mhkwave": MhkWave,
+        "pvsamv1": PvSamv1,
+        "pvwattsv5": PvWattsv5,
+        "pvwattsv7": PvWattsv7,
+        "pvwattsv8": PvWattsv8,
+        "solarwaterheat": SolarWaterHeat,
+        "tcsmoltensalt": TcsMoltenSalt,
+        "troughphysicalheat": TroughPhysicalHeat,
+        "windpower": WindPower,
+    }
 
     """reV technology options."""
 
@@ -76,13 +83,25 @@ class Gen(BaseGen):
     OUT_ATTRS.update(TPPH_ATTRS)
     OUT_ATTRS.update(BaseGen.ECON_ATTRS)
 
-    def __init__(self, technology, project_points, sam_files, resource_file,
-                 low_res_resource_file=None, output_request=('cf_mean',),
-                 site_data=None, curtailment=None, gid_map=None,
-                 drop_leap=False, sites_per_worker=None,
-                 memory_utilization_limit=0.4, scale_outputs=True,
-                 write_mapped_gids=False, bias_correct=None):
-        """reV generation analysis class.
+    def __init__(
+        self,
+        technology,
+        project_points,
+        sam_files,
+        resource_file,
+        low_res_resource_file=None,
+        output_request=("cf_mean",),
+        site_data=None,
+        curtailment=None,
+        gid_map=None,
+        drop_leap=False,
+        sites_per_worker=None,
+        memory_utilization_limit=0.4,
+        scale_outputs=True,
+        write_mapped_gids=False,
+        bias_correct=None,
+    ):
+        """ReV generation analysis class.
 
         ``reV`` generation analysis runs SAM simulations by piping in
         renewable energy resource data (usually from the NSRDB or WTK),
@@ -121,14 +140,14 @@ class Gen(BaseGen):
         {'cf_mean': array([0.16966143], dtype=float32)}
         >>>
         >>> sites = [3, 4, 7, 9]
-        >>> req = ('cf_mean', 'cf_profile', 'lcoe_fcr')
+        >>> req = ('cf_mean', 'lcoe_fcr')
         >>> gen = Gen(sam_tech, sites, fp_sam, fp_res, output_request=req)
         >>> 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 ]),
-        'cf_profile': array([[0., 0., 0., 0.],
+         'cf_mean': array([0.17713654, 0.17724372, 0.1824783 , 0.1854574 ]),
+        : array([[0., 0., 0., 0.],
                 [0., 0., 0., 0.],
                 [0., 0., 0., 0.],
                 ...,
@@ -289,7 +308,17 @@ class Gen(BaseGen):
             site-specific values. Note that some or all site-specific
             inputs can be specified via the `project_points` input
             table instead. If ``None``, no site-specific data is
-            considered. By default, ``None``.
+            considered.
+
+            .. Note:: This input is often used to provide site-based
+               regional capital cost multipliers. ``reV`` does not
+               ingest multipliers directly; instead, this file is
+               expected to have a ``capital_cost`` column that gives the
+               multiplier-adjusted capital cost value for each location.
+               Therefore, you *must* re-create this input file every
+               time you change your base capital cost assumption.
+
+            By default, ``None``.
         curtailment : dict | str, optional
             Inputs for curtailment parameters, which can be:
 
@@ -351,22 +380,33 @@ class Gen(BaseGen):
             ``bias_correct`` table on a site-by-site basis. If ``None``, no
             corrections are applied. By default, ``None``.
         """
-        pc = self.get_pc(points=project_points, points_range=None,
-                         sam_configs=sam_files, tech=technology,
-                         sites_per_worker=sites_per_worker,
-                         res_file=resource_file,
-                         curtailment=curtailment)
-
-        super().__init__(pc, output_request, site_data=site_data,
-                         drop_leap=drop_leap,
-                         memory_utilization_limit=memory_utilization_limit,
-                         scale_outputs=scale_outputs)
+        pc = self.get_pc(
+            points=project_points,
+            points_range=None,
+            sam_configs=sam_files,
+            tech=technology,
+            sites_per_worker=sites_per_worker,
+            res_file=resource_file,
+            curtailment=curtailment,
+        )
+
+        super().__init__(
+            pc,
+            output_request,
+            site_data=site_data,
+            drop_leap=drop_leap,
+            memory_utilization_limit=memory_utilization_limit,
+            scale_outputs=scale_outputs,
+        )
 
         if self.tech not in self.OPTIONS:
-            msg = ('Requested technology "{}" is not available. '
-                   'reV generation can analyze the following '
-                   'SAM technologies: {}'
-                   .format(self.tech, list(self.OPTIONS.keys())))
+            msg = (
+                'Requested technology "{}" is not available. '
+                "reV generation can analyze the following "
+                "SAM technologies: {}".format(
+                    self.tech, list(self.OPTIONS.keys())
+                )
+            )
             logger.error(msg)
             raise KeyError(msg)
 
@@ -374,8 +414,8 @@ class Gen(BaseGen):
         self._res_file = resource_file
         self._lr_res_file = low_res_resource_file
         self._sam_module = self.OPTIONS[self.tech]
-        self._run_attrs['sam_module'] = self._sam_module.MODULE
-        self._run_attrs['res_file'] = resource_file
+        self._run_attrs["sam_module"] = self._sam_module.MODULE
+        self._run_attrs["res_file"] = resource_file
 
         self._multi_h5_res, self._hsds = check_res_file(resource_file)
         self._gid_map = self._parse_gid_map(gid_map)
@@ -414,11 +454,12 @@ 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 'gid' column is added.
+            non-sequential or do not start from 0, so a `SupplyCurveField.GID`
+            column is added.
         """
         if self._meta is None:
             res_cls = Resource
-            kwargs = {'hsds': self._hsds}
+            kwargs = {"hsds": self._hsds}
             if self._multi_h5_res:
                 res_cls = MultiFileResource
                 kwargs = {}
@@ -428,25 +469,28 @@ class Gen(BaseGen):
                 res_gids = [self._gid_map[i] for i in res_gids]
 
             with res_cls(self.res_file, **kwargs) as res:
-                meta_len = res.shapes['meta'][0]
+                meta_len = res.shapes["meta"][0]
 
                 if np.max(res_gids) > meta_len:
-                    msg = ('ProjectPoints has a max site gid of {} which is '
-                           'out of bounds for the meta data of len {} from '
-                           'resource file: {}'
-                           .format(np.max(res_gids),
-                                   meta_len, self.res_file))
+                    msg = (
+                        "ProjectPoints has a max site gid of {} which is "
+                        "out of bounds for the meta data of len {} from "
+                        "resource file: {}".format(
+                            np.max(res_gids), meta_len, self.res_file
+                        )
+                    )
                     logger.error(msg)
                     raise ProjectPointsValueError(msg)
 
-                self._meta = res['meta', res_gids]
+                self._meta = res["meta", res_gids]
 
-            self._meta.loc[:, 'gid'] = res_gids
+            self._meta.loc[:, ResourceMetaField.GID] = res_gids
             if self.write_mapped_gids:
-                self._meta.loc[:, 'gid'] = self.project_points.sites
+                sites = self.project_points.sites
+                self._meta.loc[:, ResourceMetaField.GID] = sites
             self._meta.index = self.project_points.sites
-            self._meta.index.name = 'gid'
-            self._meta.loc[:, 'reV_tech'] = self.project_points.tech
+            self._meta.index.name = ResourceMetaField.GID
+            self._meta.loc[:, "reV_tech"] = self.project_points.tech
 
         return self._meta
 
@@ -462,7 +506,7 @@ class Gen(BaseGen):
         if self._time_index is None:
             if not self._multi_h5_res:
                 res_cls = Resource
-                kwargs = {'hsds': self._hsds}
+                kwargs = {"hsds": self._hsds}
             else:
                 res_cls = MultiFileResource
                 kwargs = {}
@@ -474,19 +518,22 @@ class Gen(BaseGen):
             step = self.project_points.sam_config_obj.time_index_step
             if downscale is not None:
                 from rex.utilities.downscale import make_time_index
+
                 year = time_index.year[0]
-                ds_freq = downscale['frequency']
+                ds_freq = downscale["frequency"]
                 time_index = make_time_index(year, ds_freq)
-                logger.info('reV solar generation running with temporal '
-                            'downscaling frequency "{}" with final '
-                            'time_index length {}'
-                            .format(ds_freq, len(time_index)))
+                logger.info(
+                    "reV solar generation running with temporal "
+                    'downscaling frequency "{}" with final '
+                    "time_index length {}".format(ds_freq, len(time_index))
+                )
             elif step is not None:
                 time_index = time_index[::step]
 
             time_index = self.handle_lifetime_index(time_index)
-            time_index = self.handle_leap_ti(time_index,
-                                             drop_leap=self._drop_leap)
+            time_index = self.handle_leap_ti(
+                time_index, drop_leap=self._drop_leap
+            )
 
             self._time_index = time_index
 
@@ -520,30 +567,32 @@ class Gen(BaseGen):
         # Only one time index may be passed, check that lifetime periods match
         n_unique_periods = len(np.unique(lifetime_periods))
         if n_unique_periods != 1:
-            msg = ('reV cannot handle multiple analysis_periods when '
-                   'modeling with `system_use_lifetime_output` set '
-                   'to 1. Found {} different analysis_periods in the SAM '
-                   'configs'.format(n_unique_periods))
+            msg = (
+                "reV cannot handle multiple analysis_periods when "
+                "modeling with `system_use_lifetime_output` set "
+                "to 1. Found {} different analysis_periods in the SAM "
+                "configs".format(n_unique_periods)
+            )
             logger.error(msg)
             raise ConfigError(msg)
 
         # Collect requested variables to check for lifetime compatibility
         array_vars = [
-            var for var, attrs in GEN_ATTRS.items()
-            if attrs['type'] == 'array'
+            var for var, attrs in GEN_ATTRS.items() if attrs["type"] == "array"
         ]
-        valid_vars = ['gen_profile', 'cf_profile', 'cf_profile_ac']
+        valid_vars = ["gen_profile", "cf_profile", "cf_profile_ac"]
         invalid_vars = set(array_vars) - set(valid_vars)
-        invalid_requests = [var for var in self.output_request
-                            if var in invalid_vars]
+        invalid_requests = [
+            var for var in self.output_request if var in invalid_vars
+        ]
 
         if invalid_requests:
             # SAM does not output full lifetime for all array variables
             msg = (
-                'reV can only handle the following output arrays '
-                'when modeling with `system_use_lifetime_output` set '
-                'to 1: {}. Try running without {}.'.format(
-                    ', '.join(valid_vars), ', '.join(invalid_requests)
+                "reV can only handle the following output arrays "
+                "when modeling with `system_use_lifetime_output` set "
+                "to 1: {}. Try running without {}.".format(
+                    ", ".join(valid_vars), ", ".join(invalid_requests)
                 )
             )
             logger.error(msg)
@@ -551,8 +600,10 @@ class Gen(BaseGen):
 
         sam_meta = self.sam_metas[next(iter(self.sam_metas))]
         analysis_period = sam_meta["analysis_period"]
-        logger.info('reV generation running with a full system '
-                    'life of {} years.'.format(analysis_period))
+        logger.info(
+            "reV generation running with a full system "
+            "life of {} years.".format(analysis_period)
+        )
 
         old_end = ti[-1]
         new_end = old_end + pd.DateOffset(years=analysis_period - 1)
@@ -563,10 +614,18 @@ class Gen(BaseGen):
         return ti
 
     @classmethod
-    def _run_single_worker(cls, points_control, tech=None, res_file=None,
-                           lr_res_file=None, output_request=None,
-                           scale_outputs=True, gid_map=None, nn_map=None,
-                           bias_correct=None):
+    def _run_single_worker(
+        cls,
+        points_control,
+        tech=None,
+        res_file=None,
+        lr_res_file=None,
+        output_request=None,
+        scale_outputs=True,
+        gid_map=None,
+        nn_map=None,
+        bias_correct=None,
+    ):
         """Run a SAM generation analysis based on the points_control iterator.
 
         Parameters
@@ -627,21 +686,24 @@ class Gen(BaseGen):
 
         # Extract the site df from the project points df.
         site_df = points_control.project_points.df
-        site_df = site_df.set_index('gid', drop=True)
+        site_df = site_df.set_index(ResourceMetaField.GID, drop=True)
 
         # run generation method for specified technology
         try:
             out = cls.OPTIONS[tech].reV_run(
-                points_control, res_file, site_df,
+                points_control,
+                res_file,
+                site_df,
                 lr_res_file=lr_res_file,
                 output_request=output_request,
-                gid_map=gid_map, nn_map=nn_map,
-                bias_correct=bias_correct
+                gid_map=gid_map,
+                nn_map=nn_map,
+                bias_correct=bias_correct,
             )
 
         except Exception as e:
             out = {}
-            logger.exception('Worker failed for PC: {}'.format(points_control))
+            logger.exception("Worker failed for PC: {}".format(points_control))
             raise e
 
         if scale_outputs:
@@ -651,8 +713,8 @@ class Gen(BaseGen):
                     # iterate through variable names in each site's output dict
                     if k in cls.OUT_ATTRS:
                         # 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)
+                        dtype = cls.OUT_ATTRS[k].get("dtype", "float32")
+                        scale_factor = cls.OUT_ATTRS[k].get("scale_factor", 1)
 
                         # apply scale factor and dtype
                         out[site][k] *= scale_factor
@@ -666,8 +728,9 @@ class Gen(BaseGen):
                             out[site][k] = out[site][k].astype(dtype)
                         else:
                             # use numpy array conversion for scalar values
-                            out[site][k] = np.array([out[site][k]],
-                                                    dtype=dtype)[0]
+                            out[site][k] = np.array(
+                                [out[site][k]], dtype=dtype
+                            )[0]
 
         return out
 
@@ -691,44 +754,56 @@ class Gen(BaseGen):
         """
 
         if isinstance(gid_map, str):
-            if gid_map.endswith('.csv'):
+            if gid_map.endswith(".csv"):
                 gid_map = pd.read_csv(gid_map).to_dict()
-                assert 'gid' in gid_map, 'Need "gid" in gid_map column'
-                assert 'gid_map' in gid_map, 'Need "gid_map" in gid_map column'
-                gid_map = {gid_map['gid'][i]: gid_map['gid_map'][i]
-                           for i in gid_map['gid'].keys()}
+                msg = f"Need {ResourceMetaField.GID} in gid_map column"
+                assert ResourceMetaField.GID in gid_map, msg
+                assert "gid_map" in gid_map, 'Need "gid_map" in gid_map column'
+                gid_map = {
+                    gid_map[ResourceMetaField.GID][i]: gid_map["gid_map"][i]
+                    for i in gid_map[ResourceMetaField.GID].keys()
+                }
 
-            elif gid_map.endswith('.json'):
-                with open(gid_map, 'r') as f:
+            elif gid_map.endswith(".json"):
+                with open(gid_map) as f:
                     gid_map = json.load(f)
 
         if isinstance(gid_map, dict):
             if not self._multi_h5_res:
                 res_cls = Resource
-                kwargs = {'hsds': self._hsds}
+                kwargs = {"hsds": self._hsds}
             else:
                 res_cls = MultiFileResource
                 kwargs = {}
 
             with res_cls(self.res_file, **kwargs) as res:
                 for gen_gid, res_gid in gid_map.items():
-                    msg1 = ('gid_map values must all be int but received '
-                            '{}: {}'.format(gen_gid, res_gid))
-                    msg2 = ('Could not find the gen_gid to res_gid mapping '
-                            '{}: {} in the resource meta data.'
-                            .format(gen_gid, res_gid))
+                    msg1 = (
+                        "gid_map values must all be int but received "
+                        "{}: {}".format(gen_gid, res_gid)
+                    )
+                    msg2 = (
+                        "Could not find the gen_gid to res_gid mapping "
+                        "{}: {} in the resource meta data.".format(
+                            gen_gid, res_gid
+                        )
+                    )
                     assert isinstance(gen_gid, int), msg1
                     assert isinstance(res_gid, int), msg1
                     assert res_gid in res.meta.index.values, msg2
 
                 for gen_gid in self.project_points.sites:
-                    msg3 = ('Could not find the project points gid {} in the '
-                            'gen_gid input of the gid_map.'.format(gen_gid))
+                    msg3 = (
+                        "Could not find the project points gid {} in the "
+                        "gen_gid input of the gid_map.".format(gen_gid)
+                    )
                     assert gen_gid in gid_map, msg3
 
         elif gid_map is not None:
-            msg = ('Could not parse gid_map, must be None, dict, or path to '
-                   'csv or json, but received: {}'.format(gid_map))
+            msg = (
+                "Could not parse gid_map, must be None, dict, or path to "
+                "csv or json, but received: {}".format(gid_map)
+            )
             logger.error(msg)
             raise InputError(msg)
 
@@ -748,24 +823,32 @@ class Gen(BaseGen):
         """
         nn_map = None
         if self.lr_res_file is not None:
-
             handler_class = Resource
-            if '*' in self.res_file or '*' in self.lr_res_file:
+            if "*" in self.res_file or "*" in self.lr_res_file:
                 handler_class = MultiFileResource
 
-            with handler_class(self.res_file) as hr_res:
-                with handler_class(self.lr_res_file) as lr_res:
-                    logger.info('Making nearest neighbor map for multi '
-                                'resolution resource data...')
-                    nn_d, nn_map = MultiResolutionResource.make_nn_map(hr_res,
-                                                                       lr_res)
-                    logger.info('Done making nearest neighbor map for multi '
-                                'resolution resource data!')
+            with handler_class(self.res_file) as hr_res, handler_class(
+                self.lr_res_file
+            ) as lr_res:
+                logger.info(
+                    "Making nearest neighbor map for multi "
+                    "resolution resource data..."
+                )
+                nn_d, nn_map = MultiResolutionResource.make_nn_map(
+                    hr_res, lr_res
+                )
+                logger.info(
+                    "Done making nearest neighbor map for multi "
+                    "resolution resource data!"
+                )
 
-            logger.info('Made nearest neighbor mapping between nominal-'
-                        'resolution and low-resolution resource files. '
-                        'Min / mean / max dist: {:.3f} / {:.3f} / {:.3f}'
-                        .format(nn_d.min(), nn_d.mean(), nn_d.max()))
+            logger.info(
+                "Made nearest neighbor mapping between nominal-"
+                "resolution and low-resolution resource files. "
+                "Min / mean / max dist: {:.3f} / {:.3f} / {:.3f}".format(
+                    nn_d.min(), nn_d.mean(), nn_d.max()
+                )
+            )
 
         return nn_map
 
@@ -819,23 +902,34 @@ class Gen(BaseGen):
         if isinstance(bias_correct, type(None)):
             return bias_correct
 
-        elif isinstance(bias_correct, str):
-            bias_correct = pd.read_csv(bias_correct)
+        if isinstance(bias_correct, str):
+            bias_correct = pd.read_csv(bias_correct).rename(
+                SupplyCurveField.map_to(ResourceMetaField), axis=1
+            )
 
-        msg = ('Bias correction data must be a filepath to csv or a dataframe '
-               'but received: {}'.format(type(bias_correct)))
+        msg = (
+            "Bias correction data must be a filepath to csv or a dataframe "
+            "but received: {}".format(type(bias_correct))
+        )
         assert isinstance(bias_correct, pd.DataFrame), msg
 
-        msg = ('Bias correction table must have "gid" column but only found: '
-               '{}'.format(list(bias_correct.columns)))
-        assert 'gid' in bias_correct or bias_correct.index.name == 'gid', msg
+        msg = (
+            "Bias correction table must have {!r} column but only found: "
+            "{}".format(ResourceMetaField.GID, list(bias_correct.columns))
+        )
+        assert (
+            ResourceMetaField.GID in bias_correct
+            or bias_correct.index.name == ResourceMetaField.GID
+        ), msg
 
-        if bias_correct.index.name != 'gid':
-            bias_correct = bias_correct.set_index('gid')
+        if bias_correct.index.name != ResourceMetaField.GID:
+            bias_correct = bias_correct.set_index(ResourceMetaField.GID)
 
-        msg = ('Bias correction table must have "method" column but only '
-               'found: {}'.format(list(bias_correct.columns)))
-        assert 'method' in bias_correct, msg
+        msg = (
+            'Bias correction table must have "method" column but only '
+            "found: {}".format(list(bias_correct.columns))
+        )
+        assert "method" in bias_correct, msg
 
         return bias_correct
 
@@ -856,13 +950,15 @@ class Gen(BaseGen):
         output_request = self._output_request_type_check(req)
 
         # ensure that cf_mean is requested from output
-        if 'cf_mean' not in output_request:
-            output_request.append('cf_mean')
+        if "cf_mean" not in output_request:
+            output_request.append("cf_mean")
 
         for request in output_request:
             if request not in self.OUT_ATTRS:
-                msg = ('User output request "{}" not recognized. '
-                       'Will attempt to extract from PySAM.'.format(request))
+                msg = (
+                    'User output request "{}" not recognized. '
+                    "Will attempt to extract from PySAM.".format(request)
+                )
                 logger.debug(msg)
 
         return list(set(output_request))
@@ -886,20 +982,19 @@ class Gen(BaseGen):
         """
 
         gids = pc.project_points.gids
-        gid_map = kwargs.get('gid_map', None)
-        bias_correct = kwargs.get('bias_correct', None)
+        gid_map = kwargs.get("gid_map", None)
+        bias_correct = kwargs.get("bias_correct", None)
 
         if bias_correct is not None:
             if gid_map is not None:
                 gids = [gid_map[gid] for gid in gids]
 
             mask = bias_correct.index.isin(gids)
-            kwargs['bias_correct'] = bias_correct[mask]
+            kwargs["bias_correct"] = bias_correct[mask]
 
         return kwargs
 
-    def run(self, out_fpath=None, max_workers=1, timeout=1800,
-            pool_size=None):
+    def run(self, out_fpath=None, max_workers=1, timeout=1800, pool_size=None):
         """Execute a parallel reV generation run with smart data flushing.
 
         Parameters
@@ -937,45 +1032,68 @@ class Gen(BaseGen):
         if pool_size is None:
             pool_size = os.cpu_count() * 2
 
-        kwargs = {'tech': self.tech,
-                  'res_file': self.res_file,
-                  'lr_res_file': self.lr_res_file,
-                  'output_request': self.output_request,
-                  'scale_outputs': self.scale_outputs,
-                  'gid_map': self._gid_map,
-                  'nn_map': self._nn_map,
-                  'bias_correct': self._bc}
-
-        logger.info('Running reV generation for: {}'
-                    .format(self.points_control))
-        logger.debug('The following project points were specified: "{}"'
-                     .format(self.project_points))
-        logger.debug('The following SAM configs are available to this run:\n{}'
-                     .format(pprint.pformat(self.sam_configs, indent=4)))
-        logger.debug('The SAM output variables have been requested:\n{}'
-                     .format(self.output_request))
+        kwargs = {
+            "tech": self.tech,
+            "res_file": self.res_file,
+            "lr_res_file": self.lr_res_file,
+            "output_request": self.output_request,
+            "scale_outputs": self.scale_outputs,
+            "gid_map": self._gid_map,
+            "nn_map": self._nn_map,
+            "bias_correct": self._bc,
+        }
+
+        logger.info(
+            "Running reV generation for: {}".format(self.points_control)
+        )
+        logger.debug(
+            'The following project points were specified: "{}"'.format(
+                self.project_points
+            )
+        )
+        logger.debug(
+            "The following SAM configs are available to this run:\n{}".format(
+                pprint.pformat(self.sam_configs, indent=4)
+            )
+        )
+        logger.debug(
+            "The SAM output variables have been requested:\n{}".format(
+                self.output_request
+            )
+        )
 
         # use serial or parallel execution control based on max_workers
         try:
             if max_workers == 1:
-                logger.debug('Running serial generation for: {}'
-                             .format(self.points_control))
+                logger.debug(
+                    "Running serial generation for: {}".format(
+                        self.points_control
+                    )
+                )
                 for i, pc_sub in enumerate(self.points_control):
                     self.out = self._run_single_worker(pc_sub, **kwargs)
-                    logger.info('Finished reV gen serial compute for: {} '
-                                '(iteration {} out of {})'
-                                .format(pc_sub, i + 1,
-                                        len(self.points_control)))
+                    logger.info(
+                        "Finished reV gen serial compute for: {} "
+                        "(iteration {} out of {})".format(
+                            pc_sub, i + 1, len(self.points_control)
+                        )
+                    )
                 self.flush()
             else:
-                logger.debug('Running parallel generation for: {}'
-                             .format(self.points_control))
-                self._parallel_run(max_workers=max_workers,
-                                   pool_size=pool_size, timeout=timeout,
-                                   **kwargs)
+                logger.debug(
+                    "Running parallel generation for: {}".format(
+                        self.points_control
+                    )
+                )
+                self._parallel_run(
+                    max_workers=max_workers,
+                    pool_size=pool_size,
+                    timeout=timeout,
+                    **kwargs,
+                )
 
         except Exception as e:
-            logger.exception('reV generation failed!')
+            logger.exception("reV generation failed!")
             raise e
 
         return self._out_fpath