Wind direction heterogeneity

examples/examples_heterogeneous/00x_wind_direction_heterogeneity.py

@@ -0,0 +1,79 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+import floris.layout_visualization as layoutviz
+from floris import FlorisModel
+from floris.flow_visualization import visualize_cut_plane
+
+
+visualize = True
+
+# Get a test fi (single turbine at 0,0)
+fmodel = FlorisModel("../inputs/gch.yaml")
+fmodel.set(layout_x=[0, 0, 600, 600], layout_y=[0, -300, 0, -300])
+
+fmodel.set(
+    wind_directions=[270.0],
+    wind_speeds=[8.0],
+    turbulence_intensities=[0.06],
+    wind_shear=0.0
+)
+fmodel.run()
+P_wo_het = fmodel.get_turbine_powers()/1e6
+
+het_inflow_config = {
+    "x": np.array([-1000.0, -1000.0, 1000.0, 1000.0]),
+    "y": np.array([-500.0, 500.0, -500.0, 500.0]),
+    "speed_multipliers": np.array([[1.0, 1.0, 1.0, 1.0]]),
+    "u": np.array([[8.0, 8.0, 8.0, 8.0]]),
+    "v": np.array([[-2.0, 0.0, -2.0, 0.0]]),
+    #"v": np.array([[0.0, 0.0, 0.0, 0.0]]),
+}
+
+fmodel.set(heterogeneous_inflow_config=het_inflow_config)
+fmodel.run()
+P_w_het = fmodel.get_turbine_powers()/1e6
+
+print("Difference (MW):", P_w_het - P_wo_het)
+
+if visualize:
+    fig, ax = plt.subplots(2, 1, figsize=(4,8))
+    fmodel.set(
+        heterogeneous_inflow_config={
+            "x": np.array([-1000.0, -1000.0, 1000.0, 1000.0]),
+            "y": np.array([-1000.0, 1000.0, -1000.0, 1000.0]),
+            "speed_multipliers":np.array([[1.0, 1.0, 1.0, 1.0]])
+        }
+    )
+    fmodel.run()
+    horizontal_plane = fmodel.calculate_horizontal_plane(
+        x_resolution=200,
+        y_resolution=100,
+        height=90.0,
+        x_bounds=(-200, 1000),
+        y_bounds=(-500, 500),
+    )
+    visualize_cut_plane(
+        horizontal_plane,
+        ax=ax[0],
+        label_contours=False,
+        title="Without WD het"
+    )
+
+    fmodel.set(heterogeneous_inflow_config=het_inflow_config)
+    horizontal_plane = fmodel.calculate_horizontal_plane(
+        x_resolution=200,
+        y_resolution=100,
+        height=90.0,
+        x_bounds=(-200, 1000),
+        y_bounds=(-500, 500),
+    )
+    #import ipdb; ipdb.set_trace()
+    visualize_cut_plane(
+        horizontal_plane,
+        ax=ax[1],
+        label_contours=False,
+        title="With WD het"
+    )
+
+    plt.show()

examples/examples_heterogeneous/00x_wind_direction_heterogeneity_visualization.py

