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

reV/bespoke/cli_bespoke.py

@@ -54,6 +54,8 @@ def _log_bespoke_cli_inputs(config):
                 .format(config.get("fixed_operating_cost_function")))
     logger.info('Bespoke variable operating cost function: "{}"'
                 .format(config.get("variable_operating_cost_function")))
+    logger.info('Bespoke balance of system cost function: "{}"'
+                .format(config.get("balance_of_system_cost_function")))
     logger.info('Bespoke wake loss multiplier: "{}"'
                 .format(config.get("wake_loss_multiplier", 1)))
     logger.info('The following project points were specified: "{}"'

reV/bespoke/place_turbines.py

@@ -48,51 +48,74 @@ class PlaceTurbines:
                  capital_cost_function,
                  fixed_operating_cost_function,
                  variable_operating_cost_function,
+                 balance_of_system_cost_function,
                  include_mask, pixel_side_length, min_spacing,
                  wake_loss_multiplier=1):
         """
         Parameters
         ----------
         wind_plant : WindPowerPD
-            wind plant object to analyze wind plant performance. This object
-            should have everything in the plant defined, such that only the
-            turbine coordinates and plant capacity need to be defined during
-            the optimization.
+            wind plant object to analyze wind plant performance. This
+            object should have everything in the plant defined, such
+            that only the turbine coordinates and plant capacity need to
+            be defined during the optimization.
         objective_function : str
-            The objective function of the optimization as a string, should
-            return the objective to be minimized during layout optimization.
-            Variables available are:
-
-                - n_turbines: the number of turbines
-                - system_capacity: wind plant capacity
-                - aep: annual energy production
-                - fixed_charge_rate: user input fixed_charge_rate if included
-                  as part of the sam system config.
-                - capital_cost: plant capital cost as evaluated
+            The objective function of the optimization as a string,
+            should return the objective to be minimized during layout
+            optimization. Variables available are:
+
+                - ``n_turbines``: the number of turbines
+                - ``system_capacity``: wind plant capacity
+                - ``aep``: annual energy production
+                - ``avg_sl_dist_to_center_m``: Average straight-line
+                  distance to the supply curve point center from all
+                  turbine locations (in m). Useful for computing plant
+                  BOS costs.
+                - ``avg_sl_dist_to_medoid_m``: Average straight-line
+                  distance to the medoid of all turbine locations
+                  (in m). Useful for computing plant BOS costs.
+                - ``nn_conn_dist_m``: Total BOS connection distance
+                  using nearest-neighbor connections. This variable is
+                  only available for the
+                  ``balance_of_system_cost_function`` equation.
+                - ``fixed_charge_rate``: user input fixed_charge_rate if
+                  included as part of the sam system config.
+                - ``capital_cost``: plant capital cost as evaluated
                   by `capital_cost_function`
-                - fixed_operating_cost: plant fixed annual operating cost as
-                  evaluated by `fixed_operating_cost_function`
-                - variable_operating_cost: plant variable annual operating cost
-                  as evaluated by `variable_operating_cost_function`
-                - self.wind_plant: the SAM wind plant object, through which
-                  all SAM variables can be accessed
-                - cost: the annual cost of the wind plant (from cost_function)
+                - ``fixed_operating_cost``: plant fixed annual operating
+                  cost as evaluated by `fixed_operating_cost_function`
+                - ``variable_operating_cost``: plant variable annual
+                  operating cost as evaluated by
+                  `variable_operating_cost_function`
+                - ``balance_of_system_cost``: plant balance of system
+                  cost as evaluated by `balance_of_system_cost_function`
+                - ``self.wind_plant``: the SAM wind plant object,
+                  through which all SAM variables can be accessed
 
         capital_cost_function : str
-            The plant capital cost function as a string, must return the total
-            capital cost in $. Has access to the same variables as the
-            objective_function.
+            The plant capital cost function as a string, must return the
+            total capital cost in $. Has access to the same variables as
+            the objective_function.
         fixed_operating_cost_function : str
-            The plant annual fixed operating cost function as a string, must
-            return the fixed operating cost in $/year. Has access to the same
-            variables as the objective_function.
+            The plant annual fixed operating cost function as a string,
+            must return the fixed operating cost in $/year. Has access
+            to the same variables as the objective_function.
         variable_operating_cost_function : str
-            The plant annual variable operating cost function as a string, must
-            return the variable operating cost in $/kWh. Has access to the same
-            variables as the objective_function.
-        exclusions : ExclusionMaskFromDict
-            The exclusions that define where turbines can be placed. Contains
-            exclusions.latitude, exclusions.longitude, and exclusions.mask
+            The plant annual variable operating cost function as a
+            string, must return the variable operating cost in $/kWh.
+            Has access to the same variables as the objective_function.
+            You can set this to "0" to effectively ignore variable
+            operating costs.
+        balance_of_system_cost_function : str
+            The plant balance-of-system cost function as a string, must
+            return the variable operating cost in $. Has access to the
+            same variables as the objective_function. You can set this
+            to "0" to effectively ignore balance-of-system costs.
+        include_mask : np.ndarray
+            Supply curve point 2D inclusion mask where included pixels
+            are set to 1 and excluded pixels are set to 0.
+        pixel_side_length : int
+            Side length (m) of a single pixel of the `include_mask`.
         min_spacing : float
             The minimum spacing between turbines (in meters).
         wake_loss_multiplier : float, optional
@@ -110,6 +133,7 @@ class PlaceTurbines:
         self.fixed_operating_cost_function = fixed_operating_cost_function
         self.variable_operating_cost_function = \
             variable_operating_cost_function
+        self.balance_of_system_cost_function = balance_of_system_cost_function
 
         self.objective_function = objective_function
         self.include_mask = include_mask
@@ -128,12 +152,14 @@ class PlaceTurbines:
         self.packing_polygons = None
         self.optimized_design_variables = None
         self.safe_polygons = None
+        self._optimized_nn_conn_dist_m = None
 
         self.ILLEGAL = ('import ', 'os.', 'sys.', '.__', '__.', 'eval', 'exec')
         self._preflight(self.objective_function)
         self._preflight(self.capital_cost_function)
         self._preflight(self.fixed_operating_cost_function)
         self._preflight(self.variable_operating_cost_function)
+        self._preflight(self.balance_of_system_cost_function)
 
     def _preflight(self, eqn):
         """Run preflight checks on the equation string."""
@@ -147,7 +173,7 @@ class PlaceTurbines:
         """From the exclusions data, create a shapely MultiPolygon as
         self.safe_polygons that defines where turbines can be placed.
         """
-        nx, ny = np.shape(self.include_mask)
+        ny, nx = np.shape(self.include_mask)
         self.safe_polygons = MultiPolygon()
         side_x = np.arange(nx + 1) * self.pixel_side_length
         side_y = np.arange(ny, -1, -1) * self.pixel_side_length
@@ -210,6 +236,23 @@ class PlaceTurbines:
         self.x_locations = packing.turbine_x
         self.y_locations = packing.turbine_y
 
+    def _sc_center(self):
+        """Supply curve point center. """
+        ny, nx = np.shape(self.include_mask)
+        cx = nx * self.pixel_side_length / 2
+        cy = ny * self.pixel_side_length / 2
+        return cx, cy
+
+    def _avg_sl_dist_to_cent(self, x_locs, y_locs):
+        """Average straight-line distance to center from turb locations. """
+        cx, cy = self._sc_center()
+        return np.hypot(x_locs - cx, y_locs - cy).mean()
+
+    def _avg_sl_dist_to_med(self, x_locs, y_locs):
+        """Average straight-line distance to turbine medoid. """
+        cx, cy = _turb_medoid(x_locs, y_locs)
+        return np.hypot(x_locs - cx, y_locs - cy).mean()
+
     # pylint: disable=W0641,W0123
     def optimization_objective(self, x):
         """The optimization objective used in the bespoke optimization
