def test_2_nested_drivers_same_assembly(self):
print "*** test_2_nested_drivers_same_assembly ***"
#
# Solve (x-3)^2 + xy + (y+4)^2 = 3
# using two optimizers nested. The inner loop optimizes y
# the outer loop takes care of x
#
# Optimal solution: x = 6.6667; y = -7.3333
top = set_as_top(Assembly())
# create the outer driver
outer_driver = top.add('driver', CONMINdriver())
# create the inner driver
inner_driver = top.add('driver1', CONMINdriver())
top.add('comp1', ExprComp(expr='x-3'))
top.add('comp2', ExprComp(expr='-3'))
top.add('comp3', ExprComp2(expr='x*x + (x+3)*y + (y+4)**2'))
top.add('comp4', ExprComp2(expr='x+y'))
top.comp1.x = 50
top.comp3.y = -50
# Hook stuff up
top.connect('comp1.f_x', 'comp3.x')
top.connect('comp3.f_xy', 'comp4.y')
top.connect('comp2.f_x', 'comp4.x')
# Driver process definition
outer_driver.workflow.add('driver1')
inner_driver.workflow.add(['comp1','comp2','comp3','comp4'])
inner_driver.itmax = 30
inner_driver.fdch = .000001
inner_driver.fdchm = .000001
inner_driver.add_objective('comp3.f_xy')
inner_driver.add_parameter('comp3.y', low=-50, high=50)
outer_driver.itmax = 30
outer_driver.fdch = .000001
outer_driver.fdchm = .000001
outer_driver.add_objective('comp4.f_xy')
outer_driver.add_parameter('comp1.x', low=-50, high=50)
top.run()
# Notes: CONMIN does not quite reach the anlytical minimum
# In fact, it only gets to about 2 places of accuracy.
# This is also the case for a single 2-var problem.
self.assertAlmostEqual(top.comp1.x, 6.66667, places=4)
self.assertAlmostEqual(top.comp3.y, -7.33333, places=4)
# test dumping of iteration tree
stream = StringIO()
dump_iteration_tree(top, full=False, f=stream, tabsize=3)
s = stream.getvalue()
s = s.replace('comp2', 'comp2or3')
s = s.replace('comp3', 'comp2or3')
self.assertEqual(s,
'\n driver\n driver1\n comp1\n comp2or3\n'
' comp2or3\n comp4\n')
def setUp(self):
self.top = set_as_top(Assembly())
self.top.add('driver', CONMINdriver())
self.top.add('comp', OptRosenSuzukiComponent())
self.top.driver.workflow.add('comp')
self.top.driver.iprint = 0
self.top.driver.itmax = 30
def test_2_drivers(self):
print "*** test_2_drivers ***"
self.rosen_setUp()
drv = self.top.add('driver1a', CONMINdriver())
self.top.add('comp1a', ExprComp(expr='x**2'))
self.top.add('comp2a', ExprComp(expr='x-5.0*sqrt(x)'))
self.top.connect('comp1a.f_x', 'comp2a.x')
self.top.driver.workflow.add('driver1a')
drv.workflow.add(['comp1a', 'comp2a'])
drv.itmax = 40
# Note, this is a bad test for our gradient stuff. It has 2 local
# minima, and pretty much requires forward or backward difference
# to reach one of them if you start at 0.0. Still, it works. -- KTM
drv.add_objective('comp2a.f_x')
drv.add_parameter('comp1a.x', low=0, high=99)
self.top.run()
assert_rel_error(self, self.opt_objective,
self.top.driver1.eval_objective(), 0.01)
self.assertAlmostEqual(self.opt_design_vars[0],
self.top.comp1.x,
places=1)
assert_rel_error(self, self.opt_design_vars[1], self.top.comp2.x, 0.01)
assert_rel_error(self, self.opt_design_vars[2], self.top.comp3.x, 0.01)
assert_rel_error(self, self.opt_design_vars[3], self.top.comp4.x, 0.01)
self.assertAlmostEqual(-6.2498054387439232,
self.top.driver1a.eval_objective(),
places=2)
self.assertAlmostEqual(2.4860514783551508, self.top.comp1a.x, places=1)
def test_2_drivers(self):
print "*** test_2_drivers ***"
self.rosen_setUp()
drv = self.top.add('driver1a', CONMINdriver())
self.top.add('comp1a', ExprComp(expr='x**2'))
self.top.add('comp2a', ExprComp(expr='x-5.0*sqrt(x)'))
self.top.connect('comp1a.f_x', 'comp2a.x')
self.top.driver.workflow.add('driver1a')
drv.workflow.add(['comp1a', 'comp2a'])
drv.itmax = 40
drv.add_objective('comp2a.f_x')
drv.add_parameter('comp1a.x', low=0, high=99)
self.top.run()
self.assertAlmostEqual(self.opt_objective,
self.top.driver1.eval_objective(),
places=2)
self.assertAlmostEqual(self.opt_design_vars[0],
self.top.comp1.x,
places=1)
assert_rel_error(self, self.opt_design_vars[1], self.top.comp2.x, 0.01)
assert_rel_error(self, self.opt_design_vars[2], self.top.comp3.x, 0.01)
self.assertAlmostEqual(self.opt_design_vars[3],
self.top.comp4.x,
places=1)
self.assertAlmostEqual(-6.2498054387439232,
self.top.driver1a.eval_objective(),
places=2)
self.assertAlmostEqual(2.4860514783551508, self.top.comp1a.x, places=1)
def setUp(self):
self.top = set_as_top(Assembly())
self.top.add('comp', OptRosenSuzukiComponent())
driver = self.top.add('driver', CONMINdriver())
driver.workflow.add('comp')
driver.iprint = 0
driver.itmax = 30
driver.add_objective('10*comp.result')
driver.add_parameter('comp.x')
def __init__(self):
super(TestAssembly,self).__init__()
self.add('dummy_top',TestContainer())
self.add('comp',TestComponent())
self.add('driver', CONMINdriver())
self.driver.workflow.add(['comp'])
#self.driver.iprint = 4 #debug verbosity
self.driver.add_objective('comp.x')
self.driver.add_parameter('comp.dummy_data.dummy1',low= -10.0 , high= 10.0)
def configure(self):
self.add('dummy_top', TestContainer())
self.add('comp', TestComponent())
self.add('driver', CONMINdriver())
self.driver.workflow.add(['comp'])
#self.driver.iprint = 4 #debug verbosity
self.driver.add_objective('comp.x')
self.driver.add_parameter('comp.dummy_data.dummy1',
low=-10.0,
high=10.0)
def setUp(self):
self.top = set_as_top(Assembly())
self.top.add('comp', RosenSuzukiMixed())
driver = self.top.add('driver', CONMINdriver())
driver.workflow.add('comp')
driver.iprint = 0
driver.itmax = 30
driver.add_objective('10*comp.result')
map(driver.add_parameter, ['comp.x0', 'comp.x12', 'comp.x3'])
# pylint: disable-msg=C0301
map(driver.add_constraint, [
'comp.x0**2+comp.x0+comp.x12[0]**2-comp.x12[0]+comp.x12[1]**2+comp.x12[1]+comp.x3**2-comp.x3 < 8',
'comp.x0**2-comp.x0+2*comp.x12[0]**2+comp.x12[1]**2+2*comp.x3**2-comp.x3 < 10',
'2*comp.x0**2+2*comp.x0+comp.x12[0]**2-comp.x12[0]+comp.x12[1]**2-comp.x3 < 5'
])
def setUp(self):
self.top = set_as_top(Assembly())
self.top.add('comp', RosenSuzuki2D())
driver = self.top.add('driver', CONMINdriver())
driver.workflow.add('comp')
driver.iprint = 0
driver.itmax = 30
driver.add_objective('10*comp.result')
driver.add_parameter('comp.x')
# pylint: disable=C0301
map(driver.add_constraint, [
'comp.x[0][0]**2+comp.x[0][0]+comp.x[0][1]**2-comp.x[0][1]+comp.x[1][0]**2+comp.x[1][0]+comp.x[1][1]**2-comp.x[1][1] < 8',
'comp.x[0][0]**2-comp.x[0][0]+2*comp.x[0][1]**2+comp.x[1][0]**2+2*comp.x[1][1]**2-comp.x[1][1] < 10',
'2*comp.x[0][0]**2+2*comp.x[0][0]+comp.x[0][1]**2-comp.x[0][1]+comp.x[1][0]**2-comp.x[1][1] < 5'
])
def rosen_setUp(self):
# Chop up the equations for the Rosen-Suzuki optimization problem
# into 4 ExprComp components and some Adders so that our driver
# will iterate over more than one compnent
top = set_as_top(Assembly())
self.top = top
# create the first driver
drv = top.add('driver1', CONMINdriver())
top.add('comp1', ExprComp(expr='x**2 - 5.0*x'))
top.add('comp2', ExprComp(expr='x**2 - 5.0*x'))
top.add('comp3', ExprComp(expr='2.0*x**2 - 21.0*x'))
top.add('comp4', ExprComp(expr='x**2 + 7.0*x'))
top.add('adder1', Adder())
top.add('adder2', Adder())
top.add('adder3', Adder())
top.connect('comp1.f_x', 'adder1.x1')
top.connect('comp2.f_x', 'adder1.x2')
top.connect('comp3.f_x', 'adder2.x1')
top.connect('comp4.f_x', 'adder2.x2')
top.connect('adder1.sum', 'adder3.x1')
top.connect('adder2.sum', 'adder3.x2')
top.driver.workflow.add('driver1')
drv.workflow.add(
['comp1', 'comp2', 'comp3', 'comp4', 'adder1', 'adder2', 'adder3'])
drv.itmax = 30
#drv.conmin_diff = True
drv.add_objective('adder3.sum+50.')
drv.add_parameter('comp1.x', -10., 99.)
drv.add_parameter('comp2.x', -10., 99.)
drv.add_parameter('comp3.x', -10., 99.)
drv.add_parameter('comp4.x', -10., 99.)
map(drv.add_constraint, [
'comp1.x**2 + comp2.x**2 + comp3.x**2 + comp4.x**2 + comp1.x-comp2.x+comp3.x-comp4.x < 8.0',
'comp1.x**2 + 2.*comp2.x**2 + comp3.x**2 + 2.*comp4.x**2 - comp1.x - comp4.x < 10.',
'2.0*comp1.x**2 + comp2.x**2 + comp3.x**2 + 2.0*comp1.x - comp2.x - comp4.x < 5.0',
])
# expected optimal values
self.opt_objective = 6.
self.opt_design_vars = [0., 1., 2., -1.]
def configure(self):
""" Configure a simple DOE to set start points for CONMIN. """
self.add('gp_fun', GoldsteinPrice())
conmin = self.add('conmin', CONMINdriver())
conmin.workflow.add('gp_fun')
conmin.add_parameter('gp_fun.x1')
conmin.add_parameter('gp_fun.x2')
conmin.add_objective('gp_fun.f')
doe = self.add('driver', DOEdriver())
doe.workflow.add('conmin')
doe.add_parameter('gp_fun.x1', low=-1.5, high=1.5, start=1)
doe.add_parameter('gp_fun.x2', low=-1.5, high=1.5, start=1)
doe.DOEgenerator = FullFactorial(5)
doe.add_responses(
['gp_fun.f', 'gp_fun.x1', 'gp_fun.x2', 'gp_fun.exec_count'])
self.recorders = [CSVCaseRecorder(), DumpCaseRecorder()]
def configure(self):
self.add('driver', CONMINdriver())
self.add('preproc', PreProc())
self.add('comp', OptRosenSuzukiComponent())
self.add('postproc', PostProc())
self.driver.workflow.add(('preproc', 'comp', 'postproc'))
self.driver.iprint = 0
self.driver.itmax = 30
self.connect('preproc.x_out', 'comp.x')
self.connect('comp.result', 'postproc.result_in')
self.driver.add_objective('postproc.result_out')
self.driver.add_parameter(('preproc.x_in[0]', 'preproc.x_in[1]',
'preproc.x_in[2]', 'preproc.x_in[3]'))
# pylint: disable=C0301
map(self.driver.add_constraint, [
'comp.x[0]**2+comp.x[0]+comp.x[1]**2-comp.x[1]+comp.x[2]**2+comp.x[2]+comp.x[3]**2-comp.x[3] < 8',
'comp.x[0]**2-comp.x[0]+2*comp.x[1]**2+comp.x[2]**2+2*comp.x[3]**2-comp.x[3] < 10',
'2*comp.x[0]**2+2*comp.x[0]+comp.x[1]**2-comp.x[1]+comp.x[2]**2-comp.x[3] < 5'])
self.recorders = [ListCaseRecorder()]
def test_initial_run(self):
# Test the fix that put run_iteration at the top
# of the start_iteration method
class MyComp(Component):
x = Float(0.0, iotype='in', low=-10, high=10)
xx = Float(0.0, iotype='in', low=-10, high=10)
f_x = Float(iotype='out')
y = Float(iotype='out')
def execute(self):
if self.xx != 1.0:
self.raise_exception("Lazy", RuntimeError)
self.f_x = 2.0 * self.x
self.y = self.x
@add_delegate(HasParameters)
class SpecialDriver(Driver):
implements(IHasParameters)
def execute(self):
self.set_parameters([1.0])
top = set_as_top(Assembly())
top.add('comp', MyComp())
top.add('driver', CONMINdriver())
top.add('subdriver', SpecialDriver())
top.driver.workflow.add('subdriver')
top.subdriver.workflow.add('comp')
top.subdriver.add_parameter('comp.xx')
top.driver.add_parameter('comp.x')
top.driver.add_constraint('comp.y > 1.0')
top.driver.add_objective('comp.f_x')
top.run()
def test_2_nested_assemblies(self):
print "*** test_2_nested_assemblies ***"
#
# Solve (x-3)^2 + xy + (y+4)^2 = 3
# using two optimizers nested. The inner loop optimizes y
# the outer loop takes care of x
# Enough components created to assure that the optimizers don't "touch"
#
# Optimal solution: x = 6.6667; y = -7.3333
self.top = set_as_top(Assembly())
# create the outer driver
outer_driver = self.top.add('driver', CONMINdriver())
nested = self.top.add('nested', Assembly())
# create the inner driver
inner_driver = nested.add('driver', CONMINdriver())
#inner_driver = nested.driver
nested.add('comp1', ExprComp(expr='x-3'))
nested.add('comp2', ExprComp(expr='-3'))
nested.add('comp3', ExprComp2(expr='x*x + (x+3)*y + (y+4)**2'))
nested.add('comp4', ExprComp2(expr='x+y'))
nested.comp1.x = 50
nested.comp3.y = -50
# Hook stuff up
nested.connect('comp1.f_x', 'comp3.x')
nested.connect('comp3.f_xy', 'comp4.y')
nested.connect('comp2.f_x', 'comp4.x')
nested.create_passthrough('comp1.x')
nested.create_passthrough('comp4.f_xy')
outer_driver.workflow.add('nested')
inner_driver.workflow.add(['comp1', 'comp2', 'comp3', 'comp4'])
inner_driver.itmax = 30
inner_driver.fdch = .000001
inner_driver.fdchm = .000001
#inner_driver.conmin_diff = True
inner_driver.add_objective('comp3.f_xy')
inner_driver.add_parameter('comp3.y', low=-50, high=50)
outer_driver.itmax = 30
outer_driver.fdch = .000001
outer_driver.fdchm = .000001
outer_driver.conmin_diff = True
outer_driver.add_objective('nested.f_xy') # comp4.f_xy passthrough
outer_driver.add_parameter('nested.x', low=-50,
high=50) # comp1.x passthrough
self.top.run()
# Notes: CONMIN does not quite reach the analytical minimum
# In fact, it only gets to about 2 places of accuracy.
# This is also the case for a single 2-var problem.
self.assertAlmostEqual(nested.x, 6.66667, places=4)
self.assertAlmostEqual(nested.comp3.y, -7.33333, places=4)
# test dumping of iteration tree
stream = StringIO()
dump_iteration_tree(self.top, full=False, f=stream, tabsize=3)
s = stream.getvalue()
# Comp2 and Comp3 are ambiguous in the sort
s = s.replace('comp2', 'comp2or3')
s = s.replace('comp3', 'comp2or3')
self.assertEqual(
s, '\n driver\n nested\n driver\n '
'comp1\n comp2or3\n comp2or3\n'
' comp4\n')