def test_concurrent_eval_padded(self): # This test only makes sure we don't lock up if we overallocate our integer desvar space # to the next power of 2. class GAGroup(om.Group): def setup(self): self.add_subsystem('p1', om.IndepVarComp('x', 1.0)) self.add_subsystem('p2', om.IndepVarComp('y', 1.0)) self.add_subsystem('p3', om.IndepVarComp('z', 1.0)) self.add_subsystem('comp', om.ExecComp(['f = x + y + z'])) self.add_design_var('p1.x', lower=-100, upper=100) self.add_design_var('p2.y', lower=-100, upper=100) self.add_design_var('p3.z', lower=-100, upper=100) self.add_objective('comp.f') prob = om.Problem() prob.model = GAGroup() driver = prob.driver = om.SimpleGADriver() driver.options['max_gen'] = 5 driver.options['pop_size'] = 40 driver.options['run_parallel'] = True prob.setup() # No meaningful result from a short run; just make sure we don't hang. prob.run_driver()
def test_option_parallel(self): import openmdao.api as om from openmdao.test_suite.components.branin import Branin prob = om.Problem() model = prob.model model.add_subsystem('p1', om.IndepVarComp('xC', 7.5)) model.add_subsystem('p2', om.IndepVarComp('xI', 0.0)) model.add_subsystem('comp', Branin()) model.connect('p2.xI', 'comp.x0') model.connect('p1.xC', 'comp.x1') model.add_design_var('p2.xI', lower=-5.0, upper=10.0) model.add_design_var('p1.xC', lower=0.0, upper=15.0) model.add_objective('comp.f') prob.driver = om.SimpleGADriver() prob.driver.options['bits'] = {'p1.xC': 8} prob.driver.options['max_gen'] = 10 prob.driver.options['run_parallel'] = True prob.setup() prob.run_driver() # Optimal solution print('comp.f', prob['comp.f']) print('p2.xI', prob['p2.xI']) print('p1.xC', prob['p1.xC'])
def test_mixed_integer_branin_discrete(self): prob = om.Problem() model = prob.model indep = om.IndepVarComp() indep.add_output('xC', val=7.5) indep.add_discrete_output('xI', val=0) model.add_subsystem('p', indep) model.add_subsystem('comp', BraninDiscrete()) model.connect('p.xI', 'comp.x0') model.connect('p.xC', 'comp.x1') model.add_design_var('p.xI', lower=-5, upper=10) model.add_design_var('p.xC', lower=0.0, upper=15.0) model.add_objective('comp.f') prob.driver = om.SimpleGADriver(max_gen=75, pop_size=25) prob.driver.options['bits'] = {'p.xC': 8} prob.driver._randomstate = 1 prob.setup() prob.run_driver() # Optimal solution assert_rel_error(self, prob['comp.f'], 0.49398, 1e-4) self.assertTrue(prob['p.xI'] in [3, -3]) self.assertTrue(isinstance(prob['p.xI'], int))
def test_vectorized_constraints(self): prob = om.Problem() model = prob.model dim = 2 model.add_subsystem('x', om.IndepVarComp('x', np.ones(dim)), promotes=['*']) model.add_subsystem('f_x', om.ExecComp('f_x = sum(x * x)', x=np.ones(dim), f_x=1.0), promotes=['*']) model.add_subsystem('g_x', om.ExecComp('g_x = 1 - x', x=np.ones(dim), g_x=np.zeros(dim)), promotes=['*']) prob.driver = om.SimpleGADriver() prob.model.add_design_var('x', lower=-10, upper=10) prob.model.add_objective('f_x') prob.model.add_constraint('g_x', upper=np.zeros(dim)) prob.setup() prob.run_driver() # Check that the constraint is satisfied (x >= 1) for i in range(dim): self.assertLessEqual(1.0, prob["x"][i])
def test_analysis_error(self): class ValueErrorComp(om.ExplicitComponent): def setup(self): self.add_input('x', 1.0) self.add_output('f', 1.0) def compute(self, inputs, outputs): raise ValueError prob = om.Problem() model = prob.model model.add_subsystem('p', om.IndepVarComp('x', 0.0)) model.add_subsystem('comp', ValueErrorComp()) model.connect('p.x', 'comp.x') model.add_design_var('p.x', lower=-5.0, upper=10.0) model.add_objective('comp.f') prob.driver = om.SimpleGADriver(max_gen=75, pop_size=25) prob.driver._randomstate = 1 prob.setup() # prob.run_driver() self.assertRaises(ValueError, prob.run_driver)
def test_vector_desvars_multiobj(self): prob = om.Problem() indeps = prob.model.add_subsystem('indeps', om.IndepVarComp()) indeps.add_output('x', 3) indeps.add_output('y', [4.0, -4]) prob.model.add_subsystem('paraboloid1', om.ExecComp('f = (x+5)**2- 3')) prob.model.add_subsystem( 'paraboloid2', om.ExecComp('f = (y[0]-3)**2 + (y[1]-1)**2 - 3', y=[0, 0])) prob.model.connect('indeps.x', 'paraboloid1.x') prob.model.connect('indeps.y', 'paraboloid2.y') prob.driver = om.SimpleGADriver() prob.model.add_design_var('indeps.x', lower=-5, upper=5) prob.model.add_design_var('indeps.y', lower=[-10, 0], upper=[10, 3]) prob.model.add_objective('paraboloid1.f') prob.model.add_objective('paraboloid2.f') prob.setup() prob.run_driver() np.testing.assert_array_almost_equal(prob['indeps.x'], -5) np.testing.assert_array_almost_equal(prob['indeps.y'], [3, 1])
def test_mixed_integer_branin(self): prob = om.Problem() model = prob.model model.add_subsystem('p1', om.IndepVarComp('xC', 7.5)) model.add_subsystem('p2', om.IndepVarComp('xI', 0.0)) model.add_subsystem('comp', Branin()) model.connect('p2.xI', 'comp.x0') model.connect('p1.xC', 'comp.x1') model.add_design_var('p2.xI', lower=-5.0, upper=10.0) model.add_design_var('p1.xC', lower=0.0, upper=15.0) model.add_objective('comp.f') prob.driver = om.SimpleGADriver(max_gen=75, pop_size=25) prob.driver.options['bits'] = {'p1.xC': 8} prob.driver._randomstate = 1 prob.setup() prob.run_driver() # Optimal solution assert_rel_error(self, prob['comp.f'], 0.49398, 1e-4) self.assertTrue(int(prob['p2.xI']) in [3, -3])
def test_basic_with_assert(self): import openmdao.api as om from openmdao.test_suite.components.branin import Branin prob = om.Problem() model = prob.model model.add_subsystem('p1', om.IndepVarComp('xC', 7.5)) model.add_subsystem('p2', om.IndepVarComp('xI', 0.0)) model.add_subsystem('comp', Branin()) model.connect('p2.xI', 'comp.x0') model.connect('p1.xC', 'comp.x1') model.add_design_var('p2.xI', lower=-5.0, upper=10.0) model.add_design_var('p1.xC', lower=0.0, upper=15.0) model.add_objective('comp.f') prob.driver = om.SimpleGADriver() prob.driver.options['bits'] = {'p1.xC': 8} prob.driver._randomstate = 1 prob.setup() prob.run_driver() # Optimal solution assert_rel_error(self, prob['comp.f'], 0.49399549, 1e-4)
def test_proc_per_model(self): # Test that we can run a GA on a distributed component without lockups. prob = om.Problem() model = prob.model model.add_subsystem('p', om.IndepVarComp('x', 3.0), promotes=['x']) model.add_subsystem('d1', D1(), promotes=['*']) model.add_subsystem('d2', D2(), promotes=['*']) model.add_subsystem('obj_comp', Summer(), promotes=['*']) model.nonlinear_solver = om.NewtonSolver() model.linear_solver = om.DirectSolver() model.add_design_var('x', lower=-0.5, upper=0.5) model.add_objective('obj') driver = prob.driver = om.SimpleGADriver() prob.driver.options['pop_size'] = 4 prob.driver.options['max_gen'] = 3 prob.driver.options['run_parallel'] = True prob.driver.options['procs_per_model'] = 2 prob.setup() prob.set_solver_print(level=0) prob.run_driver()
def test_mixed_integer_3bar(self): class ObjPenalty(om.ExplicitComponent): """ Weight objective with penalty on stress constraint. """ def setup(self): self.add_input('obj', 0.0) self.add_input('stress', val=np.zeros((3, ))) self.add_output('weighted', 0.0) def compute(self, inputs, outputs): obj = inputs['obj'] stress = inputs['stress'] pen = 0.0 for j in range(len(stress)): if stress[j] > 1.0: pen += 10.0*(stress[j] - 1.0)**2 outputs['weighted'] = obj + pen prob = om.Problem() model = prob.model model.add_subsystem('xc_a1', om.IndepVarComp('area1', 5.0, units='cm**2'), promotes=['*']) model.add_subsystem('xc_a2', om.IndepVarComp('area2', 5.0, units='cm**2'), promotes=['*']) model.add_subsystem('xc_a3', om.IndepVarComp('area3', 5.0, units='cm**2'), promotes=['*']) model.add_subsystem('xi_m1', om.IndepVarComp('mat1', 1), promotes=['*']) model.add_subsystem('xi_m2', om.IndepVarComp('mat2', 1), promotes=['*']) model.add_subsystem('xi_m3', om.IndepVarComp('mat3', 1), promotes=['*']) model.add_subsystem('comp', ThreeBarTruss(), promotes=['*']) model.add_subsystem('obj_with_penalty', ObjPenalty(), promotes=['*']) model.add_design_var('area1', lower=1.2, upper=1.3) model.add_design_var('area2', lower=2.0, upper=2.1) model.add_design_var('mat1', lower=1, upper=4) model.add_design_var('mat2', lower=1, upper=4) model.add_design_var('mat3', lower=1, upper=4) model.add_objective('weighted') prob.driver = om.SimpleGADriver() prob.driver.options['bits'] = {'area1': 6, 'area2': 6} prob.driver.options['max_gen'] = 75 prob.driver._randomstate = 1 prob.setup() prob['area3'] = 0.0005 prob.run_driver() # Note, GA doesn't do so well with the continuous vars, naturally, so we reduce the space # as much as we can. Objective is still rather random, but it is close. GA does a great job # of picking the correct values for the integer desvars though. self.assertLess(prob['mass'], 6.0) assert_rel_error(self, prob['mat1'], 3, 1e-5) assert_rel_error(self, prob['mat2'], 3, 1e-5)
def test_constrained_without_penalty(self): class Cylinder(om.ExplicitComponent): """Main class""" def setup(self): self.add_input('radius', val=1.0) self.add_input('height', val=1.0) self.add_output('Area', val=1.0) self.add_output('Volume', val=1.0) def compute(self, inputs, outputs): radius = inputs['radius'] height = inputs['height'] area = height * radius * 2 * 3.14 + 3.14 * radius ** 2 * 2 volume = 3.14 * radius ** 2 * height outputs['Area'] = area outputs['Volume'] = volume prob = om.Problem() prob.model.add_subsystem('cylinder', Cylinder(), promotes=['*']) indeps = prob.model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*']) indeps.add_output('radius', 2.) # height indeps.add_output('height', 3.) # radius # setup the optimization driver = prob.driver = om.SimpleGADriver() prob.driver.options['penalty_parameter'] = 0. # no penalty, same as unconstrained prob.driver.options['penalty_exponent'] = 1. prob.driver.options['max_gen'] = 50 prob.driver.options['bits'] = {'radius': 8, 'height': 8} prob.model.add_design_var('radius', lower=0.5, upper=5.) prob.model.add_design_var('height', lower=0.5, upper=5.) prob.model.add_objective('Area') prob.model.add_constraint('Volume', lower=10.) prob.setup() prob.run_driver() if extra_prints: print('radius', prob['radius']) # exact solution is (5/pi)^(1/3) ~= 1.167 print('height', prob['height']) # exact solution is 2*radius print('Area', prob['Area']) print('Volume', prob['Volume']) # should be around 10 self.assertTrue(driver.supports["equality_constraints"], True) self.assertTrue(driver.supports["inequality_constraints"], True) # it is going to the unconstrained optimum self.assertAlmostEqual(prob['radius'], 0.5, 1) self.assertAlmostEqual(prob['height'], 0.5, 1)
def test_simple_test_func(self): class MyComp(om.ExplicitComponent): def setup(self): self.add_input('x', np.zeros((2, ))) self.add_output('a', 0.0) self.add_output('b', 0.0) self.add_output('c', 0.0) self.add_output('d', 0.0) def compute(self, inputs, outputs): x = inputs['x'] outputs['a'] = (2.0*x[0] - 3.0*x[1])**2 outputs['b'] = 18.0 - 32.0*x[0] + 12.0*x[0]**2 + 48.0*x[1] - 36.0*x[0]*x[1] + 27.0*x[1]**2 outputs['c'] = (x[0] + x[1] + 1.0)**2 outputs['d'] = 19.0 - 14.0*x[0] + 3.0*x[0]**2 - 14.0*x[1] + 6.0*x[0]*x[1] + 3.0*x[1]**2 prob = om.Problem() model = prob.model model.add_subsystem('px', om.IndepVarComp('x', np.array([0.2, -0.2]))) model.add_subsystem('comp', MyComp()) model.add_subsystem('obj', om.ExecComp('f=(30 + a*b)*(1 + c*d)')) model.connect('px.x', 'comp.x') model.connect('comp.a', 'obj.a') model.connect('comp.b', 'obj.b') model.connect('comp.c', 'obj.c') model.connect('comp.d', 'obj.d') # Played with bounds so we don't get subtractive cancellation of tiny numbers. model.add_design_var('px.x', lower=np.array([0.2, -1.0]), upper=np.array([1.0, -0.2])) model.add_objective('obj.f') prob.driver = om.SimpleGADriver() prob.driver.options['bits'] = {'px.x': 16} prob.driver.options['max_gen'] = 75 prob.driver._randomstate = 11 prob.setup() prob.run_driver() if extra_prints: print('obj.f', prob['obj.f']) print('px.x', prob['px.x']) # TODO: Satadru listed this solution, but I get a way better one. # Solution: xopt = [0.2857, -0.8571], fopt = 23.2933 assert_rel_error(self, prob['obj.f'], 12.37306086, 1e-4) assert_rel_error(self, prob['px.x'][0], 0.2, 1e-4) assert_rel_error(self, prob['px.x'][1], -0.88653391, 1e-4)
def test_constrained_with_penalty(self): import openmdao.api as om class Cylinder(om.ExplicitComponent): """Main class""" def setup(self): self.add_input('radius', val=1.0) self.add_input('height', val=1.0) self.add_output('Area', val=1.0) self.add_output('Volume', val=1.0) def compute(self, inputs, outputs): radius = inputs['radius'] height = inputs['height'] area = height * radius * 2 * 3.14 + 3.14 * radius**2 * 2 volume = 3.14 * radius**2 * height outputs['Area'] = area outputs['Volume'] = volume prob = om.Problem() prob.model.add_subsystem('cylinder', Cylinder(), promotes=['*']) indeps = prob.model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*']) indeps.add_output('radius', 2.) # height indeps.add_output('height', 3.) # radius # setup the optimization prob.driver = om.SimpleGADriver() prob.driver.options['penalty_parameter'] = 3. prob.driver.options['penalty_exponent'] = 1. prob.driver.options['max_gen'] = 50 prob.driver.options['bits'] = {'radius': 8, 'height': 8} prob.model.add_design_var('radius', lower=0.5, upper=5.) prob.model.add_design_var('height', lower=0.5, upper=5.) prob.model.add_objective('Area') prob.model.add_constraint('Volume', lower=10.) prob.setup() prob.run_driver() # These go to 0.5 for unconstrained problem. With constraint and penalty, they # will be above 1.0 (actual values will vary.) self.assertGreater(prob['radius'], 1.) self.assertGreater(prob['height'], 1.)
def benchmark_genetic_4(self): prob = om.Problem() prob.model = GAGroup() driver = prob.driver = om.SimpleGADriver() driver.options['max_gen'] = MAXGEN driver.options['pop_size'] = POPSIZE driver.options['run_parallel'] = True prob.setup() t0 = time() prob.run_driver() print('Elapsed Time', time() - t0)
def test_indivisible_error(self): prob = om.Problem() model = prob.model model.add_subsystem('par', om.ParallelGroup()) prob.driver = om.SimpleGADriver() prob.driver.options['run_parallel'] = True prob.driver.options['procs_per_model'] = 3 with self.assertRaises(RuntimeError) as context: prob.setup() self.assertEqual(str(context.exception), "The total number of processors is not evenly divisible by the " "specified number of processors per model.\n Provide a number of " "processors that is a multiple of 3, or specify a number " "of processors per model that divides into 4.")
def test_driver_options(self): """Tests if Pm and Pc options can be set.""" prob = om.Problem() model = prob.model indeps = model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*']) indeps.add_output('x', 1.) model.add_subsystem('model', om.ExecComp('y=x**2'), promotes=['*']) driver = prob.driver = om.SimpleGADriver() driver.options['Pm'] = 0.1 driver.options['Pc'] = 0.01 driver.options['max_gen'] = 5 driver.options['bits'] = {'x': 8} prob.model.add_design_var('x', lower=-10., upper=10.) prob.model.add_objective('y') prob.setup() prob.run_driver() self.assertEqual(driver.options['Pm'], 0.1) self.assertEqual(driver.options['Pc'], 0.01)
def test_option_procs_per_model(self): import openmdao.api as om from openmdao.test_suite.components.branin import Branin prob = om.Problem() model = prob.model model.add_subsystem('p1', om.IndepVarComp('xC', 7.5)) model.add_subsystem('p2', om.IndepVarComp('xI', 0.0)) par = model.add_subsystem('par', om.ParallelGroup()) par.add_subsystem('comp1', Branin()) par.add_subsystem('comp2', Branin()) model.connect('p2.xI', 'par.comp1.x0') model.connect('p1.xC', 'par.comp1.x1') model.connect('p2.xI', 'par.comp2.x0') model.connect('p1.xC', 'par.comp2.x1') model.add_subsystem('comp', om.ExecComp('f = f1 + f2')) model.connect('par.comp1.f', 'comp.f1') model.connect('par.comp2.f', 'comp.f2') model.add_design_var('p2.xI', lower=-5.0, upper=10.0) model.add_design_var('p1.xC', lower=0.0, upper=15.0) model.add_objective('comp.f') prob.driver = om.SimpleGADriver() prob.driver.options['bits'] = {'p1.xC': 8} prob.driver.options['max_gen'] = 10 prob.driver.options['pop_size'] = 25 prob.driver.options['run_parallel'] = True prob.driver.options['procs_per_model'] = 2 prob.driver._randomstate = 1 prob.setup() prob.run_driver() # Optimal solution if extra_prints: print('comp.f', prob['comp.f']) print('p2.xI', prob['p2.xI']) print('p1.xC', prob['p1.xC'])
def test_two_branin_parallel_model(self): prob = om.Problem() model = prob.model model.add_subsystem('p1', om.IndepVarComp('xC', 7.5)) model.add_subsystem('p2', om.IndepVarComp('xI', 0.0)) par = model.add_subsystem('par', om.ParallelGroup()) par.add_subsystem('comp1', Branin()) par.add_subsystem('comp2', Branin()) model.connect('p2.xI', 'par.comp1.x0') model.connect('p1.xC', 'par.comp1.x1') model.connect('p2.xI', 'par.comp2.x0') model.connect('p1.xC', 'par.comp2.x1') model.add_subsystem('comp', om.ExecComp('f = f1 + f2')) model.connect('par.comp1.f', 'comp.f1') model.connect('par.comp2.f', 'comp.f2') model.add_design_var('p2.xI', lower=-5.0, upper=10.0) model.add_design_var('p1.xC', lower=0.0, upper=15.0) model.add_objective('comp.f') prob.driver = om.SimpleGADriver() prob.driver.options['bits'] = {'p1.xC': 8} prob.driver.options['max_gen'] = 40 prob.driver.options['pop_size'] = 25 prob.driver.options['run_parallel'] = False prob.driver.options['procs_per_model'] = 2 prob.driver._randomstate = 1 prob.setup() prob.run_driver() if extra_prints: print('comp.f', prob['comp.f']) print('p2.xI', prob['p2.xI']) # Optimal solution assert_rel_error(self, prob['comp.f'], 0.98799098, 1e-4) self.assertTrue(int(prob['p2.xI']) in [3, -3])
def test_mpi_bug_solver(self): # This test verifies that mpi doesn't hang due to collective calls in the solver. prob = om.Problem() prob.model = SellarMDA() prob.model.add_design_var('x', lower=0, upper=10) prob.model.add_design_var('z', lower=0, upper=10) prob.model.add_objective('obj') prob.driver = om.SimpleGADriver(run_parallel=True) # Set these low because we don't need to run long. prob.driver.options['max_gen'] = 2 prob.driver.options['pop_size'] = 5 prob.setup() prob.set_solver_print(level=0) prob.run_driver()
def test_SimpleGADriver_missing_objective(self): prob = om.Problem() model = prob.model model.add_subsystem('x', om.IndepVarComp('x', 2.0), promotes=['*']) model.add_subsystem('f_x', Paraboloid(), promotes=['*']) prob.driver = om.SimpleGADriver() prob.model.add_design_var('x', lower=0) prob.model.add_constraint('x', lower=0) prob.setup() with self.assertRaises(Exception) as raises_msg: prob.run_driver() exception = raises_msg.exception msg = "Driver requires objective to be declared" self.assertEqual(exception.args[0], msg)
def solve(dim=2, bits=31, n_nan_points=100, nan_range=5e-2, plot=False): """Solve a modified Rosenbrock optimization problem using a genetic algorithm and a specified number of bits for x. Parameters ---------- dim : int Dimensionality of the Rosenbrock problem. Defaults is 2. bits : int Number of bits to use to encode each dimension of the design variable, x. Note: Values of bits > 31 result in exceptions due to Numpy's integer representation as 32-bit integers. n_nan_points : int Number of regions where the Rosenbrock function is NaN to insert at random per dimension. Default is 100. nan_range : float Distance from NaN points at which function is considered NaN. Default is 1e4. plot : bool True if a contour plot should be made. Only matters if dim == 2. Returns ------- x : numpy.ndarray Solution vector f : float Value of Rosenbrock at x dt : float Wall-clock time it took to perform the optimization in seconds """ nan_points = [] while len(nan_points) < n_nan_points * dim: nan_point = -2. + np.random.rand(dim) * 4. if np.linalg.norm(nan_point - np.ones(dim)) > nan_range: nan_points += [nan_point] x0 = -2 + np.random.rand(dim) * 4. prob = om.Problem() prob.model.add_subsystem('coor', om.IndepVarComp('x', x0), promotes=['*']) prob.model.add_subsystem('obj', Rosen(dim=dim, nan_points=nan_points, nan_range=nan_range), promotes=['*']) prob.model.add_design_var('x', lower=-2, upper=2) prob.model.add_objective('f') prob.driver = om.SimpleGADriver(bits={'x': bits}, run_parallel=run_parallel) # prob.model.approx_totals() # prob.driver = om.ScipyOptimizeDriver(optimizer='SLSQP', debug_print=['objs', 'desvars'], disp=True) prob.set_solver_print(2) prob.setup() prob.run_model() t0 = time.time() prob.run_driver() dt = time.time() - t0 res = [np.copy(prob['x']), np.copy(prob['f'])[0], dt, None, None, None] if plot and dim == 2 and rank == 0: prob.model.obj.options['sleep_time'] = 0. n_contour = 100 x = np.linspace(-2, 2, n_contour) x, y = np.meshgrid(x, x) f = np.zeros_like(x) for i in range(n_contour): for j in range(n_contour): prob['x'] = [x[i, j], y[i, j]] prob.run_model() f[i, j] = prob['f'][0] import matplotlib.pyplot as plt from matplotlib.colors import LogNorm fig, ax = plt.subplots() cs = ax.contourf(x, y, f, levels=np.logspace(-1, np.log10(3000)), norm=LogNorm()) ax.plot([x0[0], res[0][0], 1], [x0[1], res[0][1], 1], 'ro-') res[3:] = [fig, ax, cs] prob.cleanup() return tuple(res)
def test_multi_obj(self): class Box(om.ExplicitComponent): def setup(self): self.add_input('length', val=1.) self.add_input('width', val=1.) self.add_input('height', val=1.) self.add_output('front_area', val=1.0) self.add_output('top_area', val=1.0) self.add_output('area', val=1.0) self.add_output('volume', val=1.) def compute(self, inputs, outputs): length = inputs['length'] width = inputs['width'] height = inputs['height'] outputs['top_area'] = length * width outputs['front_area'] = length * height outputs[ 'area'] = 2 * length * height + 2 * length * width + 2 * height * width outputs['volume'] = length * height * width prob = om.Problem() prob.model.add_subsystem('box', Box(), promotes=['*']) indeps = prob.model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*']) indeps.add_output('length', 1.5) indeps.add_output('width', 1.5) indeps.add_output('height', 1.5) # setup the optimization prob.driver = om.SimpleGADriver() prob.driver.options['max_gen'] = 100 prob.driver.options['bits'] = {'length': 8, 'width': 8, 'height': 8} prob.driver.options['multi_obj_exponent'] = 1. prob.driver.options['penalty_parameter'] = 10. prob.driver.options['multi_obj_weights'] = { 'box.front_area': 0.1, 'box.top_area': 0.9 } prob.driver.options['multi_obj_exponent'] = 1 prob.model.add_design_var('length', lower=0.1, upper=2.) prob.model.add_design_var('width', lower=0.1, upper=2.) prob.model.add_design_var('height', lower=0.1, upper=2.) prob.model.add_objective('front_area', scaler=-1) # maximize prob.model.add_objective('top_area', scaler=-1) # maximize prob.model.add_constraint('volume', upper=1.) # run #1 prob.setup() prob.run_driver() front = prob['front_area'] top = prob['top_area'] l1 = prob['length'] w1 = prob['width'] h1 = prob['height'] print('Box dims: ', l1, w1, h1) print('Front and top area: ', front, top) print('Volume: ', prob['volume']) # should be around 1 # run #2 # weights changed prob2 = om.Problem() prob2.model.add_subsystem('box', Box(), promotes=['*']) indeps2 = prob2.model.add_subsystem('indeps', om.IndepVarComp(), promotes=['*']) indeps2.add_output('length', 1.5) indeps2.add_output('width', 1.5) indeps2.add_output('height', 1.5) # setup the optimization prob2.driver = om.SimpleGADriver() prob2.driver.options['max_gen'] = 100 prob2.driver.options['bits'] = {'length': 8, 'width': 8, 'height': 8} prob2.driver.options['multi_obj_exponent'] = 1. prob2.driver.options['penalty_parameter'] = 10. prob2.driver.options['multi_obj_weights'] = { 'box.front_area': 0.9, 'box.top_area': 0.1 } prob2.driver.options['multi_obj_exponent'] = 1 prob2.model.add_design_var('length', lower=0.1, upper=2.) prob2.model.add_design_var('width', lower=0.1, upper=2.) prob2.model.add_design_var('height', lower=0.1, upper=2.) prob2.model.add_objective('front_area', scaler=-1) # maximize prob2.model.add_objective('top_area', scaler=-1) # maximize prob2.model.add_constraint('volume', upper=1.) # run #1 prob2.setup() prob2.run_driver() front2 = prob2['front_area'] top2 = prob2['top_area'] l2 = prob2['length'] w2 = prob2['width'] h2 = prob2['height'] print('Box dims: ', l2, w2, h2) print('Front and top area: ', front2, top2) print('Volume: ', prob['volume']) # should be around 1 self.assertGreater(w1, w2) # front area does not depend on width self.assertGreater(h2, h1) # top area does not depend on height
#model.add_constraint('tMain', lower=-40.0, upper = 85.0) """ #run the ExternalCode Component once and record initial values prob.setup(check=True) """ prob.run_model() tBat_c1 = prob['tBat_c'] tBat_h1 = prob['tBat_h'] tProp_c1 = prob['tProp_c'] tProp_h1 = prob['tProp_h'] tMain_c1 = prob['tMain_c'] tMain_h1 = prob['tMain_h'] """ # find optimal solution with simple GA driver prob.driver = om.SimpleGADriver() prob.driver.options['bits'] = {'length':5, 'eps':6, 'r_bat': 3, 'R_m': 5, 'R_p': 5, 'R_s':5} prob.driver.options['max_gen'] = 10 #prob.driver.options['run_parallel'] = 'true' prob.driver.options['debug_print'] = ['desvars'] prob.driver.add_recorder(om.SqliteRecorder("mdp_genopt.sql")) model.add_design_var('length', lower = 0.0, upper=0.254) model.add_design_var('eps', lower = 0.02, upper=0.8) model.add_design_var('r_bat', lower = 0.0, upper=1.0) model.add_design_var('R_m', lower = 1., upper=250.0) model.add_design_var('R_p', lower = 1., upper=250.0) model.add_design_var('R_s', lower = 1., upper=250.0) prob.model.add_objective('obj_p')
self.connect("dv_StaggerRow.stagger_row" , "Friction.stagger_row") self.connect("dv_afCol.af_col" , "Friction.af_col") self.connect("dv_afRow.af_row" , "Friction.af_row") self.connect("dv_aspect.aspect" , "Friction.aspect") # Connect AVL outputs to L2D calculation inputs self.connect("AVL.CDtot", "L2D.CD") self.connect("AVL.CLtot", "L2D.CL") self.connect("Friction.CDtotal", "L2D.CDf") # Iniatate the the OpenMDAO problem openMDAOProblem = Problem() openMDAOProblem.model = MaxLtoD() # Set design driver parameters openMDAOProblem.driver = om.SimpleGADriver() # openMDAOProblem.driver.options['bits'] = {'dvStagger.stagger': 8, # 'dvStaggerRow.stagger_row': 8, # 'dvGap.gap': 8,} openMDAOProblem.driver.options['max_gen'] = 10 openMDAOProblem.driver.options['pop_size'] = 50 openMDAOProblem.driver.options['run_parallel'] = True openMDAOProblem.driver.options['procs_per_model'] = 2 openMDAOProblem.driver.options['debug_print'] = ['desvars', 'objs', 'totals'] openMDAOProblem.model.add_design_var("dv_Gap.gap", lower=0.5, upper=5.0) # Geometry design values openMDAOProblem.model.add_design_var("dv_Stagger.stagger", lower=0.5, upper=5.0) # Geometry design values openMDAOProblem.model.add_design_var("dv_StaggerRow.stagger_row", lower=0.0, upper=5.0) openMDAOProblem.model.add_design_var("dv_afCol.af_col", lower=1.0, upper=5.0) openMDAOProblem.model.add_design_var("dv_afRow.af_row", lower=1.0, upper=5.0) openMDAOProblem.model.add_design_var("dv_aspect.aspect", lower=5.0, upper=10.0)