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 time_vec(input_dict):
start = time.time()
floris = Floris(input_dict=input_dict.floris)
end = time.time()
init_time = end - start
start = time.time()
floris.steady_state_atmospheric_condition()
end = time.time()
calc_time = end - start
return init_time, calc_time
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_secondary_steering(sample_inputs_fixture):
"""
Tandem turbines with the upstream turbine yawed and yaw added recovery
correction enabled
"""
sample_inputs_fixture.floris["wake"]["properties"][
"velocity_model"
] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["properties"][
"deflection_model"
] = DEFLECTION_MODEL
floris = Floris(input_dict=sample_inputs_fixture.floris)
floris.farm.turbines[0].yaw_angle = 5.0
# Enable secondary steering
floris.farm.wake.deflection_model.use_secondary_steering = True
floris.farm.wake.velocity_model.calculate_VW_velocities = True
floris.farm.flow_field.reinitialize_flow_field()
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i in range(len(floris.farm.turbine_map.turbines)):
check = secondary_steering_baseline
assert test_results[i][0] == approx(check[i][0])
assert test_results[i][1] == approx(check[i][1])
assert test_results[i][2] == approx(check[i][2])
assert test_results[i][3] == approx(check[i][3])
def test_regression_yaw(sample_inputs_fixture):
"""
Tandem turbines with the upstream turbine yawed
"""
sample_inputs_fixture.floris["wake"]["properties"][
"velocity_model"
] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["properties"][
"deflection_model"
] = DEFLECTION_MODEL
floris = Floris(input_dict=sample_inputs_fixture.floris)
# yaw the upstream turbine 5 degrees
floris.farm.turbines[0].yaw_angle = 5.0
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i in range(len(floris.farm.turbine_map.turbines)):
baseline = yawed_baseline
assert test_results[i][0] == approx(baseline[i][0])
assert test_results[i][1] == approx(baseline[i][1])
assert test_results[i][2] == approx(baseline[i][2])
assert test_results[i][3] == approx(baseline[i][3])
def test_regression_yaw():
"""
Tandem turbines with the upstream turbine yawed
"""
test_class = JensenJimenezRegressionTest()
floris = Floris(input_dict=test_class.input_dict)
# yaw the upstream turbine 5 degrees
rotation_angle = 5.0
floris.farm.set_yaw_angles([rotation_angle, 0.0])
floris.farm.flow_field.calculate_wake()
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
if test_class.debug:
print("({:.7f}, {:.7f}, {:.7f}, {:.7f}, {:.7f})".format(
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
))
baseline = test_class.yawed_baseline(i)
assert pytest.approx(turbine.Cp) == baseline[0]
assert pytest.approx(turbine.Ct) == baseline[1]
assert pytest.approx(turbine.power) == baseline[2]
assert pytest.approx(turbine.aI) == baseline[3]
assert pytest.approx(turbine.average_velocity) == baseline[4]
def test_gauss_to_curl_to_gauss(sample_inputs_fixture):
"""
Start with the Gauss wake model
Then, switch to Curl
Then, switch back to Gauss
"""
# Establish that the Gauss test passes
sample_inputs_fixture.floris["wake"]["properties"][
"velocity_model"] = "gauss_legacy"
sample_inputs_fixture.floris["wake"]["properties"][
"deflection_model"] = "gauss"
floris = Floris(input_dict=sample_inputs_fixture.floris)
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i in range(len(floris.farm.turbine_map.turbines)):
baseline = gauss_baseline
assert test_results[i][0] == approx(baseline[i][0])
assert test_results[i][1] == approx(baseline[i][1])
assert test_results[i][2] == approx(baseline[i][2])
assert test_results[i][3] == approx(baseline[i][3])
# Change the model to Curl, rerun calculate_wake, and compare to Curl
floris.farm.set_wake_model("curl")
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i in range(len(floris.farm.turbine_map.turbines)):
baseline = curl_baseline
assert test_results[i][0] == approx(baseline[i][0])
assert test_results[i][1] == approx(baseline[i][1])
assert test_results[i][2] == approx(baseline[i][2])
assert test_results[i][3] == approx(baseline[i][3])
# Change back to Gauss, rerun calculate_wake, and compare to gauss
floris.farm.set_wake_model("gauss_legacy")
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i in range(len(floris.farm.turbine_map.turbines)):
baseline = gauss_baseline
assert test_results[i][0] == approx(baseline[i][0])
assert test_results[i][1] == approx(baseline[i][1])
assert test_results[i][2] == approx(baseline[i][2])
assert test_results[i][3] == approx(baseline[i][3])
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 time_serial(input_dict, wd, ws):
init_times = np.zeros(len(wd))
calc_times = np.zeros(len(wd))
for i, (d, s) in enumerate(zip(wd, ws)):
input_dict.floris["flow_field"]["wind_directions"] = [d]
input_dict.floris["flow_field"]["wind_speeds"] = [s]
start = time.time()
floris = Floris(input_dict=input_dict.floris)
end = time.time()
init_times[i] = end - start
start = time.time()
floris.steady_state_atmospheric_condition()
end = time.time()
calc_times[i] = end - start
return np.sum(init_times), np.sum(calc_times)
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_tandem():
"""
Tandem turbines
"""
test_class = JensenJimenezRegressionTest()
floris = Floris(input_dict=test_class.input_dict)
floris.farm.flow_field.calculate_wake()
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
if test_class.debug:
print("({:.7f}, {:.7f}, {:.7f}, {:.7f}, {:.7f})".format(turbine.Cp, turbine.Ct, turbine.power, turbine.aI, turbine.average_velocity))
baseline = test_class.baseline(i)
assert pytest.approx(turbine.Cp) == baseline[0]
assert pytest.approx(turbine.Ct) == baseline[1]
assert pytest.approx(turbine.power) == baseline[2]
assert pytest.approx(turbine.aI) == baseline[3]
assert pytest.approx(turbine.average_velocity) == baseline[4]
def test_regression_yaw_added_recovery():
"""
Tandem turbines with the upstream turbine yawed and yaw added recovery
correction enabled
"""
test_class = GaussRegressionTest()
floris = Floris(input_dict=test_class.input_dict)
floris.farm.set_yaw_angles([5.0, 0.0, 0.0])
# With yaw added recovery off, GCH should be same as Gauss
floris.farm.wake.velocity_model.use_yaw_added_recovery = False
floris.farm.flow_field.calculate_wake()
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
if test_class.debug:
print("({:.7f}, {:.7f}, {:.7f}, {:.7f}, {:.7f})".format(
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
))
baseline = test_class.yawed_baseline(i)
assert pytest.approx(turbine.Cp) == baseline[0]
assert pytest.approx(turbine.Ct) == baseline[1]
assert pytest.approx(turbine.power) == baseline[2]
assert pytest.approx(turbine.aI) == baseline[3]
assert pytest.approx(turbine.average_velocity) == baseline[4]
# With yaw added recovery on, the results should change
floris.farm.wake.velocity_model.use_yaw_added_recovery = True
floris.farm.flow_field.calculate_wake()
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
if test_class.debug:
print("({:.7f}, {:.7f}, {:.7f}, {:.7f}, {:.7f})".format(
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
))
baseline = test_class.yaw_added_recovery_baseline(i)
assert pytest.approx(turbine.Cp) == baseline[0]
assert pytest.approx(turbine.Ct) == baseline[1]
assert pytest.approx(turbine.power) == baseline[2]
assert pytest.approx(turbine.aI) == baseline[3]
assert pytest.approx(turbine.average_velocity) == baseline[4]
def test_change_wind_direction(sample_inputs_fixture):
"""
Tandem turbines aligned to the wind direction, first calculated at 270 degrees wind
direction, and then calculated at 315 degrees wind direction.
"""
sample_inputs_fixture.floris["wake"]["properties"][
"velocity_model"
] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["properties"][
"deflection_model"
] = DEFLECTION_MODEL
floris = Floris(input_dict=sample_inputs_fixture.floris)
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
assert test_results[i][0] == approx(baseline[i][0])
assert test_results[i][1] == approx(baseline[i][1])
assert test_results[i][2] == approx(baseline[i][2])
assert test_results[i][3] == approx(baseline[i][3])
floris.farm.wind_map.input_direction = [315.0]
floris.farm.wind_map.calculate_wind_direction()
floris.farm.turbine_map.reinitialize_turbines()
floris.farm.flow_field.reinitialize_flow_field()
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
assert test_results[i][0] == approx(wd315_baseline[i][0])
assert test_results[i][1] == approx(wd315_baseline[i][1])
assert test_results[i][2] == approx(wd315_baseline[i][2])
assert test_results[i][3] == approx(wd315_baseline[i][3])
def test_regression_rotation():
"""
Turbines in tandem and rotated.
The result from 270 degrees should match the results from 360 degrees.
"""
test_class = JensenJimenezRegressionTest()
floris = Floris(input_dict=test_class.input_dict)
fresh_turbine = copy.deepcopy(floris.farm.turbine_map.turbines[0])
### unrotated
floris.farm.flow_field.calculate_wake()
turbine = floris.farm.turbine_map.turbines[0]
unwaked_baseline = (turbine.Cp, turbine.Ct, turbine.power,
turbine.aI, turbine.average_velocity)
turbine = floris.farm.turbine_map.turbines[1]
waked_baseline = (turbine.Cp, turbine.Ct, turbine.power,
turbine.aI, turbine.average_velocity)
### rotated
new_map = TurbineMap(
[0.0, 0.0],
[5 * test_class.input_dict["turbine"]["properties"]["rotor_diameter"], 0.0],
[copy.deepcopy(fresh_turbine), copy.deepcopy(fresh_turbine)]
)
floris.farm.flow_field.reinitialize_flow_field(
wind_direction=360,
turbine_map=new_map
)
floris.farm.flow_field.calculate_wake()
turbine = floris.farm.turbine_map.turbines[0]
assert pytest.approx(turbine.Cp) == unwaked_baseline[0]
assert pytest.approx(turbine.Ct) == unwaked_baseline[1]
assert pytest.approx(turbine.power) == unwaked_baseline[2]
assert pytest.approx(turbine.aI) == unwaked_baseline[3]
assert pytest.approx(turbine.average_velocity) == unwaked_baseline[4]
turbine = floris.farm.turbine_map.turbines[1]
assert pytest.approx(turbine.Cp) == waked_baseline[0]
assert pytest.approx(turbine.Ct) == waked_baseline[1]
assert pytest.approx(turbine.power) == waked_baseline[2]
assert pytest.approx(turbine.aI) == waked_baseline[3]
assert pytest.approx(turbine.average_velocity) == waked_baseline[4]
def test_regression_multiple_calc_wake(sample_inputs_fixture):
"""
Verify turbine values stay the same with repeated (3x) calculate_wake calls.
"""
sample_inputs_fixture.floris["wake"]["properties"][
"velocity_model"
] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["properties"][
"deflection_model"
] = DEFLECTION_MODEL
floris = Floris(input_dict=sample_inputs_fixture.floris)
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
assert test_results[i][0] == approx(baseline[i][0])
assert test_results[i][1] == approx(baseline[i][1])
assert test_results[i][2] == approx(baseline[i][2])
assert test_results[i][3] == approx(baseline[i][3])
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
assert test_results[i][0] == approx(baseline[i][0])
assert test_results[i][1] == approx(baseline[i][1])
assert test_results[i][2] == approx(baseline[i][2])
assert test_results[i][3] == approx(baseline[i][3])
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i, turbine in enumerate(floris.farm.turbine_map.turbines):
assert test_results[i][0] == approx(baseline[i][0])
assert test_results[i][1] == approx(baseline[i][1])
assert test_results[i][2] == approx(baseline[i][2])
assert test_results[i][3] == approx(baseline[i][3])
def test_regression_tandem(sample_inputs_fixture):
"""
Tandem turbines
"""
sample_inputs_fixture.floris["wake"]["properties"][
"velocity_model"
] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["properties"][
"deflection_model"
] = DEFLECTION_MODEL
floris = Floris(input_dict=sample_inputs_fixture.floris)
floris.farm.flow_field.calculate_wake()
test_results = turbines_to_array(floris.farm.turbine_map.turbines)
if DEBUG:
print_test_values(floris.farm.turbine_map.turbines)
for i in range(len(floris.farm.turbine_map.turbines)):
check = baseline
assert test_results[i][0] == approx(check[i][0])
assert test_results[i][1] == approx(check[i][1])
assert test_results[i][2] == approx(check[i][2])
assert test_results[i][3] == approx(check[i][3])
def test_read_yaml():
fi = Floris.from_file(YAML_INPUT)
assert isinstance(fi, Floris)
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 run_floris():
floris = Floris.from_file("examples/example_input.yaml")
return floris
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 floris_fixture():
sample_inputs = SampleInputs()
return Floris(sample_inputs.floris)
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 __init__(self, input_file):
self.input_file = input_file
self.floris = Floris(input_file=input_file)
def test_regression_rotation():
"""
Turbines in tandem and rotated.
The result from 270 degrees should match the results from 360 degrees.
"""
test_class = CurlRegressionTest()
floris = Floris(input_dict=test_class.input_dict)
fresh_turbine = copy.deepcopy(floris.farm.turbine_map.turbines[0])
wind_map = floris.farm.wind_map
### unrotated
floris.farm.flow_field.calculate_wake()
turbine = floris.farm.turbine_map.turbines[0]
unwaked_baseline = (
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
)
turbine = floris.farm.turbine_map.turbines[1]
first_waked_baseline = (
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
)
turbine = floris.farm.turbine_map.turbines[2]
second_waked_baseline = (
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
)
### rotated
wind_map.input_direction = [360]
wind_map.calculate_wind_direction()
new_map = TurbineMap(
[0.0, 0.0, 0.0],
[
10 *
test_class.input_dict["turbine"]["properties"]["rotor_diameter"],
5 *
test_class.input_dict["turbine"]["properties"]["rotor_diameter"],
0.0,
],
[
copy.deepcopy(fresh_turbine),
copy.deepcopy(fresh_turbine),
copy.deepcopy(fresh_turbine),
],
)
floris.farm.flow_field.reinitialize_flow_field(turbine_map=new_map,
wind_map=wind_map)
floris.farm.flow_field.calculate_wake()
turbine = floris.farm.turbine_map.turbines[0]
if test_class.debug:
print("({:.7f}, {:.7f}, {:.7f}, {:.7f}, {:.7f})".format(
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
))
assert pytest.approx(turbine.Cp) == unwaked_baseline[0]
assert pytest.approx(turbine.Ct) == unwaked_baseline[1]
assert pytest.approx(turbine.power) == unwaked_baseline[2]
assert pytest.approx(turbine.aI) == unwaked_baseline[3]
assert pytest.approx(turbine.average_velocity) == unwaked_baseline[4]
turbine = floris.farm.turbine_map.turbines[1]
if test_class.debug:
print("({:.7f}, {:.7f}, {:.7f}, {:.7f}, {:.7f})".format(
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
))
assert pytest.approx(turbine.Cp) == first_waked_baseline[0]
assert pytest.approx(turbine.Ct) == first_waked_baseline[1]
assert pytest.approx(turbine.power) == first_waked_baseline[2]
assert pytest.approx(turbine.aI) == first_waked_baseline[3]
assert pytest.approx(turbine.average_velocity) == first_waked_baseline[4]
turbine = floris.farm.turbine_map.turbines[2]
if test_class.debug:
print("({:.7f}, {:.7f}, {:.7f}, {:.7f}, {:.7f})".format(
turbine.Cp,
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
))
# TODO: this is a hack and you know it :(
assert pytest.approx(turbine.Cp, rel=1e-4) == second_waked_baseline[0]
assert pytest.approx(turbine.Ct, rel=1e-4) == second_waked_baseline[1]
assert pytest.approx(turbine.power, rel=1e-3) == second_waked_baseline[2]
assert pytest.approx(turbine.aI, rel=1e-3) == second_waked_baseline[3]
assert pytest.approx(turbine.average_velocity,
rel=1e-3) == second_waked_baseline[4]
def test_regression_rotation(sample_inputs_fixture):
"""
Turbines in tandem and rotated.
The result from 270 degrees should match the results from 360 degrees.
"""
sample_inputs_fixture.floris["wake"]["properties"][
"velocity_model"
] = VELOCITY_MODEL
sample_inputs_fixture.floris["wake"]["properties"][
"deflection_model"
] = DEFLECTION_MODEL
floris = Floris(input_dict=sample_inputs_fixture.floris)
fresh_turbine = copy.deepcopy(floris.farm.turbine_map.turbines[0])
wind_map = floris.farm.wind_map
# unrotated
floris.farm.flow_field.calculate_wake()
turbine = floris.farm.turbine_map.turbines[0]
unwaked_baseline = (
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
)
turbine = floris.farm.turbine_map.turbines[1]
first_waked_baseline = (
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
)
turbine = floris.farm.turbine_map.turbines[2]
second_waked_baseline = (
turbine.Ct,
turbine.power,
turbine.aI,
turbine.average_velocity,
)
# rotated
wind_map.input_direction = [360]
wind_map.calculate_wind_direction()
new_map = TurbineMap(
[0.0, 0.0, 0.0],
[
10
* sample_inputs_fixture.floris["turbine"]["properties"]["rotor_diameter"],
5 * sample_inputs_fixture.floris["turbine"]["properties"]["rotor_diameter"],
0.0,
],
[
copy.deepcopy(fresh_turbine),
copy.deepcopy(fresh_turbine),
copy.deepcopy(fresh_turbine),
],
)
floris.farm.flow_field.reinitialize_flow_field(
turbine_map=new_map, wind_map=wind_map
)
floris.farm.flow_field.calculate_wake()
turbine = floris.farm.turbine_map.turbines[0]
assert approx(turbine.Ct) == unwaked_baseline[0]
assert approx(turbine.power) == unwaked_baseline[1]
assert approx(turbine.aI) == unwaked_baseline[2]
assert approx(turbine.average_velocity) == unwaked_baseline[3]
turbine = floris.farm.turbine_map.turbines[1]
assert approx(turbine.Ct) == first_waked_baseline[0]
assert approx(turbine.power) == first_waked_baseline[1]
assert approx(turbine.aI) == first_waked_baseline[2]
assert approx(turbine.average_velocity) == first_waked_baseline[3]
turbine = floris.farm.turbine_map.turbines[2]
assert approx(turbine.Ct, rel=1e-5) == second_waked_baseline[0]
assert approx(turbine.power, rel=1e-5) == second_waked_baseline[1]
assert approx(turbine.aI, rel=1e-5) == second_waked_baseline[2]
assert approx(turbine.average_velocity, rel=1e-5) == second_waked_baseline[3]
def test_read_dict():
fi = Floris.from_dict(DICT_INPUT)
assert isinstance(fi, Floris)
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.
# See https://floris.readthedocs.io for documentation
import sys
from pycallgraph import Config, PyCallGraph, GlobbingFilter
from floris.simulation import Floris
from pycallgraph.output import GraphvizOutput
config = Config(groups=True)
config.trace_filter = GlobbingFilter(exclude=[
"pycallgraph.*", "json*", "codecs*", "_bootlocale*", "_weakrefset*"
])
graphviz = GraphvizOutput()
graphviz.output_file = "initialization.png"
with PyCallGraph(config=config, output=graphviz):
if len(sys.argv) > 1:
floris = Floris(sys.argv[1])
else:
floris = Floris("../examples/example_input.json")
graphviz = GraphvizOutput()
graphviz.output_file = "calculate_wake.png"
with PyCallGraph(config=config, output=graphviz):
floris.farm.flow_field.calculate_wake()
# 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()
