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 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 turbineTypeOptimizationProblem(): return TurbineTypeOptimizationProblem( TurbineTypeDummyCost([2, 0, 1]), turbineTypes=[0, 0, 0], lower=[0, 0, 0], upper=[2, 2, 2], driver=DOEDriver(FullFactorialGenerator(3)))
def test_full_factorial_array(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('xy', np.array([0., 0.])), promotes=['*']) model.add_subsystem('comp', ParaboloidArray(), promotes=['*']) model.add_design_var('xy', lower=np.array([-50., -50.]), upper=np.array([50., 50.])) model.add_objective('f_xy') prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.add_recorder(SqliteRecorder("cases.sql")) prob.setup(check=False) prob.run_driver() prob.cleanup() expected = { 0: { 'xy': np.array([-50., -50.]) }, 1: { 'xy': np.array([0., -50.]) }, 2: { 'xy': np.array([50., -50.]) }, 3: { 'xy': np.array([-50., 0.]) }, 4: { 'xy': np.array([0., 0.]) }, 5: { 'xy': np.array([50., 0.]) }, 6: { 'xy': np.array([-50., 50.]) }, 7: { 'xy': np.array([0., 50.]) }, 8: { 'xy': np.array([50., 50.]) }, } cases = CaseReader("cases.sql").driver_cases self.assertEqual(cases.num_cases, 9) for n in range(cases.num_cases): outputs = cases.get_case(n).outputs self.assertEqual(outputs['xy'][0], expected[n]['xy'][0]) self.assertEqual(outputs['xy'][1], expected[n]['xy'][1])
def test_full_factorial(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x']) model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y']) model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy']) model.add_design_var('x', lower=0.0, upper=1.0) model.add_design_var('y', lower=0.0, upper=1.0) model.add_objective('f_xy') prob.driver = DOEDriver(FullFactorialGenerator(levels=3), parallel=True) prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup() failed, output = run_driver(prob) self.assertFalse(failed) prob.cleanup() expected = { 0: {'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])}, 1: {'x': np.array([.5]), 'y': np.array([0.]), 'f_xy': np.array([19.25])}, 2: {'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])}, 3: {'x': np.array([0.]), 'y': np.array([.5]), 'f_xy': np.array([26.25])}, 4: {'x': np.array([.5]), 'y': np.array([.5]), 'f_xy': np.array([23.75])}, 5: {'x': np.array([1.]), 'y': np.array([.5]), 'f_xy': np.array([21.75])}, 6: {'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])}, 7: {'x': np.array([.5]), 'y': np.array([1.]), 'f_xy': np.array([28.75])}, 8: {'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])}, } size = prob.comm.size rank = prob.comm.rank # cases will be split across files for each proc filename = "CASES.db_%d" % rank expect_msg = "Cases from rank %d are being written to %s." % (rank, filename) self.assertTrue(expect_msg in output) cases = CaseReader(filename).driver_cases # cases recorded on this proc num_cases = cases.num_cases self.assertEqual(num_cases, len(expected)//size+(rank<len(expected)%size)) for n in range(num_cases): case = cases.get_case(n) idx = n * size + rank # index of expected case self.assertEqual(cases.get_case(n).outputs['x'], expected[idx]['x']) self.assertEqual(cases.get_case(n).outputs['y'], expected[idx]['y']) self.assertEqual(cases.get_case(n).outputs['f_xy'], expected[idx]['f_xy'])
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_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_full_factorial(self): from openmdao.api import Problem, IndepVarComp from openmdao.test_suite.components.paraboloid import Paraboloid from openmdao.api import DOEDriver, FullFactorialGenerator from openmdao.api import SqliteRecorder, CaseReader from mpi4py import MPI prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x']) model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y']) model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy']) model.add_design_var('x', lower=0.0, upper=1.0) model.add_design_var('y', lower=0.0, upper=1.0) model.add_objective('f_xy') prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.options['parallel'] = True prob.driver.add_recorder(SqliteRecorder("cases.sql")) prob.setup() prob.run_driver() prob.cleanup() self.assertEqual(MPI.COMM_WORLD.size, 2) # check recorded cases from each case file rank = MPI.COMM_WORLD.rank filename = "cases.sql_%d" % rank self.assertEqual(filename, "cases.sql_%d" % rank) cases = CaseReader(filename).driver_cases self.assertEqual(cases.num_cases, 5 if rank == 0 else 4) values = [] for n in range(cases.num_cases): outputs = cases.get_case(n).outputs values.append((outputs['x'], outputs['y'], outputs['f_xy'])) self.assertEqual( "\n" + "\n".join([ "x: %5.2f, y: %5.2f, f_xy: %6.2f" % (x, y, f_xy) for x, y, f_xy in values ]), self.expect_text)
def test_indivisable_error(self): prob = Problem() prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.options['parallel'] = 3 with self.assertRaises(RuntimeError) as context: prob.setup() self.assertEqual( str(context.exception), "The number of processors is not evenly divisable by the " "specified number of parallel cases.\n Provide a number of " "processors that is a multiple of 3, or specify a number " "of parallel cases that divides into 4.")
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 test_minprocs_error(self): prob = Problem(FanInGrouped()) # require 2 procs for the ParallelGroup prob.model._proc_info['sub'] = (2, None, 1.0) # run cases on all procs prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.options['parallel'] = True with self.assertRaises(RuntimeError) as context: prob.setup() self.assertEqual( str(context.exception), ": MPI process allocation failed: can't meet min_procs " "required for the following subsystems: ['sub']")
def test_fan_in_grouped(self): from openmdao.api import Problem from openmdao.test_suite.groups.parallel_groups import FanInGrouped from openmdao.api import DOEDriver, FullFactorialGenerator from openmdao.api import SqliteRecorder, CaseReader from mpi4py import MPI prob = Problem(FanInGrouped()) model = prob.model model.add_design_var('iv.x1', lower=0.0, upper=1.0) model.add_design_var('iv.x2', lower=0.0, upper=1.0) model.add_objective('c3.y') prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.add_recorder(SqliteRecorder("cases.sql")) # run 2 cases at a time, each using 2 of our 4 procs doe_parallel = prob.driver.options['parallel'] = 2 prob.setup() prob.run_driver() prob.cleanup() rank = MPI.COMM_WORLD.rank # check recorded cases from each case file if rank < doe_parallel: filename = "cases.sql_%d" % rank cases = CaseReader(filename).driver_cases values = [] for n in range(cases.num_cases): outputs = cases.get_case(n).outputs values.append( (outputs['iv.x1'], outputs['iv.x2'], outputs['c3.y'])) self.assertEqual( "\n" + "\n".join([ "iv.x1: %5.2f, iv.x2: %5.2f, c3.y: %6.2f" % (x1, x2, y) for x1, x2, y in values ]), self.expect_text)
def test_turbineType_and_XYZ_optimization(): plot_comp = DummyCostPlotComp(optimal) plot_comp = NoPlot() cost_comp = DummyCost( optimal_state=optimal, inputs=['x', 'y', 'z', 'type']) xyz_opt_problem = TurbineXYZOptimizationProblem( cost_comp, turbineXYZ=[(0, 0, 0), (1, 1, 1)], min_spacing=2, boundary_comp=get_boundary_comp(), plot_comp=plot_comp, driver=EasyScipyOptimizeDriver(disp=False)) tf = TurbineTypeOptimizationProblem( cost_comp=xyz_opt_problem, turbineTypes=[0, 0], lower=0, upper=1, driver=DOEDriver(FullFactorialGenerator(2))) cost = tf.optimize()[0] npt.assert_almost_equal(cost, 0)
def test_full_factorial(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x']) model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y']) model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy']) model.add_design_var('x', lower=0.0, upper=1.0) model.add_design_var('y', lower=0.0, upper=1.0) model.add_objective('f_xy') prob.driver = DOEDriver(generator=FullFactorialGenerator(levels=3)) prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup(check=False) prob.run_driver() prob.cleanup() expected = { 0: {'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])}, 1: {'x': np.array([.5]), 'y': np.array([0.]), 'f_xy': np.array([19.25])}, 2: {'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])}, 3: {'x': np.array([0.]), 'y': np.array([.5]), 'f_xy': np.array([26.25])}, 4: {'x': np.array([.5]), 'y': np.array([.5]), 'f_xy': np.array([23.75])}, 5: {'x': np.array([1.]), 'y': np.array([.5]), 'f_xy': np.array([21.75])}, 6: {'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])}, 7: {'x': np.array([.5]), 'y': np.array([1.]), 'f_xy': np.array([28.75])}, 8: {'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])}, } cases = CaseReader("CASES.db").driver_cases self.assertEqual(cases.num_cases, 9) for n in range(cases.num_cases): self.assertEqual(cases.get_case(n).outputs['x'], expected[n]['x']) self.assertEqual(cases.get_case(n).outputs['y'], expected[n]['y']) self.assertEqual(cases.get_case(n).outputs['f_xy'], expected[n]['f_xy'])
def turbineTypeOptimizationProblem(): return TopFarmProblem( design_vars={'type': ([0, 0, 0], 0, 2)}, cost_comp=DummyCost(np.array([[2, 0, 1]]).T, ['type']), driver=DOEDriver(FullFactorialGenerator(3)))
def test_fan_in_grouped_serial(self): # run cases on all procs (parallel model will run on single proc) doe_parallel = True prob = Problem(FanInGrouped()) model = prob.model model.add_design_var('iv.x1', lower=0.0, upper=1.0) model.add_design_var('iv.x2', lower=0.0, upper=1.0) model.add_objective('c3.y') prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.add_recorder(SqliteRecorder("cases.sql")) prob.driver.options['parallel'] = doe_parallel prob.setup(check=False) failed, output = run_driver(prob) self.assertFalse(failed) prob.cleanup() expected = { 0: { 'iv.x1': np.array([0.]), 'iv.x2': np.array([0.]), 'c3.y': np.array([0.0]) }, 1: { 'iv.x1': np.array([.5]), 'iv.x2': np.array([0.]), 'c3.y': np.array([-3.0]) }, 2: { 'iv.x1': np.array([1.]), 'iv.x2': np.array([0.]), 'c3.y': np.array([-6.0]) }, 3: { 'iv.x1': np.array([0.]), 'iv.x2': np.array([.5]), 'c3.y': np.array([17.5]) }, 4: { 'iv.x1': np.array([.5]), 'iv.x2': np.array([.5]), 'c3.y': np.array([14.5]) }, 5: { 'iv.x1': np.array([1.]), 'iv.x2': np.array([.5]), 'c3.y': np.array([11.5]) }, 6: { 'iv.x1': np.array([0.]), 'iv.x2': np.array([1.]), 'c3.y': np.array([35.0]) }, 7: { 'iv.x1': np.array([.5]), 'iv.x2': np.array([1.]), 'c3.y': np.array([32.0]) }, 8: { 'iv.x1': np.array([1.]), 'iv.x2': np.array([1.]), 'c3.y': np.array([29.0]) }, } rank = prob.comm.rank size = prob.comm.size // doe_parallel num_cases = 0 # cases will be split across files for each proc up to the number requested filename = "cases.sql_%d" % rank expect_msg = "Cases from rank %d are being written to %s." % (rank, filename) self.assertTrue(expect_msg in output) cases = CaseReader(filename).driver_cases # cases recorded on this proc num_cases = cases.num_cases self.assertEqual(num_cases, len(expected) // size + (rank < len(expected) % size)) for n in range(num_cases): idx = n * size + rank # index of expected case outputs = cases.get_case(n).outputs self.assertEqual(outputs['iv.x1'], expected[idx]['iv.x1']) self.assertEqual(outputs['iv.x2'], expected[idx]['iv.x2']) self.assertEqual(outputs['c3.y'], expected[idx]['c3.y']) # total number of cases recorded across all requested procs num_cases = prob.comm.allgather(num_cases) self.assertEqual(sum(num_cases), len(expected))