def test_interp(h, wd, ws, h_i, wd_l, ws_k):
ds = xr.Dataset({
'TI': 1,
'P': 1,
'XYHLK': (['x', 'y', 'h', 'wd', 'ws'], np.random.rand(10, 20, len(h), len(wd), len(ws))),
'XYHL': (['x', 'y', 'h', 'wd'], np.random.rand(10, 20, len(h), len(wd))),
'XYHK': (['x', 'y', 'h', 'ws'], np.random.rand(10, 20, len(h), len(ws))),
'K': (['ws'], np.random.rand(len(ws))),
'L': (['wd'], np.random.rand(len(wd))),
'KL': (['wd', 'ws'], np.random.rand(len(wd), len(ws))),
'XY': (['x', 'y'], np.random.rand(10, 20)),
'H': (['h'], np.random.rand(len(h))),
'XYH': (['x', 'y', 'h'], np.random.rand(10, 20, len(h))),
'XYL': (['x', 'y', 'wd'], np.random.rand(10, 20, len(wd))),
'XYK': (['x', 'y', 'ws'], np.random.rand(10, 20, len(ws))),
'I': (['i'], np.random.rand(2)),
'IL': (['i', 'wd'], np.random.rand(2, len(wd))),
'IK': (['i', 'ws'], np.random.rand(2, len(ws))),
'ILK': (['i', 'wd', 'ws'], np.random.rand(2, len(wd), len(ws))),
},
coords={'x': np.linspace(0, 100, 10),
'y': np.linspace(200, 300, 20),
'h': h,
'wd': wd,
'ws': ws,
'i': [0, 1]}
)
site = XRSite(ds)
lw = LocalWind(x_i=[25, 50], y_i=[225, 250], h_i=h_i, wd=wd_l, ws=ws_k, wd_bin_size=1)
for n in ['XYHLK', 'XYHL', 'XYHK', 'K', 'L', 'KL', 'XY', 'H', 'XYH', 'XYL', 'XYK', 'I', 'IL', 'IK', 'ILK']:
ip1 = site.interp(site.ds[n], lw.coords)
ip2 = ds[n].sel_interp_all(lw.coords)
npt.assert_array_equal(ip1.shape, ip2.shape)
npt.assert_array_almost_equal(ip1.data, ip2.data)
def test_plot_wd_distribution_with_ws_levels_xr(site):
import xarray as xr
ds = xr.Dataset(data_vars={
'Sector_frequency': ('wd', f),
'Weibull_A': ('wd', A),
'Weibull_k': ('wd', k)
},
coords={'wd': np.linspace(0, 360, len(f), endpoint=False)})
site2 = XRSite(ds,
shear=PowerShear(h_ref=100, alpha=.2),
interp_method='nearest')
p = site2.plot_wd_distribution(n_wd=12, ws_bins=[0, 5, 10, 15, 20, 25])
if 0:
plt.show()
# print(np.round(p.values, 4).tolist())
npt.assert_array_almost_equal(p,
[[0.0075, 0.0179, 0.0091, 0.0014, 0.0001],
[0.0069, 0.0188, 0.0115, 0.0022, 0.0001],
[0.0098, 0.025, 0.0142, 0.0025, 0.0001],
[0.0109, 0.0339, 0.0214, 0.0036, 0.0001],
[0.0114, 0.0411, 0.0271, 0.004, 0.0001],
[0.0108, 0.0324, 0.0185, 0.0026, 0.0001],
[0.0147, 0.0434, 0.0247, 0.0035, 0.0001],
[0.0164, 0.0524, 0.0389, 0.0092, 0.0007],
[0.0185, 0.0595, 0.0524, 0.0184, 0.0026],
[0.0153, 0.0564, 0.054, 0.0191, 0.0024],
[0.0103, 0.0386, 0.0369, 0.0127, 0.0015],
[0.0092, 0.0231, 0.0152, 0.0038, 0.0004]],
4)
plt.close('all')
def test_elevation():
ti = 0.1
ds = xr.Dataset(
data_vars={'Elevation': (['x', 'y'], np.arange(.8, 1.4, .1).reshape((3, 2))),
'P': 1, 'TI': ti},
coords={'x': [0, 5, 10], 'y': [0, 5]})
site = XRSite(ds)
npt.assert_array_almost_equal(site.elevation([2.5, 7.5], [2.5, 2.5]), [0.95, 1.15])
def test_WaspGridSiteDistanceClass(site):
wgs = XRSite(site.ds,
distance=TerrainFollowingDistance(distance_resolution=2000))
assert wgs.distance.distance_resolution == 2000
assert wgs.distance.__call__.__func__ == TerrainFollowingDistance(
).__call__.__func__
wgs = XRSite(site.ds, distance=StraightDistance())
assert wgs.distance.__call__.__func__ == StraightDistance(
).__call__.__func__
def __init__(self):
site = self.from_wasp_grd(ParqueFicticio_path,
speedup_using_pickle=False)
site.ds['water_depth'] = -site.ds['Elevation'] / 10
ds = site.ds.drop_vars([
'flow_inc', 'ws_mean', 'orog_spd', 'Turning', 'Elevation',
'Speedup'
])
ds['x'] = x
ds['y'] = y
XRSite.__init__(self, ds)
self.boundary = boundary
self.initial_position = np.array([wt_x, wt_y]).T
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_wrong_height():
ti = 0.1
ds = xr.Dataset(
data_vars={'Speedup': (['x', 'y', 'h'], np.arange(.8, 1.4, .1).reshape((3, 2, 1))),
'Sector_frequency': ('wd', f), 'Weibull_A': ('wd', A), 'Weibull_k': ('wd', k), 'TI': ti},
coords={'x': [0, 5, 10], 'y': [0, 5], 'h': [100], 'wd': np.linspace(0, 360, len(f), endpoint=False)})
site = XRSite(ds, shear=PowerShear(h_ref=100, alpha=.2), interp_method='linear')
y = np.arange(5)
x = y * 2
X, Y = np.meshgrid(x, y)
x_i, y_i = X.flatten(), Y.flatten()
wdir_lst = np.arange(0, 360, 90)
wsp_lst = np.arange(3, 6)
lw = site.local_wind(x_i=x_i, y_i=y_i, h_i=100, wd=wdir_lst, ws=wsp_lst)
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 complex_ws_site():
ti = 0.1
P = weibull.cdf(np.array([3, 5, 7, 9, 11, 13]), 10, 2) - weibull.cdf(np.array([0, 3, 5, 7, 9, 11]), 10, 2)
ds = xr.Dataset(
data_vars={'Speedup': (['ws'], np.arange(.8, 1.4, .1)),
'P': (('wd', 'ws'), P[na, :] * np.array(f)[:, na]), 'TI': ti},
coords={'ws': [1.5, 4, 6, 8, 10, 12], 'wd': np.linspace(0, 360, len(f), endpoint=False)})
return XRSite(ds, shear=PowerShear(h_ref=100, alpha=.2), interp_method='linear')
def complex_grid_site():
ti = 0.1
ds = xr.Dataset(
data_vars={'Speedup': (['x', 'y'], np.arange(.8, 1.4, .1).reshape((3, 2))),
'Turning': (['x', 'y'], np.arange(-2, 4, 1).reshape((3, 2))),
'Sector_frequency': ('wd', f), 'Weibull_A': ('wd', A), 'Weibull_k': ('wd', k), 'TI': ti},
coords={'x': [0, 5, 10], 'y': [0, 5], 'wd': np.linspace(0, 360, len(f), endpoint=False)})
return XRSite(ds, shear=PowerShear(h_ref=100, alpha=.2), interp_method='linear')
def test_wd_independent_site():
ti = 0.1
ds = xr.Dataset(
data_vars={
'WS': 10, 'Sector_frequency': 1,
'Weibull_A': 4, 'Weibull_k': 2, 'TI': ti},
coords={})
site = XRSite(ds, shear=None)
npt.assert_equal(site.ds.sector_width, 360)
def complex_fixed_pos_site():
ti = 0.1
ds = xr.Dataset(
data_vars={'Speedup': ('i', np.arange(.8, 1.3, .1)),
'Turning': ('i', np.arange(-2, 3)),
'Sector_frequency': ('wd', f), 'Weibull_A': ('wd', A), 'Weibull_k': ('wd', k), 'TI': ti},
coords={'i': np.arange(5), 'wd': np.linspace(0, 360, len(f), endpoint=False)})
x_i = np.arange(5)
return XRSite(ds, initial_position=np.array([x_i, x_i + 1]).T, shear=PowerShear(h_ref=100, alpha=.2))
def test_i_time_dependent_WS():
t = np.arange(4)
WS_it = t[na] / 10 + np.array([9, 10])[:, na]
ds = xr.Dataset(
data_vars={'WS': (('i', 'time'), WS_it), 'P': ('wd', f), 'TI': 0.1},
coords={'wd': np.linspace(0, 360, len(f), endpoint=False)})
site = XRSite(ds)
wfm = NOJ(site, V80())
sim_res = wfm([0, 200], [0, 0], ws=WS_it.mean(0), wd=np.zeros(4), time=t)
npt.assert_array_equal(sim_res.WS, WS_it)
def test_neighbour_farm_speed():
# import and setup site and windTurbines
site = IEA37Site(16)
# setup current, neighbour and all positions
wt_x, wt_y = site.initial_position.T
neighbour_x, neighbour_y = wt_x - 4000, wt_y
all_x, all_y = np.r_[wt_x, neighbour_x], np.r_[wt_y, neighbour_y]
windTurbines = WindTurbines.from_WindTurbines([IEA37_WindTurbines(), IEA37_WindTurbines()])
windTurbines._names = ["Current wind farm", "Neighbour wind farm"]
types = [0] * len(wt_x) + [1] * len(neighbour_x)
wf_model = PropagateDownwind(site, windTurbines,
wake_deficitModel=BastankhahGaussianDeficit(use_effective_ws=True),
superpositionModel=LinearSum())
# Consider wd=270 +/- 30 deg only
wd_lst = np.arange(240, 301)
sim_res, t = timeit(wf_model, verbose=False)(all_x, all_y, type=types, ws=9.8, wd=wd_lst)
if 1:
ext = 100
flow_box = wf_model(neighbour_x, neighbour_y, wd=wd_lst).flow_box(
x=np.linspace(min(wt_x) - ext, max(wt_x) + ext, 53),
y=np.linspace(min(wt_y) - ext, max(wt_y) + ext, 51),
h=[100, 110, 120])
wake_site = XRSite.from_flow_box(flow_box)
wake_site.save('tmp.nc')
else:
wake_site = XRSite.load('tmp.nc')
wf_model_wake_site = PropagateDownwind(wake_site, windTurbines,
wake_deficitModel=BastankhahGaussianDeficit(use_effective_ws=True),
superpositionModel=LinearSum())
sim_res_wake_site, _ = timeit(wf_model_wake_site, verbose=False)(wt_x, wt_y, ws=9.8, wd=wd_lst)
npt.assert_allclose(sim_res.aep().sel(wt=np.arange(len(wt_x))).sum(), sim_res_wake_site.aep().sum(), rtol=0.0005)
npt.assert_array_almost_equal(sim_res.aep().sel(wt=np.arange(len(wt_x))), sim_res_wake_site.aep(), 2)
def test_interp_special_cases():
wd = np.arange(5)
ws = np.arange(10)
ds = xr.Dataset({
'TI': (['i', 'wd', 'ws'], np.random.rand(10, len(wd), len(ws))),
'P': 1
},
coords={'i': np.arange(10),
'wd': wd,
'ws': ws}
)
site = XRSite(ds)
with pytest.raises(ValueError, match=r"Number of points, i\(=10\), in site data variable, TI, must match "):
lw = LocalWind(x_i=[25, 50], y_i=[225, 250], h_i=110, wd=wd, ws=ws, wd_bin_size=1)
site.interp(site.ds.TI, lw.coords)
x = y = np.arange(10)
lw = LocalWind(x_i=x, y_i=y, h_i=110, wd=wd, ws=ws, wd_bin_size=1)
ip1 = site.interp(site.ds.TI, lw.coords)
ip2 = ds.TI.sel_interp_all(lw.coords)
npt.assert_array_equal(ip1.shape, ip2.shape)
npt.assert_array_almost_equal(ip1.data, ip2.data)
def test_turning_mean(complex_grid_site, wfm):
ds = xr.Dataset(
data_vars={'Turning': (['x', 'y'], np.arange(-2, 4, 1).reshape((2, 3)).T),
'Sector_frequency': ('wd', f), 'Weibull_A': ('wd', A), 'Weibull_k': ('wd', k), 'TI': .1},
coords={'x': [0, 500, 1000], 'y': [0, 500], 'wd': np.linspace(0, 360, len(f), endpoint=False)})
site = XRSite(ds)
wt = V80()
wfm = wfm(site, wt, NOJDeficit())
sim_res = wfm([500, 500], [100, 400], wd=0, ws=10)
print(sim_res.Power)
if 0:
sim_res.flow_map(XYGrid(y=np.linspace(0, 500, 100))).plot_wake_map()
plt.show()
assert sim_res.WS_eff.sel(wt=0).item() < sim_res.WS_eff.sel(wt=1).item()
fm = sim_res.flow_map(Points([500, 500], [100, 400], [70, 70]))
assert fm.WS_eff.sel(i=0).item() < fm.WS_eff.sel(i=1).item()
def test_i_dependent_WS():
ds = xr.Dataset(
data_vars={'WS': ('i', [8, 9, 10]), 'P': ('wd', f)},
coords={'wd': np.linspace(0, 360, len(f), endpoint=False)})
site = XRSite(ds)
lw = site.local_wind([0, 200, 400], [0, 0, 0], [70, 70, 70], wd=0, ws=10)
npt.assert_array_equal(lw.WS, [8, 9, 10])
WS = np.arange(6).reshape(3, 2) + 9
ds = xr.Dataset(
data_vars={'WS': (('i', 'ws'), WS), 'Sector_frequency': ('wd', f),
'Weibull_A': ('wd', A), 'Weibull_k': ('wd', k)},
coords={'wd': np.linspace(0, 360, len(f), endpoint=False), 'ws': [9, 10], 'i': [0, 1, 2]})
site = XRSite(ds)
lw = site.local_wind([0, 200, 400], [0, 0, 0], [70, 70, 70], wd=0, ws=10)
npt.assert_array_equal(lw.WS.squeeze(), [10, 12, 14])
def uniform_site():
ti = 0.1
ds = xr.Dataset(
data_vars={'WS': 10, 'P': ('wd', f), 'TI': ti},
coords={'wd': np.linspace(0, 360, len(f), endpoint=False)})
return XRSite(ds, shear=PowerShear(h_ref=100, alpha=.2))
def test_load_save(complex_grid_site):
complex_grid_site.save(tfp + "tmp.nc")
site = XRSite.load(tfp + "tmp.nc", interp_method='linear')
test_complex_grid_local_wind(site)
def uniform_weibull_site():
ti = 0.1
ds = xr.Dataset(
data_vars={'Sector_frequency': ('wd', f), 'Weibull_A': ('wd', A), 'Weibull_k': ('wd', k), 'TI': ti},
coords={'wd': np.linspace(0, 360, len(f), endpoint=False)})
return XRSite(ds, shear=PowerShear(h_ref=100, alpha=.2))
