def test_DensityScaleFromSite():
ds = Hornsrev1Site().ds
ds['Air_density'] = 1.3
u_p, p_c, ct_c = v80_upct.copy()
for rho_ref in [1.225, 1.2]:
curve = PowerCtTabular(ws=u_p,
power=p_c,
power_unit='w',
ct=ct_c,
ws_cutin=4,
ws_cutout=25,
method='linear',
additional_models=[DensityScale(rho_ref)])
wfm = get_wfm(curve, site=XRSite(ds))
ri, oi = wfm.windTurbines.function_inputs
npt.assert_array_equal(ri, [])
npt.assert_array_equal(oi, ['Air_density'])
u = np.arange(4, 25, .1)
sim_res = wfm(
[0],
[0],
wd=0,
ws=u,
)
p = sim_res.Power.values.squeeze()
ct = sim_res.CT.values.squeeze()
npt.assert_array_almost_equal(p,
np.interp(u, u_p, p_c) * 1.3 / rho_ref)
npt.assert_array_almost_equal(ct,
np.interp(u, u_p, ct_c) * 1.3 / rho_ref)
def test_GCL_ex80():
site = Hornsrev1Site()
x, y = site.initial_position.T
windTurbines = V80()
wfm = PropagateDownwind(site,
windTurbines,
wake_deficitModel=GCLDeficit(),
superpositionModel=LinearSum())
if 0:
windTurbines.plot(x, y)
plt.show()
sim_res = timeit(wfm.__call__,
line_profile=0,
profile_funcs=[get_dU],
verbose=0)(x, y, ws=np.arange(10, 15))[0]
# test that the result is equal to previuos runs (no evidens that these number are correct)
aep_ref = 1055.956615887197
npt.assert_almost_equal(
sim_res.aep_ilk(normalize_probabilities=True).sum(), aep_ref, 5)
sim_res = wfm(x, y, ws=np.arange(3, 10))
npt.assert_array_almost_equal(
sim_res.aep_ilk(normalize_probabilities=True).sum(), 261.6143039016946,
5)
def test_own_turbulence_is_zero(turbulenceModel):
site = Hornsrev1Site()
windTurbines = IEA37_WindTurbines()
wf_model = All2AllIterative(site, windTurbines, wake_deficitModel=IEA37SimpleBastankhahGaussianDeficit(),
turbulenceModel=turbulenceModel())
sim_res = wf_model([0], [0])
npt.assert_array_equal(sim_res.TI_eff, sim_res.TI.broadcast_like(sim_res.TI_eff))
def test_twotype_windturbines():
v80 = V80()
def power(ws, types):
power = v80.power(ws)
# add 10% type 1 turbines
power[types == 1] *= 1.1
return power
wts = WindTurbines(names=['V80', 'V88'],
diameters=[80, 88],
hub_heights=[70, 77],
ct_funcs=[v80.ct_funcs[0], v80.ct_funcs[0]],
power_funcs=[v80.power, lambda ws: v80.power(ws) * 1.1],
power_unit='w')
import matplotlib.pyplot as plt
types0 = [0] * 9
types1 = [0, 0, 0, 1, 1, 1, 0, 0, 0]
types2 = [1] * 9
wts.plot(wt9_x, wt9_y, types1)
wfm = NOJ(Hornsrev1Site(), wts)
npt.assert_almost_equal(
wfm(wt9_x, wt9_y, type=types0).aep(), 81.2066072392765)
npt.assert_almost_equal(
wfm(wt9_x, wt9_y, type=types1).aep(), 83.72420504573488)
npt.assert_almost_equal(
wfm(wt9_x, wt9_y, type=types2).aep(), 88.87227386796884)
if 0:
plt.show()
def test_wake_blockage_split(upstream_only, ref):
class MyWakeModel(WakeDeficitModel):
args4deficit = []
def calc_deficit(self, dw_ijlk, **kwargs):
return np.ones_like(dw_ijlk) * 2
class MyBlockageModel(BlockageDeficitModel):
args4deficit = []
def calc_deficit(self, dw_ijlk, **kwargs):
return np.ones_like(dw_ijlk)
site = Hornsrev1Site()
windTurbines = IEA37_WindTurbines()
wf_model = All2AllIterative(
site,
windTurbines,
wake_deficitModel=MyWakeModel(),
blockage_deficitModel=MyBlockageModel(upstream_only=upstream_only))
sim_res = wf_model([0], [0], ws=10, wd=270)
fm = sim_res.flow_map(XYGrid(x=[-100, 100], y=[-100, 0, 100]))
if 0:
sim_res.flow_map().plot_wake_map()
print(fm.WS_eff.values.squeeze().T)
plt.show()
npt.assert_array_equal(fm.WS_eff.values.squeeze().T, ref)
def test_from_flow_box_2wt():
site = Hornsrev1Site()
windTurbines = V80()
# simulate current and neighbour wt
wfm = BastankhahGaussian(site, windTurbines)
wd = np.arange(30)
sim_res = wfm([0, 0], [0, 500], wd=wd)
ref_aep = sim_res.aep().sel(wt=0)
wt_x, wt_y = [0], [0]
neighbour_x, neighbour_y = [0], [500]
# make site with effects of neighbour wt
sim_res = wfm(neighbour_x, neighbour_y, wd=wd)
e = 100
box = sim_res.flow_box(x=np.linspace(min(wt_x) - e, max(wt_x) + e, 21),
y=np.linspace(min(wt_y) - e, max(wt_y) + e, 21),
h=windTurbines.hub_height(windTurbines.types()))
site = XRSite.from_flow_box(box)
# Simujlate current wt and compare aep
wfm = BastankhahGaussian(site, windTurbines)
sim_res = wfm(wt_x, wt_y, wd=wd)
aep = sim_res.aep()
if 0:
site.ds.WS.sel(ws=10, wd=3).plot()
windTurbines.plot(wt_x, wt_y)
windTurbines.plot(neighbour_x, neighbour_y)
plt.show()
npt.assert_array_almost_equal(ref_aep, aep.sel(wt=0))
def check_speed_Hornsrev(WFModel):
assert getattr(sys, 'gettrace')() is None, "Skipping speed check, In debug mode!!!"
wt = HornsrevV80()
site = Hornsrev1Site()
wf_model = WFModel(site, wt)
aep, t_lst = timeit(lambda x, y: wf_model(x, y).aep().sum())(wt_x, wt_y)
fn = tfp + "speed_check/%s.txt" % WFModel.__name__
if os.path.isfile(fn):
with open(fn) as fid:
lines = fid.readlines()
# check aep
npt.assert_almost_equal(float(lines[-1].split(";")[1]), aep)
timings = np.array([(np.mean(eval(l.split(";")[2])), np.std(eval(l.split(";")[2]))) for l in lines])
dates = [np.datetime64(l.split(";")[0]) for l in lines]
dates = np.r_[dates, datetime.now()]
y = np.r_[timings[:, 0], np.mean(t_lst)]
error = np.r_[timings[:, 1], np.std(t_lst)]
fig, axes = plt.subplots(2, 1)
fig.suptitle(WFModel.__name__)
for x, ax in zip([dates, np.arange(len(dates))], axes):
ax.fill_between(x, y - 2 * error, y + 2 * error)
ax.plot(x, y, '.-k')
ax.axhline(y[:-1].mean() + 2 * error[:-1].mean(), ls='--', color='gray')
if y[-1] > (y[:-1].mean() + 2 * error[:-1].mean()):
raise Exception("Simulation time too slow, %f > %f" % (y[-1], (y[:-1].mean() + 2 * error[:-1].mean())))
if getattr(sys, 'gettrace')() is None:
with open(fn, 'a') as fid:
fid.write("%s;%.10f;%s\n" % (datetime.now(), aep, t_lst))
def test_time_series_operating_wrong_shape():
from py_wake.wind_turbines.power_ct_functions import PowerCtFunctionList, PowerCtTabular
d = np.load(os.path.dirname(examples.__file__) + "/data/time_series.npz")
wd, ws, ws_std = [d[k][:6 * 24] for k in ['wd', 'ws', 'ws_std']]
ws += 3
t = np.arange(6 * 24)
wt = V80()
site = Hornsrev1Site()
# replace powerCtFunction
wt.powerCtFunction = PowerCtFunctionList(
key='operating',
powerCtFunction_lst=[
PowerCtTabular(ws=[0, 100],
power=[0, 0],
power_unit='w',
ct=[0, 0]), # 0=No power and ct
wt.powerCtFunction
], # 1=Normal operation
default_value=1)
wfm = NOJ(site, wt)
x, y = site.initial_position.T
operating = (t < 48) | (t > 72)
with pytest.raises(
ValueError,
match=
r"Argument, operating\(shape=\(1, 144\)\), has unsupported shape."
):
wfm(x, y, ws=ws, wd=wd, time=t, operating=[operating])
def test_time_series_operating():
from py_wake.wind_turbines.power_ct_functions import PowerCtFunctionList, PowerCtTabular
d = np.load(os.path.dirname(examples.__file__) + "/data/time_series.npz")
wd, ws, ws_std = [d[k][:6 * 24] for k in ['wd', 'ws', 'ws_std']]
ws += 3
t = np.arange(6 * 24)
wt = V80()
site = Hornsrev1Site()
# replace powerCtFunction
wt.powerCtFunction = PowerCtFunctionList(
key='operating',
powerCtFunction_lst=[
PowerCtTabular(ws=[0, 100],
power=[0, 0],
power_unit='w',
ct=[0, 0]), # 0=No power and ct
wt.powerCtFunction
], # 1=Normal operation
default_value=1)
wfm = NOJ(site, wt)
x, y = site.initial_position.T
operating = (t < 48) | (t > 72)
sim_res = wfm(x, y, ws=ws, wd=wd, time=t, operating=operating)
npt.assert_array_equal(sim_res.operating[0], operating)
npt.assert_array_equal(sim_res.Power[:, operating == 0], 0)
npt.assert_array_equal(sim_res.Power[:, operating != 0] > 0, True)
operating = np.ones((80, 6 * 24))
operating[1] = (t < 48) | (t > 72)
sim_res = wfm(x, y, ws=ws, wd=wd, time=t, operating=operating)
npt.assert_array_equal(sim_res.operating, operating)
npt.assert_array_equal(sim_res.Power.values[operating == 0], 0)
npt.assert_array_equal(sim_res.Power.values[operating != 0] > 0, True)
def test_yaw_wrong_name():
wfm = NOJ(Hornsrev1Site(), V80())
for k in ['yaw_ilk', 'Yaw']:
with pytest.raises(
ValueError,
match=r'Custom \*yaw\*\-keyword arguments not allowed'):
wfm([0], [0], **{k: [[[30]]]})
def test_aep_wind_atlas_method():
site = Hornsrev1Site()
wt = IEA37_WindTurbines()
wfm = IEA37SimpleBastankhahGaussian(site, wt)
x, y = [0], [0]
wd = np.arange(360)
aep_lps = wfm(x, y, wd=wd,
ws=np.arange(3, 27)).aep(linear_power_segments=True)
aep = wfm(x, y, wd=wd, ws=np.r_[3, np.arange(3.5, 27)]).aep()
if 0:
plt.plot(aep_lps.ws,
np.cumsum(aep_lps.sum(['wt', 'wd'])),
'.-',
label='Linear power segments')
plt.plot(aep.ws,
np.cumsum(aep.sum(['wt', 'wd'])),
'.-',
label='Constant power segments')
plt.ylabel('Cumulated AEP [GWh]')
plt.xlabel('Wind speed [m/s]')
plt.legend()
plt.show()
npt.assert_almost_equal(aep_lps.sum(), 16.73490444)
npt.assert_almost_equal(aep.sum(), 16.69320343)
def main():
if __name__ == '__main__':
import matplotlib.pyplot as plt
wt = HornsrevV80()
wt.plot(wt_x, wt_y)
aep_calculator = AEPCalculator(Hornsrev1Site(), wt, NOJ(wt))
print('AEP', aep_calculator.calculate_AEP(wt_x, wt_y)[0].sum())
plt.show()
def test_add_ilk_time_wrong_dim(shape):
site = Hornsrev1Site()
wt, wd, ws = np.arange(2), np.arange(100), np.arange(100) % 20 + 3
t = pd.date_range("2000-01-01", freq="10T", periods=100)
lw = site.local_wind(wt * 1000, wt * 0, wt * 0 + 70, wd, ws, time=t)
with pytest.raises(ValueError):
lw.add_ilk('TI', np.full(shape, 0.1))
def test_add_ilk_time(ti, dims):
site = Hornsrev1Site()
wt, wd, ws = np.arange(2), np.arange(100), np.arange(100) % 20 + 3
t = pd.date_range("2000-01-01", freq="10T", periods=100)
lw = site.local_wind(wt * 1000, wt * 0, wt * 0 + 70, wd, ws, time=t)
lw.add_ilk('TI', ti)
assert lw.TI.dims == dims
def test_time_series_aep():
d = np.load(os.path.dirname(examples.__file__) + "/data/time_series.npz")
wd, ws = [d[k][::100] for k in ['wd', 'ws']]
wt = V80()
site = Hornsrev1Site()
x, y = site.initial_position.T
wfm = NOJ(site, wt)
sim_res = wfm(x, y, ws=ws, wd=wd, time=True, verbose=False)
npt.assert_allclose(sim_res.aep().sum(), 545, atol=1)
def main():
if __name__ == '__main__':
import matplotlib.pyplot as plt
wt = HornsrevV80()
site = Hornsrev1Site()
wt.plot(wt_x, wt_y)
wf_model = NOJ(site, wt)
aep = wf_model(wt_x, wt_y).aep()
plt.title('AEP: %.1fGWh' % aep.sum())
plt.show()
def main():
if __name__ == '__main__':
import matplotlib.pyplot as plt
from py_wake.examples.data.hornsrev1 import Hornsrev1Site
from py_wake.examples.data import hornsrev1
from py_wake.superposition_models import LinearSum
from py_wake.wind_farm_models import All2AllIterative
site = Hornsrev1Site()
windTurbines = hornsrev1.HornsrevV80()
ws = 10
D = 80
R = D / 2
WS_ilk = np.array([[[ws]]])
D_src_il = np.array([[D]])
ct_ilk = np.array([[[.8]]])
ss = SelfSimilarityDeficit()
x, y = -np.arange(200), np.array([0])
deficit = ss.calc_deficit(WS_ilk=WS_ilk,
D_src_il=D_src_il,
dw_ijlk=x.reshape((1, len(x), 1, 1)),
cw_ijlk=y.reshape((1, len(y), 1, 1)),
ct_ilk=ct_ilk)
plt.title('Fig 11 from [1]')
plt.xlabel('x/R')
plt.ylabel('a')
plt.plot(x / R, deficit[0, :, 0, 0] / ws)
plt.figure()
x, y = np.array([-2 * R]), np.arange(200)
deficit = ss.calc_deficit(WS_ilk=WS_ilk,
D_src_il=D_src_il,
dw_ijlk=x.reshape((1, len(x), 1, 1)),
cw_ijlk=y.reshape((1, len(y), 1, 1)),
ct_ilk=ct_ilk)
plt.title('Fig 10 from [1]')
r12 = np.sqrt(ss.lambda_ * (ss.eta + (x / R)**2)) # Eq. (13) from [1]
print(x, r12)
plt.xlabel('y/R12 (epsilon)')
plt.ylabel('f')
plt.plot((y / R) / r12, deficit[0, :, 0, 0] / deficit[0, 0, 0, 0])
plt.figure()
noj_ss = All2AllIterative(site,
windTurbines,
wake_deficitModel=NoWakeDeficit(),
superpositionModel=LinearSum(),
blockage_deficitModel=ss)
flow_map = noj_ss(x=[0], y=[0], wd=[270], ws=[10]).flow_map()
flow_map.plot_wake_map()
flow_map.plot_windturbines()
plt.show()
def test_deficit_symmetry(wake_deficitModel, blockage_deficitModel):
site = Hornsrev1Site()
windTurbines = IEA37_WindTurbines()
wfm = All2AllIterative(site, windTurbines, wake_deficitModel=wake_deficitModel,
superpositionModel=LinearSum(),
blockage_deficitModel=blockage_deficitModel,
deflectionModel=None, turbulenceModel=None)
power = wfm([0, 0, 500, 500], [0, 500, 0, 500], wd=[0], ws=[8]).power_ilk[:, 0, 0]
npt.assert_array_almost_equal(power[:2], power[2:])
def test_own_deficit_is_zero():
for deficitModel in get_models(WakeDeficitModel):
site = Hornsrev1Site()
windTurbines = IEA37_WindTurbines()
wf_model = All2AllIterative(site,
windTurbines,
wake_deficitModel=deficitModel(),
turbulenceModel=STF2017TurbulenceModel())
sim_res = wf_model([0], [0])
npt.assert_array_equal(sim_res.WS_eff,
sim_res.WS.broadcast_like(sim_res.WS_eff))
def test_time_series_override_WD():
d = np.load(os.path.dirname(examples.__file__) + "/data/time_series.npz")
wd, ws = [d[k][:6 * 24] for k in ['wd', 'ws']]
t = pd.date_range("2000-01-01", freq="10T", periods=24 * 6)
WD_it = (np.arange(80) / 100)[:, na] + wd[na]
wt = V80()
site = Hornsrev1Site()
x, y = site.initial_position.T
wfm = NOJ(site, wt)
sim_res = wfm(x, y, ws=ws, wd=wd, time=t, WD=WD_it, verbose=False)
npt.assert_array_equal(sim_res.WS, ws)
npt.assert_array_equal(sim_res.WD, WD_it)
npt.assert_array_equal(sim_res.time, t)
def test_dAEP_2wt():
site = Hornsrev1Site()
iea37_site = IEA37Site(16)
wt = IEA37_WindTurbines()
wfm = IEA37SimpleBastankhahGaussian(site, wt)
x, y = iea37_site.initial_position[np.array([0, 2, 5, 8, 14])].T
# plot 2 wt case
x, y = np.array([[0, 130 * 4], [0, 0]], dtype=np.float)
x_lst = np.array([0., 1.]) * np.arange(1, 600, 10)[:, na]
kwargs = {'ws': [10], 'wd': [270]}
_, (ax1, ax2) = plt.subplots(1, 2, sharey=False)
ax1.plot(x_lst[:, 1], [wfm.aep(x_, y, **kwargs) for x_ in x_lst])
ax1.set_xlabel('Downwind distance [m]')
ax1.set_ylabel('AEP [GWh]')
x_ = x_lst[20]
ax1.set_title("Center line")
for grad in [fd, cs, autograd]:
dAEPdx = wfm.dAEPdn(0, grad)(x_, y, **kwargs)[1]
npt.assert_almost_equal(dAEPdx / 360, 3.976975605364392e-06,
(10, 5)[grad == fd])
plot_gradients(wfm.aep(x_, y, **kwargs),
dAEPdx,
x_[1],
grad.__name__,
step=100,
ax=ax1)
y_lst = np.array([0, 1.]) * np.arange(-100, 100, 5)[:, na]
ax2.plot(y_lst[:, 1], [wfm.aep(x, y_, **kwargs) for y_ in y_lst])
ax2.set_xlabel('Crosswind distance [m]')
ax2.set_ylabel('AEP [GWh]')
y_ = y_lst[25]
ax2.set_title("%d m downstream" % x[1])
for grad in [fd, cs, autograd]:
dAEPdy = wfm.dAEPdn(1, grad)(x, y_, **kwargs)[1]
plot_gradients(wfm.aep(x, y_, **kwargs),
dAEPdy,
y_[1],
grad.__name__,
step=50,
ax=ax2)
npt.assert_almost_equal(dAEPdy / 360, 3.794435973860448e-05,
(10, 5)[grad == fd])
if 0:
plt.legend()
plt.show()
plt.close()
def test_dAEPdx():
site = Hornsrev1Site()
iea37_site = IEA37Site(16)
wt = IEA37_WindTurbines()
wfm = IEA37SimpleBastankhahGaussian(site, wt)
x, y = iea37_site.initial_position[np.array([0, 2, 5, 8, 14])].T
dAEPdxy_autograd = wfm.dAEPdxy(gradient_method=autograd)(x, y)
dAEPdxy_cs = wfm.dAEPdxy(gradient_method=cs)(x, y)
dAEPdxy_fd = wfm.dAEPdxy(gradient_method=fd)(x, y)
npt.assert_array_almost_equal(dAEPdxy_autograd, dAEPdxy_cs, 15)
npt.assert_array_almost_equal(dAEPdxy_autograd, dAEPdxy_fd, 6)
def test_time_series_values():
wt = V80()
site = Hornsrev1Site()
x, y = site.initial_position.T
wfm = NOJ(site, wt)
wd = np.arange(350, 360)
ws = np.arange(5, 10)
wd_t, ws_t = [v.flatten() for v in np.meshgrid(wd, ws)]
sim_res_t = wfm(x, y, ws=ws_t, wd=wd_t, time=True, verbose=False)
sim_res = wfm(x, y, wd=wd, ws=ws)
for k in ['WS_eff', 'TI_eff', 'Power', 'CT']:
npt.assert_array_equal(
np.moveaxis(sim_res_t[k].values.reshape((80, 5, 10)), 1, 2),
sim_res[k].values)
def test_time_series_override_TI():
d = np.load(os.path.dirname(examples.__file__) + "/data/time_series.npz")
wd, ws, ws_std = [d[k][:6 * 24] for k in ['wd', 'ws', 'ws_std']]
ti = np.minimum(ws_std / ws, .5)
t = pd.date_range("2000-01-01", freq="10T", periods=24 * 6)
wt = V80()
site = Hornsrev1Site()
x, y = site.initial_position.T
wfm = NOJ(site, wt)
sim_res = wfm(x, y, ws=ws, wd=wd, time=t, TI=ti, verbose=False)
npt.assert_array_equal(sim_res.WS, ws)
npt.assert_array_equal(sim_res.WD, wd)
npt.assert_array_equal(sim_res.time, t)
npt.assert_array_equal(sim_res.TI[0], ti)
def test_two_wt_aep():
site = Hornsrev1Site()
windTurbines = IEA37_WindTurbines()
wake_model = NOJ(site, windTurbines)
sim_res1 = wake_model([0], [0], wd=270)
sim_res2 = wake_model([0, 0], [0, 500], wd=270)
# one wt, wind from west ~ 5845 hours of full load
npt.assert_almost_equal(sim_res1.aep(normalize_probabilities=True).sum(), 3.35 * 5.845, 2)
# No wake, two wt = 2 x one wt
npt.assert_almost_equal(sim_res1.aep().sum() * 2, sim_res2.aep().sum())
# same for normalized propabilities
npt.assert_almost_equal(sim_res1.aep(normalize_probabilities=True).sum() * 2,
sim_res2.aep(normalize_probabilities=True).sum())
def main():
if __name__ == '__main__':
from py_wake import NOJ
from py_wake import IEA37SimpleBastankhahGaussian, Fuga
import py_wake
import os
import matplotlib.pyplot as plt
from py_wake.examples.data.hornsrev1 import HornsrevV80, Hornsrev1Site
from py_wake.examples.data.iea37._iea37 import IEA37Site
LUT_path = os.path.dirname(
py_wake.__file__
) + '/tests/test_files/fuga/2MW/Z0=0.03000000Zi=00401Zeta0=0.00E+00/'
wt_x, wt_y = IEA37Site(16).initial_position.T
windTurbines = HornsrevV80()
site = Hornsrev1Site()
wake_models = [
NOJ(site, windTurbines),
IEA37SimpleBastankhahGaussian(site, windTurbines),
Fuga(LUT_path, site, windTurbines)
]
for wake_model in wake_models:
# Calculate AEP
sim_res = wake_model(wt_x, wt_y)
# Plot wake map
plt.figure(wake_model.__class__.__name__)
plt.title('AEP: %.2f GWh' % sim_res.aep().sum())
flow_map = sim_res.flow_map(wd=[0], ws=[9])
flow_map.plot_wake_map()
flow_map.plot_windturbines()
plt.show()
def test_GlobalWindAtlasSite():
ref = Hornsrev1Site()
lat, long = 55.52972, 7.906111 # hornsrev
site = GlobalWindAtlasSite(lat, long, height=70, roughness=0.001, ti=0.075)
ref_mean = weibull.mean(ref.ds.Weibull_A, ref.ds.Weibull_k)
gwa_mean = weibull.mean(site.ds.Weibull_A, site.ds.Weibull_k)
if 0:
plt.figure()
plt.plot(ref.ds.wd, ref_mean, label='HornsrevSite')
plt.plot(site.ds.wd, gwa_mean, label='HornsrevSite')
for r in [0, 1.5]:
for h in [10, 200]:
A, k = [site.gwc_ds[v].sel(roughness=r, height=h) for v in ['Weibull_A', 'Weibull_k']]
plt.plot(site.gwc_ds.wd, weibull.mean(A, k), label=f'{h}, {r}')
plt.legend()
plt.show()
npt.assert_allclose(gwa_mean, ref_mean, atol=1.4)
for var, atol in [('Sector_frequency', 0.03), ('Weibull_A', 1.6), ('Weibull_k', 0.4)]:
npt.assert_allclose(site.ds[var], ref.ds[var], atol=atol)
def test_DeprecatedWindTurbines():
for wts in [
V80Deprecated(),
WindTurbines(
names=['V80'],
diameters=[80],
hub_heights=[70],
ct_funcs=[
lambda ws: np.interp(ws, hornsrev1.ct_curve[:, 0],
hornsrev1.ct_curve[:, 1])
],
power_funcs=[
lambda ws: np.interp(ws, hornsrev1.power_curve[:, 0],
hornsrev1.power_curve[:, 1])
],
power_unit='w')
]:
types0 = [0] * 9
wfm = NOJ(Hornsrev1Site(), wts)
npt.assert_array_equal(wts.types(), [0])
npt.assert_almost_equal(wfm.aep(wt9_x, wt9_y, type=types0),
81.2066072392765)
import multiprocessing
from py_wake.examples.data.hornsrev1 import Hornsrev1Site, wt_x, wt_y
from py_wake import IEA37SimpleBastankhahGaussian
from py_wake.tests.check_speed import timeit
import numpy as np
from py_wake.tests import npt
from py_wake.wind_turbines import WindTurbines
from py_wake.examples.data import wtg_path
wt = WindTurbines.from_WAsP_wtg(wtg_path + "Vestas-V80.wtg")
site = Hornsrev1Site()
wf_model = IEA37SimpleBastankhahGaussian(site, wt)
wd_lst = np.arange(0, 360, 10)
def aep_wd(args):
x, y, wd = args
return wf_model(x, y, wd=wd, ws=None).aep().sum()
def aep_all_multiprocessing(pool, x, y):
return np.sum(pool.map(aep_wd, [(x, y, i) for i in wd_lst]))
def aep_wfm_xy(args):
wfm, x, y = args
return wfm(x, y, wd=wd_lst).aep().sum()
def aep_xy(args):
def test_add_ilk_wrong_dim(shape):
site = Hornsrev1Site()
wt, wd, ws = np.arange(2), np.arange(360), np.arange(3, 26)
lw = site.local_wind(wt * 1000, wt * 0, wt * 0 + 70, wd, ws, time=False)
with pytest.raises(ValueError):
lw.add_ilk('TI', np.full(shape, 0.1))