def test_spanning_tree():
x9, y9 = np.array([[50, 90],
[100, 150],
[200, 150],
[300, 140],
[340, 110],
[300, 55],
[200, 50],
[100, 50],
[160, 110]]).T
for x, y, ref in [(x9, y9, 561.0566071630595), (wt_x, wt_y, 44232.604068779656)]:
x = np.asarray(x)
y = np.asarray(y)
sp1 = mst(x, y)
sp2 = spanning_tree(x, y)
if 0:
for sp in [sp1, sp2]:
plt.figure()
plt.plot(x, y, '.')
s = []
for i in sp.keys():
if i[0] < i[1] and i[::-1] in sp:
continue
plt.plot(x[np.array(i)], y[np.array(i)], 'k-')
s.append(np.hypot(np.diff(x[np.array(i)]), np.diff(y[np.array(i)])))
plt.title("%s, %s" % (sum(sp.values()), np.sum(s)))
plt.show()
npt.assert_almost_equal(sum(sp1.values()), ref)
npt.assert_almost_equal(sum([v for k, v in sp2.items() if k[::-1] not in sp2 or k[0] < k[1]]), ref)
def test_dtu_cm_npv():
with warnings.catch_warnings():
warnings.simplefilter("ignore")
distance_from_shore = 10 # [km]
energy_price = 0.2 # [Euro/kWh]
project_duration = 20 # [years]
discount_rate = 0.062860816 # [-]
eco_eval = economic_evaluation(distance_from_shore, energy_price,
project_duration, discount_rate)
number_of_turbines = 10
rated_rpm_vector = [10.0] * number_of_turbines # [RPM]
rotor_diameter_vector = [100.0] * number_of_turbines # [m]
rated_power_vector = [10.0] * number_of_turbines # [MW]
hub_height_vector = [100.0] * number_of_turbines # [m]
water_depth_vector = [15.0] * number_of_turbines # [m]
aep_vector = [8.0e6] * number_of_turbines # [kWh]
eco_eval.calculate_npv(rated_rpm_vector, rotor_diameter_vector,
rated_power_vector, hub_height_vector,
water_depth_vector, aep_vector)
npt.assert_almost_equal(eco_eval.NPV, 0.0724087) # [Euro]
def test_turbine_Type_multistart_XYZ_optimization():
plot_comp = DummyCostPlotComp(optimal, delay=.5)
plot_comp = NoPlot()
xyz = [(0, 0, 0), (1, 1, 1)]
p1 = DummyCost(optimal_state=optimal,
inputs=['x', 'y', 'z', 'type'])
p2 = TurbineXYZOptimizationProblem(
cost_comp=p1,
turbineXYZ=xyz,
min_spacing=2,
boundary_comp=get_boundary_comp(),
plot_comp=plot_comp,
driver=EasyScipyOptimizeDriver(disp=True, optimizer='COBYLA', maxiter=10))
p3 = InitialXYZOptimizationProblem(
cost_comp=p2,
turbineXYZ=xyz, min_spacing=2,
boundary_comp=get_boundary_comp(),
driver=DOEDriver(ListGenerator([[('x', [0, 4]), ('y', [2, 2]), ('z', [4, 1])]])))
tf = TurbineTypeOptimizationProblem(
cost_comp=p3,
turbineTypes=[0, 0], lower=0, upper=1,
driver=DOEDriver(FullFactorialGenerator(1)))
case_gen = tf.driver.options['generator']
cost, state, recorder = tf.optimize()
print(cost)
# print (state)
print(recorder.get('type'))
print(recorder.get('cost'))
best_index = np.argmin(recorder.get('cost'))
initial_xyz_recorder = recorder['recorder'][best_index]
xyz_recorder = initial_xyz_recorder.get('recorder')[0]
npt.assert_almost_equal(xyz_recorder['cost'][-1], cost)
def test_3level_type_multistart_XYZ_optimization():
design_vars = {k: v for k, v in zip('xy', optimal.T)}
design_vars['z'] = (optimal[:, 2], 0, 4)
xyz_problem = TopFarmProblem(design_vars,
cost_comp=DummyCost(optimal,
['x', 'y', 'z', 'type']),
constraints=[
SpacingConstraint(2),
XYBoundaryConstraint([(0, 0), (4, 4)],
'square')
],
driver=EasyScipyOptimizeDriver(disp=False))
initial_xyz_problem = TopFarmProblem(
design_vars={k: v
for k, v in zip('xyz', optimal.T)},
cost_comp=xyz_problem,
driver=DOEDriver(
ListGenerator([[('x', [0, 4]), ('y', [2, 2]), ('z', [4, 1])]])))
tf = TopFarmProblem({'type': ([0, 0], 0, 1)},
cost_comp=initial_xyz_problem,
driver=DOEDriver(FullFactorialGenerator(2)))
cost, _, recorder = tf.optimize()
best_index = np.argmin(recorder.get('cost'))
initial_xyz_recorder = recorder['recorder'][best_index]
xyz_recorder = initial_xyz_recorder.get('recorder')[0]
npt.assert_almost_equal(xyz_recorder['cost'][-1], cost)
def test_TopFarmProblem():
tf = xy3tb.get_tf(design_vars={'x': [3, 7, 4], 'y': [-3, -7, -3]},
constraints=[])
cost, state, _ = tf.optimize()
npt.assert_almost_equal(cost, 0)
npt.assert_array_almost_equal(state['x'], xy3tb.desired[:, 0])
npt.assert_array_almost_equal(state['y'], xy3tb.desired[:, 1])
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 test_AEPCalculator():
f = [1, 0, 0, 0]
A = [9.176929, 10, 10, 10]
k = [2.392578, 2, 2, 2]
wr = WindResource(np.array(f), A, k, ti=np.zeros_like(f) + .1)
wf_3tb = testfilepath + "wind_farms/3tb.yml"
with warnings.catch_warnings():
warnings.simplefilter("ignore")
wm = FusedWakeGCLWakeModel(wf_3tb)
aep_calc = AEPCalculator(wr, wm)
npt.assert_almost_equal(aep_calc([-1600, 0, 1600], [0, 0, 0]),
22.3178800761)
def test_smart_start_aep_map(seed, radius, resolution, tol):
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
wfm = NOJ(site, turbines)
aep_comp = PyWakeAEPCostModelComponent(wfm, n_wt=n_wt)
aep_1wt = wfm([0], [0]).aep().sum()
tf = TopFarmProblem(design_vars={
'x': x,
'y': y
},
cost_comp=aep_comp,
driver=EasyScipyOptimizeDriver(),
constraints=[
SpacingConstraint(160),
CircleBoundaryConstraint((0, 0), radius)
])
x = np.arange(-radius, radius, resolution)
y = np.arange(-radius, radius, resolution)
XX, YY = np.meshgrid(x, y)
tf.smart_start(XX,
YY,
aep_comp.get_aep4smart_start(wd=wd_lst, ws=ws_lst),
radius=40,
plot=0,
seed=seed)
tf.evaluate()
if 0:
wt_x, wt_y = tf['x'], tf['y']
for i, _ in enumerate(wt_x, 1):
print(wfm(wt_x[:i], wt_y[:i]).aep().sum(['wd', 'ws']))
aep_comp.windFarmModel(wt_x, wt_y, ws=ws_lst,
wd=wd_lst).flow_map().aep_xy().plot()
print(tf.evaluate())
import matplotlib.pyplot as plt
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'], tol)
def test_dtu_cm_opex():
with warnings.catch_warnings():
warnings.simplefilter("ignore")
distance_from_shore = 10 # [km]
energy_price = 0.2 # [Euro/kWh]
project_duration = 20 # [years]
eco_eval = economic_evaluation(distance_from_shore, energy_price, project_duration)
number_of_turbines = 10
rated_power_vector = [10.0] * number_of_turbines # [MW]
eco_eval.calculate_opex(rated_power_vector)
npt.assert_almost_equal(eco_eval.project_costs_sums['OPEX'] * 1.0E-6, 6.465) # [M Euro / year]
def test_turbineType_and_XYZ_optimization():
plot_comp = DummyCostPlotComp(optimal)
plot_comp = NoPlot()
cost_comp = DummyCost(
optimal_state=optimal,
inputs=['x', 'y', 'z', 'type'])
xyz_opt_problem = TurbineXYZOptimizationProblem(
cost_comp,
turbineXYZ=[(0, 0, 0), (1, 1, 1)],
min_spacing=2,
boundary_comp=get_boundary_comp(),
plot_comp=plot_comp,
driver=EasyScipyOptimizeDriver(disp=False))
tf = TurbineTypeOptimizationProblem(
cost_comp=xyz_opt_problem,
turbineTypes=[0, 0], lower=0, upper=1,
driver=DOEDriver(FullFactorialGenerator(2)))
cost = tf.optimize()[0]
npt.assert_almost_equal(cost, 0)
def test_dtu_cm_capex():
with warnings.catch_warnings():
warnings.simplefilter("ignore")
distance_from_shore = 10 # [km]
energy_price = 0.2 # [Euro/kWh]
project_duration = 20 # [years]
eco_eval = economic_evaluation(distance_from_shore, energy_price, project_duration)
number_of_turbines = 10
rated_rpm_vector = [10.0] * number_of_turbines # [RPM]
rotor_diameter_vector = [100.0] * number_of_turbines # [m]
rated_power_vector = [10.0] * number_of_turbines # [MW]
hub_height_vector = [100.0] * number_of_turbines # [m]
water_depth_vector = [15.0] * number_of_turbines # [m]
eco_eval.calculate_capex(rated_rpm_vector, rotor_diameter_vector, rated_power_vector,
hub_height_vector, water_depth_vector)
npt.assert_almost_equal(eco_eval.project_costs_sums['CAPEX'] * 1.0E-6, 93.6938301) # [M Euro]
def testCostModelComponentDiffShapeInput():
def aep_cost(x, y, h):
opt_x, opt_y = optimal.T
return -np.sum((x - opt_x)**2 + (y - opt_y)**2) + h, {
'add_out': sum(x)
}
cost_comp = AEPCostModelComponent(['x', 'y', ('h', 0)],
4,
aep_cost,
additional_output=[('add_out', 0)])
tf = TopFarmProblem(dict(zip('xy', initial.T)),
cost_comp=cost_comp,
constraints=[
SpacingConstraint(min_spacing),
XYBoundaryConstraint(boundary)
],
driver=EasyScipyOptimizeDriver(disp=False),
ext_vars={'h': 0})
cost0, _, _ = tf.optimize(state={'h': 0})
cost10, _, _ = tf.optimize(state={'h': 10})
npt.assert_almost_equal(cost10, cost0 - 10)
