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

reV/econ/econ.py

@@ -1,26 +1,24 @@
 # -*- coding: utf-8 -*-
-"""
-reV econ module (lcoe-fcr, single owner, etc...)
-"""
+"""reV econ module (lcoe-fcr, single owner, etc...)"""
 import logging
-import numpy as np
 import os
-import pandas as pd
 import pprint
 from warnings import warn
 
+import numpy as np
+import pandas as pd
+from rex.multi_file_resource import MultiFileResource
+from rex.resource import Resource
+from rex.utilities.utilities import check_res_file
+
 from reV.config.project_points import PointsControl
 from reV.generation.base import BaseGen
 from reV.handlers.outputs import Outputs
 from reV.SAM.econ import LCOE as SAM_LCOE
 from reV.SAM.econ import SingleOwner
 from reV.SAM.windbos import WindBos
-from reV.utilities.exceptions import (ExecutionError, OffshoreWindInputWarning)
-from reV.utilities import ModuleName
-
-from rex.resource import Resource
-from rex.multi_file_resource import MultiFileResource
-from rex.utilities.utilities import check_res_file
+from reV.utilities import ModuleName, ResourceMetaField
+from reV.utilities.exceptions import ExecutionError, OffshoreWindInputWarning
 
 logger = logging.getLogger(__name__)
 
@@ -29,22 +27,23 @@ class Econ(BaseGen):
     """Econ"""
 
     # Mapping of reV econ output strings to SAM econ modules
-    OPTIONS = {'lcoe_fcr': SAM_LCOE,
-               'ppa_price': SingleOwner,
-               'project_return_aftertax_npv': SingleOwner,
-               'lcoe_real': SingleOwner,
-               'lcoe_nom': SingleOwner,
-               'flip_actual_irr': SingleOwner,
-               'gross_revenue': SingleOwner,
-               'total_installed_cost': WindBos,
-               'turbine_cost': WindBos,
-               'sales_tax_cost': WindBos,
-               'bos_cost': WindBos,
-               'fixed_charge_rate': SAM_LCOE,
-               'capital_cost': SAM_LCOE,
-               'fixed_operating_cost': SAM_LCOE,
-               'variable_operating_cost': SAM_LCOE,
-               }
+    OPTIONS = {
+        "lcoe_fcr": SAM_LCOE,
+        "ppa_price": SingleOwner,
+        "project_return_aftertax_npv": SingleOwner,
+        "lcoe_real": SingleOwner,
+        "lcoe_nom": SingleOwner,
+        "flip_actual_irr": SingleOwner,
+        "gross_revenue": SingleOwner,
+        "total_installed_cost": WindBos,
+        "turbine_cost": WindBos,
+        "sales_tax_cost": WindBos,
+        "bos_cost": WindBos,
+        "fixed_charge_rate": SAM_LCOE,
+        "capital_cost": SAM_LCOE,
+        "fixed_operating_cost": SAM_LCOE,
+        "variable_operating_cost": SAM_LCOE,
+    }
     """Available ``reV`` econ `output_request` options"""
 
     # Mapping of reV econ outputs to scale factors and units.
@@ -54,7 +53,7 @@ class Econ(BaseGen):
     def __init__(self, project_points, sam_files, cf_file, site_data=None,
                  output_request=('lcoe_fcr',), sites_per_worker=100,
                  memory_utilization_limit=0.4, append=False):
-        """reV econ analysis class.
+        """ReV econ analysis class.
 
         ``reV`` econ analysis runs SAM econ calculations, typically to
         compute LCOE (using :py:class:`PySAM.Lcoefcr.Lcoefcr`), though
