NREL-reV 0.13.1__tar.gz → 0.14.1__tar.gz

{nrel_rev-0.13.1 → nrel_rev-0.14.1/NREL_reV.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NREL-reV
-Version: 0.13.1
+Version: 0.14.1
 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,7 +22,7 @@ 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-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
@@ -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.1 → nrel_rev-0.14.1}/NREL_reV.egg-info/SOURCES.txt

@@ -86,6 +86,7 @@ reV/supply_curve/__init__.py
 reV/supply_curve/aggregation.py
 reV/supply_curve/cli_sc_aggregation.py
 reV/supply_curve/cli_supply_curve.py
+reV/supply_curve/cli_tech_mapping.py
 reV/supply_curve/competitive_wind_farms.py
 reV/supply_curve/exclusions.py
 reV/supply_curve/extent.py

{nrel_rev-0.13.1 → nrel_rev-0.14.1}/NREL_reV.egg-info/requires.txt

@@ -1,6 +1,6 @@
 NREL-gaps<0.9,>=0.8.0
 NREL-NRWAL<0.1,>=0.0.11
-NREL-PySAM~=6.0.1
+NREL-PySAM~=7.0.0
 NREL-rex<0.4,>=0.3.2
 numpy<3,>=2.0.2
 packaging<25,>=24.2

{nrel_rev-0.13.1/NREL_reV.egg-info → nrel_rev-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NREL-reV
-Version: 0.13.1
+Version: 0.14.1
 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,7 +22,7 @@ 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-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
@@ -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.1 → nrel_rev-0.14.1}/README.rst

@@ -111,9 +111,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.1 → nrel_rev-0.14.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
 requires = [
-  "setuptools >= 61",
+  "setuptools >= 80",
   "setuptools_scm[toml] >= 8",
 ]
 build-backend = 'setuptools.build_meta'
@@ -33,7 +33,7 @@ classifiers=[
 dependencies = [
   "NREL-gaps>=0.8.0,<0.9",
   "NREL-NRWAL>=0.0.11,<0.1",
-  "NREL-PySAM~=6.0.1",
+  "NREL-PySAM~=7.0.0",
   "NREL-rex>=0.3.2,<0.4",
   "numpy>=2.0.2,<3",
   "packaging>=24.2,<25",

{nrel_rev-0.13.1 → nrel_rev-0.14.1}/reV/SAM/version_checker.py

@@ -6,8 +6,9 @@ Created on Mon Feb  3 14:40:42 2020
 @author: gbuster
 """
 import logging
+import importlib
 from warnings import warn
-from pkg_resources import get_distribution
+
 from packaging import version
 from reV.utilities.exceptions import PySAMVersionError, PySAMVersionWarning
 
@@ -105,7 +106,7 @@ class PySamVersionChecker:
     @property
     def pysam_version(self):
         """Get the PySAM distribution version"""
-        return str(get_distribution('nrel-pysam')).split(' ')[1]
+        return importlib.metadata.version("nrel-pysam")
 
     @classmethod
     def run(cls, tech, parameters):

{nrel_rev-0.13.1 → nrel_rev-0.14.1}/reV/bespoke/bespoke.py

@@ -23,7 +23,7 @@ from rex.multi_year_resource import MultiYearWindResource
 from rex.utilities.bc_parse_table import parse_bc_table
 from rex.utilities.execution import SpawnProcessPool
 from rex.utilities.loggers import create_dirs, log_mem
-from rex.utilities.utilities import parse_year
+from rex.utilities.utilities import parse_year, check_res_file
 
 from reV.config.output_request import SAMOutputRequest
 from reV.econ.utilities import lcoe_fcr
@@ -80,7 +80,8 @@ class BespokeMultiPlantData:
             Option to pre-load relative humidity data (useful for icing
             runs). If ``False``, relative humidities are not loaded.
         """
-        self.res_fpath = res_fpath
+        self.res_fpath = ([res_fpath]
+                          if isinstance(res_fpath, str) else res_fpath)
         self.sc_gid_to_hh = sc_gid_to_hh
         self.sc_gid_to_res_gid = sc_gid_to_res_gid
         self.hh_to_res_gids = {}
@@ -104,8 +105,9 @@ class BespokeMultiPlantData:
             hh: sorted(gids) for hh, gids in self.hh_to_res_gids.items()
         }
 
+        hsds = all(check_res_file(fp)[1] for fp in self.res_fpath)
         start_time = time.time()
-        with MultiYearWindResource(self.res_fpath) as res:
+        with MultiYearWindResource(self.res_fpath, hsds=hsds) as res:
             self._wind_dirs = {
                 hh: res[f"winddirection_{hh}m", :, gids]
                 for hh, gids in self.hh_to_res_gids.items()
@@ -488,7 +490,9 @@ class BespokeSinglePlant:
         self._pre_loaded_data = pre_loaded_data
         self._outputs = {}
 
-        res = res if not isinstance(res, str) else MultiYearWindResource(res)
+        if isinstance(res, str):
+            __, hsds = check_res_file(res)
+            res = MultiYearWindResource(res, hsds=hsds)
 
         self._sc_point = AggSCPoint(
             gid,
@@ -1087,8 +1091,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 +1188,7 @@ class BespokeSinglePlant:
                                   'wind_resource_data',
                                   'wind_turbine_powercurve_powerout',
                                   'adjust_hourly',
+                                  'adjust_timeindex',
                                   'capital_cost',
                                   'fixed_operating_cost',
                                   'variable_operating_cost',
@@ -1387,12 +1392,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 +1411,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
@@ -1972,7 +1976,8 @@ class BespokeWindPlants(BaseAggregation):
             pre_extract_inclusions=pre_extract_inclusions,
         )
 
-        self._res_fpath = res_fpath
+        self._res_fpath = ([res_fpath]
+                           if isinstance(res_fpath, str) else res_fpath)
         self._obj_fun = objective_function
         self._cap_cost_fun = capital_cost_function
         self._foc_fun = fixed_operating_cost_function
@@ -2123,8 +2128,9 @@ class BespokeWindPlants(BaseAggregation):
                     )
                 )
 
