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

reV/bespoke/bespoke.py

@@ -222,6 +222,7 @@ class BespokeSinglePlant:
         capital_cost_function,
         fixed_operating_cost_function,
         variable_operating_cost_function,
+        balance_of_system_cost_function,
         min_spacing="5x",
         wake_loss_multiplier=1,
         ga_kwargs=None,
@@ -262,19 +263,33 @@ class BespokeSinglePlant:
             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.
-                - self.wind_plant: the SAM wind plant object, through which
-                  all SAM variables can be accessed
-                - capital_cost: plant capital cost as evaluated
+                - ``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`
+                - ``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
@@ -287,6 +302,16 @@ class BespokeSinglePlant:
         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. 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.
+        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.
         min_spacing : float | int | str
             Minimum spacing between turbines in meters. Can also be a string
@@ -431,6 +456,7 @@ class BespokeSinglePlant:
         self.variable_operating_cost_function = (
             variable_operating_cost_function
         )
+        self.balance_of_system_cost_function = balance_of_system_cost_function
         self.min_spacing = min_spacing
         self.wake_loss_multiplier = wake_loss_multiplier
         self.ga_kwargs = ga_kwargs or {}
@@ -540,7 +566,7 @@ class BespokeSinglePlant:
 
         # {meta_column: sam_sys_input_key}
         required = {
-            SupplyCurveField.CAPACITY: "system_capacity",
+            SupplyCurveField.CAPACITY_AC_MW: "system_capacity",
             SupplyCurveField.TURBINE_X_COORDS: "wind_farm_xCoordinates",
             SupplyCurveField.TURBINE_Y_COORDS: "wind_farm_yCoordinates",
         }
@@ -812,28 +838,23 @@ class BespokeSinglePlant:
                 [float(np.round(n, 1)) for n in self.sc_point.gid_counts]
             )
 
-            with SupplyCurveExtent(
-                self.sc_point._excl_fpath, resolution=self.sc_point.resolution
-            ) as sc:
-                row_ind, col_ind = sc.get_sc_row_col_ind(self.sc_point.gid)
-
             self._meta = pd.DataFrame(
                 {
-                    SupplyCurveField.SC_POINT_GID: self.sc_point.gid,
-                    SupplyCurveField.SC_ROW_IND: row_ind,
-                    SupplyCurveField.SC_COL_IND: col_ind,
-                    SupplyCurveField.GID: self.sc_point.gid,
+                    "gid": self.sc_point.gid,  # needed for collection
                     SupplyCurveField.LATITUDE: self.sc_point.latitude,
                     SupplyCurveField.LONGITUDE: self.sc_point.longitude,
-                    SupplyCurveField.TIMEZONE: self.sc_point.timezone,
                     SupplyCurveField.COUNTRY: self.sc_point.country,
                     SupplyCurveField.STATE: self.sc_point.state,
                     SupplyCurveField.COUNTY: self.sc_point.county,
                     SupplyCurveField.ELEVATION: self.sc_point.elevation,
-                    SupplyCurveField.OFFSHORE: self.sc_point.offshore,
+                    SupplyCurveField.TIMEZONE: self.sc_point.timezone,
+                    SupplyCurveField.SC_POINT_GID: self.sc_point.sc_point_gid,
+                    SupplyCurveField.SC_ROW_IND: self.sc_point.sc_row_ind,
+                    SupplyCurveField.SC_COL_IND: self.sc_point.sc_col_ind,
                     SupplyCurveField.RES_GIDS: res_gids,
                     SupplyCurveField.GID_COUNTS: gid_counts,
                     SupplyCurveField.N_GIDS: self.sc_point.n_gids,
+                    SupplyCurveField.OFFSHORE: self.sc_point.offshore,
                     SupplyCurveField.AREA_SQ_KM: self.sc_point.area,
                 },
                 index=[self.sc_point.gid],
@@ -1026,6 +1047,7 @@ class BespokeSinglePlant:
                 self.capital_cost_function,
                 self.fixed_operating_cost_function,
                 self.variable_operating_cost_function,
+                self.balance_of_system_cost_function,
                 self.include_mask,
                 self.pixel_side_length,
                 self.min_spacing,
@@ -1046,13 +1068,13 @@ class BespokeSinglePlant:
                 "multi-year mean AEP."
             )
 
-            fcr = lcoe_kwargs["fixed_charge_rate"]
-            cap_cost = lcoe_kwargs["capital_cost"]
-            foc = lcoe_kwargs["fixed_operating_cost"]
-            voc = lcoe_kwargs["variable_operating_cost"]
-            aep = self.outputs["annual_energy-means"]
+            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']
 
-            my_mean_lcoe = lcoe_fcr(fcr, cap_cost, foc, aep, voc)
+            my_mean_lcoe = lcoe_fcr(fcr, cc, foc, aep, voc)
 
             self._outputs["lcoe_fcr-means"] = my_mean_lcoe
             self._meta[SupplyCurveField.MEAN_LCOE] = my_mean_lcoe
@@ -1068,21 +1090,28 @@ class BespokeSinglePlant:
             sam_sys_inputs, normalized to the original system_capacity, and
             updated based on the bespoke optimized system_capacity, includes
             fixed_charge_rate, system_capacity (kW), capital_cost ($),
-            fixed_operating_cos ($), variable_operating_cost ($/kWh)
-            Data source priority: outputs, plant_optimizer,
-            original_sam_sys_inputs, meta
+            fixed_operating_cos ($), variable_operating_cost ($/kWh),
+            balance_of_system_cost ($). Data source priority: outputs,
+            plant_optimizer, original_sam_sys_inputs, meta
         """
 
-        kwargs_list = [
-            "fixed_charge_rate",
-            "system_capacity",
-            "capital_cost",
-            "fixed_operating_cost",
-            "variable_operating_cost",
-        ]
+        kwargs_map = {
+            "fixed_charge_rate": SupplyCurveField.FIXED_CHARGE_RATE,
+            "system_capacity": SupplyCurveField.CAPACITY_AC_MW,
+            "capital_cost": SupplyCurveField.BESPOKE_CAPITAL_COST,
+            "fixed_operating_cost": (
+                SupplyCurveField.BESPOKE_FIXED_OPERATING_COST
+            ),
+            "variable_operating_cost": (
+                SupplyCurveField.BESPOKE_VARIABLE_OPERATING_COST
+            ),
+            "balance_of_system_cost": (
+                SupplyCurveField.BESPOKE_BALANCE_OF_SYSTEM_COST
+            ),
+        }
         lcoe_kwargs = {}
 
-        for kwarg in kwargs_list:
+        for kwarg, meta_field in kwargs_map.items():
             if kwarg in self.outputs:
                 lcoe_kwargs[kwarg] = self.outputs[kwarg]
             elif getattr(self.plant_optimizer, kwarg, None) is not None:
@@ -1092,11 +1121,13 @@ class BespokeSinglePlant:
             elif kwarg in self.meta:
                 value = float(self.meta[kwarg].values[0])
                 lcoe_kwargs[kwarg] = value
+            elif meta_field in self.meta:
+                value = float(self.meta[meta_field].values[0])
+                if meta_field == SupplyCurveField.CAPACITY_AC_MW:
+                    value *= 1000  # MW to kW
+                lcoe_kwargs[kwarg] = value
 
-        for k, v in lcoe_kwargs.items():
-            self._meta[k] = v
-
-        missing = [k for k in kwargs_list if k not in lcoe_kwargs]
+        missing = [k for k in kwargs_map if k not in lcoe_kwargs]
         if any(missing):
             msg = (
                 "Could not find these LCOE kwargs in outputs, "
@@ -1107,6 +1138,8 @@ class BespokeSinglePlant:
             logger.error(msg)
             raise KeyError(msg)
 
+        bos = lcoe_kwargs.pop("balance_of_system_cost")
+        lcoe_kwargs["capital_cost"] = lcoe_kwargs["capital_cost"] + bos
         return lcoe_kwargs
 
     @staticmethod
@@ -1153,19 +1186,18 @@ class BespokeSinglePlant:
             raise ModuleNotFoundError(msg)
 
     @staticmethod
-    def _check_sys_inputs(
-        plant1,
-        plant2,
-        ignore=(
-            "wind_resource_model_choice",
-            "wind_resource_data",
-            "wind_turbine_powercurve_powerout",
-            "hourly",
-            "capital_cost",
-            "fixed_operating_cost",
-            "variable_operating_cost",
-        ),
-    ):
+    def _check_sys_inputs(plant1, plant2,
+                          ignore=('wind_resource_model_choice',
+                                  'wind_resource_data',
+                                  'wind_turbine_powercurve_powerout',
+                                  'hourly',
+                                  'capital_cost',
+                                  'fixed_operating_cost',
+                                  'variable_operating_cost',
+                                  'balance_of_system_cost',
+                                  'base_capital_cost',
+                                  'base_fixed_operating_cost',
+                                  'base_variable_operating_cost')):
         """Check two reV-SAM models for matching system inputs.
 
         Parameters
@@ -1230,9 +1262,14 @@ class BespokeSinglePlant:
 
         self._outputs.update(means)
 
+        self._meta[SupplyCurveField.MEAN_RES] = self.res_df["windspeed"].mean()
+        self._meta[SupplyCurveField.MEAN_CF_DC] = np.nan
+        self._meta[SupplyCurveField.MEAN_CF_AC] = np.nan
+        self._meta[SupplyCurveField.MEAN_LCOE] = np.nan
+        self._meta[SupplyCurveField.SC_POINT_ANNUAL_ENERGY_MW] = np.nan
         # copy dataset outputs to meta data for supply curve table summary
         if "cf_mean-means" in self.outputs:
-            self._meta.loc[:, SupplyCurveField.MEAN_CF] = self.outputs[
+            self._meta.loc[:, SupplyCurveField.MEAN_CF_AC] = self.outputs[
                 "cf_mean-means"
             ]
         if "lcoe_fcr-means" in self.outputs:
@@ -1240,6 +1277,10 @@ class BespokeSinglePlant:
                 "lcoe_fcr-means"
             ]
             self.recalc_lcoe()
+        if "annual_energy-means" in self.outputs:
+            self._meta[SupplyCurveField.SC_POINT_ANNUAL_ENERGY_MW] = (
+                self.outputs["annual_energy-means"] / 1000
+            )
 
         logger.debug("Timeseries analysis complete!")
 
@@ -1268,9 +1309,12 @@ class BespokeSinglePlant:
             logger.exception(msg)
             raise RuntimeError(msg) from e
 
-        # TODO need to add:
-        # total cell area
-        # cell capacity density
+        self._outputs["full_polygons"] = self.plant_optimizer.full_polygons
+        self._outputs["packing_polygons"] = (
+            self.plant_optimizer.packing_polygons
+        )
+        system_capacity_kw = self.plant_optimizer.capacity
+        self._outputs["system_capacity"] = system_capacity_kw
 
         txc = [int(np.round(c)) for c in self.plant_optimizer.turbine_x]
         tyc = [int(np.round(c)) for c in self.plant_optimizer.turbine_y]
@@ -1284,58 +1328,92 @@ class BespokeSinglePlant:
 
         self._meta[SupplyCurveField.TURBINE_X_COORDS] = txc
         self._meta[SupplyCurveField.TURBINE_Y_COORDS] = tyc
-        self._meta["possible_x_coords"] = pxc
-        self._meta["possible_y_coords"] = pyc
+        self._meta[SupplyCurveField.POSSIBLE_X_COORDS] = pxc
+        self._meta[SupplyCurveField.POSSIBLE_Y_COORDS] = pyc
 
-        self._outputs["full_polygons"] = self.plant_optimizer.full_polygons
-        self._outputs["packing_polygons"] = (
-            self.plant_optimizer.packing_polygons
+        self._meta[SupplyCurveField.N_TURBINES] = self.plant_optimizer.nturbs
+        self._meta["avg_sl_dist_to_center_m"] = (
+            self.plant_optimizer.avg_sl_dist_to_center_m
         )
-        self._outputs["system_capacity"] = self.plant_optimizer.capacity
-
-        self._meta["n_turbines"] = self.plant_optimizer.nturbs
-        self._meta["bespoke_aep"] = self.plant_optimizer.aep
-        self._meta["bespoke_objective"] = self.plant_optimizer.objective
-        self._meta["bespoke_capital_cost"] = self.plant_optimizer.capital_cost
-        self._meta["bespoke_fixed_operating_cost"] = (
+        self._meta["avg_sl_dist_to_medoid_m"] = (
+            self.plant_optimizer.avg_sl_dist_to_medoid_m
+        )
+        self._meta["nn_conn_dist_m"] = self.plant_optimizer.nn_conn_dist_m
+        self._meta[SupplyCurveField.BESPOKE_AEP] = self.plant_optimizer.aep
+        self._meta[SupplyCurveField.BESPOKE_OBJECTIVE] = (
+            self.plant_optimizer.objective
+        )
+        self._meta[SupplyCurveField.BESPOKE_CAPITAL_COST] = (
+            self.plant_optimizer.capital_cost
+        )
+        self._meta[SupplyCurveField.BESPOKE_FIXED_OPERATING_COST] = (
             self.plant_optimizer.fixed_operating_cost
         )
-        self._meta["bespoke_variable_operating_cost"] = (
+        self._meta[SupplyCurveField.BESPOKE_VARIABLE_OPERATING_COST] = (
             self.plant_optimizer.variable_operating_cost
         )
-        self._meta["included_area"] = self.plant_optimizer.area
-        self._meta["included_area_capacity_density"] = (
+        self._meta[SupplyCurveField.BESPOKE_BALANCE_OF_SYSTEM_COST] = (
+            self.plant_optimizer.balance_of_system_cost
+        )
+        self._meta[SupplyCurveField.INCLUDED_AREA] = self.plant_optimizer.area
+        self._meta[SupplyCurveField.INCLUDED_AREA_CAPACITY_DENSITY] = (
             self.plant_optimizer.capacity_density
         )
-        self._meta["convex_hull_area"] = self.plant_optimizer.convex_hull_area
-        self._meta["convex_hull_capacity_density"] = (
+        self._meta[SupplyCurveField.CONVEX_HULL_AREA] = (
+            self.plant_optimizer.convex_hull_area
+        )
+        self._meta[SupplyCurveField.CONVEX_HULL_CAPACITY_DENSITY] = (
             self.plant_optimizer.convex_hull_capacity_density
         )
-        self._meta["full_cell_capacity_density"] = (
+        self._meta[SupplyCurveField.FULL_CELL_CAPACITY_DENSITY] = (
             self.plant_optimizer.full_cell_capacity_density
         )
 
-        logger.debug("Plant layout optimization complete!")
-
         # copy dataset outputs to meta data for supply curve table summary
         # convert SAM system capacity in kW to reV supply curve cap in MW
-        self._meta[SupplyCurveField.CAPACITY] = (
-            self.outputs["system_capacity"] / 1e3
-        )
+        capacity_ac_mw = system_capacity_kw / 1e3
+        self._meta[SupplyCurveField.CAPACITY_AC_MW] = capacity_ac_mw
+        self._meta[SupplyCurveField.CAPACITY_DC_MW] = np.nan
 
         # add required ReEDS multipliers to meta
         baseline_cost = self.plant_optimizer.capital_cost_per_kw(
             capacity_mw=self._baseline_cap_mw
         )
-        self._meta[SupplyCurveField.EOS_MULT] = (
+        eos_mult = (self.plant_optimizer.capital_cost
+                    / self.plant_optimizer.capacity
+                    / baseline_cost)
+        reg_mult = self.sam_sys_inputs.get("capital_cost_multiplier", 1)
+
+        self._meta[SupplyCurveField.EOS_MULT] = eos_mult
+        self._meta[SupplyCurveField.REG_MULT] = reg_mult
+
+        cap_cost = (
             self.plant_optimizer.capital_cost
-            / self.plant_optimizer.capacity
-            / baseline_cost
+            + self.plant_optimizer.balance_of_system_cost
+        )
+        self._meta[SupplyCurveField.COST_SITE_OCC_USD_PER_AC_MW] = (
+            cap_cost / capacity_ac_mw
+        )
+        self._meta[SupplyCurveField.COST_BASE_OCC_USD_PER_AC_MW] = (
+            cap_cost / eos_mult / reg_mult / capacity_ac_mw
+        )
+        self._meta[SupplyCurveField.COST_SITE_FOC_USD_PER_AC_MW] = (
+            self.plant_optimizer.fixed_operating_cost / capacity_ac_mw
+        )
+        self._meta[SupplyCurveField.COST_BASE_FOC_USD_PER_AC_MW] = (
+            self.plant_optimizer.fixed_operating_cost / 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.REG_MULT] = self.sam_sys_inputs.get(
-            "capital_cost_multiplier", 1
+        self._meta[SupplyCurveField.COST_BASE_VOC_USD_PER_AC_MW] = (
+            self.plant_optimizer.variable_operating_cost / capacity_ac_mw
+        )
+        self._meta[SupplyCurveField.FIXED_CHARGE_RATE] = (
+            self.plant_optimizer.fixed_charge_rate
         )
 
+        logger.debug("Plant layout optimization complete!")
         return self.outputs
 
     def agg_data_layers(self):
@@ -1402,36 +1480,18 @@ class BespokeSinglePlant:
 class BespokeWindPlants(BaseAggregation):
     """BespokeWindPlants"""
 
-    def __init__(
-        self,
-        excl_fpath,
-        res_fpath,
-        tm_dset,
-        objective_function,
-        capital_cost_function,
-        fixed_operating_cost_function,
-        variable_operating_cost_function,
-        project_points,
-        sam_files,
-        min_spacing="5x",
-        wake_loss_multiplier=1,
-        ga_kwargs=None,
-        output_request=("system_capacity", "cf_mean"),
-        ws_bins=(0.0, 20.0, 5.0),
-        wd_bins=(0.0, 360.0, 45.0),
-        excl_dict=None,
-        area_filter_kernel="queen",
-        min_area=None,
-        resolution=64,
-        excl_area=None,
-        data_layers=None,
-        pre_extract_inclusions=False,
-        prior_run=None,
-        gid_map=None,
-        bias_correct=None,
-        pre_load_data=False,
-    ):
-        r"""ReV bespoke analysis class.
+    def __init__(self, excl_fpath, res_fpath, tm_dset, objective_function,
+                 capital_cost_function, fixed_operating_cost_function,
+                 variable_operating_cost_function,
+                 balance_of_system_cost_function, project_points,
+                 sam_files, min_spacing='5x', wake_loss_multiplier=1,
+                 ga_kwargs=None, output_request=('system_capacity', 'cf_mean'),
+                 ws_bins=(0.0, 20.0, 5.0), wd_bins=(0.0, 360.0, 45.0),
+                 excl_dict=None, area_filter_kernel='queen', min_area=None,
+                 resolution=64, excl_area=None, data_layers=None,
+                 pre_extract_inclusions=False, prior_run=None, gid_map=None,
+                 bias_correct=None, pre_load_data=False):
+        """reV bespoke analysis class.
 
         Much like generation, ``reV`` bespoke analysis runs SAM
         simulations by piping in renewable energy resource data (usually
@@ -1503,17 +1563,30 @@ class BespokeWindPlants(BaseAggregation):
                 - ``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.
-                - ``self.wind_plant``: the SAM wind plant object,
-                  through which all SAM variables can be accessed
                 - ``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
+                  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 written out as a string.
@@ -1530,6 +1603,13 @@ class BespokeWindPlants(BaseAggregation):
             out as a string. This expression must return the variable
             operating cost in $/kWh. This expression has access to the
             same variables as the `objective_function` argument above.
+            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.
         project_points : int | list | tuple | str | dict | pd.DataFrame | slice
             Input specifying which sites to process. A single integer
             representing the supply curve GID of a site may be specified
@@ -1538,7 +1618,7 @@ class BespokeWindPlants(BaseAggregation):
             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:
+            contains the following columns:
 
                 - ``gid``: Integer specifying the supply curve GID of
                   each site.
@@ -1555,16 +1635,18 @@ class BespokeWindPlants(BaseAggregation):
             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. The CSV file input can also have
-            these extra columns:
+            these extra, optional columns:
 
                 - ``capital_cost_multiplier``
                 - ``fixed_operating_cost_multiplier``
                 - ``variable_operating_cost_multiplier``
+                - ``balance_of_system_cost_multiplier``
 
             These particular inputs are treated as multipliers to be
             applied to the respective cost curves
             (`capital_cost_function`, `fixed_operating_cost_function`,
-            and `variable_operating_cost_function`) both during and
+            `variable_operating_cost_function`, and
+            `balance_of_system_cost_function`) both during and
             after the optimization. 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
@@ -1839,30 +1921,23 @@ class BespokeWindPlants(BaseAggregation):
         """
 
         log_versions(logger)
-        logger.info("Initializing BespokeWindPlants...")
-        logger.info("Resource filepath: {}".format(res_fpath))
-        logger.info("Exclusion filepath: {}".format(excl_fpath))
-        logger.debug("Exclusion dict: {}".format(excl_dict))
-        logger.info(
-            "Bespoke objective function: {}".format(objective_function)
-        )
-        logger.info(
-            "Bespoke capital cost function: {}".format(capital_cost_function)
-        )
-        logger.info(
-            "Bespoke fixed operating cost function: {}".format(
-                fixed_operating_cost_function
-            )
-        )
-        logger.info(
-            "Bespoke variable operating cost function: {}".format(
-                variable_operating_cost_function
-            )
-        )
-        logger.info(
-            "Bespoke wake loss multiplier: {}".format(wake_loss_multiplier)
-        )
-        logger.info("Bespoke GA initialization kwargs: {}".format(ga_kwargs))
+        logger.info('Initializing BespokeWindPlants...')
+        logger.info('Resource filepath: {}'.format(res_fpath))
+        logger.info('Exclusion filepath: {}'.format(excl_fpath))
+        logger.debug('Exclusion dict: {}'.format(excl_dict))
+        logger.info('Bespoke objective function: {}'
+                    .format(objective_function))
+        logger.info('Bespoke capital cost function: {}'
+                    .format(capital_cost_function))
+        logger.info('Bespoke fixed operating cost function: {}'
+                    .format(fixed_operating_cost_function))
+        logger.info('Bespoke variable operating cost function: {}'
+                    .format(variable_operating_cost_function))
+        logger.info('Bespoke balance of system cost function: {}'
+                    .format(balance_of_system_cost_function))
+        logger.info('Bespoke wake loss multiplier: {}'
+                    .format(wake_loss_multiplier))
+        logger.info('Bespoke GA initialization kwargs: {}'.format(ga_kwargs))
 
         logger.info(
             "Bespoke pre-extracting exclusions: {}".format(
@@ -1897,6 +1972,7 @@ class BespokeWindPlants(BaseAggregation):
         self._cap_cost_fun = capital_cost_function
         self._foc_fun = fixed_operating_cost_function
         self._voc_fun = variable_operating_cost_function
+        self._bos_fun = balance_of_system_cost_function
         self._min_spacing = min_spacing
         self._wake_loss_multiplier = wake_loss_multiplier
         self._ga_kwargs = ga_kwargs or {}
@@ -1931,7 +2007,7 @@ class BespokeWindPlants(BaseAggregation):
             Slice or list specifying project points, string pointing to a
             project points csv, or a fully instantiated PointsControl object.
             Can also be a single site integer value. Points csv should have
-            `SupplyCurveField.GID` and 'config' column, the config maps to the
+            `SiteDataField.GID` and 'config' column, the config maps to the
             sam_configs dict keys.
         sam_configs : dict | str | SAMConfig
             SAM input configuration ID(s) and file path(s). Keys are the SAM
@@ -1986,6 +2062,7 @@ class BespokeWindPlants(BaseAggregation):
 
             with Outputs(prior_run, mode="r") as f:
                 meta = f.meta
+                meta = meta.rename(columns=SupplyCurveField.map_from_legacy())
 
             # pylint: disable=no-member
             for col in meta.columns:
@@ -2011,7 +2088,7 @@ class BespokeWindPlants(BaseAggregation):
         meta = None
 
         if self._prior_meta is not None:
-            mask = self._prior_meta[SupplyCurveField.GID] == gid
+            mask = self._prior_meta[SupplyCurveField.SC_POINT_GID] == gid
             if any(mask):
                 meta = self._prior_meta[mask]
 
@@ -2363,37 +2440,21 @@ class BespokeWindPlants(BaseAggregation):
 
     # pylint: disable=arguments-renamed
     @classmethod
-    def run_serial(
-        cls,
-        excl_fpath,
-        res_fpath,
-        tm_dset,
-        sam_sys_inputs,
-        objective_function,
-        capital_cost_function,
-        fixed_operating_cost_function,
-        variable_operating_cost_function,
-        min_spacing="5x",
-        wake_loss_multiplier=1,
-        ga_kwargs=None,
-        output_request=("system_capacity", "cf_mean"),
-        ws_bins=(0.0, 20.0, 5.0),
-        wd_bins=(0.0, 360.0, 45.0),
-        excl_dict=None,
-        inclusion_mask=None,
-        area_filter_kernel="queen",
-        min_area=None,
-        resolution=64,
-        excl_area=0.0081,
-        data_layers=None,
-        gids=None,
-        exclusion_shape=None,
-        slice_lookup=None,
-        prior_meta=None,
-        gid_map=None,
-        bias_correct=None,
-        pre_loaded_data=None,
-    ):
+    def run_serial(cls, excl_fpath, res_fpath, tm_dset,
+                   sam_sys_inputs, objective_function,
+                   capital_cost_function,
+                   fixed_operating_cost_function,
+                   variable_operating_cost_function,
+                   balance_of_system_cost_function,
+                   min_spacing='5x', wake_loss_multiplier=1, ga_kwargs=None,
+                   output_request=('system_capacity', 'cf_mean'),
+                   ws_bins=(0.0, 20.0, 5.0), wd_bins=(0.0, 360.0, 45.0),
+                   excl_dict=None, inclusion_mask=None,
+                   area_filter_kernel='queen', min_area=None,
+                   resolution=64, excl_area=0.0081, data_layers=None,
+                   gids=None, exclusion_shape=None, slice_lookup=None,
+                   prior_meta=None, gid_map=None, bias_correct=None,
+                   pre_loaded_data=None):
         """
         Standalone serial method to run bespoke optimization.
         See BespokeWindPlants docstring for parameter description.
@@ -2446,6 +2507,7 @@ class BespokeWindPlants(BaseAggregation):
                         capital_cost_function,
                         fixed_operating_cost_function,
                         variable_operating_cost_function,
+                        balance_of_system_cost_function,
                         min_spacing=min_spacing,
                         wake_loss_multiplier=wake_loss_multiplier,
                         ga_kwargs=ga_kwargs,
@@ -2523,39 +2585,37 @@ class BespokeWindPlants(BaseAggregation):
                     rs, cs = self.slice_lookup[gid]
                     gid_incl_mask = self._inclusion_mask[rs, cs]
 
-                futures.append(
-                    exe.submit(
-                        self.run_serial,
-                        self._excl_fpath,
-                        self._res_fpath,
-                        self._tm_dset,
-                        self.sam_sys_inputs_with_site_data(gid),
-                        self._obj_fun,
-                        self._cap_cost_fun,
-                        self._foc_fun,
-                        self._voc_fun,
-                        self._min_spacing,
-                        wake_loss_multiplier=self._wake_loss_multiplier,
-                        ga_kwargs=self._ga_kwargs,
-                        output_request=self._output_request,
-                        ws_bins=self._ws_bins,
-                        wd_bins=self._wd_bins,
-                        excl_dict=self._excl_dict,
-                        inclusion_mask=gid_incl_mask,
-                        area_filter_kernel=self._area_filter_kernel,
-                        min_area=self._min_area,
-                        resolution=self._resolution,
-                        excl_area=self._excl_area,
-                        data_layers=self._data_layers,
-                        gids=gid,
-                        exclusion_shape=self.shape,
-                        slice_lookup=copy.deepcopy(self.slice_lookup),
-                        prior_meta=self._get_prior_meta(gid),
-                        gid_map=self._gid_map,
-                        bias_correct=self._get_bc_for_gid(gid),
-                        pre_loaded_data=self._pre_loaded_data_for_sc_gid(gid),
-                    )
-                )
+                futures.append(exe.submit(
+                    self.run_serial,
+                    self._excl_fpath,
+                    self._res_fpath,
+                    self._tm_dset,
+                    self.sam_sys_inputs_with_site_data(gid),
+                    self._obj_fun,
+                    self._cap_cost_fun,
+                    self._foc_fun,
+                    self._voc_fun,
+                    self._bos_fun,
+                    self._min_spacing,
+                    wake_loss_multiplier=self._wake_loss_multiplier,
+                    ga_kwargs=self._ga_kwargs,
+                    output_request=self._output_request,
+                    ws_bins=self._ws_bins,
+                    wd_bins=self._wd_bins,
+                    excl_dict=self._excl_dict,
+                    inclusion_mask=gid_incl_mask,
+                    area_filter_kernel=self._area_filter_kernel,
+                    min_area=self._min_area,
+                    resolution=self._resolution,
+                    excl_area=self._excl_area,
+                    data_layers=self._data_layers,
+                    gids=gid,
+                    exclusion_shape=self.shape,
+                    slice_lookup=copy.deepcopy(self.slice_lookup),
+                    prior_meta=self._get_prior_meta(gid),
+                    gid_map=self._gid_map,
+                    bias_correct=self._get_bc_for_gid(gid),
+                    pre_loaded_data=self._pre_loaded_data_for_sc_gid(gid)))
 
             # gather results
             for future in as_completed(futures):
@@ -2617,35 +2677,34 @@ class BespokeWindPlants(BaseAggregation):
                 wlm = self._wake_loss_multiplier
                 i_bc = self._get_bc_for_gid(gid)
 
-                si = self.run_serial(
-                    self._excl_fpath,
-                    self._res_fpath,
-                    self._tm_dset,
-                    sam_inputs,
-                    self._obj_fun,
-                    self._cap_cost_fun,
-                    self._foc_fun,
-                    self._voc_fun,
-                    min_spacing=self._min_spacing,
-                    wake_loss_multiplier=wlm,
-                    ga_kwargs=self._ga_kwargs,
-                    output_request=self._output_request,
-                    ws_bins=self._ws_bins,
-                    wd_bins=self._wd_bins,
-                    excl_dict=self._excl_dict,
-                    inclusion_mask=gid_incl_mask,
-                    area_filter_kernel=afk,
-                    min_area=self._min_area,
-                    resolution=self._resolution,
-                    excl_area=self._excl_area,
-                    data_layers=self._data_layers,
-                    slice_lookup=slice_lookup,
-                    prior_meta=prior_meta,
-                    gid_map=self._gid_map,
-                    bias_correct=i_bc,
-                    gids=gid,
-                    pre_loaded_data=pre_loaded_data,
-                )
+                si = self.run_serial(self._excl_fpath,
+                                     self._res_fpath,
+                                     self._tm_dset,
+                                     sam_inputs,
+                                     self._obj_fun,
+                                     self._cap_cost_fun,
+                                     self._foc_fun,
+                                     self._voc_fun,
+                                     self._bos_fun,
+                                     min_spacing=self._min_spacing,
+                                     wake_loss_multiplier=wlm,
+                                     ga_kwargs=self._ga_kwargs,
+                                     output_request=self._output_request,
+                                     ws_bins=self._ws_bins,
+                                     wd_bins=self._wd_bins,
+                                     excl_dict=self._excl_dict,
+                                     inclusion_mask=gid_incl_mask,
+                                     area_filter_kernel=afk,
+                                     min_area=self._min_area,
+                                     resolution=self._resolution,
+                                     excl_area=self._excl_area,
+                                     data_layers=self._data_layers,
+                                     slice_lookup=slice_lookup,
+                                     prior_meta=prior_meta,
+                                     gid_map=self._gid_map,
+                                     bias_correct=i_bc,
+                                     gids=gid,
+                                     pre_loaded_data=pre_loaded_data)
                 self._outputs.update(si)
         else:
             self._outputs = self.run_parallel(max_workers=max_workers)