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 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_plackett_burman(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(PlackettBurmanGenerator()) 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([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])}, 2: {'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])}, 3: {'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, 4) 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 test_uniform(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_design_var('x', lower=-10, upper=10) model.add_design_var('y', lower=-10, upper=10) model.add_objective('f_xy') prob.driver = DOEDriver(UniformGenerator(num_samples=5, seed=0)) prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup(check=False) prob.run_driver() prob.cleanup() # all values should be between -10 and 10, check expected values for seed = 0 expected = { 0: {'x': np.array([ 0.97627008]), 'y': np.array([ 4.30378733])}, 1: {'x': np.array([ 2.05526752]), 'y': np.array([ 0.89766366])}, 2: {'x': np.array([-1.52690401]), 'y': np.array([ 2.91788226])}, 3: {'x': np.array([-1.24825577]), 'y': np.array([ 7.83546002])}, 4: {'x': np.array([ 9.27325521]), 'y': np.array([-2.33116962])}, } cases = CaseReader("CASES.db").driver_cases self.assertEqual(cases.num_cases, 5) for n in range(cases.num_cases): assert_rel_error(self, cases.get_case(n).outputs['x'], expected[n]['x'], 1e-4) assert_rel_error(self, cases.get_case(n).outputs['y'], expected[n]['y'], 1e-4)
def test_uniform(self): from openmdao.api import Problem, IndepVarComp from openmdao.test_suite.components.paraboloid import Paraboloid from openmdao.api import DOEDriver, UniformGenerator, SqliteRecorder, CaseReader prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_design_var('x', lower=-10, upper=10) model.add_design_var('y', lower=-10, upper=10) model.add_objective('f_xy') prob.driver = DOEDriver(UniformGenerator(num_samples=5)) prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup() prob.run_driver() prob.cleanup() cases = CaseReader("CASES.db").driver_cases self.assertEqual(cases.num_cases, 5) values = [] for n in range(cases.num_cases): case = cases.get_case(n) values.append((case.outputs['x'], case.outputs['y'], case.outputs['f_xy']))
def test_doe(self): filename = 'pyxdsm_doe' out_format = PYXDSM_OUT prob = Problem(model=Group()) indeps = prob.model.add_subsystem('indeps', IndepVarComp(), promotes=['*']) indeps.add_output('x') prob.model.add_subsystem('C1', ExecComp(['y=2.0*x+1.'], x=2.0), promotes=['*']) prob.driver = DOEDriver() prob.model.add_design_var('x', lower=0.0, upper=10.0) prob.model.add_objective('y') prob.setup(check=False) # Conclude setup but don't run model. prob.final_setup() write_xdsm(prob, filename=filename, out_format=out_format, quiet=QUIET, show_browser=SHOW, show_parallel=True) # Check if file was created self.assertTrue(os.path.isfile('.'.join([filename, out_format])))
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 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_generator_check(self): prob = Problem() with self.assertRaises(TypeError) as err: prob.driver = DOEDriver(FullFactorialGenerator) self.assertEqual(str(err.exception), "DOEDriver requires an instance of DOEGenerator, " "but a class object was found: FullFactorialGenerator") with self.assertRaises(TypeError) as err: prob.driver = DOEDriver(Problem()) self.assertEqual(str(err.exception), "DOEDriver requires an instance of DOEGenerator, " "but an instance of Problem was found.")
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_box_behnken(self): upper = 10. center = 1 prob = Problem() model = prob.model indep = model.add_subsystem('indep', IndepVarComp(), promotes=['*']) indep.add_output('x', 0.0) indep.add_output('y', 0.0) indep.add_output('z', 0.0) model.add_subsystem('comp', ExecComp('a = x**2 + y - z'), promotes=['*']) model.add_design_var('x', lower=0., upper=upper) model.add_design_var('y', lower=0., upper=upper) model.add_design_var('z', lower=0., upper=upper) model.add_objective('a') prob.driver = DOEDriver(BoxBehnkenGenerator(center=center)) prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup(check=False) prob.run_driver() prob.cleanup() cases = CaseReader("CASES.db").driver_cases # The Box-Behnken design for 3 factors involves three blocks, in each of # which 2 factors are varied thru the 4 possible combinations of high & low. # It also includes centre points (all factors at their central values). # ref: https://en.wikipedia.org/wiki/Box-Behnken_design self.assertEqual(cases.num_cases, (3*4)+center) expected = { 0: {'x': np.array([ 0.]), 'y': np.array([ 0.]), 'z': np.array([ 5.])}, 1: {'x': np.array([10.]), 'y': np.array([ 0.]), 'z': np.array([ 5.])}, 2: {'x': np.array([ 0.]), 'y': np.array([10.]), 'z': np.array([ 5.])}, 3: {'x': np.array([10.]), 'y': np.array([10.]), 'z': np.array([ 5.])}, 4: {'x': np.array([ 0.]), 'y': np.array([ 5.]), 'z': np.array([ 0.])}, 5: {'x': np.array([10.]), 'y': np.array([ 5.]), 'z': np.array([ 0.])}, 6: {'x': np.array([ 0.]), 'y': np.array([ 5.]), 'z': np.array([10.])}, 7: {'x': np.array([10.]), 'y': np.array([ 5.]), 'z': np.array([10.])}, 8: {'x': np.array([ 5.]), 'y': np.array([ 0.]), 'z': np.array([ 0.])}, 9: {'x': np.array([ 5.]), 'y': np.array([10.]), 'z': np.array([ 0.])}, 10: {'x': np.array([ 5.]), 'y': np.array([ 0.]), 'z': np.array([10.])}, 11: {'x': np.array([ 5.]), 'y': np.array([10.]), 'z': np.array([10.])}, 12: {'x': np.array([ 5.]), 'y': np.array([ 5.]), 'z': np.array([ 5.])}, } 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['z'], expected[n]['z'])
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_latin_hypercube_center(self): samples = 4 upper = 10. prob = Problem() model = prob.model indep = model.add_subsystem('indep', IndepVarComp()) indep.add_output('x', 0.0) indep.add_output('y', 0.0) model.add_subsystem('comp', Paraboloid()) model.connect('indep.x', 'comp.x') model.connect('indep.y', 'comp.y') model.add_design_var('indep.x', lower=0., upper=upper) model.add_design_var('indep.y', lower=0., upper=upper) model.add_objective('comp.f_xy') prob.driver = DOEDriver(LatinHypercubeGenerator(samples=samples, criterion='c')) prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup(check=False) prob.run_driver() prob.cleanup() cases = CaseReader("CASES.db").driver_cases self.assertEqual(cases.num_cases, samples) # the sample space for each variable (0 to upper) should be divided into # equal size buckets and each variable should have a value in each bucket bucket_size = upper/samples all_buckets = set(range(samples)) x_buckets_filled = set() y_buckets_filled = set() # with criterion of 'center', each value should be in the center of it's bucket valid_values = [round(bucket_size*(bucket + 1/2), 3) for bucket in all_buckets] for n in range(cases.num_cases): x = float(cases.get_case(n).outputs['indep.x']) y = float(cases.get_case(n).outputs['indep.y']) x_buckets_filled.add(int(x/bucket_size)) y_buckets_filled.add(int(y/bucket_size)) self.assertTrue(round(x, 3) in valid_values, '%f not in %s' % (x, valid_values)) self.assertTrue(round(y, 3) in valid_values, '%f not in %s' % (y, valid_values)) self.assertEqual(x_buckets_filled, all_buckets) self.assertEqual(y_buckets_filled, all_buckets)
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 test_with_uniform_generator(get_tf): tf = get_tf(driver=DOEDriver(UniformGenerator(10))) arr = tf.get_DOE_array() uta.assertGreaterEqual(arr[:, 0].min(), 10) # x uta.assertLessEqual(arr[:, 0].max(), 11) # x uta.assertGreaterEqual(arr[:, 1].min(), 6) # y uta.assertLessEqual(arr[:, 1].max(), 8) # y uta.assertGreaterEqual(arr[:, 2].min(), 3) # z uta.assertLessEqual(arr[:, 2].max(), 4) # z cost, _, recorder = tf.optimize() npt.assert_equal(cost, np.min(recorder.get('cost')))
def test_list_driver(get_tf): xyz = [[[1, 2], [3, 4], [5, 6]], [[4, 3], [6, 5], [2, 1]]] lst = [[('x', [1, 2]), ('y', [3, 4]), ('z', [5, 6])], [('x', [4, 3]), ('y', [6, 5]), ('z', [2, 1])]] tf = get_tf(driver=lst) # pure list npt.assert_array_equal(tf.get_DOE_array(), xyz) tf = get_tf(driver=ListGenerator(lst)) # list generator npt.assert_array_equal(tf.get_DOE_array(), xyz) tf = get_tf(driver=DOEDriver(ListGenerator(lst))) # DOEDriver npt.assert_array_equal(tf.get_DOE_array(), xyz)
def test_ListRecorder(): from openmdao.api import Problem, IndepVarComp from openmdao.test_suite.components.paraboloid import Paraboloid prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_design_var('x', lower=-10, upper=10) model.add_design_var('y', lower=-10, upper=10) model.add_objective('f_xy') xyf = [[0.98, 4.30, 74.1844], [2.06, 0.90, 23.7476], [-1.53, 2.92, 60.9397], [-1.25, 7.84, 145.4481]] prob.driver = DOEDriver(ListGenerator([[('x', xy[0]), ('y', xy[1])] for xy in xyf])) recorder = TopFarmListRecorder() recorder._initialize_database() recorder._cleanup_abs2meta() recorder.record_iteration_problem(None, None, None) recorder.record_iteration_system(None, None, None) recorder.record_iteration_solver(None, None, None) recorder.record_viewer_data(None) recorder.record_metadata_solver(None) recorder.record_derivatives_driver(None, None, None) recorder.shutdown() prob.driver.add_recorder(recorder) prob.driver.recording_options['record_desvars'] = True prob.driver.recording_options['includes'] = ['*'] prob.driver.recording_options['record_inputs'] = True prob.setup() prob.run_driver() prob.cleanup() assert recorder.num_cases == 4 npt.assert_array_equal(recorder.get('counter'), range(1, 5)) npt.assert_array_equal(recorder['counter'], range(1, 5)) npt.assert_array_almost_equal(recorder.get(['x', 'y', 'f_xy']), xyf, 4) for xyf, k in zip(xyf[0], ['x', 'y', 'f_xy']): npt.assert_allclose(recorder[k][0], xyf) with pytest.raises(KeyError, match="missing"): recorder.get('missing')
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_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 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 test_no_generator(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_design_var('x', lower=-10, upper=10) model.add_design_var('y', lower=-10, upper=10) model.add_objective('f_xy') prob.driver = DOEDriver() prob.driver.add_recorder(SqliteRecorder("cases.sql")) prob.setup(check=False) prob.run_driver() prob.cleanup() cases = CaseReader("cases.sql").driver_cases self.assertEqual(cases.num_cases, 0)
def test_ListRecorder(): from openmdao.api import Problem, IndepVarComp from openmdao.test_suite.components.paraboloid import Paraboloid prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_design_var('x', lower=-10, upper=10) model.add_design_var('y', lower=-10, upper=10) model.add_objective('f_xy') xyf = [[0.98, 4.30, 74.1844], [2.06, 0.90, 23.7476], [-1.53, 2.92, 60.9397], [-1.25, 7.84, 145.4481]] prob.driver = DOEDriver( ListGenerator([[('x', xy[0]), ('y', xy[1])] for xy in xyf])) recorder = ListRecorder() prob.driver.add_recorder(recorder) prob.setup() prob.run_driver() prob.cleanup() cases = recorder.driver_cases assert cases.num_cases == 4 npt.assert_array_equal(recorder.get('counter'), range(1, 5)) npt.assert_array_equal(recorder['counter'], range(1, 5)) npt.assert_array_almost_equal(recorder.get(['x', 'y', 'f_xy']), xyf, 4) for xyf, k in zip(xyf[0], ['x', 'y', 'f_xy']): npt.assert_allclose(cases.get_case(0).outputs[k][0], xyf) with pytest.raises(KeyError, match="missing"): recorder.get('missing')
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))