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 __init__(self, cost_comp, turbineTypes, lower, upper, turbineXYZ, boundary_comp, min_spacing=None,
driver=EasyRandomSearchDriver(random_search_driver.RandomizeTurbineTypeAndPosition()), plot_comp=None, record_id=None, expected_cost=1):
sys.stderr.write("%s is deprecated. Use TopFarmProblem instead\n" % self.__class__.__name__)
TopFarmProblem.__init__(self, cost_comp, driver, plot_comp, record_id, expected_cost)
TurbineTypeOptimizationProblem.initialize(self, turbineTypes, lower, upper)
TurbineXYZOptimizationProblem.initialize(self, turbineXYZ, boundary_comp, min_spacing)
self.setup(check=True, mode=self.mode)
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 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 __init__(self, cost_comp, turbineTypes, lower, upper, **kwargs):
sys.stderr.write("%s is deprecated. Use TopFarmProblem instead\n" % self.__class__.__name__)
TopFarmProblem.__init__(self,
design_vars={topfarm.type_key: (turbineTypes, lower, upper)},
cost_comp=cost_comp,
**kwargs)
self.setup()
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 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 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_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_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 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_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_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 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 main():
if __name__ == '__main__':
n_wt = 16
site = IEA37Site(n_wt)
windTurbines = IEA37_WindTurbines()
windFarmModel = IEA37SimpleBastankhahGaussian(site, windTurbines)
tf = TopFarmProblem(
design_vars=dict(zip('xy', site.initial_position.T)),
cost_comp=PyWakeAEPCostModelComponent(windFarmModel, n_wt),
driver=EasyRandomSearchDriver(
randomize_func=RandomizeTurbinePosition_Circle(), max_iter=5),
constraints=[CircleBoundaryConstraint([0, 0], 1300.1)],
plot_comp=XYPlotComp())
tf.optimize()
tf.plot_comp.show()
def main():
if __name__ == '__main__':
site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
wake_model = IEA37SimpleBastankhahGaussian(windTurbines)
aep_calc = PyWakeAEP(site, windTurbines, wake_model)
tf = TopFarmProblem(
design_vars=dict(zip('xy', site.initial_position.T)),
cost_comp=aep_calc.get_TopFarm_cost_component(16),
driver=EasyRandomSearchDriver(
randomize_func=RandomizeTurbinePosition_Circle(), max_iter=5),
constraints=[CircleBoundaryConstraint([0, 0], 1300.1)],
plot_comp=XYPlotComp())
# tf.evaluate()
tf.optimize()
tf.plot_comp.show()
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 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 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(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(**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 = 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 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_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 __init__(self, turbines, cost_comp, min_spacing, boundary,
boundary_type='convex_hull', plot_comp=None,
driver=ScipyOptimizeDriver(),
record_id="Opt_%s" % time.strftime("%Y%m%d_%H%M%S"),
expected_cost=1):
sys.stderr.write("%s is deprecated. Use TopFarmProblem instead\n" % self.__class__.__name__)
constraints = []
if min_spacing and len(turbines) > 1:
constraints.append(SpacingConstraint(min_spacing))
if boundary is not None:
constraints.append(XYBoundaryConstraint(boundary, boundary_type))
TopFarmProblem.__init__(
self,
design_vars={k: v for k, v in zip([topfarm.x_key, topfarm.y_key, topfarm.z_key], np.asarray(turbines).T)},
cost_comp=cost_comp,
driver=driver,
constraints=constraints,
plot_comp=plot_comp,
record_id=record_id,
expected_cost=expected_cost)
self.setup()
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 test_random_search_driver_randomize_all_uniform():
np.random.seed(1)
class Cost():
i = 0
def __call__(self, *args, **kwargs):
self.i += 1
return self.i
cost_comp = CostModelComponent(input_keys=['x', 'y', 'type'],
n_wt=2,
cost_function=Cost(),
income_model=True)
tf = TopFarmProblem(
{
'x': ([1, 6], [0, 1], [5, 6]),
'y': ([-1., 0], -6, 0),
'type': ([3, 3], 3, 8)
},
cost_comp=cost_comp,
constraints=[],
driver=EasyRandomSearchDriver(randomize_func=RandomizeAllUniform(
['x', 'type']),
max_iter=600,
disp=False),
)
_, state, recorder = tf.optimize()
# check that integer design variables are somewhat evenly distributed
x, y, t = recorder['x'], recorder['y'], recorder['type']
for arr, l, u in [(x[:, 0], 0, 5), (x[:, 1], 1, 6), (t[:, 0], 3, 8)]:
count = [(arr == i).sum() for i in range(l, u + 1)]
npt.assert_equal(601, sum(count))
npt.assert_array_less(600 / len(count) * .70, count)
count, _ = np.histogram(y[:, 0], np.arange(-6, 1))
npt.assert_equal(y.shape[0], sum(count))
npt.assert_array_less(600 / len(count) * .70, count)
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 _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)