@@ -176,17 +175,26 @@ class Econ(BaseGen):
         """
 
         # get a points control instance
-        pc = self.get_pc(points=project_points, points_range=None,
-                         sam_configs=sam_files, cf_file=cf_file,
-                         sites_per_worker=sites_per_worker, append=append)
-
-        super().__init__(pc, output_request, site_data=site_data,
-                         memory_utilization_limit=memory_utilization_limit)
+        pc = self.get_pc(
+            points=project_points,
+            points_range=None,
+            sam_configs=sam_files,
+            cf_file=cf_file,
+            sites_per_worker=sites_per_worker,
+            append=append,
+        )
+
+        super().__init__(
+            pc,
+            output_request,
+            site_data=site_data,
+            memory_utilization_limit=memory_utilization_limit,
+        )
 
         self._cf_file = cf_file
         self._append = append
-        self._run_attrs['cf_file'] = cf_file
-        self._run_attrs['sam_module'] = self._sam_module.MODULE
+        self._run_attrs["cf_file"] = cf_file
+        self._run_attrs["sam_module"] = self._sam_module.MODULE
 
     @property
     def cf_file(self):
@@ -212,19 +220,20 @@ class Econ(BaseGen):
             with Outputs(self.cf_file) as cfh:
                 # only take meta that belongs to this project's site list
                 self._meta = cfh.meta[
-                    cfh.meta['gid'].isin(self.points_control.sites)]
+                    cfh.meta[ResourceMetaField.GID].isin(
+                        self.points_control.sites)]
 
-            if 'offshore' in self._meta:
-                if self._meta['offshore'].sum() > 1:
-                    w = ('Found offshore sites in econ meta data. '
-                         'This functionality has been deprecated. '
-                         'Please run the reV offshore module to '
-                         'calculate offshore wind lcoe.')
-                    warn(w, OffshoreWindInputWarning)
-                    logger.warning(w)
+            if ("offshore" in self._meta and self._meta["offshore"].sum() > 1):
+                w = ('Found offshore sites in econ meta data. '
+                     'This functionality has been deprecated. '
+                     'Please run the reV offshore module to '
+                     'calculate offshore wind lcoe.')
+                warn(w, OffshoreWindInputWarning)
+                logger.warning(w)
 
         elif self._meta is None and self.cf_file is None:
-            self._meta = pd.DataFrame({'gid': self.points_control.sites})
+            self._meta = pd.DataFrame(
+                {ResourceMetaField.GID: self.points_control.sites})
 
         return self._meta
 
@@ -233,7 +242,7 @@ class Econ(BaseGen):
         """Get the generation resource time index data."""
         if self._time_index is None and self.cf_file is not None:
             with Outputs(self.cf_file) as cfh:
-                if 'time_index' in cfh.datasets:
+                if "time_index" in cfh.datasets:
                     self._time_index = cfh.time_index
 
         return self._time_index
@@ -264,11 +273,11 @@ class Econ(BaseGen):
             res_kwargs = {}
         else:
             res_cls = Resource
-            res_kwargs = {'hsds': hsds}
+            res_kwargs = {"hsds": hsds}
 
         with res_cls(cf_file, **res_kwargs) as f:
-            gid0 = f.meta['gid'].values[0]
-            gid1 = f.meta['gid'].values[-1]
+            gid0 = f.meta[ResourceMetaField.GID].values[0]
+            gid1 = f.meta[ResourceMetaField.GID].values[-1]
 
         i0 = pp.index(gid0)
         i1 = pp.index(gid1) + 1
@@ -277,8 +286,15 @@ class Econ(BaseGen):
         return pc
 
     @classmethod
-    def get_pc(cls, points, points_range, sam_configs, cf_file,
-               sites_per_worker=None, append=False):
+    def get_pc(
+        cls,
+        points,
+        points_range,
+        sam_configs,
+        cf_file,
+        sites_per_worker=None,
+        append=False,
+    ):
         """
         Get a PointsControl instance.
 
@@ -311,13 +327,19 @@ class Econ(BaseGen):
         pc : reV.config.project_points.PointsControl
             PointsControl object instance.
         """
-        pc = super().get_pc(points, points_range, sam_configs, ModuleName.ECON,
-                            sites_per_worker=sites_per_worker,
-                            res_file=cf_file)
+        pc = super().get_pc(
+            points,
+            points_range,
+            sam_configs,
+            ModuleName.ECON,
+            sites_per_worker=sites_per_worker,
+            res_file=cf_file,
+        )
 
         if append:
-            pc = cls._econ_append_pc(pc.project_points, cf_file,
-                                     sites_per_worker=sites_per_worker)
+            pc = cls._econ_append_pc(
+                pc.project_points, cf_file, sites_per_worker=sites_per_worker
+            )
 
         return pc
 
@@ -330,9 +352,10 @@ class Econ(BaseGen):
         pc : reV.config.project_points.PointsControl
             Iterable points control object from reV config module.
             Must have project_points with df property with all relevant
-            site-specific inputs and a 'gid' column. By passing site-specific
-            inputs in this dataframe, which was split using points_control,
-            only the data relevant to the current sites is passed.
+            site-specific inputs and a `SiteDataField.GID` column.
+            By passing site-specific inputs in this dataframe, which
+            was split using points_control, only the data relevant to
+            the current sites is passed.
         econ_fun : method
             reV_run() method from one of the econ modules (SingleOwner,
             SAM_LCOE, WindBos).
@@ -354,15 +377,16 @@ class Econ(BaseGen):
 
         # Extract the site df from the project points df.
         site_df = pc.project_points.df
-        site_df = site_df.set_index('gid', drop=True)
+        site_df = site_df.set_index(ResourceMetaField.GID, drop=True)
 
         # SAM execute econ analysis based on output request
         try:
-            out = econ_fun(pc, site_df, output_request=output_request,
-                           **kwargs)
+            out = econ_fun(
+                pc, site_df, output_request=output_request, **kwargs
+            )
         except Exception as e:
             out = {}
-            logger.exception('Worker failed for PC: {}'.format(pc))
+            logger.exception("Worker failed for PC: {}".format(pc))
             raise e
 
         return out
@@ -381,24 +405,27 @@ class Econ(BaseGen):
             Output variables requested from SAM.
         """
 
