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)
