def main():
if __name__ == '__main__':
from py_wake.examples.data.iea37._iea37 import IEA37Site
from py_wake.examples.data.iea37._iea37 import IEA37_WindTurbines
from py_wake.superposition_models import LinearSum
from py_wake.wind_farm_models import All2AllIterative
from py_wake.deficit_models.no_wake import NoWakeDeficit
from py_wake.deficit_models.vortexcylinder import VortexCylinder
from py_wake.deficit_models.vortexdipole import VortexDipole
import matplotlib.pyplot as plt
from py_wake import HorizontalGrid
from timeit import default_timer as timer
# setup site, turbines and wind farm model
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
d = windTurbines.diameter()
ra = Rathmann()
grid = HorizontalGrid(x=np.linspace(-6, 6, 100) * d, y=np.linspace(0, 4, 100) * d)
noj_ra = All2AllIterative(site, windTurbines, wake_deficitModel=NoWakeDeficit(),
superpositionModel=LinearSum(), blockage_deficitModel=ra)
noj_vc = All2AllIterative(site, windTurbines, wake_deficitModel=NoWakeDeficit(),
superpositionModel=LinearSum(), blockage_deficitModel=VortexCylinder())
noj_vd = All2AllIterative(site, windTurbines, wake_deficitModel=NoWakeDeficit(),
superpositionModel=LinearSum(), blockage_deficitModel=VortexDipole())
t1 = timer()
flow_map = noj_ra(x=[0], y=[0], wd=[270], ws=[10]).flow_map(grid=grid)
t2 = timer()
flow_map_vc = noj_vc(x=[0], y=[0], wd=[270], ws=[10]).flow_map(grid=grid)
t3 = timer()
flow_map_vd = noj_vd(x=[0], y=[0], wd=[270], ws=[10]).flow_map(grid=grid)
t4 = timer()
print(t2 - t1, t3 - t2, t4 - t3)
plt.figure()
clevels = np.array([.6, .7, .8, .9, .95, .98, .99, .995, .998, .999, 1., 1.005, 1.01, 1.02, 1.05]) * 10.
flow_map.plot_wake_map(levels=clevels)
plt.contour(flow_map.x, flow_map.y, flow_map.WS_eff[:, :, 0, -1, 0], levels=clevels, colors='k', linewidths=1)
plt.contour(flow_map.x, flow_map.y, flow_map_vc.WS_eff[:, :, 0, -1, 0], levels=clevels, colors='r', linewidths=1, linestyles='dashed')
plt.contour(flow_map.x, flow_map.y, flow_map_vd.WS_eff[:, :, 0, -1, 0], levels=clevels, colors='b', linewidths=1, linestyles='dotted')
plt.title('Rathmann')
plt.ylabel("Crosswind distance [y/R]")
plt.xlabel("Downwind distance [x/R]")
plt.show()
# run wind farm simulation
sim_res = noj_ra(x, y, wd=[0, 30, 45, 60, 90], ws=[5, 10, 15])
# calculate AEP
aep = sim_res.aep().sum()
# plot wake map
plt.figure()
print(noj_ra)
flow_map = sim_res.flow_map(wd=0, ws=10)
flow_map.plot_wake_map(levels=clevels, plot_colorbar=False)
plt.title('Rathmann model, AEP: %.3f GWh' % aep)
plt.show()
def get_iea37_cost(n_wt=9):
"""Cost component that wraps the IEA 37 AEP calculator"""
wd = npa(range(16)) * 22.5 # only 16 bins
site = IEA37Site(n_wt)
wind_turbines = IEA37_WindTurbines()
wake_model = IEA37SimpleBastankhahGaussian(site, wind_turbines)
return PyWakeAEPCostModelComponent(wake_model, n_wt, wd=wd)
def test_ti_map():
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
wake_model = NOJ(site,
windTurbines,
turbulenceModel=STF2017TurbulenceModel())
aep = AEPCalculator(wake_model)
x_j = np.linspace(-1500, 1500, 200)
y_j = np.linspace(-1500, 1500, 100)
X, Y, Z = aep.ti_map(x_j, y_j, 110, x, y, wd=[0], ws=[9])
m = 49, slice(100, 133, 2)
if 0:
print(np.round(Z[m], 2).tolist()) # ref
import matplotlib.pyplot as plt
c = plt.contourf(X, Y, Z, np.arange(.075, .50, .001))
plt.colorbar(c)
windTurbines.plot(x, y)
plt.plot(X[m], Y[m], '.-r')
plt.show()
ref = [
0.48, 0.08, 0.08, 0.13, 0.16, 0.18, 0.19, 0.19, 0.2, 0.18, 0.17, 0.12,
0.13, 0.13, 0.13, 0.12, 0.12
]
npt.assert_array_almost_equal(Z[m], ref, 2)
def main():
if __name__ == '__main__':
from py_wake.examples.data.iea37 import iea37_path
from py_wake.examples.data.iea37._iea37 import IEA37Site
from py_wake.examples.data.iea37._iea37 import IEA37_WindTurbines
from py_wake.wake_models import NOJ
# setup site, turbines and wakemodel
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines(iea37_path + 'iea37-335mw.yaml')
wake_model = NOJ(site, windTurbines)
# calculate AEP
aep_calculator = AEPCalculator(wake_model)
aep = aep_calculator.calculate_AEP(x, y)[0].sum()
print(aep_calculator.WS_eff_ilk.shape)
# plot wake map
import matplotlib.pyplot as plt
aep_calculator.plot_wake_map(wt_x=x, wt_y=y, wd=[0], ws=[9])
plt.title('AEP: %.2f GWh' % aep)
windTurbines.plot(x, y)
plt.show()
def main():
if __name__ == '__main__':
from py_wake.aep_calculator import AEPCalculator
from py_wake.examples.data.iea37 import iea37_path
from py_wake.examples.data.iea37._iea37 import IEA37Site
from py_wake.examples.data.iea37._iea37 import IEA37_WindTurbines
# setup site, turbines and wakemodel
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines(iea37_path + 'iea37-335mw.yaml')
from py_wake.tests.test_files import tfp
path = tfp + 'fuga/2MW/Z0=0.03000000Zi=00401Zeta0=0.00E+0/'
wake_model = Fuga(path, site, windTurbines)
# calculate AEP
aep_calculator = AEPCalculator(wake_model)
aep = aep_calculator.calculate_AEP(x, y)[0].sum()
# plot wake map
import matplotlib.pyplot as plt
aep_calculator.plot_wake_map(wt_x=x, wt_y=y, wd=[0], ws=[9])
plt.title('AEP: %.2f GWh' % aep)
windTurbines.plot(x, y)
plt.show()
def main():
if __name__ == '__main__':
from py_wake.examples.data.iea37._iea37 import IEA37Site
from py_wake.examples.data.iea37._iea37 import IEA37_WindTurbines
import matplotlib.pyplot as plt
# setup site, turbines and wind farm model
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
path = tfp + 'fuga/2MW/Z0=0.03000000Zi=00401Zeta0=0.00E+0/'
for wf_model in [
Fuga(path, site, windTurbines),
FugaBlockage(path, site, windTurbines)
]:
plt.figure()
print(wf_model)
# run wind farm simulation
sim_res = wf_model(x, y)
# calculate AEP
aep = sim_res.aep().sum()
# plot wake map
flow_map = sim_res.flow_map(wd=30, ws=9.8)
flow_map.plot_wake_map()
flow_map.plot_windturbines()
plt.title('AEP: %.2f GWh' % aep)
plt.show()
plt.show()
def test_wake_model():
site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
wake_model = NOJ(site, windTurbines)
with pytest.raises(ValueError, match="Turbines 0 and 1 are at the same position"):
wake_model([0, 0], [0, 0], wd=np.arange(0, 360, 22.5), ws=[9.8])
def test_aep_map():
site = IEA37Site(16)
x = [0, 0]
y = [0, 200]
windTurbines = IEA37_WindTurbines()
wake_model = IEA37SimpleBastankhahGaussian(site, windTurbines)
aep = AEPCalculator(wake_model)
# print(aep.calculate_AEP([0], [0]).sum())
x_j = np.arange(-150, 150, 20)
y_j = np.arange(-250, 250, 20)
X, Y, Z = aep.aep_map(x_j, y_j, 0, x, y, wd=[0], ws=np.arange(3, 25))
m = 17
if 0:
import matplotlib.pyplot as plt
c = plt.contourf(X, Y, Z, 100) # , np.arange(2, 10, .01))
plt.colorbar(c)
windTurbines.plot(x, y)
plt.plot(X[m], Y[m], '.-r')
plt.show()
# print(np.round(Z[m], 2).tolist()) # ref
ref = [
21.5, 21.4, 21.02, 20.34, 18.95, 16.54, 13.17, 10.17, 10.17, 13.17,
16.54, 18.95, 20.34, 21.02, 21.4
]
npt.assert_array_almost_equal(Z[m].squeeze('h'), ref, 2)
def test_wake_radius(deficitModel, wake_radius_ref):
mean_ref = [105, 68, 135, 93, 123]
# check that ref is reasonable
npt.assert_allclose(wake_radius_ref, mean_ref, rtol=.5)
npt.assert_array_almost_equal(deficitModel.wake_radius(
D_src_il=np.reshape([100, 50, 100, 100, 100], (5, 1)),
dw_ijlk=np.reshape([500, 500, 1000, 500, 500], (5, 1, 1, 1)),
ct_ilk=np.reshape([.8, .8, .8, .4, .8], (5, 1, 1)),
TI_ilk=np.reshape([.1, .1, .1, .1, .05], (5, 1, 1)),
TI_eff_ilk=np.reshape([.1, .1, .1, .1, .05], (5, 1, 1)))[:, 0, 0, 0],
wake_radius_ref)
# Check that it works when called from WindFarmModel
site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
wfm = PropagateDownwind(site, windTurbines, wake_deficitModel=deficitModel, turbulenceModel=GCLTurbulence())
wfm(x=[0, 500], y=[0, 0], wd=[30], ws=[10])
if 0:
sim_res = wfm([0], [0], wd=[270], ws=10)
sim_res.flow_map(HorizontalGrid(x=np.arange(-100, 1500, 10))).WS_eff.plot()
x = np.arange(0, 1500, 10)
wr = deficitModel.wake_radius(
D_src_il=np.reshape([130], (1, 1)),
dw_ijlk=np.reshape(x, (1, len(x), 1, 1)),
ct_ilk=sim_res.CT.values,
TI_ilk=np.reshape(sim_res.TI.values, (1, 1, 1)),
TI_eff_ilk=sim_res.TI_eff.values)[0, :, 0, 0]
plt.title(deficitModel.__class__.__name__)
plt.plot(x, wr)
plt.plot(x, -wr)
plt.axis('equal')
plt.show()
def test_deficitModel_wake_map_convection(deficitModel, ref):
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
wf_model = PropagateDownwind(site, windTurbines, wake_deficitModel=deficitModel, superpositionModel=WeightedSum(),
turbulenceModel=GCLTurbulence())
x_j = np.linspace(-1500, 1500, 200)
y_j = np.linspace(-1500, 1500, 100)
flow_map = wf_model(x, y, wd=0, ws=9).flow_map(HorizontalGrid(x_j, y_j))
X, Y = flow_map.X, flow_map.Y
Z = flow_map.WS_eff_xylk[:, :, 0, 0]
mean_ref = [3.2, 4.9, 8., 8.2, 7.9, 7.4, 7., 7., 7.4, 7.9, 8.1, 8.1, 8., 7.8, 7.9, 8.1, 8.4]
if 0:
flow_map.plot_wake_map()
plt.plot(X[49, 100:133:2], Y[49, 100:133:2], '.-')
windTurbines.plot(x, y)
plt.figure()
plt.plot(Z[49, 100:133:2], label='Actual')
plt.plot(ref, label='Reference')
plt.plot(mean_ref, label='Mean ref')
plt.legend()
plt.show()
# check that ref is reasonable
npt.assert_allclose(ref[2:], mean_ref[2:], atol=2.6)
npt.assert_array_almost_equal(Z[49, 100:133:2], ref, 2)
def main():
if __name__ == '__main__':
from py_wake.examples.data.iea37._iea37 import IEA37Site
from py_wake.examples.data.iea37._iea37 import IEA37_WindTurbines
from py_wake import NOJ
import matplotlib.pyplot as plt
# setup site, turbines and wakemodel
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
wf_model = NOJ(site,
windTurbines,
turbulenceModel=GCLTurbulenceModel())
# calculate AEP
sim_res = wf_model(x, y)
print(sim_res.TI_eff_ilk.flatten())
# plot wake mape
aep = sim_res.aep()
flow_map = sim_res.flow_map(wd=0, ws=9.8)
flow_map.plot_ti_map()
plt.title('AEP: %.2f GWh' % aep)
plt.show()
def main():
if __name__ == '__main__':
from py_wake.examples.data.iea37._iea37 import IEA37Site
from py_wake.examples.data.iea37._iea37 import IEA37_WindTurbines
import matplotlib.pyplot as plt
# setup site, turbines and wind farm model
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
wf_model = IEA37SimpleBastankhahGaussian(site, windTurbines)
print(wf_model)
# run wind farm simulation
sim_res = wf_model(x, y)
# calculate AEP
aep = sim_res.aep()
# plot wake map
flow_map = sim_res.flow_map(wd=30, ws=9.8)
flow_map.plot_wake_map()
flow_map.plot_windturbines()
plt.title('AEP: %.2f GWh' % aep.sum())
plt.show()
def test_with_all_deficit_models(WFM, deficitModel):
site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
wfm = WFM(site,
windTurbines,
wake_deficitModel=deficitModel,
rotorAvgModel=RotorCenter(),
superpositionModel=LinearSum(),
deflectionModel=None,
turbulenceModel=STF2017TurbulenceModel())
wfm2 = WFM(site,
windTurbines,
wake_deficitModel=deficitModel,
rotorAvgModel=EqGridRotorAvg(1),
superpositionModel=LinearSum(),
deflectionModel=None,
turbulenceModel=STF2017TurbulenceModel())
kwargs = {
'x': [0, 0, 500, 500],
'y': [0, 500, 0, 500],
'wd': [0],
'ws': [8]
}
npt.assert_equal(wfm.aep(**kwargs), wfm2.aep(**kwargs))
def test_IEA37_ex16(deficitModel, aep_ref):
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
wf_model = PropagateDownwind(site,
windTurbines,
wake_deficitModel=deficitModel,
superpositionModel=SquaredSum(),
turbulenceModel=GCLTurbulence())
aep_ilk = wf_model(x, y, wd=np.arange(0, 360, 22.5),
ws=[9.8]).aep_ilk(normalize_probabilities=True)
aep_MW_l = aep_ilk.sum((0, 2)) * 1000
# check if ref is reasonable
aep_est = 16 * 3.35 * 24 * 365 * .8 # n_wt * P_rated * hours_pr_year - 20% wake loss = 375628.8
npt.assert_allclose(aep_ref[0], aep_est, rtol=.11)
npt.assert_allclose(aep_ref[1], [
9500, 8700, 11500, 14300, 21300, 25900, 39600, 44300, 23900, 13900,
15200, 33000, 72100, 18300, 12500, 8000
],
rtol=.15)
npt.assert_almost_equal(aep_MW_l.sum(), aep_ref[0], 5)
npt.assert_array_almost_equal(aep_MW_l, aep_ref[1], 5)
def test_IEA37WindTurbines():
wt = IEA37WindTurbines()
site = IEA37Site(16)
x, y = site.initial_position.T
for wfm in get_wfms(wt, site, IEA37SimpleBastankhahGaussianDeficit(), SquaredSum()):
sim_res = wfm(x, y, ws=9.8, wd=np.arange(0, 360, 22.5))
npt.assert_almost_equal(sim_res.aep(normalize_probabilities=True).sum() * 1e3, 366941.57116, 5)
def test_wake_map():
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines(iea37_path + 'iea37-335mw.yaml')
wake_model = NOJ(site, windTurbines)
aep = AEPCalculator(wake_model)
x_j = np.linspace(-1500, 1500, 200)
y_j = np.linspace(-1500, 1500, 100)
X, Y, Z = aep.wake_map(x_j, y_j, 110, x, y, wd=[0], ws=[9])
if 0:
import matplotlib.pyplot as plt
c = plt.contourf(X, Y, Z) # , np.arange(2, 10, .01))
plt.colorbar(c)
windTurbines.plot(x, y)
plt.show()
ref = [
3.27, 3.27, 9.0, 7.46, 7.46, 7.46, 7.46, 7.31, 7.31, 7.31, 7.31, 8.3,
8.3, 8.3, 8.3, 8.3, 8.3
]
npt.assert_array_almost_equal(Z[49, 100:133:2], ref, 2)
def test_plot_wd_distribution_uniformSite():
site = IEA37Site(16)
p1 = site.plot_wd_distribution(n_wd=12, ax=plt)
if 0:
plt.show()
plt.close('all')
def test_yaw_tilt(yaw, tilt, cx, cz):
site = IEA37Site(16)
x, y = [0], [0]
windTurbines = V80()
D = windTurbines.diameter()
wfm = IEA37SimpleBastankhahGaussian(
site, windTurbines, deflectionModel=JimenezWakeDeflection())
x_lst = np.linspace(-200, 1000, 100)
y_lst = np.linspace(-100, 100, 201)
z_lst = np.arange(10, 200, 1)
fm_yz = wfm(x, y, wd=270, ws=10, yaw=yaw,
tilt=tilt).flow_map(YZGrid(x=5 * D, y=y_lst, z=z_lst))
fm_xz = wfm(x, y, wd=180, ws=10, yaw=yaw,
tilt=tilt).flow_map(YZGrid(x=0, y=x_lst, z=z_lst))
fm_xy = wfm(x, y, wd=270, ws=10, yaw=yaw,
tilt=tilt).flow_map(XYGrid(x=x_lst))
if 0:
axes = plt.subplots(3, 1)[1].flatten()
fm_xy.plot_wake_map(ax=axes[0])
axes[0].axvline(5 * D)
fm_xz.plot_wake_map(ax=axes[1])
axes[1].axvline(5 * D)
fm_yz.plot_wake_map(ax=axes[2])
plt.show()
wake_center = fm_yz.WS_eff.where(fm_yz.WS_eff == fm_yz.WS_eff.min(),
drop=True).squeeze()
npt.assert_allclose(wake_center.y, cx, atol=.1)
npt.assert_allclose(wake_center.h, cz, atol=.24)
def main():
if __name__ == '__main__':
from py_wake.examples.data.iea37._iea37 import IEA37Site
from py_wake.examples.data.iea37._iea37 import IEA37_WindTurbines
from py_wake import NOJ
# setup site, turbines and flow model
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
import matplotlib.pyplot as plt
_, (ax1, ax2) = plt.subplots(1, 2)
for ax, wf_model, lbl in [
(ax1,
NOJ(site, windTurbines,
turbulenceModel=STF2005TurbulenceModel()), 'STF2005'),
(ax2,
NOJ(site, windTurbines,
turbulenceModel=STF2017TurbulenceModel()), 'STF2017')
]:
sim_res = wf_model(x, y)
print(sim_res.TI_eff_ilk[:, 0])
# plot wake map
flow_map = sim_res.flow_map(wd=0, ws=9.8)
c = flow_map.plot_ti_map(ax=ax)
ax.set_title('Turbulence intensity calculated by %s' % lbl)
plt.show()
def run_NOJ():
windTurbines = IEA37_WindTurbines()
site = IEA37Site(64)
wake_model = NOJ(windTurbines)
aep_calculator = AEPCalculator(site, windTurbines, wake_model)
x, y = site.initial_position.T
print(aep_calculator.calculate_AEP(x, y).sum())
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 test_wake_radius_not_implemented():
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
wfm = PropagateDownwind(site, windTurbines, wake_deficitModel=NoWakeDeficit(),
turbulenceModel=GCLTurbulence())
with pytest.raises(NotImplementedError, match="wake_radius not implemented for NoWakeDeficit"):
wfm(x, y)
def get_iea37_cost(n_wt=9):
"""Cost component that wraps the IEA 37 AEP calculator"""
wd = npa(range(16)) * 22.5 # only 16 bins
site = IEA37Site(n_wt)
wind_turbines = IEA37_WindTurbines()
wake_model = IEA37SimpleBastankhahGaussian(wind_turbines)
aep_calc = PyWakeAEP(site, wind_turbines, wake_model)
return aep_calc.get_TopFarm_cost_component(n_wt, wd=wd)
def test_smart_start_aep_map_PyWakeAEP():
site = IEA37Site(16)
n_wt = 4
x, y = site.initial_position[:n_wt].T
wd_lst = np.arange(0, 360, 45)
ws_lst = [10]
turbines = hornsrev1.HornsrevV80()
site = UniformSite([1], .75)
site.default_ws = ws_lst
site.default_wd = wd_lst
aep = PyWakeAEP(wake_model=NOJ(site, turbines))
aep_1wt = aep.calculate_AEP([0], [0]).sum()
tf = TopFarmProblem(design_vars={
'x': x,
'y': y
},
cost_comp=aep.get_TopFarm_cost_component(n_wt),
driver=EasyScipyOptimizeDriver(),
constraints=[
SpacingConstraint(160),
CircleBoundaryConstraint((0, 0), 500)
])
x = np.arange(-500, 500, 10)
y = np.arange(-500, 500, 10)
XX, YY = np.meshgrid(x, y)
tf.smart_start(XX,
YY,
aep.get_aep4smart_start(wd=wd_lst, ws=ws_lst),
radius=40,
seed=1)
tf.evaluate()
if 0:
wt_x, wt_y = tf['x'], tf['y']
for i, _ in enumerate(wt_x, 1):
print(aep.calculate_AEP(wt_x[:i], wt_y[:i]).sum((1, 2)))
X_j, Y_j, aep_map = aep.aep_map(x,
y,
0,
wt_x,
wt_y,
ws=ws_lst,
wd=wd_lst)
print(tf.evaluate())
import matplotlib.pyplot as plt
c = plt.contourf(X_j, Y_j, aep_map, 100)
plt.colorbar(c)
plt.plot(wt_x, wt_y, '2r')
for c in tf.model.constraint_components:
c.plot()
plt.axis('equal')
plt.show()
npt.assert_almost_equal(aep_1wt * n_wt, tf['AEP'], 5)
def main():
if __name__ == '__main__':
try:
import matplotlib.pyplot as plt
plt.gcf()
plot_comp = XYPlotComp()
plot = True
except RuntimeError:
plot_comp = NoPlot()
plot = False
n_wt = 16
site = IEA37Site(n_wt)
windTurbines = IEA37_WindTurbines()
wake_model = IEA37SimpleBastankhahGaussian(site, windTurbines)
Drotor_vector = [windTurbines.diameter()] * n_wt
power_rated_vector = [float(windTurbines.power(20) / 1000)] * n_wt
hub_height_vector = [windTurbines.hub_height()] * n_wt
AEPCalc = AEPCalculator(wake_model)
def aep_func(x, y, **kwargs):
return AEPCalc.calculate_AEP(x_i=x, y_i=y).sum(-1).sum(-1) * 10**6
def irr_func(aep, **kwargs):
my_irr = economic_evaluation(Drotor_vector, power_rated_vector,
hub_height_vector,
aep).calculate_irr()
print(my_irr)
return my_irr
aep_comp = CostModelComponent(input_keys=['x', 'y'],
n_wt=n_wt,
cost_function=aep_func,
output_key="aep",
output_unit="GWh",
objective=False,
output_val=np.zeros(n_wt))
irr_comp = CostModelComponent(input_keys=['aep'],
n_wt=n_wt,
cost_function=irr_func,
output_key="irr",
output_unit="%",
objective=True,
income_model=True)
group = TopFarmGroup([aep_comp, irr_comp])
problem = TopFarmProblem(
design_vars=dict(zip('xy', site.initial_position.T)),
cost_comp=group,
driver=EasyRandomSearchDriver(
randomize_func=RandomizeTurbinePosition_Circle(), max_iter=50),
constraints=[
SpacingConstraint(200),
CircleBoundaryConstraint([0, 0], 1300.1)
],
plot_comp=plot_comp)
cost, state, recorder = problem.optimize()
def test_double_wind_farm_model():
"""Check that a new wind farm model does not change results of previous"""
site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()
wfm = PropagateDownwind(site, windTurbines, wake_deficitModel=IEA37SimpleBastankhahGaussianDeficit())
aep_ref = wfm(x, y).aep().sum()
PropagateDownwind(site, windTurbines, wake_deficitModel=NoWakeDeficit())
aep = wfm(x, y).aep().sum()
npt.assert_array_equal(aep, aep_ref)
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_get_model_input():
site, windTurbines = IEA37Site(16), IEA37_WindTurbines()
wfm = IEA37SimpleBastankhahGaussian(site, windTurbines)
args = get_model_input(wfm, [1000], [0], ws=10, wd=270)
npt.assert_array_almost_equal(args['dw_ijl'], [[[1000]]])
npt.assert_array_almost_equal(args['hcw_ijl'], [[[0]]])
npt.assert_array_almost_equal(args['dh_ijl'], [[[0]]])
npt.assert_array_almost_equal(args['yaw_ilk'], [[[0]]])
npt.assert_array_almost_equal(args['WS_ilk'], [[[10]]])
npt.assert_array_almost_equal(args['ct_ilk'], [[[8 / 9]]])
def test_plot_ws_distribution_iea37():
from py_wake.examples.data.iea37 import IEA37Site
n_wt = 16 # must be 16, 32 or 64
site = IEA37Site(n_wt)
p = site.plot_ws_distribution(wd=[0])
npt.assert_almost_equal(p, [[1 / 300] * 300])
if 0:
plt.show()
def get_iea37_initial(n_wt=9):
"""Initial positions for IEA Task 37 wind farms
Parameters
----------
n_wt : int, optional
Number of wind turbines in farm (must be valid IEA 37 farm)
"""
site = IEA37Site(n_wt)
return site.initial_position