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])