NREL-reV 0.13.1__py3-none-any.whl → 0.14.1__py3-none-any.whl

reV/econ/economies_of_scale.py

@@ -34,31 +34,54 @@ class EconomiesOfScale:
     lcoe : $/MWh
     """
 
-    def __init__(self, eqn, data):
+    def __init__(self, data, cap_eqn=None, fixed_eqn=None, var_eqn=None):
         """
+
         Parameters
         ----------
-        eqn : str
-            LCOE scaling equation to implement "economies of scale".
-            Equation must be in python string format and return a scalar
-            value to multiply the capital cost by. Independent variables in
-            the equation should match the keys in the data input arg. This
-            equation may use numpy functions with the package prefix "np".
         data : dict | pd.DataFrame
             Namespace of econ data to use to calculate economies of scale. Keys
             in dict or column labels in dataframe should match the Independent
             variables in the eqn input. Should also include variables required
             to calculate LCOE.
+        cap_eqn : str, optional
+            LCOE scaling equation to implement "economies of scale".
+            Equation must be in python string format and return a scalar
+            value to multiply the capital cost by. Independent variables in
+            the equation should match the keys in the data input arg. This
+            equation may use numpy functions with the package prefix "np". If
+            ``None``, no economies of scale are applied to the capital cost.
+            By default, ``None``.
+        fixed_eqn : str, optional
+            LCOE scaling equation to implement "economies of scale".
+            Equation must be in python string format and return a scalar
+            value to multiply the fixed operating cost by. Independent
+            variables in the equation should match the keys in the data input
+            arg. This equation may use numpy functions with the package prefix
+            "np". If ``None``, no economies of scale are applied to the
+            fixed operating cost. By default, ``None``.
+        var_eqn : str, optional
+            LCOE scaling equation to implement "economies of scale".
+            Equation must be in python string format and return a scalar
+            value to multiply the variable operating cost by. Independent
+            variables in the equation should match the keys in the data input
+            arg. This equation may use numpy functions with the package prefix
+            "np". If ``None``, no economies of scale are applied to the
+            variable operating cost. By default, ``None``.
         """
-        self._eqn = eqn
         self._data = data
+        self._cap_eqn = cap_eqn
+        self._fixed_eqn = fixed_eqn
+        self._var_eqn = var_eqn
+        self._vars = None
         self._preflight()
 
     def _preflight(self):
         """Run checks to validate EconomiesOfScale equation and input data."""
 
-        if self._eqn is not None:
-            check_eval_str(str(self._eqn))
+        for eq in self._all_equations:
+            if eq is not None:
+                check_eval_str(str(eq))
 
         if isinstance(self._data, pd.DataFrame):
             self._data = {
@@ -79,11 +102,16 @@ class EconomiesOfScale:
         if any(missing):
             e = (
                 "Cannot evaluate EconomiesOfScale, missing data for variables"
-                ": {} for equation: {}".format(missing, self._eqn)
+                ": {} for equation: {}".format(missing, self._cap_eqn)
             )
             logger.error(e)
             raise KeyError(e)
 
+    @property
+    def _all_equations(self):
+        """gen: All EOS equations"""
+        yield from (self._cap_eqn, self._fixed_eqn, self._var_eqn)
+
     @staticmethod
     def is_num(s):
         """Check if a string is a number"""
@@ -111,36 +139,51 @@ class EconomiesOfScale:
             the equation string. This will return an empty list if the equation
             has no variables.
         """
-        var_names = []
-        if self._eqn is not None:
-            delimiters = (">", "<", ">=", "<=", "==", ",", "*", "/", "+", "-",
-                          " ", "(", ")", "[", "]")
+        if self._vars is not None:
+            return self._vars
+
+        self._vars = []
+        for eq in self._all_equations:
+            if eq is None:
+                continue
+
+            delimiters = (">", "<", ">=", "<=", "==", ",", "*", "/", "+",
+                          "-", " ", "(", ")", "[", "]")
             regex_pattern = "|".join(map(re.escape, delimiters))
-            var_names = []
-            for sub in re.split(regex_pattern, str(self._eqn)):
-                if sub and not self.is_num(sub) and not self.is_method(sub):
-                    var_names.append(sub)
-            var_names = sorted(set(var_names))
+            for sub_str in re.split(regex_pattern, str(eq)):
+                is_valid_var_name = (sub_str and not self.is_num(sub_str)
+                                     and not self.is_method(sub_str))
+                if is_valid_var_name:
+                    self._vars.append(sub_str)
 
-        return var_names
+        self._vars = sorted(set(self._vars))
+        return self._vars
 
