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 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 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_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_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 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 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 internal_probe(input_dict):
floris = Floris(input_dict=input_dict.floris)
internal_quantity = floris.steady_state_atmospheric_condition()
return internal_quantity
def floris_fixture():
sample_inputs = SampleInputs()
return Floris(sample_inputs.floris)
def __init__(self, input_file):
self.input_file = input_file
self.floris = Floris(input_file=input_file)
def memory_profile(input_dict):
floris = Floris(input_dict=input_dict.floris)
mem_usage = memory_profiler.memory_usage(
(floris.steady_state_atmospheric_condition, (), {}), max_usage=True)
return mem_usage
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_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]
# 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()
def test_gauss_to_curl_to_gauss():
"""
Start with the Gauss wake model
Then, switch to Curl
Then, switch back to Gauss
"""
test_class = ChangeModelTest()
# Establish that the Gauss test passes
gauss_test_class = GaussRegressionTest()
floris = Floris(input_dict=gauss_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 = gauss_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]
# Change the model to Curl, rerun calculate_wake, and compare to Curl
floris.farm.set_wake_model("curl")
floris.farm.flow_field.calculate_wake()
curl_test_class = CurlRegressionTest()
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 = curl_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]
# Change back to Gauss, rerun calculate_wake, and compare to gauss
floris.farm.set_wake_model("gauss")
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 = gauss_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]