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