@@ -217,8 +260,9 @@ class PlaceTurbines:
         x = [bool(y) for y in x]
         if len(x) > 0:
             n_turbines = np.sum(x)
-            self.wind_plant["wind_farm_xCoordinates"] = self.x_locations[x]
-            self.wind_plant["wind_farm_yCoordinates"] = self.y_locations[x]
+            x_locs, y_locs = self.x_locations[x], self.y_locations[x]
+            self.wind_plant["wind_farm_xCoordinates"] = x_locs
+            self.wind_plant["wind_farm_yCoordinates"] = y_locs
 
             system_capacity = n_turbines * self.turbine_capacity
             self.wind_plant["system_capacity"] = system_capacity
@@ -226,8 +270,14 @@ class PlaceTurbines:
             self.wind_plant.assign_inputs()
             self.wind_plant.execute()
             aep = self._aep_after_scaled_wake_losses()
+            avg_sl_dist_to_center_m = self._avg_sl_dist_to_cent(x_locs, y_locs)
+            avg_sl_dist_to_medoid_m = self._avg_sl_dist_to_med(x_locs, y_locs)
+            if "nn_conn_dist_m" in self.balance_of_system_cost_function:
+                nn_conn_dist_m = _compute_nn_conn_dist(x_locs, y_locs)
         else:
             n_turbines = system_capacity = aep = 0