-        output_request = self._output_request_type_check(req)
+        output_request = super()._parse_output_request(req)
 
         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)
 
-        modules = []
-        for request in output_request:
-            if request in self.OPTIONS:
-                modules.append(self.OPTIONS[request])
+        modules = [self.OPTIONS[request] for request in output_request
+                   if request in self.OPTIONS]
 
         if not any(modules):
-            msg = ('None of the user output requests were recognized. '
-                   'Cannot run reV econ. '
-                   'At least one of the following must be requested: {}'
-                   .format(list(self.OPTIONS.keys())))
+            msg = (
+                "None of the user output requests were recognized. "
+                "Cannot run reV econ. "
+                "At least one of the following must be requested: {}".format(
+                    list(self.OPTIONS.keys())
+                )
+            )
             logger.exception(msg)
             raise ExecutionError(msg)
 
@@ -413,9 +440,11 @@ class Econ(BaseGen):
             self._sam_module = SingleOwner
             self._fun = SingleOwner.reV_run
         else:
-            msg = ('Econ outputs requested from different SAM modules not '
-                   'currently supported. Output request variables require '
-                   'SAM methods: {}'.format(modules))
+            msg = (
+                "Econ outputs requested from different SAM modules not "
+                "currently supported. Output request variables require "
+                "SAM methods: {}".format(modules)
+            )
             raise ValueError(msg)
 
         return list(set(output_request))
@@ -441,12 +470,14 @@ class Econ(BaseGen):
         """
 
         if dset in self.site_data:
-            data_shape = (n_sites, )
+            data_shape = (n_sites,)
             data = self.site_data[dset].values[0]
 
             if isinstance(data, (list, tuple, np.ndarray, str)):
-                msg = ('Cannot pass through non-scalar site_data '
-                       'input key "{}" as an output_request!'.format(dset))
+                msg = (
+                    "Cannot pass through non-scalar site_data "
+                    'input key "{}" as an output_request!'.format(dset)
+                )
                 logger.error(msg)
                 raise ExecutionError(msg)
 
@@ -455,8 +486,7 @@ class Econ(BaseGen):
 
         return data_shape
 
-    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 econ run with smart data flushing.
 
         Parameters
@@ -494,52 +524,74 @@ class Econ(BaseGen):
         else:
             self._init_fpath(out_fpath, ModuleName.ECON)
 
-        self._init_h5(mode='a' if self._append else 'w')
+        self._init_h5(mode="a" if self._append else "w")
         self._init_out_arrays()
 
         diff = list(set(self.points_control.sites)
-                    - set(self.meta['gid'].values))
+                    - set(self.meta[ResourceMetaField.GID].values))
         if diff:
-            raise Exception('The following analysis sites were requested '
-                            'through project points for econ but are not '
-                            'found in the CF file ("{}"): {}'
-                            .format(self.cf_file, diff))
+            raise Exception(
+                "The following analysis sites were requested "
+                "through project points for econ but are not "
+                'found in the CF file ("{}"): {}'.format(self.cf_file, diff)
+            )
 
         # make a kwarg dict
-        kwargs = {'output_request': self.output_request,
-                  'cf_file': self.cf_file,
-                  'year': self.year}
-
-        logger.info('Running econ with smart data flushing '
-                    '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 = {
+            "output_request": self.output_request,
+            "cf_file": self.cf_file,
+            "year": self.year,
+        }
+
+        logger.info(
+            "Running econ with smart data flushing " "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
+            )
+        )
 
         try:
-            kwargs['econ_fun'] = self._fun
+            kwargs["econ_fun"] = self._fun
             if max_workers == 1:
-                logger.debug('Running serial econ for: {}'
-                             .format(self.points_control))
+                logger.debug(
+                    "Running serial econ 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 econ serial compute for: {} '
-                                '(iteration {} out of {})'
-                                .format(pc_sub, i + 1,
-                                        len(self.points_control)))
+                    logger.info(
+                        "Finished reV econ serial compute for: {} "
+                        "(iteration {} out of {})".format(
+                            pc_sub, i + 1, len(self.points_control)
+                        )
+                    )
                 self.flush()
             else:
-                logger.debug('Running parallel econ for: {}'
-                             .format(self.points_control))
-                self._parallel_run(max_workers=max_workers,
-                                   pool_size=pool_size, timeout=timeout,
-                                   **kwargs)
+                logger.debug(
+                    "Running parallel econ 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('SmartParallelJob.execute() failed for econ.')
+            logger.exception("SmartParallelJob.execute() failed for econ.")
             raise e
 
         return self._out_fpath

reV/econ/economies_of_scale.py

@@ -3,14 +3,18 @@
 reV module for calculating economies of scale where larger power plants will
 have reduced capital cost.
 """
