Eagle density function for eco-constrained design setups

ard/eco/eagle_density.py

@@ -0,0 +1,129 @@
+import numpy as np
+from scipy.interpolate import RectBivariateSpline
+
+import openmdao.api as om
+
+
+class EagleDensityFunction(om.ExplicitComponent):
+    """
+    OpenMDAO component to evaluate eagle presence density at turbine locations.
+
+    An Ard/OpenMDAO component that evaluates the eagle presence density metric
+    calculated by the National Laboratory of the Rockies's Stochastic Soaring
+    Raptor Simulator (SSRS) at the turbine locations. The eagle presence density
+    is an output of an SSRS simulation indicating the unit density function of
+    a raptor flying through the point during a given migratory period.
+
+    Options
+    -------
+    modeling_options : dict
+        a modeling options dictionary (inherited from
+        `templates.LanduseTemplate`)
+
+    Inputs
+    ------
+    x_turbines : np.ndarray
+        a 1-D numpy array that represents the x (i.e. Easting) coordinate of
+        the location of each of the turbines in the farm in meters
+    y_turbines : np.ndarray
+        a 1-D numpy array that represents the y (i.e. Northing) coordinate of
+        the location of each of the turbines in the farm in meters
+
+    Outputs
+    -------
+    eagle_normalized_density : np.ndarray
+        a 1-D numpy array that represents the normalized eagle presence density
+        at each of the turbine locations (unitless)
+    """
+
+    def initialize(self):
+        """Initialization of OM component."""
+        self.options.declare("modeling_options")
+
+    def setup(self):
+        """Setup of OM component."""
+
+        # load modeling options and turbine count
+        modeling_options = self.modeling_options = self.options["modeling_options"]
+
+        self.N_turbines = modeling_options["layout"]["N_turbines"]
+
+        # grab the eagle presence density settings
+        self.pres = self.modeling_options["eco"]["eagle_presence_density_map"]
+        self.eagle_density_function = RectBivariateSpline(
+            self.pres["x"], self.pres["y"], self.pres["normalized_presence_density"]
+        )
+        self.eagle_density_function_dx = self.eagle_density_function.partial_derivative(
+            dx=1, dy=0
+        )
+        self.eagle_density_function_dy = self.eagle_density_function.partial_derivative(
+            dx=0, dy=1
+        )
+
+        # add the full layout inputs
+        self.add_input(
+            "x_turbines",
+            np.zeros((self.N_turbines,)),
+            units="m",
+            desc="turbine location in x-direction",
+        )
+        self.add_input(
+            "y_turbines",
+            np.zeros((self.N_turbines,)),
+            units="m",
+            desc="turbine location in y-direction",
+        )
+
+        # add outputs that are universal
+        self.add_output(
+            "eagle_normalized_density",
+            np.zeros((self.N_turbines,)),
+            units=None,
+            desc="normalized eagle presence density",
+        )
+
+    def setup_partials(self):
+        """Setup the OpenMDAO component partial derivatives."""
+        self.declare_partials(
+            "eagle_normalized_density",
+            "x_turbines",
+            diagonal=True,
+            method="exact",
+        )
+        self.declare_partials(
+            "eagle_normalized_density",
+            "y_turbines",
+            diagonal=True,
+            method="exact",
+        )
+
+    def compute(self, inputs, outputs):
+        """
+        Computation for the OM component.
+        """
+
+        # unpack the turbine locations
+        x_turbines = inputs["x_turbines"]  # m
+        y_turbines = inputs["y_turbines"]  # m
+
+        # evaluate the density function at each turbine point
+        outputs["eagle_normalized_density"] = self.eagle_density_function(
+            x_turbines,
+            y_turbines,
+            grid=False,
+        )
+
+    def compute_partials(self, inputs, partials):
+        """
+        Compute the partials for the OM component
+        """
+
+        # unpack the turbine locations
+        x_turbines = inputs["x_turbines"]  # m
+        y_turbines = inputs["y_turbines"]  # m
+
+        # evaluate the gradients for each variable
+        dfdx = self.eagle_density_function_dx(x_turbines, y_turbines, grid=False)
+        dfdy = self.eagle_density_function_dy(x_turbines, y_turbines, grid=False)
+        partials["eagle_normalized_density", "x_turbines"] = dfdx
+        partials["eagle_normalized_density", "y_turbines"] = dfdy

ard/layout/exclusions.py

@@ -25,6 +25,12 @@ class FarmExclusionDistancePolygon(om.ExplicitComponent):
     y_turbines : np.ndarray
         a 1D numpy array indicating the y-dimension locations of the turbines,
         with length `N_turbines` (mirrored w.r.t. `FarmAeroTemplate`)
+
+    Outputs
+    -------
+    exclusion_distances : np.ndarray
+        a 1D array of distances (in meters) from each turbine to its assigned
+        polygonal exclusion region
     """
 
     def initialize(self):
@@ -49,7 +55,7 @@ def setup(self):
                 "The circular exclusions from windIO have not been implemented here, yet."
             )
         if "polygons" not in self.windIO["site"]["exclusions"]:
-            raise KeyError(
+            raise NotImplementedError(
                 "Currently only polygon exclusions from windIO have been implemented and none were found."
             )
         self.exclusion_vertices = [
@@ -62,7 +68,7 @@ def setup(self):
             for polygon in self.windIO["site"]["exclusions"]["polygons"]
         ]
         self.exclusion_regions = self.modeling_options.get("exclusions", {}).get(
-            "turbine_exclusion_assignments",  # get the exclusion region assignments from modeling_options, if there
+            "turbine_exclusion_assignments",  # exclusion region assignments, if there
             np.zeros(self.N_turbines, dtype=int),  # default to zero for all turbines
         )
 
@@ -87,7 +93,7 @@ def setup(self):
 
     def setup_partials(self):
         """Derivative setup for the OpenMDAO component."""
-        # the default (but not preferred!) derivatives are FDM
+        # override the OpenMDAO default FDM derivatives by declaring exact derivatives
         self.declare_partials(
             "*",
             "*",

ard/layout/gridfarm.py

@@ -91,8 +91,8 @@ def setup(self):
         angle_skew = self.modeling_options["layout"]["angle_skew"]
 
         # add four-parameter grid farm layout DVs
-        self.add_input("spacing_primary", spacing_primary, units="unitless")
-        self.add_input("spacing_secondary", spacing_secondary, units="unitless")
+        self.add_input("spacing_primary", spacing_primary, units=None)
+        self.add_input("spacing_secondary", spacing_secondary, units=None)
         self.add_input("angle_orientation", angle_orientation, units="deg")
         self.add_input("angle_skew", angle_skew, units="deg")
 
@@ -227,13 +227,13 @@ def setup(self):
         self.add_input(
             "spacing_primary",
             self.modeling_options["layout"]["spacing_primary"],
-            units="unitless",
+            units=None,
             desc="turbine row spacing in rotor diameters",
         )
         self.add_input(
             "spacing_secondary",
             self.modeling_options["layout"]["spacing_secondary"],
-            units="unitless",
+            units=None,
             desc="turbine column spacing (along rows) in rotor diameters",
         )
         self.add_input(

test/ard/unit/eco/inputs/ard_system_eagle_density.yaml

@@ -0,0 +1,6 @@
+modeling_options: &modeling_options
+  windIO_plant:
+  layout:
+    N_turbines: 9
+  eco:
+    eagle_presence_density_map: !include presence_density.yaml