+            avg_sl_dist_to_center_m = avg_sl_dist_to_medoid_m = 0
+            nn_conn_dist_m = 0
 
         fixed_charge_rate = self.fixed_charge_rate
         capital_cost = eval(self.capital_cost_function,
@@ -236,13 +286,16 @@ class PlaceTurbines:
                                     globals(), locals())
         variable_operating_cost = eval(self.variable_operating_cost_function,
                                        globals(), locals())
-
+        balance_of_system_cost = eval(self.balance_of_system_cost_function,
+                                      globals(), locals())
         capital_cost *= self.wind_plant.sam_sys_inputs.get(
             'capital_cost_multiplier', 1)
         fixed_operating_cost *= self.wind_plant.sam_sys_inputs.get(
             'fixed_operating_cost_multiplier', 1)
         variable_operating_cost *= self.wind_plant.sam_sys_inputs.get(
             'variable_operating_cost_multiplier', 1)
+        balance_of_system_cost *= self.wind_plant.sam_sys_inputs.get(
+            'balance_of_system_cost_multiplier', 1)
 
         objective = eval(self.objective_function, globals(), locals())
 
@@ -353,6 +406,7 @@ class PlaceTurbines:
         """
 
         fixed_charge_rate = self.fixed_charge_rate
+        avg_sl_dist_to_center_m = self.avg_sl_dist_to_center_m
         n_turbines = int(round(capacity_mw * 1e3 / self.turbine_capacity))
         system_capacity = n_turbines * self.turbine_capacity
         mult = self.wind_plant.sam_sys_inputs.get(
@@ -377,6 +431,28 @@ class PlaceTurbines:
         """This is the final optimized turbine y locations (m)"""
         return self.y_locations[self.optimized_design_variables]
 
+    @property
+    @none_until_optimized
+    def avg_sl_dist_to_center_m(self):
+        """This is the final avg straight line distance to center (m)"""
+        return self._avg_sl_dist_to_cent(self.turbine_x, self.turbine_y)
+
+    @property
+    @none_until_optimized
+    def avg_sl_dist_to_medoid_m(self):
+        """This is the final avg straight line distance to turb medoid (m)"""
+        return self._avg_sl_dist_to_med(self.turbine_x, self.turbine_y)
+
+    @property
+    @none_until_optimized
+    def nn_conn_dist_m(self):
+        """This is the final avg straight line distance to turb medoid (m)"""
+        if self._optimized_nn_conn_dist_m is None:
+            self._optimized_nn_conn_dist_m = _compute_nn_conn_dist(
+                self.turbine_x, self.turbine_y
+            )
+        return self._optimized_nn_conn_dist_m
+
     @property
     @none_until_optimized
     def nturbs(self):
@@ -476,6 +552,10 @@ class PlaceTurbines:
         n_turbines = self.nturbs
         system_capacity = self.capacity
         aep = self.aep
+        avg_sl_dist_to_center_m = self.avg_sl_dist_to_center_m
+        avg_sl_dist_to_medoid_m = self.avg_sl_dist_to_medoid_m
+        nn_conn_dist_m = self.nn_conn_dist_m
+
         mult = self.wind_plant.sam_sys_inputs.get(
             'capital_cost_multiplier', 1)
         return eval(self.capital_cost_function, globals(), locals()) * mult
@@ -490,6 +570,10 @@ class PlaceTurbines:
         n_turbines = self.nturbs
         system_capacity = self.capacity
         aep = self.aep
+        avg_sl_dist_to_center_m = self.avg_sl_dist_to_center_m
+        avg_sl_dist_to_medoid_m = self.avg_sl_dist_to_medoid_m
+        nn_conn_dist_m = self.nn_conn_dist_m
+
         mult = self.wind_plant.sam_sys_inputs.get(
             'fixed_operating_cost_multiplier', 1)
         return eval(self.fixed_operating_cost_function,
@@ -505,11 +589,32 @@ class PlaceTurbines:
         n_turbines = self.nturbs
         system_capacity = self.capacity
         aep = self.aep
+        avg_sl_dist_to_center_m = self.avg_sl_dist_to_center_m
+        avg_sl_dist_to_medoid_m = self.avg_sl_dist_to_medoid_m
+        nn_conn_dist_m = self.nn_conn_dist_m
+
         mult = self.wind_plant.sam_sys_inputs.get(
             'variable_operating_cost_multiplier', 1)
         return eval(self.variable_operating_cost_function,
                     globals(), locals()) * mult
 
+    @property
+    @none_until_optimized
+    def balance_of_system_cost(self):
+        """This is the balance of system cost of the optimized plant ($)"""
+        fixed_charge_rate = self.fixed_charge_rate
+        n_turbines = self.nturbs
+        system_capacity = self.capacity
+        aep = self.aep
+        avg_sl_dist_to_center_m = self.avg_sl_dist_to_center_m
+        avg_sl_dist_to_medoid_m = self.avg_sl_dist_to_medoid_m
+        nn_conn_dist_m = self.nn_conn_dist_m
+
+        mult = self.wind_plant.sam_sys_inputs.get(
+            'balance_of_system_cost_multiplier', 1)
+        return eval(self.balance_of_system_cost_function,
+                    globals(), locals()) * mult
+
     # pylint: disable=W0641,W0123
     @property
     @none_until_optimized
@@ -522,4 +627,43 @@ class PlaceTurbines:
         capital_cost = self.capital_cost
         fixed_operating_cost = self.fixed_operating_cost
         variable_operating_cost = self.variable_operating_cost
+        balance_of_system_cost = self.balance_of_system_cost
+        avg_sl_dist_to_center_m = self.avg_sl_dist_to_center_m
+        avg_sl_dist_to_medoid_m = self.avg_sl_dist_to_medoid_m
+        nn_conn_dist_m = self.nn_conn_dist_m
+
         return eval(self.objective_function, globals(), locals())
+
+
+def _turb_medoid(x_locs, y_locs):
+    """Turbine medoid. """
+    return np.median(x_locs), np.median(y_locs)
+
+
+def _compute_nn_conn_dist(x_coords, y_coords):
+    """Connect turbines using a greedy nearest-neighbor approach. """
+    if len(x_coords) <= 1:
+        return 0
+
+    coordinates = np.c_[x_coords, y_coords]
+    allowed_conns = np.r_[coordinates.mean(axis=0)[None], coordinates]
+
+    mask = np.zeros_like(allowed_conns)
+    mask[0] = 1
+    left_to_connect = np.ma.array(allowed_conns, mask=mask)
+
+    mask = np.ones_like(allowed_conns)
+    mask[0] = 0
+    allowed_conns = np.ma.array(allowed_conns, mask=mask)
+
+    total_dist = 0
+    for __ in range(len(coordinates)):
+        dists = left_to_connect[:, :, None] - allowed_conns.T[None]
+        dists = np.hypot(dists[:, 0], dists[:, 1])
+        min_dists = dists.min(axis=-1)
+        total_dist += min_dists.min()
+        next_connection = min_dists.argmin()
+        allowed_conns.mask[next_connection] = 0
+        left_to_connect.mask[next_connection] = 1
+
+    return total_dist

reV/config/output_request.py

@@ -37,7 +37,7 @@ class OutputRequest(list):
         for request in inp:
             if request in self.CORRECTIONS.values():
                 self.append(request)
-            elif request in self.CORRECTIONS.keys():
+            elif request in self.CORRECTIONS:
                 self.append(self.CORRECTIONS[request])
                 msg = ('Correcting output request "{}" to "{}".'
                        .format(request, self.CORRECTIONS[request]))
@@ -61,6 +61,7 @@ class SAMOutputRequest(OutputRequest):
     # all available SAM output variables should be in the values
     CORRECTIONS = {'cf_means': 'cf_mean',
                    'cf': 'cf_mean',
+                   'capacity': 'system_capacity',
                    'capacity_factor': 'cf_mean',
                    'capacityfactor': 'cf_mean',
                    'cf_profiles': 'cf_profile',

reV/config/project_points.py

@@ -623,9 +623,7 @@ class ProjectPoints:
 
         # pylint: disable=no-member
         if SiteDataField.CONFIG not in df.columns:
-            df = cls._parse_sites(
-                df[SiteDataField.GID].values, res_file=res_file
-            )
+            df[SiteDataField.CONFIG] = None
 
         gids = df[SiteDataField.GID].values
         if not np.array_equal(np.sort(gids), gids):

reV/econ/econ.py

@@ -76,25 +76,36 @@ class Econ(BaseGen):
             (or slice) representing the GIDs of multiple sites can be
             specified to evaluate reV at multiple specific locations.
             A string pointing to a project points CSV file may also be
-            specified. Typically, the CSV contains two columns:
+            specified. Typically, the CSV contains the following
+            columns:
 
-                - ``gid``: Integer specifying the GID of each site.
+                - ``gid``: Integer specifying the generation GID of each
+                  site.
                 - ``config``: Key in the `sam_files` input dictionary
                   (see below) corresponding to the SAM configuration to
                   use for each particular site. This value can also be
                   ``None`` (or left out completely) if you specify only
                   a single SAM configuration file as the `sam_files`
                   input.
-
-            The CSV file may also contain site-specific inputs by
+                - ``capital_cost_multiplier``: This is an *optional*
+                  multiplier input that, if included, will be used to
+                  regionally scale the ``capital_cost`` input in the SAM
+                  config. If you include this column in your CSV, you
+                  *do not* need to specify ``capital_cost``, unless you
+                  would like that value to vary regionally and
+                  independently of the multiplier (i.e. the multiplier
+                  will still be applied on top of the ``capital_cost``
+                  input).
+
+            The CSV file may also contain other site-specific inputs by
             including a column named after a config keyword (e.g. a
-            column called ``capital_cost`` may be included to specify a
-            site-specific capital cost value for each location). Columns
-            that do not correspond to a config key may also be included,
-            but they will be ignored. A DataFrame following the same
-            guidelines as the CSV input (or a dictionary that can be
-            used to initialize such a DataFrame) may be used for this
-            input as well.
+            column called ``wind_turbine_rotor_diameter`` may be
+            included to specify a site-specific turbine diameter for
+            each location). Columns that do not correspond to a config
+            key may also be included, but they will be ignored. A
+            DataFrame following the same guidelines as the CSV input
+            (or a dictionary that can be used to initialize such a
+            DataFrame) may be used for this input as well.
         sam_files : dict | str
             A dictionary mapping SAM input configuration ID(s) to SAM
             configuration(s). Keys are the SAM config ID(s) which
@@ -352,7 +363,7 @@ 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 `SupplyCurveField.GID` column.
+            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.
@@ -405,7 +416,7 @@ 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:

reV/econ/economies_of_scale.py

@@ -113,7 +113,8 @@ class EconomiesOfScale:
         """
         var_names = []
         if self._eqn is not None:
-            delimiters = ("*", "/", "+", "-", " ", "(", ")", "[", "]", ",")
+            delimiters = (">", "<", ">=", "<=", "==", ",", "*", "/", "+", "-",
+                          " ", "(", ")", "[", "]")
             regex_pattern = "|".join(map(re.escape, delimiters))
             var_names = []
             for sub in re.split(regex_pattern, str(self._eqn)):
@@ -190,6 +191,29 @@ 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
+
+        return cap * cost_per_mw
+
     @property
     def raw_capital_cost(self):
         """Unscaled (raw) capital cost found in the data input arg.
@@ -199,10 +223,13 @@ class EconomiesOfScale:
         out : float | np.ndarray
             Unscaled (raw) capital_cost found in the data input arg.
         """
-        key_list = [
-            SupplyCurveField.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
@@ -220,18 +247,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
@@ -241,12 +256,12 @@ class EconomiesOfScale:
         out : float | np.ndarray
             Fixed charge rate from input data arg
         """
-        key_list = [
-            SupplyCurveField.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
@@ -258,12 +273,14 @@ class EconomiesOfScale:
         out : float | np.ndarray
             Fixed operating cost from input data arg
         """
-        key_list = [
-            SupplyCurveField.FIXED_OPERATING_COST,
-            "mean_fixed_operating_cost",
-            "foc",
-            "mean_foc",
-        ]
+        foc_from_cap = self._cost_from_cap(
+            SupplyCurveField.COST_SITE_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
@@ -275,12 +292,14 @@ class EconomiesOfScale:
         out : float | np.ndarray
             Variable operating cost from input data arg
         """
-        key_list = [
-            SupplyCurveField.VARIABLE_OPERATING_COST,
-            "mean_variable_operating_cost",
-            "voc",
-            "mean_voc",
-        ]
+        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
+
+        key_list = ["variable_operating_cost", "mean_variable_operating_cost",
+                    "voc", "mean_voc"]
         return self._get_prioritized_keys(self._data, key_list)
 
     @property

reV/generation/base.py

@@ -45,6 +45,21 @@ with open(os.path.join(ATTR_DIR, 'windbos.json')) as f:
 with open(os.path.join(ATTR_DIR, 'lcoe_fcr_inputs.json')) as f:
     LCOE_IN_ATTRS = json.load(f)
 
+LCOE_REQUIRED_OUTPUTS = ("system_capacity", "capital_cost_multiplier",
+                         "capital_cost", "fixed_operating_cost",
+                         "variable_operating_cost", "base_capital_cost",
+                         "base_fixed_operating_cost",
+                         "base_variable_operating_cost", "fixed_charge_rate")
+"""Required econ outputs in generation file."""
+
+
+def _add_lcoe_outputs(output_request):
+    """Add required lcoe outputs to output request. """
+    for out_var in LCOE_REQUIRED_OUTPUTS:
+        if out_var not in output_request:
+            output_request.append(out_var)
+    return output_request
+
 
 class BaseGen(ABC):
     """Base class for reV gen and econ classes to run SAM simulations."""
@@ -302,7 +317,7 @@ class BaseGen(ABC):
             Meta data df for sites in project points. Column names are meta
             data variables, rows are different sites. The row index
             does not indicate the site number if the project points are
-            non-sequential or do not start from 0, so a `SupplyCurveField.GID`
+            non-sequential or do not start from 0, so a `SiteDataField.GID`
             column is added.
         """
         return self._meta
@@ -859,7 +874,6 @@ class BaseGen(ABC):
         """
         self.project_points.join_df(site_data, key=self.site_data.index.name)
 
-    @abstractmethod
     def _parse_output_request(self, req):
         """Set the output variables requested from the user.
 
@@ -873,6 +887,12 @@ class BaseGen(ABC):
         output_request : list
             Output variables requested from SAM.
         """
+        output_request = self._output_request_type_check(req)
+
+        if "lcoe_fcr" in output_request:
+            output_request = _add_lcoe_outputs(output_request)
+
+        return output_request
 
     def _get_data_shape(self, dset, n_sites):
         """Get the output array shape based on OUT_ATTRS or PySAM.Outputs.