def test_average_velocity():
# TODO: why do we use cube root - mean - cube (like rms) instead of a simple average (np.mean)?
# Dimensions are (n wind directions, n wind speeds, n turbines, grid x, grid y)
velocities = np.ones((1, 1, 1, 5, 5))
assert average_velocity(velocities) == 1
# Constructs an array of shape 1 x 1 x 2 x 3 x 3 with finrst turbie all 1, second turbine all 2
velocities = np.stack(
(
np.ones((1, 1, 3, 3)), # The first dimension here is the wind direction and the second
2 * np.ones((1, 1, 3, 3)), # is the wind speed since we are stacking on axis=2
),
axis=2,
)
# Pull out the first wind speed for the test
np.testing.assert_array_equal(average_velocity(velocities)[0, 0], np.array([1, 2]))
# Test boolean filter
ix_filter = [True, False, True, False]
velocities = np.stack( # 4 turbines with 3 x 3 velocity array; shape (1,1,4,3,3)
[i * np.ones((1, 1, 3, 3)) for i in range(1,5)],
# (
# np.ones(
# (1, 1, 3, 3)
# ), # The first dimension here is the wind direction and second is the wind speed since we are stacking on axis=2
# 2 * np.ones((1, 1, 3, 3)),
# 3 * np.ones((1, 1, 3, 3)),
# 4 * np.ones((1, 1, 3, 3)),
# ),
axis=2,
)
avg = average_velocity(velocities, ix_filter)
assert avg.shape == (1, 1, 2) # 1 wind direction, 1 wind speed, 2 turbines filtered
# Pull out the first wind direction and wind speed for the comparison
assert np.allclose(avg[0, 0], np.array([1.0, 3.0]))
# This fails in GitHub Actions due to a difference in precision:
# E assert 3.0000000000000004 == 3.0
# np.testing.assert_array_equal(avg[0], np.array([1.0, 3.0]))
# Test integer array filter
# np.arange(1, 5).reshape((-1,1,1)) * np.ones((1, 1, 3, 3))
velocities = np.stack( # 4 turbines with 3 x 3 velocity array; shape (1,1,4,3,3)
[i * np.ones((1, 1, 3, 3)) for i in range(1,5)],
axis=2,
)
avg = average_velocity(velocities, INDEX_FILTER)
assert avg.shape == (1, 1, 2) # 1 wind direction, 1 wind speed, 2 turbines filtered
# Pull out the first wind direction and wind speed for the comparison
assert np.allclose(avg[0, 0], np.array([1.0, 3.0]))
def test_regression_tandem(sample_inputs_fixture):
"""
Tandem turbines
"""
sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
sample_inputs_fixture.floris["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL
floris = Floris.from_dict(sample_inputs_fixture.floris)
floris.initialize_domain()
floris.steady_state_atmospheric_condition()
n_turbines = floris.farm.n_turbines
n_wind_speeds = floris.flow_field.n_wind_speeds
n_wind_directions = floris.flow_field.n_wind_directions
velocities = floris.flow_field.u
yaw_angles = floris.farm.yaw_angles
test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4))
farm_avg_velocities = average_velocity(
velocities,
)
farm_cts = Ct(
velocities,
yaw_angles,
floris.farm.turbine_fCts,
floris.farm.turbine_type_map,
)
farm_powers = power(
floris.flow_field.air_density,
velocities,
yaw_angles,
floris.farm.pPs,
floris.farm.turbine_power_interps,
floris.farm.turbine_type_map,
)
farm_axial_inductions = axial_induction(
velocities,
yaw_angles,
floris.farm.turbine_fCts,
floris.farm.turbine_type_map,
)
for i in range(n_wind_directions):
for j in range(n_wind_speeds):
for k in range(n_turbines):
test_results[i, j, k, 0] = farm_avg_velocities[i, j, k]
test_results[i, j, k, 1] = farm_cts[i, j, k]
test_results[i, j, k, 2] = farm_powers[i, j, k]
test_results[i, j, k, 3] = farm_axial_inductions[i, j, k]
if DEBUG:
print_test_values(
farm_avg_velocities,
farm_cts,
farm_powers,
farm_axial_inductions,
)
assert_results_arrays(test_results[0], baseline)
def test_regression_rotation(sample_inputs_fixture):
"""
Turbines in tandem and rotated.
The result from 270 degrees should match the results from 360 degrees.
Wind from the West (Left)
^
|
y
1|1 3
|
|
|
0|0 2
|----------|
0 1 x->
Wind from the North (Top), rotated
^
|
y
1|3 2
|
|
|
0|1 0
|----------|
0 1 x->
In 270, turbines 2 and 3 are waked. In 360, turbines 0 and 2 are waked.
The test compares turbines 2 and 3 with 0 and 2 from 270 and 360.
"""
TURBINE_DIAMETER = 126.0
sample_inputs_fixture.floris["wake"]["model_strings"][
"velocity_model"] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["model_strings"][
"deflection_model"] = DEFLECTION_MODEL
sample_inputs_fixture.floris["farm"]["layout_x"] = [
0.0,
0.0,
5 * TURBINE_DIAMETER,
5 * TURBINE_DIAMETER,
]
sample_inputs_fixture.floris["farm"]["layout_y"] = [
0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER
]
sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [
270.0, 360.0
]
sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0]
floris = Floris.from_dict(sample_inputs_fixture.floris)
floris.initialize_domain()
floris.steady_state_atmospheric_condition()
farm_avg_velocities = average_velocity(floris.flow_field.u)
t0_270 = farm_avg_velocities[0, 0, 0] # upstream
t1_270 = farm_avg_velocities[0, 0, 1] # upstream
t2_270 = farm_avg_velocities[0, 0, 2] # waked
t3_270 = farm_avg_velocities[0, 0, 3] # waked
t0_360 = farm_avg_velocities[1, 0, 0] # waked
t1_360 = farm_avg_velocities[1, 0, 1] # upstream
t2_360 = farm_avg_velocities[1, 0, 2] # waked
t3_360 = farm_avg_velocities[1, 0, 3] # upstream
assert np.allclose(t0_270, t1_360)
assert np.allclose(t1_270, t3_360)
assert np.allclose(t2_270, t0_360)
assert np.allclose(t3_270, t2_360)
def test_regression_secondary_steering(sample_inputs_fixture):
"""
Tandem turbines with the upstream turbine yawed and secondary steering enabled
"""
sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True
sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True
sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = False
floris = Floris.from_dict(sample_inputs_fixture.floris)
yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES))
yaw_angles[:,:,0] = 5.0
floris.farm.yaw_angles = yaw_angles
floris.initialize_domain()
floris.steady_state_atmospheric_condition()
n_turbines = floris.farm.n_turbines
n_wind_speeds = floris.flow_field.n_wind_speeds
n_wind_directions = floris.flow_field.n_wind_directions
velocities = floris.flow_field.u
yaw_angles = floris.farm.yaw_angles
test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4))
farm_avg_velocities = average_velocity(
velocities,
)
farm_cts = Ct(
velocities,
yaw_angles,
floris.farm.turbine_fCts,
floris.farm.turbine_type_map,
)
farm_powers = power(
floris.flow_field.air_density,
velocities,
yaw_angles,
floris.farm.pPs,
floris.farm.turbine_power_interps,
floris.farm.turbine_type_map,
)
farm_axial_inductions = axial_induction(
velocities,
yaw_angles,
floris.farm.turbine_fCts,
floris.farm.turbine_type_map,
)
for i in range(n_wind_directions):
for j in range(n_wind_speeds):
for k in range(n_turbines):
test_results[i, j, k, 0] = farm_avg_velocities[i, j, k]
test_results[i, j, k, 1] = farm_cts[i, j, k]
test_results[i, j, k, 2] = farm_powers[i, j, k]
test_results[i, j, k, 3] = farm_axial_inductions[i, j, k]
if DEBUG:
print_test_values(
farm_avg_velocities,
farm_cts,
farm_powers,
farm_axial_inductions,
)
assert_results_arrays(test_results[0], secondary_steering_baseline)