-    def _evaluate(self):
+    def _evaluate(self, eqn):
         """Evaluate the EconomiesOfScale equation with Independent variables
         parsed into a kwargs dictionary input.
 
+        Parameters
+        ----------
+        eqn : str
+            LCOE scaling equation to implement "economies of scale".
+            Equation must be in python string format and return a scalar
+            multiplier. Independent variables in the equation should match the
+            keys in the data input arg. This equation may use numpy functions
+            with the package prefix "np". If ``None``, this function returns
+            ``1``.
+
         Returns
         -------
         out : float | np.ndarray
-            Evaluated output of the EconomiesOfScale equation. Should be
-            numeric scalars to apply directly to the capital cost.
+            Evaluated output of the EconomiesOfScale equation.
         """
-        out = 1
-        if self._eqn is not None:
-            kwargs = {k: self._data[k] for k in self.vars}
-            # pylint: disable=eval-used
-            out = eval(str(self._eqn), globals(), kwargs)
+        if eqn is None:
+            return 1
 
-        return out
+        kwargs = {k: self._data[k] for k in self.vars}
+        # pylint: disable=eval-used
+        return eval(str(eqn), globals(), kwargs)
 
     @staticmethod
     def _get_prioritized_keys(input_dict, key_list):
@@ -180,8 +223,8 @@ class EconomiesOfScale:
 
     @property
     def capital_cost_scalar(self):
-        """Evaluated output of the EconomiesOfScale equation. Should be
-        numeric scalars to apply directly to the capital cost.
+        """Evaluated output of the EconomiesOfScale capital cost equation.
+        Should be numeric scalars to apply directly to the capital cost.
 
         Returns
         -------
@@ -189,7 +232,35 @@ class EconomiesOfScale:
             Evaluated output of the EconomiesOfScale equation. Should be
             numeric scalars to apply directly to the capital cost.
         """
-        return self._evaluate()
+        return self._evaluate(self._cap_eqn)
+
+    @property
+    def fixed_operating_cost_scalar(self):
+        """Evaluated output of the EconomiesOfScale fixed operating cost
+        equation. Should be numeric scalars to apply directly to the fixed
+        operating cost.
+
+        Returns
+        -------
+        out : float | np.ndarray
+            Evaluated output of the EconomiesOfScale equation. Should be
+            numeric scalars to apply directly to the fixed operating cost.
+        """
+        return self._evaluate(self._fixed_eqn)
+
+    @property
+    def variable_operating_cost_scalar(self):
+        """Evaluated output of the EconomiesOfScale equation variable
+        operating cost. Should be numeric scalars to apply directly to the
+        variable operating cost.
+
+        Returns
+        -------
+        out : float | np.ndarray
+            Evaluated output of the EconomiesOfScale equation. Should be
+            numeric scalars to apply directly to the variable operating cost.
+        """
+        return self._evaluate(self._var_eqn)
 
     def _cost_from_cap(self, col_name):
         """Get full cost value from cost per mw in data.
@@ -221,10 +292,10 @@ class EconomiesOfScale:
         Returns
         -------
         out : float | np.ndarray
-            Unscaled (raw) capital_cost found in the data input arg.
+            Unscaled (raw) capital_cost ($) found in the data input arg.
         """
         raw_capital_cost_from_cap = self._cost_from_cap(
-            SupplyCurveField.COST_SITE_OCC_USD_PER_AC_MW
+            SupplyCurveField.COST_SITE_CC_USD_PER_AC_MW
         )
         if raw_capital_cost_from_cap is not None:
             return raw_capital_cost_from_cap
@@ -240,8 +311,8 @@ class EconomiesOfScale:
         Returns
         -------
         out : float | np.ndarray
-            Capital cost found in the data input arg scaled by the evaluated
-            EconomiesOfScale equation.
+            Capital cost ($) found in the data input arg scaled by the
+            evaluated EconomiesOfScale equation.
         """
         cc = copy.deepcopy(self.raw_capital_cost)
         cc *= self.capital_cost_scalar
@@ -265,13 +336,13 @@ class EconomiesOfScale:
         return self._get_prioritized_keys(self._data, key_list)
 
     @property
-    def foc(self):
-        """Fixed operating cost from input data arg
+    def raw_fixed_operating_cost(self):
+        """Unscaled (raw) fixed operating cost from input data arg
 
         Returns
         -------
         out : float | np.ndarray