+        hsds = all(check_res_file(fp)[1] for fp in self._res_fpath)
         # just check that this file exists, cannot check res_fpath if *glob
-        with MultiYearWindResource(self._res_fpath) as f:
+        with MultiYearWindResource(self._res_fpath, hsds=hsds) as f:
             assert any(f.dsets)
 
     def _pre_load_data(self, pre_load_data):
@@ -2494,6 +2500,7 @@ class BespokeWindPlants(BaseAggregation):
             "area_filter_kernel": area_filter_kernel,
             "min_area": min_area,
             "h5_handler": MultiYearWindResource,
+            "hsds": all(check_res_file(fp)[1] for fp in res_fpath),
         }
 
         with AggFileHandler(excl_fpath, res_fpath, **file_kwargs) as fh:

{nrel_rev-0.13.1 → nrel_rev-0.14.1}/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)

{nrel_rev-0.13.1 → nrel_rev-0.14.1}/reV/config/project_points.py

@@ -464,8 +464,10 @@ class ProjectPoints:
         h_var = "wind_turbine_hub_ht"
         if self._h is None:
             if "wind" in self.tech:
-                # wind technology, get a list of h values
-                self._h = [self[site][1][h_var] for site in self.sites]
+                if h_var in self.df.columns:
+                    self._h = self.df[h_var].values.tolist()
+                else:
+                    self._h = [self[site][1][h_var] for site in self.sites]
 
         return self._h
 
@@ -837,7 +839,6 @@ class ProjectPoints:
             logger.error(msg)
             raise ConfigError(msg)
 
-
         unused_configs = set(curtail_configs) - set(df_configs)
         if unused_configs:
             msg = ("One or more curtailment configurations not found in "
@@ -1164,12 +1165,14 @@ class ProjectPoints:
         multi_h5_res, hsds = check_res_file(res_file)
         if multi_h5_res:
             res_cls = MultiFileResourceX
+            res_kwargs = {}
         else:
             res_cls = ResourceX
+            res_kwargs = {"hsds": hsds}
 
         logger.info("Extracting ProjectPoints for desired regions")
         points = []
-        with res_cls(res_file, hsds=hsds) as f:
+        with res_cls(res_file, **res_kwargs) as f:
             meta = f.meta
             for region, region_col in regions.items():
                 logger.debug("- {}: {}".format(region_col, region))
@@ -1181,7 +1184,7 @@ class ProjectPoints:
                     if duplicates:
                         msg = (
                             "reV Cannot currently handle duplicate "
-                            "Resource gids! The given regions containg the "
+                            "Resource gids! The given regions containing the "
                             "same gids:\n{}".format(duplicates)
                         )
                         logger.error(msg)

{nrel_rev-0.13.1 → nrel_rev-0.14.1}/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)