def main():
if __name__ == '__main__':
from py_wake.examples.data.iea37 import IEA37Site, IEA37_WindTurbines
from py_wake.deficit_models.selfsimilarity import SelfSimilarityDeficit
import matplotlib.pyplot as plt
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
from py_wake.deficit_models.noj import NOJDeficit
from py_wake.superposition_models import SquaredSum
# NOJ wake model
noj = PropagateDownwind(site,
windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum())
# NOJ wake and selfsimilarity blockage
noj_ss = All2AllIterative(
site,
windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum(),
blockage_deficitModel=SelfSimilarityDeficit())
for wm in [noj, noj_ss]:
plt.figure()
wm(x=x, y=y, wd=[30], ws=[9]).flow_map().plot_wake_map()
plt.show()
def main():
if __name__ == '__main__':
from py_wake.examples.data.iea37 import IEA37Site, IEA37_WindTurbines
from py_wake.deficit_models.selfsimilarity import SelfSimilarityDeficit
from py_wake.deficit_models.gaussian import ZongGaussianDeficit
from py_wake.turbulence_models.stf import STF2017TurbulenceModel
from py_wake.flow_map import XYGrid
import matplotlib.pyplot as plt
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
from py_wake.deficit_models.noj import NOJDeficit
from py_wake.superposition_models import SquaredSum
# NOJ wake model
noj = PropagateDownwind(site,
windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum())
# NOJ wake and selfsimilarity blockage
noj_ss = All2AllIterative(
site,
windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum(),
blockage_deficitModel=SelfSimilarityDeficit())
# Zong convection superposition
zongp_ss = PropagateDownwind(site,
windTurbines,
wake_deficitModel=ZongGaussianDeficit(),
superpositionModel=WeightedSum(),
turbulenceModel=STF2017TurbulenceModel())
# Zong convection superposition
zong_ss = All2AllIterative(
site,
windTurbines,
wake_deficitModel=ZongGaussianDeficit(),
superpositionModel=WeightedSum(),
blockage_deficitModel=SelfSimilarityDeficit(),
turbulenceModel=STF2017TurbulenceModel())
for wm in [noj, noj_ss, zongp_ss, zong_ss]:
sim = wm(x=x, y=y, wd=[30], ws=[9])
plt.figure()
sim.flow_map(XYGrid(resolution=200)).plot_wake_map()
plt.title(' AEP: %.3f GWh' % sim.aep().sum())
plt.show()
def test_wake_and_blockage(setup):
site, windTurbines, ss = setup
noj_ss = All2AllIterative(site,
windTurbines,
wake_deficitModel=NOJDeficit(),
blockage_deficitModel=ss,
superpositionModel=LinearSum())
flow_map = noj_ss(x=[0], y=[0], wd=[270], ws=[10]).flow_map()
X_j, Y_j = flow_map.XY
WS_eff = flow_map.WS_eff_xylk[:, :, 0, 0]
npt.assert_array_almost_equal(WS_eff[200, ::50], [
9.940967, 9.911659, 9.855934, 9.736016, 9.44199, 4.560631, 5.505472,
6.223921, 6.782925, 7.226399
])
npt.assert_array_almost_equal(WS_eff[250, ::50], [
9.937601, 9.90397, 9.834701, 9.659045, 9.049764, 4.560631, 5.505472,
6.223921, 6.782925, 7.226399
])
if 0:
plt.contourf(X_j, Y_j, WS_eff)
plt.plot(X_j[200, ::50], Y_j[200, ::50], '.-')
plt.plot(X_j[250, ::50], Y_j[250, ::50], '.-')
print(list(np.round(WS_eff[200, ::50], 6)))
print(list(np.round(WS_eff[250, ::50], 6)))
ss.windTurbines.plot([0], [0], wd=[270])
plt.show()
def test_wake_and_blockage(setup, blockage_model, center_ref, side_ref):
site, windTurbines = setup
noj_ss = All2AllIterative(site,
windTurbines,
wake_deficitModel=NOJDeficit(),
blockage_deficitModel=blockage_model(),
superpositionModel=LinearSum())
xy = np.linspace(-200, 200, 500)
flow_map = noj_ss(x=[0], y=[0], wd=[270],
ws=[10]).flow_map(XYGrid(x=xy[::50], y=xy[[190, 250]]))
X_j, Y_j = flow_map.XY
WS_eff = flow_map.WS_eff_xylk[:, :, 0, 0]
if debug:
flow_map_full = noj_ss(x=[0], y=[0], wd=[270], ws=[10]).flow_map()
X_j_full, Y_j_full = flow_map_full.XY
WS_eff_full = flow_map_full.WS_eff_xylk[:, :, 0, 0]
plt.contourf(X_j_full, Y_j_full, WS_eff_full)
plt.plot(X_j.T, Y_j.T, '.-')
print(list(np.round(np.array(WS_eff[0]), 6)))
print(list(np.round(np.array(WS_eff[1]), 6)))
plt.title(blockage_model.__name__)
plt.show()
npt.assert_array_almost_equal(WS_eff[0], center_ref)
npt.assert_array_almost_equal(WS_eff[1], side_ref)
def test_Mirror_flow_map(wfm_cls, groundModel, superpositionModel):
site = UniformSite([1], ti=0.1)
wt = V80()
wfm = NOJ(site, wt, k=.5, superpositionModel=superpositionModel)
fm_ref = wfm([0, 0 + 1e-20], [0, 0 + 1e-20], wd=0, h=[50, -50]).flow_map(
YZGrid(x=0, y=np.arange(-100, 100, 1) + .1, z=np.arange(1, 100)))
fm_ref.plot_wake_map()
plt.title("Underground WT added manually")
plt.figure()
wfm = wfm_cls(site,
wt,
NOJDeficit(k=.5),
groundModel=groundModel,
superpositionModel=superpositionModel)
fm_res = wfm([0], [0], wd=0, h=[50]).flow_map(
YZGrid(x=0, y=np.arange(-100, 100, 1) + .1, z=np.arange(1, 100)))
fm_res.plot_wake_map()
plt.title("With Mirror GroundModel")
if 0:
plt.show()
plt.close()
npt.assert_array_equal(fm_ref.WS_eff, fm_res.WS_eff)
def test_All2AllIterativeDeflection():
site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
wf_model = All2AllIterative(site, windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum(),
deflectionModel=JimenezWakeDeflection())
wf_model([0], [0])
def run_wfm(mwc,
test_cases=['Wieringermeer', 'Lillgrund', 'Hornsrev1'],
deficit_setups=[{
'deficit_model': NOJDeficit(),
'superpositionModel': SquaredSum(),
'rotorAvgModel': RotorCenter(),
'turbulenceModel': STF2017TurbulenceModel()
}],
gaussian_filter=True):
'''
Evaluate wake models for the different test cases
'''
mwc_out = {}
for i in range(len(deficit_setups)):
deficit_setups[i]['setup_name'] = get_setup_name(deficit_setups[i])
for case in test_cases:
mwc_out[case] = mwc[case]
mwc_out[case]['deficit_setups'] = deficit_setups
# mwc_out[case]['deficit_models'] = []
if case == 'Wieringermeer':
sigma = 2.5 * np.ones((len(mwc[case]['wt_x'])))
elif case == 'Lillgrund':
sigma = 3.3 * np.ones((len(mwc[case]['wt_x'])))
elif case == 'Hornsrev1':
sigma = sigma_hornsrev('vanderLaan', mwc[case]['wt_x'],
mwc[case]['wt_y'])
for i in range(len(deficit_setups)):
# set up model
wfm = PropagateDownwind(
mwc[case]['site'],
mwc[case]['wt'],
deficit_setups[i]['deficit_model'],
superpositionModel=deficit_setups[i]['superpositionModel'],
rotorAvgModel=deficit_setups[i]['rotorAvgModel'],
turbulenceModel=deficit_setups[i]['turbulenceModel'])
# simulation
sim_res = wfm(mwc[case]['wt_x'],
mwc[case]['wt_y'],
ws=mwc[case]['U0'])
# Gaussian averaging
if gaussian_filter:
powerGA = np.zeros(sim_res.Power.shape)
for iAD in range(len(mwc[case]['wt_x'])):
powerGA[iAD, :, 0] = GaussianFilter(
sim_res.Power.values[iAD, :,
0], np.arange(0, 360.0, 1),
int(np.ceil(3 * sigma[iAD])), sigma[iAD])
sim_res['PowerGA'] = xr.DataArray(powerGA,
dims=['wt', 'wd', 'ws'])
sim_res['PowerGA'].attrs[
'Description'] = 'Gaussian averaged power production [W]'
mwc_out[case][deficit_setups[i]['setup_name']] = sim_res
mwc_out[case][deficit_setups[i]
['setup_name']]['gaussian_filter'] = gaussian_filter
def test_str():
site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
wf_model = All2AllIterative(site, windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum(),
blockage_deficitModel=SelfSimilarityDeficit(),
deflectionModel=JimenezWakeDeflection(),
turbulenceModel=STF2005TurbulenceModel())
assert str(wf_model) == "All2AllIterative(EngineeringWindFarmModel, NOJDeficit-wake, SelfSimilarityDeficit-blockage, RotorCenter-rotor-average, SquaredSum-superposition, JimenezWakeDeflection-deflection, STF2005TurbulenceModel-turbulence)"
def test_All2AllIterativeDeflection():
site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
wf_model = All2AllIterative(site,
windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum(),
deflectionModel=JimenezWakeDeflection())
sim_res = wf_model([0, 500], [0, 0], wd=270, ws=10, yaw=30)
if 0:
sim_res.flow_map(
XYGrid(x=np.linspace(-200, 1000, 100))).plot_wake_map()
plt.show()
def test_NOJ_Nibe_result():
# Replicate result from: Jensen, Niels Otto. "A note on wind generator interaction." (1983).
site = UniformSite([1], 0.1)
x_i = [0, 0, 0]
y_i = [0, -40, -100]
h_i = [50, 50, 50]
wfm = All2AllIterative(site,
NibeA0,
wake_deficitModel=NOJDeficit(),
superpositionModel=LinearSum())
WS_eff_ilk = wfm.calc_wt_interaction(x_i, y_i, h_i, [0, 1, 1], 0.0, 8.1)[0]
npt.assert_array_almost_equal(WS_eff_ilk[:, 0, 0], [8.1, 4.35, 5.7])
def run_wms(swc,
test_cases=[
'Wieringermeer-West', 'Wieringermeer-East', 'Nibe',
'Nordtank-500', 'NREL-5MW_TIlow', 'NREL-5MW_TIhigh'
],
deficit_models=[NOJDeficit(),
BastankhahGaussianDeficit()],
wds=np.linspace(-30, 30, 61)):
'''
Run the different wake models for the specified sites and output simulation results
'''
swc_out = {}
for case in test_cases:
swc_out[case] = swc[case]
x_j = swc[case]['sDown'] * (np.dot(
swc[case]['xDown'][:, na],
np.cos(wds / 180.0 * np.pi)[na, :])).flatten()
y_j = swc[case]['sDown'] * (np.dot(
swc[case]['xDown'][:, na],
np.sin(wds / 180.0 * np.pi)[na, :])).flatten()
ii, jj = len(swc[case]['xDown']), len(wds)
swc_out[case]['x'] = x_j.reshape(ii, jj)
swc_out[case]['y'] = y_j.reshape(ii, jj)
swc_out[case]['wds'] = wds
swc_out[case]['deficit_models'] = []
for model in deficit_models:
# set up model
tmp = {}
wfm = PropagateDownwind(swc[case]['site'],
swc[case]['wt'],
model,
superpositionModel=SquaredSum(),
rotorAvgModel=RotorCenter(),
turbulenceModel=STF2017TurbulenceModel())
# simulation
sim_res = wfm([0], [0], h=[100], wd=[270])
lw_j, WS_eff_jlk, TI_eff_jlk = wfm._flow_map(
x_j, y_j,
np.ones_like(x_j) * 100, sim_res)
deficit_name = modify_deficit_name_sw(wfm.wake_deficitModel,
TI_eff_jlk)
tmp['bar_label'] = modify_deficit_name(wfm.wake_deficitModel)
tmp['WS_eff'] = WS_eff_jlk[:, 0, 0].reshape(ii, jj)
tmp['TI_eff'] = TI_eff_jlk[:, 0, 0].reshape(ii, jj)
swc_out[case][deficit_name] = tmp
swc_out[case]['deficit_models'].append(deficit_name)
return swc_out
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_stf(turbulence_model, ref_ti):
# setup site, turbines and wind farm model
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
for wake_model in [
NOJ(site, windTurbines, turbulenceModel=turbulence_model),
All2AllIterative(site,
windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum(),
turbulenceModel=turbulence_model)
]:
res = wake_model(x, y)
# print(np.round(res.TI_eff_ilk[:, 0, 0], 3).tolist())
npt.assert_array_almost_equal(res.TI_eff_ilk[:, 0, 0], ref_ti, 3)
def test_models_with_noj(turbulence_model, ref_ti):
# setup site, turbines and wind farm model
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
for wake_model in [NOJ(site, windTurbines, turbulenceModel=turbulence_model),
All2AllIterative(site, windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum(),
turbulenceModel=turbulence_model),
]:
res = wake_model(x, y)
# print(turbulence_model.__class__.__name__, np.round(res.TI_eff_ilk[:, 0, 0], 3).tolist())
if 0:
res.flow_map(wd=0).plot_ti_map()
plt.show()
npt.assert_array_almost_equal(res.TI_eff_ilk[:, 0, 0], ref_ti, 3)
def test_wake_and_blockage(setup, blockage_model, center_ref, side_ref):
site, windTurbines = setup
noj_ss = All2AllIterative(site,
windTurbines,
wake_deficitModel=NOJDeficit(),
blockage_deficitModel=blockage_model(),
superpositionModel=LinearSum())
flow_map = noj_ss(x=[0], y=[0], wd=[270], ws=[10]).flow_map()
X_j, Y_j = flow_map.XY
WS_eff = flow_map.WS_eff_xylk[:, :, 0, 0]
if debug:
plt.contourf(X_j, Y_j, WS_eff)
plt.plot(X_j[190, ::50], Y_j[190, ::50], '.-')
plt.plot(X_j[250, ::50], Y_j[250, ::50], '.-')
print(list(np.round(np.array(WS_eff[190, ::50]), 6)))
print(list(np.round(np.array(WS_eff[250, ::50]), 6)))
plt.title(blockage_model.__name__)
plt.show()
npt.assert_array_almost_equal(WS_eff[190, ::50], center_ref)
npt.assert_array_almost_equal(WS_eff[250, ::50], side_ref)
def get_wfms(wt, site=Hornsrev1Site(), wake_model=NOJDeficit(), superpositionModel=SquaredSum()):
wfm1 = PropagateDownwind(site, wt, wake_model, superpositionModel=superpositionModel)
wfm2 = All2AllIterative(site, wt, wake_model, superpositionModel=superpositionModel)
wfm2.verbose = False
wfm1.verbose = False
return wfm1, wfm2
def test_superposition_model_indices(superpositionModel, sum_func):
class WTSite(UniformSite):
def local_wind(self,
x_i=None,
y_i=None,
h_i=None,
wd=None,
ws=None,
wd_bin_size=None,
ws_bins=None):
lw = UniformSite.local_wind(self,
x_i=x_i,
y_i=y_i,
h_i=h_i,
wd=wd,
ws=ws,
wd_bin_size=wd_bin_size,
ws_bins=ws_bins)
lw['WS'] = xr.DataArray(
lw.WS_ilk + np.arange(len(x_i))[:, np.newaxis, np.newaxis],
[('wt', [0, 1, 2]), ('wd', np.atleast_1d(wd)),
('ws', np.atleast_1d(ws))])
return lw
site = WTSite([1], 0.1)
x_i = [0, 0, 0]
y_i = [0, -40, -100]
h_i = [50, 50, 50]
# WS_ilk different at each wt position
WS_ilk = site.local_wind(x_i, y_i, h_i, wd=0, ws=8.1).WS_ilk
npt.assert_array_equal(WS_ilk, np.reshape([8.1, 9.1, 10.1], (3, 1, 1)))
for wake_model in [
PropagateDownwind(site,
NibeA0,
wake_deficitModel=NOJDeficit(),
superpositionModel=superpositionModel),
All2AllIterative(site,
NibeA0,
wake_deficitModel=NOJDeficit(),
superpositionModel=superpositionModel)
]:
# No wake (ct = 0), i.e. WS_eff == WS
WS_eff_ilk = wake_model.calc_wt_interaction(x_i, y_i, h_i, [1, 1, 1],
0.0, 8.1)[0]
npt.assert_array_equal(WS_eff_ilk, WS_ilk)
ref = WS_ilk - np.reshape(
[0, 3.75, sum_func([2.4, 3.58974359])], (3, 1, 1))
# full wake (CT=8/9)
WS_eff_ilk = wake_model.calc_wt_interaction(x_i, y_i, h_i, [0, 0, 0],
0.0, 8.1)[0]
npt.assert_array_almost_equal(WS_eff_ilk, ref)
sim_res = wake_model(x_i, y_i, h_i, [0, 0, 0], 0.0, 8.1)
WS_eff_ilk = sim_res.flow_map(HorizontalGrid(x=[0], y=y_i,
h=50)).WS_eff_xylk[:, 0]
npt.assert_array_almost_equal(WS_eff_ilk, ref)
from py_wake.turbulence_models.stf import STF2017TurbulenceModel
from py_wake.wind_farm_models.engineering_models import PropagateDownwind, All2AllIterative
from py_wake.utils.model_utils import get_models
from numpy import newaxis as na
class GCLLocalDeficit(GCLDeficit):
def __init__(self):
GCLDeficit.__init__(self, use_effective_ws=True, use_effective_ti=True)
@pytest.mark.parametrize(
'deficitModel,aep_ref',
# test that the result is equal to last run (no evidens that these number are correct)
[
(NOJDeficit(), (367205.0846866496, [
9833.86287, 8416.99088, 10820.37673, 13976.26422, 22169.66036,
25234.9215, 37311.64388, 42786.37028, 24781.33444, 13539.82115,
14285.22744, 31751.29488, 75140.15677, 17597.10319, 11721.21226,
7838.84383
])),
(NOJLocalDeficit(), (335151.6404628441, [
8355.71335, 7605.92379, 10654.172, 13047.6971, 19181.46408,
23558.34198, 36738.52415, 38663.44595, 21056.39764, 12042.79324,
13813.46269, 30999.42279, 63947.61202, 17180.40299, 11334.12323,
6972.14345
])),
(BastankhahGaussianDeficit(), (355971.9717035484, [
9143.74048, 8156.71681, 11311.92915, 13955.06316, 19807.65346,
25196.64182, 39006.65223, 41463.31044, 23042.22602, 12978.30551,
14899.26913, 32320.21637, 67039.04091, 17912.40907, 12225.04134,
windTurbines = IEA37_WindTurbines()
wf_model = All2AllIterative(site,
windTurbines,
wake_deficitModel=NOJDeficit(),
superpositionModel=SquaredSum(),
blockage_deficitModel=SelfSimilarityDeficit(),
deflectionModel=JimenezWakeDeflection(),
turbulenceModel=STF2005TurbulenceModel())
assert str(
wf_model
) == "All2AllIterative(EngineeringWindFarmModel, NOJDeficit-wake, SelfSimilarityDeficit-blockage, RotorCenter-rotor-average, SquaredSum-superposition, JimenezWakeDeflection-deflection, STF2005TurbulenceModel-turbulence)"
@pytest.mark.parametrize(
'wake_deficitModel,deflectionModel,superpositionModel',
[(NOJDeficit(), None, SquaredSum()),
(IEA37SimpleBastankhahGaussianDeficit(), JimenezWakeDeflection(),
WeightedSum())])
def test_huge_flow_map(wake_deficitModel, deflectionModel, superpositionModel):
site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
wake_model = PropagateDownwind(site,
windTurbines,
wake_deficitModel=wake_deficitModel,
superpositionModel=superpositionModel,
deflectionModel=deflectionModel,
turbulenceModel=STF2005TurbulenceModel())
n_wt = 2
flow_map = wake_model(*site.initial_position[:n_wt].T,
wd=[0, 90]).flow_map(HorizontalGrid(resolution=1000))
# check that deficit matrix > 10MB (i.e. it enters the memory saving loop)
ax.set_ylabel('Integrated velocity deficit')
ax.get_xaxis().set_visible(False)
self._add_legend(fig)
def plot_multiwake_power(self):
for case in self.multi_wake_cases:
case.plot(self.windFarmModel_dict)
if __name__ == '__main__':
import matplotlib
matplotlib.rcParams.update({'figure.max_open_warning': 0})
validation = Validation()
site, windTurbines = ValidationSite(), ValidationWindTurbines()
validation.add_windFarmModel(
"NOJ",
PropagateDownwind(site, windTurbines, wake_deficitModel=NOJDeficit()),
':')
validation.add_windFarmModel(
"NOJ(k=0.04)",
PropagateDownwind(site,
windTurbines,
wake_deficitModel=NOJDeficit(k=0.04)), ':')
# validation.plot_deficit_profile()
# validation.plot_integrated_deficit()
# plt.close('all')
validation.plot_multiwake_power()
plt.show()
all_deficit_modules = []
for loader, module_name, _ in pkgutil.walk_packages([os.path.dirname(deficit_models.__file__)]):
_module = loader.find_module(module_name).load_module(module_name)
for n in dir(_module):
v = _module.__dict__[n]
if inspect.isclass(v) and issubclass(v, DeficitModel) and \
v not in [DeficitModel, ConvectionDeficitModel] and not issubclass(v, RotorAvgModel):
all_deficit_modules.append(v())
return all_deficit_modules
@pytest.mark.parametrize(
'deficitModel,aep_ref',
# test that the result is equal to last run (no evidens that these number are correct)
[(NOJDeficit(), (367205.0846866496, [9833.86287, 8416.99088, 10820.37673, 13976.26422, 22169.66036,
25234.9215, 37311.64388, 42786.37028, 24781.33444, 13539.82115,
14285.22744, 31751.29488, 75140.15677, 17597.10319, 11721.21226,
7838.84383])),
(NOJLocalDeficit(), (335151.6404628441, [8355.71335, 7605.92379, 10654.172, 13047.6971, 19181.46408,
23558.34198, 36738.52415, 38663.44595, 21056.39764, 12042.79324,
13813.46269, 30999.42279, 63947.61202, 17180.40299, 11334.12323,
6972.14345])),
(BastankhahGaussianDeficit(), (355971.9717035484,
[9143.74048, 8156.71681, 11311.92915, 13955.06316, 19807.65346,
25196.64182, 39006.65223, 41463.31044, 23042.22602, 12978.30551,
14899.26913, 32320.21637, 67039.04091, 17912.40907, 12225.04134,
7513.75582])),
(IEA37SimpleBastankhahGaussianDeficit(), read_iea37_windfarm(iea37_path + 'iea37-ex16.yaml')[2]),
(FugaDeficit(LUT_path=tfp + 'fuga/2MW/Z0=0.00014617Zi=00399Zeta0=0.00E+0/'),
wd, ws_lst = case.get_result(wfm)
for ax, ws, xD in zip(axes, ws_lst, case.xD):
int_vel_def = integrate_velocity_deficit_arc(wd, ws * case.U0, xD, case.U0)
ax.bar(ibar, int_vel_def, width=0.5, color=co, edgecolor=co, label=wfm_name)
for ax, xD in zip(axes, case.xD):
ax.set_ylabel('Integrated velocity deficit')
ax.get_xaxis().set_visible(False)
self._add_legend(fig)
def plot_multiwake_power(self):
for case in self.multi_wake_cases:
case.plot(self.windFarmModel_dict)
if __name__ == '__main__':
import matplotlib
matplotlib.rcParams.update({'figure.max_open_warning': 0})
validation = Validation()
site, windTurbines = ValidationSite(), ValidationWindTurbines()
validation.add_windFarmModel("NOJ", PropagateDownwind(site, windTurbines, wake_deficitModel=NOJDeficit()), ':')
validation.add_windFarmModel(
"NOJ(k=0.04)",
PropagateDownwind(site, windTurbines, wake_deficitModel=NOJDeficit(k=0.04)), ':')
validation.plot_deficit_profile()
# validation.plot_integrated_deficit()
# plt.close('all')
validation.plot_multiwake_power()
plt.show()