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,