def test_asdict(turbine_grid_fixture: TurbineGrid):
floris = Floris.from_dict(DICT_INPUT)
floris.flow_field.initialize_velocity_field(turbine_grid_fixture)
dict1 = floris.as_dict()
new_floris = Floris.from_dict(dict1)
new_floris.flow_field.initialize_velocity_field(turbine_grid_fixture)
dict2 = new_floris.as_dict()
assert dict1 == dict2
def memory_profile(input_dict):
# Run once to initialize Python and memory
floris = Floris.from_dict(copy.deepcopy(input_dict.floris))
floris.initialize_domain()
floris.steady_state_atmospheric_condition()
with perf():
for i in range(N_ITERATIONS):
floris = Floris.from_dict(copy.deepcopy(input_dict.floris))
floris.initialize_domain()
floris.steady_state_atmospheric_condition()
print("Size of one data array:", 64 * N_WIND_DIRECTIONS * N_WIND_SPEEDS * N_TURBINES * 25 / (1000 * 1000), "MB")
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_small_grid_rotation(sample_inputs_fixture):
"""
Where wake models are masked based on the x-location of a turbine, numerical precision
can cause masking to fail unexpectedly. For example, in the configuration here one of
the turbines has these delta x values;
[[4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13]
[4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13]
[4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13]
[4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13]
[4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13 4.54747351e-13]]
and therefore the masking statement is False when it should be True. This causes the current
turbine to be affected by its own wake. This test requires that at least in this particular
configuration the masking correctly filters grid points.
"""
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
X, Y = np.meshgrid(
6.0 * 126.0 * np.arange(0, 5, 1),
6.0 * 126.0 * np.arange(0, 5, 1)
)
X = X.flatten()
Y = Y.flatten()
sample_inputs_fixture.floris["farm"]["layout_x"] = X
sample_inputs_fixture.floris["farm"]["layout_y"] = Y
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)
velocities = floris.flow_field.u
yaw_angles = floris.farm.yaw_angles
farm_powers = power(
floris.flow_field.air_density,
velocities,
yaw_angles,
floris.farm.pPs,
floris.farm.turbine_power_interps,
floris.farm.turbine_type_map,
)
# A "column" is oriented parallel to the wind direction
# Columns 1 - 4 should have the same power profile
# Column 5 leading turbine is completely unwaked
# and the rest of the turbines have a partial wake from their immediate upstream turbine
assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,5:10])
assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,10:15])
assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,15:20])
assert np.allclose(farm_powers[2,0,20], farm_powers[2,0,0])
assert np.allclose(farm_powers[2,0,21], farm_powers[2,0,21:25])
def run_floris(input_dict):
try:
start = time.perf_counter()
floris = Floris.from_dict(copy.deepcopy(input_dict.floris))
floris.initialize_domain()
floris.steady_state_atmospheric_condition()
end = time.perf_counter()
return end - start
except KeyError as e:
# Catch the errors when an invalid wake model was given because the model was not yet implemented
return -1.0
def test_regression_yaw(sample_inputs_fixture):
"""
Tandem turbines with the upstream turbine yawed
"""
sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
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()
with pytest.raises(ValueError):
floris.steady_state_atmospheric_condition()
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)
# else:
# floris = Floris("example_input.json")
# floris.farm.flow_field.calculate_wake()
# start = time.time()
# cProfile.run('re.compile("floris.steady_state_atmospheric_condition()")')
# end = time.time()
# print(start, end, end - start)
sample_inputs = SampleInputs()
sample_inputs.floris["wake"]["model_strings"]["velocity_model"] = "gauss"
sample_inputs.floris["wake"]["model_strings"]["deflection_model"] = "gauss"
sample_inputs.floris["wake"]["enable_secondary_steering"] = True
sample_inputs.floris["wake"]["enable_yaw_added_recovery"] = True
sample_inputs.floris["wake"]["enable_transverse_velocities"] = True
factor = 100
TURBINE_DIAMETER = sample_inputs.floris["turbine"]["rotor_diameter"]
sample_inputs.floris["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * i for i in range(factor)]
sample_inputs.floris["farm"]["layout_y"] = [0.0 for i in range(factor)]
factor = 10
sample_inputs.floris["flow_field"]["wind_directions"] = factor * [270.0]
sample_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0]
N = 5
for i in range(N):
floris = Floris.from_dict(copy.deepcopy(sample_inputs.floris))
floris.steady_state_atmospheric_condition()
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)
def test_init():
fi = Floris.from_dict(DICT_INPUT)
assert isinstance(fi.farm, Farm)
assert isinstance(fi.wake, WakeModelManager)
assert isinstance(fi.flow_field, FlowField)
def test_read_dict():
fi = Floris.from_dict(DICT_INPUT)
assert isinstance(fi, Floris)
def time_profile(input_dict):
floris = Floris.from_dict(input_dict.floris)
start = time.perf_counter()
floris.steady_state_atmospheric_condition()
end = time.perf_counter()
return end - start
