NREL-reV 0.8.7__py3-none-any.whl → 0.9.0__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

@@ -4,11 +4,10 @@
 place turbines for bespoke wind plants
 """
 import numpy as np
+from shapely.geometry import MultiPoint, MultiPolygon, Point, Polygon
 
-from shapely.geometry import Point, Polygon, MultiPolygon, MultiPoint
-
-from reV.bespoke.pack_turbs import PackTurbines
 from reV.bespoke.gradient_free import GeneticAlgorithm
+from reV.bespoke.pack_turbs import PackTurbines
 from reV.utilities.exceptions import WhileLoopPackingError
 
 
@@ -49,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
@@ -111,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
@@ -129,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."""
@@ -148,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
@@ -190,7 +215,7 @@ class PlaceTurbines:
                 self.packing_polygons = MultiPolygon([])
 
     def initialize_packing(self):
-        """run the turbine packing algorithm (maximizing plant capacity) to
+        """Run the turbine packing algorithm (maximizing plant capacity) to
         define potential turbine locations that will be used as design
         variables in the gentic algorithm.
         """
@@ -211,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
@@ -218,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
@@ -227,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,
@@ -237,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())
 
@@ -354,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(
@@ -364,7 +417,7 @@ class PlaceTurbines:
     def fixed_charge_rate(self):
         """Fixed charge rate if input to the SAM WindPowerPD object, None if
         not found in inputs."""
-        return self.wind_plant.sam_sys_inputs.get('fixed_charge_rate', None)
+        return self.wind_plant.sam_sys_inputs.get("fixed_charge_rate", None)
 
     @property
     @none_until_optimized
@@ -378,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):
@@ -395,7 +470,8 @@ class PlaceTurbines:
     def convex_hull(self):
         """This is the convex hull of the turbine locations"""
         turbines = MultiPoint([Point(x, y)
-                               for x,y in zip(self.turbine_x, self.turbine_y)])
+                               for x, y in zip(self.turbine_x,
+                                               self.turbine_y)])
         return turbines.convex_hull
 
     @property
@@ -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',