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')