NREL-reV 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

{nrel_rev-0.13.0.dist-info → nrel_rev-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NREL-reV
-Version: 0.13.0
+Version: 0.14.0
 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>
@@ -22,8 +22,8 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: NREL-gaps<0.9,>=0.8.0
 Requires-Dist: NREL-NRWAL<0.1,>=0.0.11
-Requires-Dist: NREL-PySAM~=6.0.1
-Requires-Dist: NREL-rex<0.4,>=0.3.1
+Requires-Dist: NREL-PySAM~=7.0.0
+Requires-Dist: NREL-rex<0.4,>=0.3.2
 Requires-Dist: numpy<3,>=2.0.2
 Requires-Dist: packaging<25,>=24.2
 Requires-Dist: plotly<7,>=6.0.1
@@ -156,9 +156,6 @@ Option 1: Install from PIP (recommended for analysts):
 3. Install reV:
     1) ``pip install NREL-reV`` or
 
-       - NOTE: If you install using conda and want to run from files directly on S3 like in the `running reV locally example <https://nrel.github.io/reV/misc/examples.running_locally.html>`_
-         you will also need to install S3 filesystem dependencies: ``pip install NREL-reV[s3]``
-
        - NOTE: If you install using conda and want to use `HSDS <https://github.com/NREL/hsds-examples>`_
          you will also need to install HSDS dependencies: ``pip install NREL-reV[hsds]``
 

