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 testAEP_topfarm_optimization_2tb_scale(get_fuga, scale):
D = 80.0
B = 2 * D + 10
init_pos = np.array([(-10, 1 * D), (10, -D)])
wind_atlas = 'MyFarm/north_pm30_only.lib'
pyFuga = get_fuga(init_pos[:1, 0], init_pos[:1, 1], wind_atlas=wind_atlas)
AEP_pr_tb = pyFuga.get_aep()[1]
pyFuga = get_fuga(init_pos[:, 0], init_pos[:, 1], wind_atlas=wind_atlas)
boundary = [(-B, B), (B, B), (B, -B), (-B, -B), (-B, B)]
plot_comp = NoPlot()
# plot_comp = PlotComp()
cost_comp = AEPCostModelComponent(
'xy',
init_pos.shape[0],
lambda x, y: scale * pyFuga.get_aep(np.array([x, y]).T)[0], # only aep
lambda x, y: scale * pyFuga.get_aep_gradients(np.array([x, y]).T)[:2]
) # only dAEPdx and dAEPdy
tf = TopFarmProblem(
dict(zip('xy', init_pos.T)),
cost_comp,
constraints=[SpacingConstraint(2 * D),
XYBoundaryConstraint(boundary)],
plot_comp=plot_comp,
driver=EasyScipyOptimizeDriver(tol=1e-8, disp=False),
expected_cost=AEP_pr_tb * 2 * scale)
cost, _, rec = tf.optimize()
tf.plot_comp.show()
uta.assertAlmostEqual(-cost / scale, AEP_pr_tb * 2, delta=.02)
def main():
if __name__ == '__main__':
from topfarm.cost_models.dummy import DummyCost, DummyCostPlotComp
from topfarm.constraint_components.spacing import SpacingConstraint
from topfarm.constraint_components.boundary import XYBoundaryConstraint
initial = np.array([[6, 0], [6, -8], [1,
1]]) # initial turbine layouts
optimal = np.array([[2.5, -3], [6, -7],
[4.5, -3]]) # optimal turbine layouts
boundary = np.array([(0, 0), (6, 0), (6, -10),
(0, -10)]) # turbine boundaries
desired = np.array([[3, -3], [7, -7], [4,
-3]]) # desired turbine layouts
plot_comp = DummyCostPlotComp(optimal)
tf = TopFarmProblem(
design_vars=dict(zip('xy', initial.T)),
cost_comp=DummyCost(optimal_state=desired, inputs=['x', 'y']),
constraints=[XYBoundaryConstraint(boundary),
SpacingConstraint(2)],
driver=EasyScipyOptimizeDriver(),
plot_comp=plot_comp)
tf.optimize()
plot_comp.show()
def tf(xy_boundary=[(0, 0), (4, 4)],
z_boundary=(0, 4),
xy_boundary_type='square',
**kwargs):
optimal = [(0, 2, 4), (4, 2, 1)]
xyz = np.array([(0, 1, 0), (1, 1, 1)])
p1 = DummyCost(optimal, 'xyz')
design_vars = dict(zip('xy', xyz.T))
design_vars['z'] = (xyz[:, 2], z_boundary[0], z_boundary[1])
k = {
'design_vars':
design_vars,
'cost_comp':
p1,
'driver':
EasyScipyOptimizeDriver(optimizer='COBYLA', disp=False,
maxiter=10),
}
k.update(kwargs)
return TopFarmProblem(constraints=[
XYBoundaryConstraint(xy_boundary, xy_boundary_type),
SpacingConstraint(2)
],
**k)
def test_TopFarmListRecorder_continue(tf_generator, load_case, n_rec, n_fev):
D = 80.0
D2 = 2 * D + 10
init_pos = np.array([(0, 2 * D), (0, 0), (0, -2 * D)])
init_pos[:, 0] += [-40, 0, 40]
pyFuga = test_pyfuga.get_fuga()(init_pos[:, 0],
init_pos[:, 1],
wind_atlas='MyFarm/north_pm45_only.lib')
boundary = [(-D2, -D2), (D2, D2)]
plot_comp = XYPlotComp()
plot_comp = NoPlot()
tf = TopFarmProblem(
dict(zip('xy', init_pos.T)),
cost_comp=pyFuga.get_TopFarm_cost_component(),
constraints=[
SpacingConstraint(2 * D),
XYBoundaryConstraint(boundary, 'square')
],
driver=EasyScipyOptimizeDriver(tol=1e-10, disp=False),
plot_comp=plot_comp,
record_id=tfp +
'recordings/test_TopFarmListRecorder_continue:%s' % load_case,
expected_cost=25)
_, _, recorder = tf.optimize()
# Create test file:
# 1) delete file "test_files/recordings/test_TopFarmListRecorder_continue"
# 2) Uncomment line below, run and recomment
# if load_case=="": recorder.save() # create test file
npt.assert_equal(recorder.driver_cases.num_cases, n_rec)
npt.assert_equal(tf.driver.result['nfev'], n_fev)
tf.plot_comp.show()
def main():
if __name__ == '__main__':
from topfarm.cost_models.dummy import DummyCost, DummyCostPlotComp
from topfarm.constraint_components.spacing import SpacingConstraint
from topfarm.constraint_components.boundary import XYBoundaryConstraint
from openmdao.api import view_model
initial = np.array([[6, 0], [6, -8], [1,
1]]) # initial turbine layouts
optimal = np.array([[2.5, -3], [6, -7],
[4.5, -3]]) # optimal turbine layouts
boundary = np.array([(0, 0), (6, 0), (6, -10),
(0, -10)]) # turbine boundaries
desired = np.array([[3, -3], [7, -7], [4,
-3]]) # desired turbine layouts
drivers = [
EasySimpleGADriver(max_gen=10,
pop_size=100,
bits={
'x': [12] * 3,
'y': [12] * 3
},
random_state=1),
EasyScipyOptimizeDriver()
]
plot_comp = DummyCostPlotComp(optimal)
tf = TopFarmProblem(
design_vars=dict(zip('xy', initial.T)),
cost_comp=DummyCost(optimal_state=desired, inputs=['x', 'y']),
constraints=[XYBoundaryConstraint(boundary),
SpacingConstraint(2)],
driver=drivers[1],
plot_comp=plot_comp)
cost, _, recorder = tf.optimize()
plot_comp.show()
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 get_tf(init_pos, pyFuga, boundary, boundary_type='convex_hull'):
return TopFarmProblem(dict(zip('xy', init_pos.T)),
pyFuga.get_TopFarm_cost_component(),
constraints=[
SpacingConstraint(160),
XYBoundaryConstraint(boundary, boundary_type)
],
driver=EasyScipyOptimizeDriver(disp=False))
def get_tf(cost_comp):
return TopFarmProblem(dict(zip('xy', initial.T)),
cost_comp=cost_comp,
constraints=[
SpacingConstraint(min_spacing),
XYBoundaryConstraint(boundary)
],
driver=EasyScipyOptimizeDriver(disp=False))
def _topfarm_obj(gradients, cost_comp=None, **kwargs):
return TopFarmProblem(
{'x': initial[:, 0], 'y': initial[:, 1]},
cost_comp=cost_comp or CostModelComponent(['x', 'y'], 4, cost, gradients),
constraints=[SpacingConstraint(2), XYBoundaryConstraint(boundary)],
driver=EasyScipyOptimizeDriver(),
**kwargs)
def test_setup_as_constraint_z():
tf = TopFarmProblem(
{'z': (initial[:, 2], 0, 2)},
DummyCost(desired[:, :2], 'z'),
driver=EasyScipyOptimizeDriver(disp=False),
)
tf.optimize()
npt.assert_array_less(tf['z'], 2 + 1e-10)
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 get_tf(**kwargs):
k = {'cost_comp': DummyCost(desired[:, :2], [topfarm.x_key, topfarm.y_key]),
'design_vars': {topfarm.x_key: initial[:, 0], topfarm.y_key: initial[:, 1]},
'driver': EasyScipyOptimizeDriver(disp=False),
'plot_comp': NoPlot(),
'constraints': [SpacingConstraint(2), XYBoundaryConstraint(boundary)]}
k.update(kwargs)
return TopFarmProblem(**k)
def get_tf(wake_model):
return TopFarmProblem(
design_vars=dict(zip('xy', init_pos.T)),
cost_comp=AEPCalculator(wind_res, wake_model,
wdir=np.arange(0, 360, 12)
).get_TopFarm_cost_component(),
constraints=[SpacingConstraint(min_spacing),
XYBoundaryConstraint(boundary)],
driver=EasyScipyOptimizeDriver())
def get_tf(initial, optimal, boundary, plot_comp=NoPlot()):
initial, optimal = map(np.array, [initial, optimal])
return TopFarmProblem(
{
'x': initial[:, 0],
'y': initial[:, 1]
},
DummyCost(optimal),
constraints=[XYBoundaryConstraint(boundary, 'polygon')],
driver=EasyScipyOptimizeDriver(tol=1e-8, disp=False),
plot_comp=plot_comp)
def test_TopFarmListRecorder_continue_wrong_recorder(tf_generator):
tf = TopFarmProblem({'type': ([0, 0, 0], 0, 1)},
cost_comp=DummyCost(np.array([[0, 1, 0]]).T, ['type']),
driver=EasyScipyOptimizeDriver(disp=False),
record_id=tfp +
'recordings/test_TopFarmListRecorder_continue:latest')
tf.optimize()
assert 'type' in tf.recorder.keys()
assert 'x' not in tf.recorder.keys()
def test_setup_as_constraint_xyz():
desvar = dict(zip('xy', initial.T))
desvar['z'] = (initial[:, 2], 0, 2)
tf = TopFarmProblem(desvar,
DummyCost(desired, 'xyz'),
driver=EasyScipyOptimizeDriver(disp=False),
constraints=[XYBoundaryConstraint(boundary)])
tf.optimize()
tb_pos = tf.turbine_positions
tol = 1e-4
assert tb_pos[1][0] < 6 + tol # check within border
npt.assert_array_less(tf['z'], 2 + tol) # check within height limit
def get_tf(windFarmModel):
return TopFarmProblem(design_vars=dict(zip('xy', init_pos.T)),
cost_comp=PyWakeAEPCostModelComponent(
windFarmModel,
n_wt=3,
ws=10,
wd=np.arange(0, 360, 12)),
constraints=[
SpacingConstraint(min_spacing),
XYBoundaryConstraint(boundary)
],
driver=EasyScipyOptimizeDriver(),
plot_comp=plot_comp())
def get_TurbineXYZOptimizationProblem(cost_comp=DummyCost(
optimal, ['x', 'y', 'z']),
turbineXYZ=[[0, 0, 0], [2, 2, 2]],
xy_boundary=[(0, 0), (5, 5)],
z_boundary=[1, 4],
xy_boundary_type='square',
plot_comp=None):
return TurbineXYZOptimizationProblem(
cost_comp=cost_comp,
turbineXYZ=turbineXYZ,
boundary_comp=BoundaryComp(len(turbineXYZ), xy_boundary,
z_boundary, xy_boundary_type),
plot_comp=plot_comp,
driver=EasyScipyOptimizeDriver(disp=False))
def main():
if __name__ == '__main__':
# define the conditions for the wind farm
boundary = [(0, 0), (6, 0), (6, -10), (0, -10)] # turbine boundaries
initial = np.array([[6, 0], [6, -8], [1, 1], [-1, -8]]) # initial turbine pos
desired = np.array([[3, -3], [7, -7], [4, -3], [3, -7]]) # desired turbine pos
optimal = np.array([[2.5, -3], [6, -7], [4.5, -3], [3, -7]]) # optimal layout
min_spacing = 2 # min distance between turbines
# ------------------------ OPTIMIZATION ------------------------
# create the wind farm and run the optimization
def wt_cost(i, x, y):
time.sleep(0.01)
return (desired[i, 0] - x[i])**2 + (desired[i, 1] - y[i])**2
n_wt = len(initial)
comps = [CostModelComponent('xy', 4,
cost_function=lambda x, y, i=i:wt_cost(i, x, y),
objective=False,
output_key='cost%d' % i) for i in range(n_wt)]
def sum_map(**kwargs):
return np.sum([kwargs['cost%d' % i] for i in range(n_wt)])
comps.append(CostModelComponent(['cost%d' % i for i in range(n_wt)], 1,
cost_function=sum_map,
objective=True))
cost_comp = TopFarmParallelGroup(comps)
tf = TopFarmProblem(
design_vars={'x': initial[:, 0], 'y': initial[:, 1]},
cost_comp=cost_comp,
constraints=[XYBoundaryConstraint(boundary),
SpacingConstraint(min_spacing)],
# plot_comp=DummyCostPlotComp(desired),
plot_comp=NoPlot(),
driver=EasyScipyOptimizeDriver()
)
# view_model(tf)
#print(tf.evaluate({'x': desired[:, 0], 'y': desired[:, 1]}))
print(tf.evaluate({'x': optimal[:, 0], 'y': optimal[:, 1]}, disp=False))
#print(tf.evaluate({'x': initial[:, 0], 'y': initial[:, 1]}))
# tic = time.time()
cost, state, recorder = tf.optimize()
# toc = time.time()
# print('optimized in {:.3f}s '.format(toc-tic))
tf.plot_comp.show()
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_2level_turbineType_and_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))
tf = TopFarmProblem({'type': ([0, 0], 0, 1)},
cost_comp=xyz_problem,
driver=DOEDriver(FullFactorialGenerator(2)))
cost = tf.optimize()[0]
assert cost == 0
def testPolygonConcave():
optimal = [(1.5, 1.3), (4, 1)]
boundary = [(0, 0), (5, 0), (5, 2), (3, 2), (3, 1), (2, 1), (2, 2), (0, 2),
(0, 0)]
plot_comp = NoPlot() # DummyCostPlotComp(optimal)
initial = [(-0, .1), (4, 1.5)][::-1]
tf = TopFarm(initial,
DummyCost(optimal, inputs=['x', 'y']),
0,
boundary=boundary,
boundary_type='polygon',
plot_comp=plot_comp,
driver=EasyScipyOptimizeDriver(tol=1e-8, disp=False))
tf.evaluate()
tf.optimize()
np.testing.assert_array_almost_equal(tf.turbine_positions[:, :2], optimal,
4)
plot_comp.show()
def testPolygonTwoRegionsStartInWrong():
optimal = [(1, 1), (4, 1)]
boundary = [(0, 0), (5, 0), (5, 2), (3, 2), (3, 0), (2, 0), (2, 2), (0, 2),
(0, 0)]
plot_comp = NoPlot()
# plot_comp = DummyCostPlotComp(optimal, delay=.1)
initial = [(3.5, 1.5), (0.5, 1.5)]
tf = TopFarm(initial,
DummyCost(optimal, inputs=['x', 'y']),
0,
boundary=boundary,
boundary_type='polygon',
plot_comp=plot_comp,
driver=EasyScipyOptimizeDriver(tol=1e-6, disp=False))
tf.optimize()
plot_comp.show()
np.testing.assert_array_almost_equal(tf.turbine_positions[:, :2], optimal,
4)
def test_setup_as_constraint_xy():
# plot_comp = DummyCostPlotComp(desired)
plot_comp = NoPlot()
tf = TopFarmProblem({
'x': initial[:, 0],
'y': initial[:, 1]
},
DummyCost(desired[:, :2]),
constraints=[XYBoundaryConstraint(boundary)],
driver=EasyScipyOptimizeDriver(disp=False),
plot_comp=plot_comp)
tf.optimize()
tb_pos = tf.turbine_positions[:, :2]
tf.plot_comp.show()
tol = 1e-4
assert tb_pos[1][0] < 6 + tol # check within border
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_NestedTopFarmListRecorder(tf_generator):
optimal = [(0, 2, 4, 1), (4, 2, 1, 0)]
type_lst = [[0, 0], [1, 0], [0, 1]]
p1 = DummyCost(optimal_state=optimal, inputs=['x', 'y', 'z', 'type'])
p2 = tf_generator(cost_comp=p1, driver=EasyScipyOptimizeDriver(disp=False))
tf = TopFarmProblem({'type': ([0, 0], 0, 1)},
cost_comp=p2,
driver=DOEDriver(
ListGenerator([[('type', t)] for t in type_lst])))
cost, _, recorder = tf.optimize()
npt.assert_almost_equal(cost, 0)
npt.assert_array_almost_equal(recorder.get('type'), type_lst)
npt.assert_array_almost_equal(recorder.get('cost'), [1, 0, 2])
for sub_rec in recorder.get('recorder'):
npt.assert_array_almost_equal(
np.array([sub_rec[k][-1] for k in ['x', 'y', 'z']]).T,
np.array(optimal)[:, :3])
def find_optimal_scaling(topfarm_generator_scalable):
i = 0.000001
res = []
while i < 100000:
driver = EasyScipyOptimizeDriver(disp=False, tol=1e-6 * i)
tf = topfarm_generator_scalable(driver)
tf.model.get_objectives()['cost_comp.cost']['scaler'] = i
cost, _, recorder = tf.optimize()
N = recorder.driver_cases.num_cases
res.append((i, N, cost))
print(i, N, cost)
i *= 2
import matplotlib.pyplot as plt
plt.figure()
res = np.array(res)
plt.plot(res[:, 0], res[:, 1])
plt.xscale('log')
plt.show()
def test_turbineXYZ_optimization():
optimal = np.array([(5, 4, 3), (3, 2, 1)])
turbineXYZ = np.array([[0, 0, 0], [2, 2, 2]])
design_vars = {k: v for k, v in zip('xy', turbineXYZ.T)}
design_vars['z'] = (turbineXYZ[:, 2], 1, 4)
xy_boundary = [(0, 0), (5, 5)]
tf = TopFarmProblem(
design_vars=design_vars,
cost_comp=DummyCost(optimal, 'xyz'),
driver=EasyScipyOptimizeDriver(disp=False),
constraints=[XYBoundaryConstraint(xy_boundary, 'square')])
cost, state = tf.evaluate()
assert cost == 52
np.testing.assert_array_equal(state['x'], [0, 2])
cost = tf.optimize()[0]
assert cost < 1e6
np.testing.assert_array_almost_equal(tf.turbine_positions, optimal[:, :2],
3)
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)