-            Fixed operating cost from input data arg
+            Unscaled (raw) fixed operating cost ($/year) from input data arg
         """
         foc_from_cap = self._cost_from_cap(
             SupplyCurveField.COST_SITE_FOC_USD_PER_AC_MW
@@ -284,42 +355,70 @@ class EconomiesOfScale:
         return self._get_prioritized_keys(self._data, key_list)
 
     @property
-    def voc(self):
-        """Variable operating cost from input data arg
+    def scaled_fixed_operating_cost(self):
+        """Fixed operating cost found in the data input arg scaled by the
+        evaluated EconomiesOfScale input equation.
 
         Returns
         -------
         out : float | np.ndarray
-            Variable operating cost from input data arg
+            Fixed operating cost ($/year) found in the data input arg scaled
+            by the evaluated EconomiesOfScale equation.
         """
-        voc_from_cap = self._cost_from_cap(
-            SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MW
-        )
-        if voc_from_cap is not None:
-            return voc_from_cap
+        foc = copy.deepcopy(self.raw_fixed_operating_cost)
+        foc *= self.fixed_operating_cost_scalar
+        return foc
+
+    @property
+    def raw_variable_operating_cost(self):
+        """Unscaled (raw) variable operating cost from input data arg
+
+        Returns
+        -------
+        out : float | np.ndarray
+            Unscaled (raw) variable operating cost ($/kWh) from input
+            data arg
+        """
+        voc_mwh = self._data.get(SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MWH)
+        if voc_mwh is not None:
+            return voc_mwh / 1000  # convert to $/kWh
 
         key_list = ["variable_operating_cost", "mean_variable_operating_cost",
                     "voc", "mean_voc"]
         return self._get_prioritized_keys(self._data, key_list)
 
+    @property
+    def scaled_variable_operating_cost(self):
+        """Variable operating cost found in the data input arg scaled by the
+        evaluated EconomiesOfScale input equation.
+
+        Returns
+        -------
+        out : float | np.ndarray
+            Variable operating cost ($/kWh) found in the data input arg
+            scaled by the evaluated EconomiesOfScale equation.
+        """
+        voc = copy.deepcopy(self.raw_variable_operating_cost)
+        voc *= self.variable_operating_cost_scalar
+        return voc
+
     @property
     def aep(self):
-        """Annual energy production back-calculated from the raw LCOE:
+        """Annual energy production (kWh) back-calculated from the raw LCOE:
 