@@ -0,0 +1,71 @@
+"""Example: Visualize flow by sweeping turbines
+
+Demonstrate the use calculate_horizontal_plane_with_turbines
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import floris.flow_visualization as flowviz
+from floris import FlorisModel
+
+
+fmodel = FlorisModel("../inputs/gch.yaml")
+
+viz_by_sweep = False
+
+# # Some wake models may not yet have a visualization method included, for these cases can use
+# # a slower version which scans a turbine model to produce the horizontal flow
+x = np.array([-100, 0, 100, 200, 300, 400, 500, 600])
+v = -np.array([[0, 1, 2, 3, 4, 5, 6, 7]])
+
+het_inflow_config = {
+    "x": np.repeat(x, 2),
+    "y": np.tile(np.array([-100.0, 100.0]), 8),
+    #"z": np.array([90.0, 90.0, 90.0, 91.0]),
+    "speed_multipliers": 1.0*np.ones((1, 16)),
+    "u": 8.0*np.ones((1, v.shape[1]*2)),
+    "v": np.repeat(v, 2, axis=1)
+    #"v": np.array([[0.0, 0.0, 0.0, 0.0]]),
+}
+
+# Set a 2 turbine layout
+fmodel.set(
+    layout_x=[0, 300],
+    layout_y=[0, 0],
+    wind_directions=[270],
+    wind_speeds=[8],
+    turbulence_intensities=[0.06],
+    heterogeneous_inflow_config=het_inflow_config,
+)
+
+if viz_by_sweep:
+    horizontal_plane = flowviz.calculate_horizontal_plane_with_turbines(
+        fmodel,
+        x_resolution=20,
+        y_resolution=10,
+        x_bounds=(-100, 500),
+        y_bounds=(-100, 100),
+    )
+    title = "Coarse turbine scan method"
+else:
+    horizontal_plane = fmodel.calculate_horizontal_plane(
+        x_resolution=200,
+        y_resolution=100,
+        height=90.0,
+        x_bounds=(-100, 500),
+        y_bounds=(-100, 100),
+    )
+    title = "Standard flow visualization calculation"
+
+fig, ax = plt.subplots(figsize=(10, 4))
+flowviz.visualize_cut_plane(
+    horizontal_plane,
+    ax=ax,
+    label_contours=True,
+    title=title
+)
+
+
+plt.show()

floris/core/core.py

@@ -96,20 +96,23 @@ def __attrs_post_init__(self) -> None:
                 turbine_diameters=self.farm.rotor_diameters,
                 wind_directions=self.flow_field.wind_directions,
                 grid_resolution=self.solver["turbine_grid_points"],
+                heterogeneous_inflow_config=self.flow_field.heterogeneous_inflow_config,
             )
         elif self.solver["type"] == "turbine_cubature_grid":
             self.grid = TurbineCubatureGrid(
                 turbine_coordinates=self.farm.coordinates,
                 turbine_diameters=self.farm.rotor_diameters,
                 wind_directions=self.flow_field.wind_directions,
                 grid_resolution=self.solver["turbine_grid_points"],
+                heterogeneous_inflow_config=self.flow_field.heterogeneous_inflow_config,
             )
         elif self.solver["type"] == "flow_field_grid":
             self.grid = FlowFieldGrid(
                 turbine_coordinates=self.farm.coordinates,
                 turbine_diameters=self.farm.rotor_diameters,
                 wind_directions=self.flow_field.wind_directions,
                 grid_resolution=self.solver["flow_field_grid_points"],
+                heterogeneous_inflow_config=self.flow_field.heterogeneous_inflow_config,
             )
         elif self.solver["type"] == "flow_field_planar_grid":
             self.grid = FlowFieldPlanarGrid(
@@ -119,6 +122,7 @@ def __attrs_post_init__(self) -> None:
                 normal_vector=self.solver["normal_vector"],
                 planar_coordinate=self.solver["planar_coordinate"],
                 grid_resolution=self.solver["flow_field_grid_points"],
+                heterogeneous_inflow_config=self.flow_field.heterogeneous_inflow_config,
                 x1_bounds=self.solver["flow_field_bounds"][0],
                 x2_bounds=self.solver["flow_field_bounds"][1],
             )
@@ -243,6 +247,7 @@ def solve_for_points(self, x, y, z):
             turbine_coordinates=self.farm.coordinates,
             turbine_diameters=self.farm.rotor_diameters,
             wind_directions=self.flow_field.wind_directions,
+            heterogeneous_inflow_config=self.flow_field.heterogeneous_inflow_config,
             grid_resolution=1,
             x_center_of_rotation=self.grid.x_center_of_rotation,
             y_center_of_rotation=self.grid.y_center_of_rotation

floris/core/flow_field.py

@@ -105,12 +105,18 @@ def heterogeneous_config_validator(self, instance: attrs.Attribute, value: dict
             return
 
         # Check that the correct keys are supplied for the heterogeneous_inflow_config dict
-        for k in ["speed_multipliers", "x", "y"]:
+        for k in ["x", "y"]:
             if k not in value.keys():
                 raise ValueError(
-                    "heterogeneous_inflow_config must contain entries for 'speed_multipliers',"
-                    f"'x', and 'y', with 'z' optional. Missing '{k}'."
+                    "heterogeneous_inflow_config must contain entries for "
+                    f"'x' and 'y', with 'z' optional. Missing '{k}'."
                 )
+        if ("speed_multipliers" not in value.keys() and
+            ("u" not in value.keys() or "v" not in value.keys())):
+            raise ValueError(
+                "heterogeneous_inflow_config must contain entries for either 'speed_multipliers'"
+                " or 'u' and 'v'."
+            )
         if "z" not in value:
             # If only a 2D case, add "None" for the z locations
             value["z"] = None
@@ -130,7 +136,7 @@ def het_map_validator(self, instance: attrs.Attribute, value: list | None) -> No
 
 
     def __attrs_post_init__(self) -> None:
-        if self.heterogeneous_inflow_config is not None:
+        if self._speed_heterogeneity:
             self.generate_heterogeneous_wind_map()
 
 
@@ -281,7 +287,13 @@ def generate_heterogeneous_wind_map(self):
                 - **y**: A list of y locations at which the speed up factors are defined.
                 - **z** (optional): A list of z locations at which the speed up factors are defined.
         """
-        speed_multipliers = self.heterogeneous_inflow_config['speed_multipliers']
+        if "speed_multipliers" in self.heterogeneous_inflow_config:
+            speed_multipliers = self.heterogeneous_inflow_config['speed_multipliers']
+        else:
+            speed_multipliers = np.sqrt(
+                np.array(self.heterogeneous_inflow_config['u'])**2
+                + np.array(self.heterogeneous_inflow_config['v'])**2
+            ) / self.wind_speeds
         x = self.heterogeneous_inflow_config['x']
         y = self.heterogeneous_inflow_config['y']
         z = self.heterogeneous_inflow_config['z']
@@ -305,6 +317,10 @@ def generate_heterogeneous_wind_map(self):
 
         self.het_map = in_region
 
+    @property
+    def _speed_heterogeneity(self):
+        return self.heterogeneous_inflow_config is not None
+
     @staticmethod
     def interpolate_multiplier_xy(x: NDArrayFloat,
                                   y: NDArrayFloat,