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_design_var_list(turbineTypeOptimizationProblem, design_vars):
tf = TopFarmProblem(design_vars=design_vars,
cost_comp=DummyCost(np.array([[2, 0, 1]]).T, ['type']),
driver=DOEDriver(FullFactorialGenerator(3)))
cost, _, = tf.evaluate()
npt.assert_equal(tf.cost, cost)
assert tf.cost == 5
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 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 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 test_turbineType_optimization():
optimal = np.array([[1], [0]])
tf = TopFarmProblem(design_vars={'type': (optimal[:, 0], 0, 1)},
cost_comp=DummyCost(optimal_state=optimal,
inputs=['type']),
driver=DOEDriver(FullFactorialGenerator(2)))
cost, state, _ = tf.optimize()
assert cost == 0
npt.assert_array_equal(state['type'], [1, 0])
def testTopFarm():
tf = TopFarm(xy3tb.initial,
DummyCost(xy3tb.desired, ['x', 'y']),
min_spacing=2,
boundary=xy3tb.boundary)
cost, state = tf.evaluate()
assert cost == 45
npt.assert_array_equal(state['x'], xy3tb.initial[:, 0])
npt.assert_array_equal(state['y'], xy3tb.initial[:, 1])
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_z_boundary():
optimal = np.array([(0, 0, 0)]).T
tf = TopFarmProblem({'z': (optimal, 70, 90)},
DummyCost(optimal, 'z'),
driver=SimpleGADriver())
desvars = tf.driver._designvars
np.testing.assert_array_equal(desvars['indeps.z']['lower'], [70, 70])
np.testing.assert_array_equal(desvars['indeps.z']['upper'], [90, 90])
def test_TopFarmProblem_with_cirleboundary_constraint():
optimal = np.array([(0, 0)])
desvar = dict(zip('xy', optimal.T))
b = CircleBoundaryConstraint([2, 2], 2)
tf = TopFarmProblem(desvar, DummyCost(optimal, 'xy'), constraints=[b])
_, state, _ = tf.optimize()
npt.assert_array_less((state['x'] - 2)**2 + (state['y'] - 2)**2, 9)
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 test_z_boundary():
optimal = [(0, 0, 0)]
tf = TurbineXYZOptimizationProblem(DummyCost(optimal, ['z']),
optimal,
BoundaryComp(2, None, [70, 90]),
driver=SimpleGADriver())
tf.setup()
desvars = tf.driver._designvars
np.testing.assert_array_equal(desvars['indeps.z']['lower'], [70, 70])
np.testing.assert_array_equal(desvars['indeps.z']['upper'], [90, 90])
def test_setup_as_penalty_none():
driver = SimpleGADriver()
tf = TurbineXYZOptimizationProblem(DummyCost(desired, ['x', 'y']), initial,
boundary_comp=BoundaryComp(len(initial), None, None),
driver=driver)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
# check that it does not fail if xy and z is not specified
assert tf.evaluate()[0] == 121
assert tf.evaluate({'x': [2.5, 7, 4.5], 'y': [-3., -7., -3.], 'z': [0., 0., 0.]})[0] == .5
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_setup_as_penalty_xy():
driver = SimpleGADriver()
tf = TurbineXYZOptimizationProblem(DummyCost(desired, ['x', 'y']), initial,
boundary_comp=BoundaryComp(len(initial), boundary, None),
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 test_TopFarmProblem_with_cirleboundary_constraint_and_limits():
optimal = np.array([(0, 0)])
desvar = {'x': ([0], 1, 4), 'y': [0]}
b = CircleBoundaryConstraint([2, 2], 2)
tf = TopFarmProblem(desvar, DummyCost(optimal, 'xy'), constraints=[b])
_, state, _ = tf.optimize()
npt.assert_array_less((state['x'] - 2)**2 + (state['y'] - 2)**2, 9)
npt.assert_array_less(.9999999, state['x'])
def test_turbineType_optimization():
cost_comp = DummyCost(optimal_state=optimal, inputs=['type'])
tf = TurbineTypeOptimizationProblem(cost_comp=cost_comp,
turbineTypes=[0, 0],
lower=0,
upper=1,
driver=DOEDriver(
FullFactorialGenerator(2)))
cost, state, _ = tf.optimize()
assert cost == 0
npt.assert_array_equal(state['type'], [1, 0])
def main():
if __name__ == '__main__':
# ------------------------ INPUTS ------------------------
# define the conditions for the wind farm
positions = np.array([[0, 0], [6, 6]]) # initial turbine pos
optimal_types = np.array([[2], [6]]) # optimal layout
# ===============================================================================
# Setup the problem and plotting
# ===============================================================================
try:
import matplotlib.pyplot as plt
plt.gcf()
plot_comp = TurbineTypePlotComponent(
turbine_type_names=["Turbine %d" % i for i in range(5)],
plot_initial=False,
delay=0.1,
legendloc=0)
plot = True
except RuntimeError:
plot_comp = NoPlot()
plot = False
# create the wind farm
tf = TopFarmProblem(
design_vars={'type': ([0, 0], 0, 4)},
cost_comp=DummyCost(optimal_types, ['type']),
plot_comp=plot_comp,
driver=FullFactorialGenerator(5),
ext_vars={
'x': positions[:, 0],
'y': positions[:, 1]
},
)
# ===============================================================================
# # Run the optimization
# ===============================================================================
state = {}
cost, state, recorder = tf.optimize(state)
# ===============================================================================
# plot and prin the the final, optimal types
# ===============================================================================
print(state['type'])
tf.evaluate(state)
# save the figure
if plot:
folder, file = os.path.split(__file__)
plt.savefig(folder + "/figures/" + file.replace('.py', '.png'))
plt.show()
def test_TopFarmProblem_with_cirleboundary_gradients():
optimal = np.array([(0, 0)])
desvar = dict(zip('xy', optimal.T + 1.5))
plot_comp = NoPlot()
b = CircleBoundaryConstraint([1, 2], 3)
tf = TopFarmProblem(desvar,
DummyCost(optimal, 'xy'),
constraints=[b],
plot_comp=plot_comp,
driver=SimpleGADriver())
tf.check_gradients(True)
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 get_InitialXYZOptimizationProblem(driver,
min_spacing=None,
turbineXYZ=[[0, 0, 0], [2, 2, 2]],
xy_boundary=[(10, 6), (11, 8)],
xy_boundary_type='rectangle',
z_boundary=[3, 4]):
cost_comp = DummyCost([(1, 0, 4), (0, 1, 3)], ['x', 'y', 'z'])
return InitialXYZOptimizationProblem(
cost_comp, turbineXYZ,
BoundaryComp(len(turbineXYZ), xy_boundary, z_boundary,
xy_boundary_type), min_spacing, driver)
def test_TopFarmProblem_with_cirleboundary_plot():
if os.name == 'posix' and "DISPLAY" not in os.environ:
pytest.xfail("No display")
optimal = np.array([(0, 0)])
desvar = dict(zip('xy', optimal.T))
plot_comp = PlotComp()
b = CircleBoundaryConstraint([1, 2], 3)
tf = TopFarmProblem(desvar,
DummyCost(optimal, 'xy'),
constraints=[b],
plot_comp=plot_comp)
tf.evaluate()
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_setup_as_penalty_none():
driver = SimpleGADriver()
tf = TopFarmProblem(dict(zip('xy', initial.T)),
DummyCost(desired),
driver=driver)
# check that it does not fail if xy and z is not specified
assert tf.evaluate()[0] == 121
assert tf.evaluate({
'x': [2.5, 7, 4.5],
'y': [-3., -7., -3.],
'z': [0., 0., 0.]
})[0] == .5
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 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 test_TopFarmProblem_with_cirleboundary_penalty():
optimal = np.array([(0, 0)])
desvar = dict(zip('xy', optimal.T))
b = CircleBoundaryConstraint([1, 2], 3)
driver = SimpleGADriver()
tf = TopFarmProblem(desvar,
DummyCost(optimal, 'xy'),
constraints=[b],
driver=driver)
tf.evaluate()
tf.plot_comp.show()
np.testing.assert_array_almost_equal(
((b.constraintComponent.xy_boundary - [1, 2])**2).sum(1), 3**2)
npt.assert_array_less(tf.evaluate({'x': [3.9], 'y': [2]})[0], 1e10)
npt.assert_array_less(1e10, tf.evaluate({'x': [4.1], 'y': [2]})[0])