-        AEP = (fcr * raw_cap_cost + foc) / raw_lcoe
+        AEP = (fcr * raw_cap_cost + raw_foc) / (raw_lcoe - raw_voc)
 
         Returns
         -------
         out : float | np.ndarray
         """
-
-        aep = (self.fcr * self.raw_capital_cost + self.foc) / self.raw_lcoe
-        aep *= 1000  # convert MWh to KWh
-        return aep
+        num = self.fcr * self.raw_capital_cost + self.raw_fixed_operating_cost
+        denom = self.raw_lcoe - (self.raw_variable_operating_cost * 1000)
+        return num / denom * 1000  # convert MWh to KWh
 
     @property
     def raw_lcoe(self):
-        """Raw LCOE taken from the input data
+        """Raw LCOE ($/MWh) taken from the input data
 
         Returns
         -------
@@ -330,17 +429,17 @@ class EconomiesOfScale:
 
     @property
     def scaled_lcoe(self):
-        """LCOE calculated with the scaled capital cost based on the
+        """LCOE ($/MWh) calculated with the scaled costs based on the
         EconomiesOfScale input equation.
 
-        LCOE = (FCR * scaled_capital_cost + FOC) / AEP + VOC
+        LCOE = (FCR * scaled_capital_cost + scaled_FOC) / AEP + scaled_VOC
 
         Returns
         -------
         lcoe : float | np.ndarray
-            LCOE calculated with the scaled capital cost based on the
+            LCOE calculated with the scaled costs 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.scaled_fixed_operating_cost, self.aep,
+                        self.scaled_variable_operating_cost)

reV/generation/cli_gen.py

@@ -67,8 +67,10 @@ def _parse_res_files(res_fps, analysis_years):
 
     # get base filename, may have {} for year format
     if isinstance(res_fps, str) and '{}' in res_fps:
-        # need to make list of res files for each year
-        res_fps = [res_fps.format(year) for year in analysis_years]
+        # make list of res files for each year
+        # .replace("{}", "{0}") used for multiple "{}" in path
+        res_fps = [res_fps.replace("{}", "{0}").format(year)
+                   for year in analysis_years]
     elif isinstance(res_fps, str):
         # only one resource file request, still put in list
         res_fps = [res_fps]

reV/losses/scheduled.py

@@ -7,7 +7,6 @@ import warnings
 import json
 
 import numpy as np
-import PySAM
 
 from reV.losses.utils import (convert_to_full_month_names,
                               filter_unknown_month_names,
@@ -524,8 +523,8 @@ class ScheduledLossesMixin:
         information is expected to be a list of dictionaries containing
         outage specifications. See :class:`Outage` for a description of
         the specifications allowed for each outage. The scheduled losses
-        are passed to SAM via the ``adjust_hourly`` key to signify which
-        hourly capacity factors should be adjusted with outage losses.
+        are passed to SAM via the ``adjust_timeindex`` key to signify
+        which capacity factors should be adjusted with outage losses.
         If no outage info is specified in ``sam_sys_inputs``, no
         scheduled losses are added.
 
@@ -543,13 +542,13 @@ class ScheduledLossesMixin:
 
         Notes
         -----
-        The scheduled losses are passed to SAM via the ``adjust_hourly``
-        key to signify which hourly capacity factors should be adjusted
-        with outage losses. If the user specifies other hourly
-        adjustment factors via the ``adjust_hourly`` key, the effect is
-        combined. For example, if the user inputs a 33% hourly
+        The scheduled losses are passed to SAM via the
+        ``adjust_timeindex`` key to signify which capacity factors
+        should be adjusted with outage losses. If the user specifies
+        other adjustment factors via the ``adjust_timeindex`` key, the
+        effect is combined. For example, if the user inputs a 33%
         adjustment factor and reV schedules an outage for 70% of the
-        farm down for the same hour, then the resulting adjustment
+        farm down for the same time step, then the resulting adjustment
         factor is
 
             .. math: 1 - [(1 - 70/100) * (1 - 33/100)] = 0.799
@@ -575,7 +574,7 @@ class ScheduledLossesMixin:
         self._add_outages_to_sam_inputs(hourly_outages)
 
         logger.debug("Hourly adjustment factors after scheduled outages: {}"
-                     .format(list(self.sam_sys_inputs['adjust_hourly'])))
+                     .format(list(self.sam_sys_inputs['adjust_timeindex'])))
 
     def _user_outage_input(self):
         """Get outage and seed info from config. """
@@ -601,16 +600,20 @@ class ScheduledLossesMixin:
     def _add_outages_to_sam_inputs(self, outages):
         """Add the hourly adjustment factors to config, checking user input."""
 
+        if self.time_interval > 1:
+            outages = np.array([outage
+                                for _ in range(self.time_interval)
+                                for outage in outages])
         hourly_mult = 1 - outages / 100
-        hourly_mult = self._fix_pysam_bug(hourly_mult)
 
-        user_hourly_input = self.sam_sys_inputs.pop('adjust_hourly',
-                                                    [0] * 8760)
+        default_user_input = [0] * 8760 * self.time_interval
+        user_hourly_input = self.sam_sys_inputs.pop('adjust_timeindex',
+                                                    default_user_input)
         user_hourly_mult = 1 - np.array(user_hourly_input) / 100
 
         final_hourly_mult = hourly_mult * user_hourly_mult
-        self.sam_sys_inputs['adjust_hourly'] = (1 - final_hourly_mult) * 100
-        self.sam_sys_inputs['adjust_en_hourly'] = 1
+        self.sam_sys_inputs['adjust_timeindex'] = (1 - final_hourly_mult) * 100
+        self.sam_sys_inputs['adjust_en_timeindex'] = 1
 
     @property
     def outage_seed(self):
@@ -631,19 +634,3 @@ class ScheduledLossesMixin:
             pass
 
         return self.__base_seed
-
-    def _fix_pysam_bug(self, hourly_mult):
-        """Fix PySAM bug that squares HAF user input"""
-        if getattr(self, "MODULE", "").casefold() != "windpower":
-            return hourly_mult
-
-        bugged_pysam_version = (PySAM.__version__.startswith("5")
-                                or PySAM.__version__.startswith("6"))
-        if not bugged_pysam_version:
-            return hourly_mult
-
-        # Bug in PySAM windpower module that applies HAF twice (i.e.
-        # squares the input values), so we sqrt the desired loss value
-        return np.sqrt(hourly_mult)
-
-

reV/supply_curve/aggregation.py

@@ -9,6 +9,7 @@ import h5py
 import numpy as np
 import pandas as pd
 from rex.resource import Resource
+from rex.utilities import check_res_file
 from rex.utilities.execution import SpawnProcessPool
 from rex.utilities.loggers import log_mem
 
@@ -113,6 +114,7 @@ class AggFileHandler(AbstractAggFileHandler):
         area_filter_kernel="queen",
         min_area=None,
         h5_handler=None,
+        **h5_handler_kwargs,
     ):
         """
         Parameters
