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 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
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 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 _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 test_smart_start():
xs_ref = [1.6, 1.6, 3.7]
ys_ref = [1.6, 3.7, 1.6]
x = np.arange(0, 5, 0.1)
y = np.arange(0, 5, 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)])
tf.smart_start(XX, YY, ZZ, seed=0)
try:
npt.assert_array_almost_equal(tf.turbine_positions,
np.array([xs_ref, ys_ref]).T)
except AssertionError:
# wt2 and wt3 may switch
npt.assert_array_almost_equal(tf.turbine_positions,
np.array([ys_ref, xs_ref]).T)
if 0:
import matplotlib.pyplot as plt
plt.contourf(XX, YY, ZZ, 100)
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()
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 test_spacing():
tf = xy3tb.get_tf(constraints=[SpacingConstraint(2)])
tf.optimize()
tb_pos = tf.turbine_positions[:, :2]
tf.plot_comp.show()
tol = 1e-4
assert sum((tb_pos[2] - tb_pos[0])**2) > 2**2 - tol # check min spacing
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_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 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_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 test_TopFarmProblemSpacingConstraint():
tf = xy3tb.get_tf(design_vars={'x': [3, 7, 4], 'y': [-3, -7, -3]},
constraints=[SpacingConstraint(2)])
tf.evaluate({'x': xy3tb.desired[:, 0], 'y': xy3tb.desired[:, 1]})
npt.assert_array_equal(tf['wtSeparationSquared'], [32, 1, 25])
_, state, _ = tf.optimize()
npt.assert_array_almost_equal(state['x'], [2.5, 7, 4.5])
npt.assert_array_almost_equal(state['y'], xy3tb.optimal[:, 1])
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 main():
if __name__ == '__main__':
try:
import matplotlib.pyplot as plt
plt.gcf()
plot_comp = XYPlotComp()
plot = True
except RuntimeError:
plot_comp = NoPlot()
plot = False
n_wt = 16
site = IEA37Site(n_wt)
windTurbines = IEA37_WindTurbines()
wake_model = 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
AEPCalc = AEPCalculator(wake_model)
def aep_func(x, y, **kwargs):
return AEPCalc.calculate_AEP(x_i=x, y_i=y).sum(-1).sum(-1) * 10**6
def irr_func(aep, **kwargs):
my_irr = economic_evaluation(Drotor_vector, power_rated_vector,
hub_height_vector,
aep).calculate_irr()
print(my_irr)
return my_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=50),
constraints=[
SpacingConstraint(200),
CircleBoundaryConstraint([0, 0], 1300.1)
],
plot_comp=plot_comp)
cost, state, recorder = problem.optimize()
def test_TopFarmProblemSpacingPenalty():
tf = xy3tb.get_tf(design_vars={'x': [3, 7, 4], 'y': [-3, -7, -3]},
driver=EasyRandomSearchDriver(RandomizeTurbinePosition(1), 10),
constraints=[SpacingConstraint(2)])
# 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 test_spacing_as_penalty():
tf = xy3tb.get_tf(constraints=[SpacingConstraint(2)],
driver=SimpleGADriver())
# check normal result if spacing constraint is satisfied
assert tf.evaluate()[0] == 45
# check penalized result if spacing constraint is not satisfied
assert tf.evaluate({
'x': [3, 7, 4.],
'y': [-3., -7., -3.],
'z': [0., 0., 0.]
})[0] == 1e10 + 3
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 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 _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 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 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_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 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'])
turbineXYZ = np.array(turbineXYZ)
desvar = dict(zip('xy', turbineXYZ.T))
desvar['z'] = (turbineXYZ[:, 2], z_boundary[0], z_boundary[1])
constraints = [XYBoundaryConstraint(xy_boundary, xy_boundary_type)]
if min_spacing:
constraints.append(SpacingConstraint(min_spacing))
return TopFarmProblem(desvar,
cost_comp,
constraints=constraints,
driver=driver)
def get_iea37_constraints(n_wt=9):
"""Constraints for IEA Task 37 wind farms
Parameters
----------
n_wt : int, optional
Number of wind turbines in farm (must be valid IEA 37 farm)
Returns
-------
constr : list of topfarm constraints
Spacing constraint and boundary constraint for IEA 37 model
"""
diam = read_iea37_windturbine(iea37_path + 'iea37-335mw.yaml')[2]
spac_constr = SpacingConstraint(2 * diam)
bound_rad = npa([900, 1300, 2000, 3000])[n_wt == npa([9, 16, 36, 64])][0]
bound_constr = CircleBoundaryConstraint((0, 0), bound_rad)
return [spac_constr, bound_constr]