-import logging
+
 import copy
+import logging
 import re
-import numpy as np  # pylint: disable=unused-import
+
+# pylint: disable=unused-import
+import numpy as np
 import pandas as pd
+from rex.utilities.utilities import check_eval_str
 
 from reV.econ.utilities import lcoe_fcr
-from rex.utilities.utilities import check_eval_str
+from reV.utilities import SupplyCurveField
 
 logger = logging.getLogger(__name__)
 
@@ -57,23 +61,26 @@ class EconomiesOfScale:
             check_eval_str(str(self._eqn))
 
         if isinstance(self._data, pd.DataFrame):
-            self._data = {k: self._data[k].values.flatten()
-                          for k in self._data.columns}
+            self._data = {
+                k: self._data[k].values.flatten() for k in self._data.columns
+            }
 
         if not isinstance(self._data, dict):
-            e = ('Cannot evaluate EconomiesOfScale with data input of type: {}'
-                 .format(type(self._data)))
+            e = (
+                "Cannot evaluate EconomiesOfScale with data input of type: "
+                "{}".format(type(self._data))
+            )
+
             logger.error(e)
             raise TypeError(e)
 
-        missing = []
-        for name in self.vars:
-            if name not in self._data:
-                missing.append(name)
+        missing = [name for name in self.vars if name not in self._data]
 
         if any(missing):
-            e = ('Cannot evaluate EconomiesOfScale, missing data for variables'
-                 ': {} for equation: {}'.format(missing, self._eqn))
+            e = (
+                "Cannot evaluate EconomiesOfScale, missing data for variables"
+                ": {} for equation: {}".format(missing, self._eqn)
+            )
             logger.error(e)
             raise KeyError(e)
 
@@ -90,7 +97,7 @@ class EconomiesOfScale:
     @staticmethod
     def is_method(s):
         """Check if a string is a numpy/pandas or python builtin method"""
-        return bool(s.startswith(('np.', 'pd.')) or s in dir(__builtins__))
+        return bool(s.startswith(("np.", "pd.")) or s in dir(__builtins__))
 
     @property
     def vars(self):
@@ -106,14 +113,14 @@ class EconomiesOfScale:
         """
         var_names = []
         if self._eqn is not None:
-            delimiters = ('*', '/', '+', '-', ' ', '(', ')', '[', ']', ',')
-            regex_pattern = '|'.join(map(re.escape, delimiters))
+            delimiters = (">", "<", ">=", "<=", "==", ",", "*", "/", "+", "-",
+                          " ", "(", ")", "[", "]")
+            regex_pattern = "|".join(map(re.escape, delimiters))
             var_names = []
             for sub in re.split(regex_pattern, str(self._eqn)):
-                if sub:
-                    if not self.is_num(sub) and not self.is_method(sub):
-                        var_names.append(sub)
-            var_names = sorted(list(set(var_names)))
+                if sub and not self.is_num(sub) and not self.is_method(sub):
+                    var_names.append(sub)
+            var_names = sorted(set(var_names))
 
         return var_names
 
@@ -162,9 +169,10 @@ class EconomiesOfScale:
                 break
 
         if out is None:
-            e = ('Could not find requested key list ({}) in the input '
-                 'dictionary keys: {}'
-                 .format(key_list, list(input_dict.keys())))
+            e = (
+                "Could not find requested key list ({}) in the input "
+                "dictionary keys: {}".format(key_list, list(input_dict.keys()))
+            )
             logger.error(e)
             raise KeyError(e)
 
@@ -183,6 +191,33 @@ class EconomiesOfScale:
         """
         return self._evaluate()
 