{nrel_rev-0.13.0.dist-info → nrel_rev-0.14.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-nrel_rev-0.13.0.dist-info/licenses/LICENSE,sha256=hDwoTANtan2ZpufBlXm5C3W_PJ-mCqItvlcobgjxL7k,1526
+nrel_rev-0.14.0.dist-info/licenses/LICENSE,sha256=hDwoTANtan2ZpufBlXm5C3W_PJ-mCqItvlcobgjxL7k,1526
 reV/__init__.py,sha256=tXTpWu_qVo3uotfSw_TJ-gNbidGaIPPfUTwBlpCMJ-g,856
-reV/cli.py,sha256=jfGGOr6QlLz8ghA7vBgx5-VgNsy4bBQo5DdHk42-q9A,1601
-reV/version.py,sha256=hIUvlRrRzHirY4NJU-6xMqe2V_yRaRSnk6a9V3HAi6s,51
+reV/cli.py,sha256=u7G5M5moA7q8fCgC_1MB30Z7R14GNcngVf6eVNkfQU8,1682
+reV/version.py,sha256=MW2Xrj6zWXWLE73quVP27irsAbTU85t5oflVIQzGMVE,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,7 +16,7 @@ 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=2konhn_hV0YXd_h2cbBYbGPUb9oafKY0SvQhBzmOMBE,112661
+reV/bespoke/bespoke.py,sha256=573mIoJx8HXq5RH8HufjIhX20XjMJZbbR1kDGKpMzSw,112723
 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
@@ -33,11 +33,11 @@ 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
 reV/econ/econ.py,sha256=edsNPZg2amhC_GZeotkY2MU3u17NgWeCpS6okZNrwAA,23637
-reV/econ/economies_of_scale.py,sha256=GfM0vj4LnwsthzhSsUnmLt78PAUHrxZI5ghWaxvoF7A,10568
+reV/econ/economies_of_scale.py,sha256=UXBmHFDK-pngDGaIoKe90TQgW2LlNKxcjMQHMxSxky8,15044
 reV/econ/utilities.py,sha256=ZOA49S1jfsvdenvlL7m-BAJIrAvpAHSix5-wrSW0uLc,1232
 reV/generation/__init__.py,sha256=LBecrbpL69tROol_OwVHTKBrTqgSSxJW59fs0k3o0jQ,75
 reV/generation/base.py,sha256=D--WPQ8ZWElE06HtZF9rQYK1cAa4MWBDEqkOZ2hmFEE,49482
-reV/generation/cli_gen.py,sha256=5RSlr8yO9zlB-1FzFZGClqsxqsrbr9rcS_8PlOjVx2s,4435
+reV/generation/cli_gen.py,sha256=JYcTX9bM1hb_HQX-9yUwvE5fXNxRMINttlGo4Pvo138,4530
 reV/generation/generation.py,sha256=FrNN3p-WScRtnVHhaqxpTAgvVbE0cIF9_2Or_qDlJ8g,49029
 reV/generation/output_attributes/generation.json,sha256=cy8efVCJgNSYCsR3x3_VpMCtynYS3oaQG4M2MwcdzFY,4954
 reV/generation/output_attributes/lcoe_fcr.json,sha256=d_TGMkZsmsfDXQiWfhYjFkmwqi-wKF8JdHmiMCj2h38,136
@@ -61,7 +61,7 @@ reV/hybrids/hybrid_methods.py,sha256=5nGb2sadp8zT9atZJNVigpYm_JYJxt4gWCPo56-5Vjk
 reV/hybrids/hybrids.py,sha256=7DFaqkNdAUVJxd_YDoQI-psKcJAlWgOGapYb_kIv3kw,46601
 reV/losses/__init__.py,sha256=DMmJo9oOVrF1npUcjuSHo_yslf94am8xdvYrvwjEsjM,141
 reV/losses/power_curve.py,sha256=P7xhRlTDqVoz5m3BJMwqYbrSKBkZfeWVEzFVmFARVGE,45289
-reV/losses/scheduled.py,sha256=w25YIXi7ykkeP9FgB_6vpjNm1MNOYNRjM-dqqVQJvGA,27276
+reV/losses/scheduled.py,sha256=JKOVKh6jNOQx2Dj-uSPx1kpICcoHuYGPpievxkVqOQM,26878
 reV/losses/utils.py,sha256=XyM38JVlBNad9BEMJqRLuK6xba_DfFZUxNSC7EcRelM,7511
 reV/nrwal/__init__.py,sha256=HD-QXvKRM5s6Z24zfKw31yhBttrkTe8hzUnx0FZP_P0,114
 reV/nrwal/cli_nrwal.py,sha256=sa2gI86sNGk3ZJuQPxy_xsxle4KWDyPNrM11hlq6Ask,1825
@@ -77,22 +77,23 @@ reV/supply_curve/__init__.py,sha256=dbf0cO0qmt1VhV8dnDddztrcpnwua9T2HBhM6tLKaP8,
 reV/supply_curve/aggregation.py,sha256=dnnuDG9BEGEgY17uA8nSF3s6L6Q6Lxe94aS7AIKSlm0,40471
 reV/supply_curve/cli_sc_aggregation.py,sha256=qGfJyZjg4tFARG2dl-wAlHv9KjEp2u4wg1Boxz18Gf0,3347
 reV/supply_curve/cli_supply_curve.py,sha256=e-XrHQIe4OqWTL6u-TUAyHrw7Alk7vkXQ2HoLbE3zTM,2163
+reV/supply_curve/cli_tech_mapping.py,sha256=ztNJhgk3WlSD5Gn7Rh3qBLMvX_pFkjuQT7qUK4s0P2w,1731
 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/extent.py,sha256=a31po753hXSxQ8lfcCvpE8hoKc4bY7MmYq0NO0jtdqA,17414
-reV/supply_curve/points.py,sha256=k_OrtRF4G_BYl4wky-AolCOBgOAktN4_ZCV1LLYyZl8,88549
-reV/supply_curve/sc_aggregation.py,sha256=SokYyLXdjQwgvdmgiWhLSSTssnkX6ZdCSwO0WzC8SYw,63911
+reV/supply_curve/points.py,sha256=tWL_9hO5xBzDygk9TfDGotSTOgLNp9hEY7-2DJ01TrI,93336
+reV/supply_curve/sc_aggregation.py,sha256=0rxNPJgaK1eilSeRVF-IBRVAqE0UcM8gKo_SkLHdZl0,67738
 reV/supply_curve/supply_curve.py,sha256=9zhAA_9XSxE18j1Z9FuC71Wr3I0VuakfR5mt1_gHYuU,69931
-reV/supply_curve/tech_mapping.py,sha256=rsCyv6YBIbHwCXOrYdaVbuKjphi24QsjaWA7F8m8KCY,18567
-reV/utilities/__init__.py,sha256=Z77DeuW_HtMFr7ssywUEgOLikWkDTtbaEdEWiSxwO4Y,10592
+reV/supply_curve/tech_mapping.py,sha256=JAinwbh6UPzBX2qwf0EBDDYCanEfe-F6RgiE23oNBcU,18149
+reV/utilities/__init__.py,sha256=HVb1P-ee-z2P6UTjyc0s0gYFK7XYM71BQLEMxj26apA,10834
 reV/utilities/_clean_readme.py,sha256=IFI9wGPX5nnLTNVLJzH8IOHq9unQlAlHRu4Namib0LA,709
 reV/utilities/cli_functions.py,sha256=1_T_sXz0Ct8lW-vOk3mMRcpD6NYsc9cGI7dEujIi9z4,3864
 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.13.0.dist-info/METADATA,sha256=XfYD0aNmttfLYLma2YZm9fCFZDaOVaTvVtAywz-xB3g,11021
-nrel_rev-0.13.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nrel_rev-0.13.0.dist-info/entry_points.txt,sha256=4IfJtZm2iMJwrbC8J0Or7VjZWnFpvCaHYVpvSWfIwDA,616
-nrel_rev-0.13.0.dist-info/top_level.txt,sha256=S6YF2ZYgXUB6n28SY0K2H8YB9tMJdXQ9CyQbo6VC89M,4
-nrel_rev-0.13.0.dist-info/RECORD,,
+nrel_rev-0.14.0.dist-info/METADATA,sha256=wZN_Wb9S2ZCiKDgYXrPAmEiywSA_-1o12-anLqwQvHs,10733
+nrel_rev-0.14.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+nrel_rev-0.14.0.dist-info/entry_points.txt,sha256=4IfJtZm2iMJwrbC8J0Or7VjZWnFpvCaHYVpvSWfIwDA,616
+nrel_rev-0.14.0.dist-info/top_level.txt,sha256=S6YF2ZYgXUB6n28SY0K2H8YB9tMJdXQ9CyQbo6VC89M,4
+nrel_rev-0.14.0.dist-info/RECORD,,

{nrel_rev-0.13.0.dist-info → nrel_rev-0.14.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

reV/bespoke/bespoke.py

@@ -1087,8 +1087,8 @@ class BespokeSinglePlant:
             fcr = lcoe_kwargs['fixed_charge_rate']
             cc = lcoe_kwargs['capital_cost']
             foc = lcoe_kwargs['fixed_operating_cost']
-            voc = lcoe_kwargs['variable_operating_cost']
-            aep = self.outputs['annual_energy-means']
+            voc = lcoe_kwargs['variable_operating_cost']  # $/kWh
+            aep = self.outputs['annual_energy-means']  # kWh
 
             my_mean_lcoe = lcoe_fcr(fcr, cc, foc, aep, voc)
 
@@ -1184,6 +1184,7 @@ class BespokeSinglePlant:
                                   'wind_resource_data',
                                   'wind_turbine_powercurve_powerout',
                                   'adjust_hourly',
+                                  'adjust_timeindex',
                                   'capital_cost',
                                   'fixed_operating_cost',
                                   'variable_operating_cost',
@@ -1387,12 +1388,12 @@ class BespokeSinglePlant:
         self._meta[SupplyCurveField.EOS_MULT] = eos_mult
         self._meta[SupplyCurveField.REG_MULT] = reg_mult_cc
 
-        self._meta[SupplyCurveField.COST_SITE_OCC_USD_PER_AC_MW] = (
+        self._meta[SupplyCurveField.COST_SITE_CC_USD_PER_AC_MW] = (
             (self.plant_optimizer.capital_cost
              + self.plant_optimizer.balance_of_system_cost)
             / capacity_ac_mw
         )
-        self._meta[SupplyCurveField.COST_BASE_OCC_USD_PER_AC_MW] = (
+        self._meta[SupplyCurveField.COST_BASE_CC_USD_PER_AC_MW] = (
             (self.plant_optimizer.capital_cost / eos_mult / reg_mult_cc
              + self.plant_optimizer.balance_of_system_cost / reg_mult_bos)
             / capacity_ac_mw
@@ -1406,14 +1407,13 @@ class BespokeSinglePlant:
             / reg_mult_foc
             / capacity_ac_mw
         )
-        self._meta[SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MW] = (
-            self.plant_optimizer.variable_operating_cost
-            / capacity_ac_mw
+        self._meta[SupplyCurveField.COST_SITE_VOC_USD_PER_AC_MWH] = (
+            self.plant_optimizer.variable_operating_cost * 1000  # to $/MWh
         )
-        self._meta[SupplyCurveField.COST_BASE_VOC_USD_PER_AC_MW] = (
+        self._meta[SupplyCurveField.COST_BASE_VOC_USD_PER_AC_MWH] = (
             self.plant_optimizer.variable_operating_cost
             / reg_mult_voc
-            / capacity_ac_mw
+            * 1000  # to $/MWh
         )
         self._meta[SupplyCurveField.FIXED_CHARGE_RATE] = (
             self.plant_optimizer.fixed_charge_rate

reV/cli.py

@@ -12,6 +12,7 @@ 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_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
 from reV.hybrids.cli_hybrids import hybrids_command
 from reV.nrwal.cli_nrwal import nrwal_command
@@ -24,8 +25,9 @@ logger = logging.getLogger(__name__)
 
 
 commands = [bespoke_command, gen_command, econ_command, collect_command,
-            my_command, sc_agg_command, sc_command, rep_profiles_command,
-            hybrids_command, nrwal_command, qa_qc_command]
+            my_command, tm_command, sc_agg_command, sc_command,
+            rep_profiles_command, hybrids_command, nrwal_command,
+            qa_qc_command]
 main = make_cli(commands, info={"name": "reV", "version": __version__})
 main.add_command(qa_qc_extra)
 main.add_command(project_points)

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)
-
-