@@ -136,6 +138,8 @@ class AggFileHandler(AbstractAggFileHandler):
         h5_handler : rex.Resource | None
             Optional special handler similar to the rex.Resource handler which
             is default.
+        **h5_handler_kwargs
+            Optional keyword-value pairs to pass to the h5 handler.
         """
         super().__init__(
             excl_fpath,
@@ -145,9 +149,9 @@ class AggFileHandler(AbstractAggFileHandler):
         )
 
         if h5_handler is None:
-            self._h5 = Resource(h5_fpath)
+            self._h5 = Resource(h5_fpath, **h5_handler_kwargs)
         else:
-            self._h5 = h5_handler(h5_fpath)
+            self._h5 = h5_handler(h5_fpath, **h5_handler_kwargs)
 
     @property
     def h5(self):
@@ -504,8 +508,9 @@ class BaseAggregation(ABC):
             generation run.
         """
 
+        __, hsds = check_res_file(gen_fpath)
         if gen_fpath.endswith(".h5"):
-            with Resource(gen_fpath) as f:
+            with Resource(gen_fpath, hsds=hsds) as f:
                 gen_index = f.meta
         elif gen_fpath.endswith(".csv"):
             gen_index = pd.read_csv(gen_fpath)
@@ -631,7 +636,8 @@ class Aggregation(BaseAggregation):
                 )
             )
 
-        if not os.path.exists(h5_fpath):
+        __, hsds = check_res_file(h5_fpath)
+        if not hsds and not os.path.exists(h5_fpath):
             raise FileNotFoundError(
                 "Could not find required h5 file: " "{}".format(h5_fpath)
             )
@@ -645,7 +651,7 @@ class Aggregation(BaseAggregation):
                     )
                 )
 
-        with Resource(h5_fpath) as f:
+        with Resource(h5_fpath, hsds=hsds) as f:
             for dset in self._agg_dsets:
                 if dset not in f:
                     raise FileInputError(
@@ -744,6 +750,7 @@ class Aggregation(BaseAggregation):
             "excl_dict": excl_dict,
             "area_filter_kernel": area_filter_kernel,
             "min_area": min_area,
+            "hsds": check_res_file(h5_fpath)[1],
         }
         dsets = (
             *agg_dset,
@@ -1011,7 +1018,9 @@ class Aggregation(BaseAggregation):
         chunks = {}
         dtypes = {}
         time_index = None
-        with Resource(h5_fpath) as f:
+
+        __, hsds = check_res_file(h5_fpath)
+        with Resource(h5_fpath, hsds=hsds) as f:
             for dset, data in agg_out.items():
                 dsets.append(dset)
                 shape = data.shape

reV/supply_curve/cli_tech_mapping.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""
+reV Tech Mapping CLI utility functions.
+"""
+import logging
+
+from gaps.cli import as_click_command, CLICommandFromClass
+
+from reV.supply_curve.tech_mapping import TechMapping
+from reV.utilities import ModuleName
+from reV.utilities.exceptions import ConfigError
+from reV.supply_curve.cli_sc_aggregation import _format_res_fpath
+
+logger = logging.getLogger(__name__)
+
+
+def _preprocessor(config):
+    """Preprocess tech mapping config user input.
+
+    Parameters
+    ----------
+    config : dict
+        User configuration file input as (nested) dict.
+
+    Returns
+    -------
+    dict
+        Updated config file.
+    """
+    _validate_excl_fpath(config)
+    config = _format_res_fpath(config)
+    _validate_dset(config)
+
+    return config
+
+
+def _validate_excl_fpath(config):
+    paths = config["excl_fpath"]
+    if isinstance(paths, list):
+        raise ConfigError(
+            "Multiple exclusion file paths passed via excl_fpath. "
+            "Cannot run tech mapping with arbitrary multiple exclusion. "
+            "Specify a single exclusion file path to write to."
+        )
+
+
+def _validate_dset(config):
+    if config.get("dset") is None:
+        raise ConfigError(
+            "dset must be specified to run tech mapping."
+        )
+
+
+tm_command = CLICommandFromClass(TechMapping, method="run",
+                                 name=str(ModuleName.TECH_MAPPING),
+                                 add_collect=False, split_keys=None,
+                                 config_preprocessor=_preprocessor)
+main = as_click_command(tm_command)
+
+
+if __name__ == '__main__':
+    try:
+        main(obj={})
+    except Exception:
+        logger.exception('Error running reV Tech Mapping CLI.')
+        raise