+    def _cost_from_cap(self, col_name):
+        """Get full cost value from cost per mw in data.
+
+        Parameters
+        ----------
+        col_name : str
+            Name of column containing the cost per mw value.
+
+        Returns
+        -------
+        float | None
+            Cost value if it was found in data, ``None`` otherwise.
+        """
+        cap = self._data.get(SupplyCurveField.CAPACITY_AC_MW)
+        if cap is None:
+            return None
+
+        cost_per_mw = self._data.get(col_name)
+        if cost_per_mw is None:
+            return None
+
+        cost = cap * cost_per_mw
+        if cost > 0:
+            return cost
+
+        return None
+
     @property
     def raw_capital_cost(self):
         """Unscaled (raw) capital cost found in the data input arg.
@@ -192,7 +227,13 @@ class EconomiesOfScale:
         out : float | np.ndarray
             Unscaled (raw) capital_cost found in the data input arg.
         """
-        key_list = ['capital_cost', 'mean_capital_cost']
+        raw_capital_cost_from_cap = self._cost_from_cap(
+            SupplyCurveField.COST_SITE_OCC_USD_PER_AC_MW
+        )
+        if raw_capital_cost_from_cap is not None:
+            return raw_capital_cost_from_cap
+
+        key_list = ["capital_cost", "mean_capital_cost"]
         return self._get_prioritized_keys(self._data, key_list)
 
     @property
@@ -210,18 +251,6 @@ class EconomiesOfScale:
         cc *= self.capital_cost_scalar
         return cc
 
-    @property
-    def system_capacity(self):
-        """Get the system capacity in kW (SAM input, not the reV supply
-        curve capacity).
-
-        Returns
-        -------
-        out : float | np.ndarray
-        """
-        key_list = ['system_capacity', 'mean_system_capacity']
-        return self._get_prioritized_keys(self._data, key_list)
-
     @property
     def fcr(self):
         """Fixed charge rate from input data arg
@@ -231,8 +260,12 @@ class EconomiesOfScale:
         out : float | np.ndarray
             Fixed charge rate from input data arg
         """
-        key_list = ['fixed_charge_rate', 'mean_fixed_charge_rate',
-                    'fcr', 'mean_fcr']
+        fcr = self._data.get(SupplyCurveField.FIXED_CHARGE_RATE)
+        if fcr is not None and fcr > 0:
+            return fcr
+
+        key_list = ["fixed_charge_rate", "mean_fixed_charge_rate", "fcr",
+                    "mean_fcr"]
         return self._get_prioritized_keys(self._data, key_list)
 
     @property
@@ -244,8 +277,14 @@ class EconomiesOfScale:
         out : float | np.ndarray
             Fixed operating cost from input data arg
         """
-        key_list = ['fixed_operating_cost', 'mean_fixed_operating_cost',
-                    'foc', 'mean_foc']
+        foc_from_cap = self._cost_from_cap(
+            SupplyCurveField.COST_BASE_FOC_USD_PER_AC_MW
+        )
+        if foc_from_cap is not None:
+            return foc_from_cap
+
+        key_list = ["fixed_operating_cost", "mean_fixed_operating_cost",
+                    "foc", "mean_foc"]
         return self._get_prioritized_keys(self._data, key_list)
 
     @property
@@ -257,8 +296,14 @@ class EconomiesOfScale:
         out : float | np.ndarray
             Variable operating cost from input data arg
         """
-        key_list = ['variable_operating_cost', 'mean_variable_operating_cost',
-                    'voc', 'mean_voc']
+        voc_from_cap = self._cost_from_cap(
+            SupplyCurveField.COST_BASE_VOC_USD_PER_AC_MW
+        )
+        if voc_from_cap is not None:
+            return voc_from_cap
+
+        key_list = ["variable_operating_cost", "mean_variable_operating_cost",
+                    "voc", "mean_voc"]
         return self._get_prioritized_keys(self._data, key_list)
 
     @property
@@ -284,7 +329,7 @@ class EconomiesOfScale:
         -------
         lcoe : float | np.ndarray
         """
-        key_list = ['raw_lcoe', 'mean_lcoe']
+        key_list = [SupplyCurveField.RAW_LCOE, SupplyCurveField.MEAN_LCOE]
         return copy.deepcopy(self._get_prioritized_keys(self._data, key_list))
 
     @property
@@ -300,5 +345,6 @@ class EconomiesOfScale:
             LCOE calculated with the scaled capital cost based on the
             EconomiesOfScale input equation.
         """
-        return lcoe_fcr(self.fcr, self.scaled_capital_cost, self.foc,
-                        self.aep, self.voc)
+        return lcoe_fcr(
+            self.fcr, self.scaled_capital_cost, self.foc, self.aep, self.voc
+        )