def __init__(self, cost_comp, turbineXYZ, boundary_comp, min_spacing=None,
driver=ScipyOptimizeDriver(), plot_comp=None, record_id=None, expected_cost=1):
sys.stderr.write("%s is deprecated. Use TopFarmProblem instead\n" % self.__class__.__name__)
if plot_comp:
if plot_comp == "default":
plot_comp = PlotComp()
turbineXYZ = np.asarray(turbineXYZ)
design_vars = {xy: v for xy, v in zip([topfarm.x_key, topfarm.y_key], turbineXYZ.T)}
constraints = []
if min_spacing:
constraints.append(SpacingConstraint(min_spacing))
if isinstance(boundary_comp, PolygonBoundaryComp):
constraints.append(XYBoundaryConstraint(boundary_comp.xy_boundary, 'polygon'))
elif len(boundary_comp.xy_boundary):
constraints.append(XYBoundaryConstraint(boundary_comp.xy_boundary, boundary_comp.boundary_type))
if turbineXYZ.shape[1] == 3:
if len(boundary_comp.z_boundary):
design_vars[topfarm.z_key] = (turbineXYZ[:, 2], boundary_comp.z_boundary[:, 0], boundary_comp.z_boundary[:, 1])
else:
design_vars[topfarm.z_key] = turbineXYZ[:, 2]
TopFarmProblem.__init__(
self,
design_vars=design_vars,
cost_comp=cost_comp,
driver=driver,
constraints=constraints,
plot_comp=plot_comp,
record_id=record_id,
expected_cost=expected_cost)
self.setup()
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 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 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 test_smart_start_polygon_boundary():
xs_ref = [1.6, 1.6, 3.6]
ys_ref = [1.6, 3.7, 2.3]
x = np.arange(0, 5.1, 0.1)
y = np.arange(0, 5.1, 0.1)
YY, XX = np.meshgrid(y, x)
ZZ = np.sin(XX) + np.sin(YY)
min_spacing = 2.1
tf = xy3tb.get_tf(constraints=[
SpacingConstraint(min_spacing),
XYBoundaryConstraint([(0, 0), (5, 3), (5, 5), (0, 5)], 'polygon')
])
tf.smart_start(XX, YY, ZZ)
if 0:
import matplotlib.pyplot as plt
plt.contourf(XX, YY, ZZ, 100)
plt.plot(tf.xy_boundary[:, 0], tf.xy_boundary[:, 1], 'k')
for x, y in tf.turbine_positions:
circle = plt.Circle((x, y), min_spacing / 2, color='b', fill=False)
plt.gcf().gca().add_artist(circle)
plt.plot(x, y, 'rx')
plt.axis('equal')
plt.show()
npt.assert_array_almost_equal(tf.turbine_positions,
np.array([xs_ref, ys_ref]).T)
def _topfarm_obj(driver,
xy_scale=[1, 1],
cost_scale=1,
cost_offset=0,
spacing=2):
from topfarm.cost_models.dummy import DummyCostPlotComp
# plot_comp = DummyCostPlotComp(desired[:,:2] * xy_scale, plot_improvements_only=True)
plot_comp = NoPlot()
class DummyCostScaled(DummyCost):
def cost(self, **kwargs):
opt = self.optimal_state
return np.sum([(kwargs[n] - opt[:, i])**2
for i, n in enumerate(self.input_keys)
]) * cost_scale + cost_offset
def grad(self, **kwargs):
opt = self.optimal_state
return [(2 * cost_scale * (kwargs[n] - opt[:, i]))
for i, n in enumerate(self.input_keys)]
return TopFarmProblem(dict(zip('xy', (initial[:, :2] * xy_scale).T)),
DummyCostScaled(desired[:, :2] * xy_scale),
constraints=[
SpacingConstraint(spacing * xy_scale[0]),
XYBoundaryConstraint(boundary * xy_scale)
],
driver=driver,
plot_comp=plot_comp,
expected_cost=1.5 * cost_scale)
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_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 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 get_InitialXYZOptimizationProblem(driver):
optimal = [(1, 0, 4),
(0, 1, 3)]
return TopFarmProblem(
design_vars={'x': [0, 2], 'y': [0, 2], 'z': ([0, 2], 3, 4)},
cost_comp=DummyCost(optimal, ['x', 'y', 'z']),
constraints=[XYBoundaryConstraint([(10, 6), (11, 8)], 'rectangle')],
driver=driver)
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 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 test_TopFarmProblemXYBoundaryConstraintPolygon():
tf = xy3tb.get_tf(design_vars={'x': [3, 7, 4], 'y': [-3, -7, -3]},
constraints=[XYBoundaryConstraint(xy3tb.boundary, 'polygon')])
# constraint violated
tf.evaluate({'x': xy3tb.desired[:, 0], 'y': xy3tb.desired[:, 1]})
npt.assert_equal(tf['boundaryDistances'][1], -1)
_, state, _ = tf.optimize()
npt.assert_array_almost_equal(state['x'], [3, 6, 4])
npt.assert_array_almost_equal(state['y'], xy3tb.optimal[:, 1])
def get_InitialXYZOptimizationProblem(driver):
return TopFarmProblem(
{
'x': [0, 2],
'y': [0, 2],
'z': ([0, 2], 3, 4)
},
cost_comp=DummyCost([(1, 0, 4), (0, 1, 3)], 'xyz'),
constraints=[XYBoundaryConstraint([(10, 6), (11, 8)], 'rectangle')],
driver=driver)
def test_TopFarmProblemXYBoundaryPenalty():
tf = xy3tb.get_tf(design_vars={'x': [3, 7, 4], 'y': [-3, -7, -3]},
driver=EasyRandomSearchDriver(RandomizeTurbinePosition(1), 10),
constraints=[XYBoundaryConstraint(xy3tb.boundary)])
# spacing violated
cost, _ = tf.evaluate({'x': xy3tb.desired[:, 0], 'y': xy3tb.desired[:, 1]})
npt.assert_array_less(1e10, cost)
# spacing satisfied
cost, _ = tf.evaluate({'x': xy3tb.optimal[:, 0], 'y': xy3tb.optimal[:, 1]})
npt.assert_equal(1.5, cost)
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_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 test_TopFarmProblemXYBoundaryPenaltyAndLimits():
tf = xy3tb.get_tf(design_vars={'x': ([3, 7, 4], -1, 5), 'y': ([-3, -7, -3], -9, -1)},
driver=EasyRandomSearchDriver(RandomizeTurbinePosition(1), 10),
constraints=[XYBoundaryConstraint(xy3tb.boundary)])
tf.evaluate({'x': xy3tb.desired[:, 0], 'y': xy3tb.desired[:, 1]})
npt.assert_equal(tf['boundaryDistances'][1, 3], -1)
desvars = tf.driver._designvars
npt.assert_equal(desvars['indeps.x']['lower'], 0)
npt.assert_equal(desvars['indeps.x']['upper'], 5)
npt.assert_array_equal(desvars['indeps.y']['lower'], -9)
npt.assert_array_equal(desvars['indeps.y']['upper'], -1)
def test_NOJ_Topfarm(aep_calc):
init_pos = aep_calc.wake_model.windFarm.pos
with warnings.catch_warnings(
): # suppress "warning, make sure that this position array is oriented in ndarray([n_wt, 2]) or ndarray([n_wt, 3])"
warnings.simplefilter("ignore")
tf = TopFarmProblem(dict(zip('xy', init_pos.T)),
aep_calc.get_TopFarm_cost_component(),
constraints=[
SpacingConstraint(160),
XYBoundaryConstraint(init_pos, 'square')
])
tf.evaluate()
assert tf.cost == -18.90684500124578
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 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 _topfarm_obj(driver, spacing=2, keys='xy'):
# from topfarm.cost_models.dummy import DummyCostPlotComp
# plot_comp = DummyCostPlotComp(desired[:,:len(keys)], plot_improvements_only=True)
plot_comp = NoPlot()
return TopFarmProblem(dict(zip(keys, initial.T[:len(keys)])),
DummyCost(desired[:, :len(keys)], keys),
constraints=[
SpacingConstraint(spacing),
XYBoundaryConstraint(boundary)
],
plot_comp=plot_comp,
driver=driver,
expected_cost=1.5)
def test_TopFarmProblemXYBoundaryConstraint():
tf = xy3tb.get_tf(design_vars={'x': [3, 7, 4], 'y': [-3, -7, -3]},
constraints=[XYBoundaryConstraint(xy3tb.boundary)])
tf.evaluate({'x': xy3tb.desired[:, 0], 'y': xy3tb.desired[:, 1]})
npt.assert_equal(tf['boundaryDistances'][1, 3], -1)
_, state, _ = tf.optimize()
npt.assert_array_almost_equal(state['x'], [3, 6, 4])
npt.assert_array_almost_equal(state['y'], xy3tb.optimal[:, 1])
desvars = tf.driver._designvars
for xy in 'xy':
for lu in ['lower', 'upper']:
npt.assert_equal(desvars['indeps.' + xy][lu], np.nan)
def test_setup_as_penalty_xy():
driver = SimpleGADriver()
tf = TopFarmProblem(dict(zip('xy', initial.T)),
DummyCost(desired),
constraints=[XYBoundaryConstraint(boundary)],
driver=driver)
# check normal result if boundary constraint is satisfied
assert tf.evaluate()[0] == 121
# check penalized result if boundary constraint is not satisfied
assert tf.evaluate({
'x': [2.5, 7, 4.5],
'y': [-3., -7., -3.],
'z': [0., 0., 0.]
})[0] == 1e10 + 1
def main():
if __name__ == '__main__':
plot_comp = XYPlotComp()
site = get_site()
n_wt = len(site.initial_position)
windTurbines = DTU10MW()
min_spacing = 2 * windTurbines.diameter(0)
windFarmModel = 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
def aep_func(x, y, **_):
sim_res = windFarmModel(x, y)
aep = sim_res.aep()
return aep.sum(['wd', 'ws']).values * 10**6
def irr_func(aep, **_):
return economic_evaluation(Drotor_vector, power_rated_vector,
hub_height_vector, aep).calculate_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=10),
constraints=[
SpacingConstraint(min_spacing),
XYBoundaryConstraint(site.boundary),
],
plot_comp=plot_comp)
cost, state, recorder = problem.optimize()
problem.plot_comp.show()
def test_xyz_boundary():
optimal = np.array([(0, 0, 0)])
boundary = [(0, 0), (1, 3)]
desvar = dict(zip('xy', optimal.T))
desvar['z'] = (optimal[:, 2], 70, 90)
b = XYBoundaryConstraint(boundary, boundary_type='rectangle')
tf = TopFarmProblem(desvar,
DummyCost(optimal, 'xyz'),
constraints=[b],
driver=SimpleGADriver())
np.testing.assert_array_equal(b.constraintComponent.xy_boundary,
[[0, 0], [1, 0], [1, 3], [0, 3], [0, 0]])
desvars = tf.driver._designvars
np.testing.assert_array_equal(desvars['indeps.z']['lower'], [70])
np.testing.assert_array_equal(desvars['indeps.z']['upper'], [90])
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
