def test_basic_CONMIN(self):
try:
from pyopt_driver.pyopt_driver import pyOptDriver
except ImportError:
raise SkipTest("this test requires pyOpt to be installed")
self.top = OptimizationConstrained()
set_as_top(self.top)
try:
self.top.driver.optimizer = 'CONMIN'
self.top.driver.optimizer = 'COBYLA'
except ValueError:
raise SkipTest("CONMIN not present on this system")
self.top.driver.title = 'Little Test'
optdict = {}
self.top.driver.options = optdict
self.top.driver.pyopt_diff = True
self.top.run()
assert_rel_error(self, self.top.paraboloid.x, 7.175775, 0.01)
assert_rel_error(self, self.top.paraboloid.y, -7.824225, 0.01)
def test_in_assembly(self):
asm = self._get_assembly()
self.assertEqual(set(asm.list_connections()),
set([('metamodel.d', 'comp2.b'), ('metamodel.c', 'comp2.a'),
('comp1.c', 'metamodel.a'), ('comp1.d', 'metamodel.b')]))
# do some training
data = [1,2,3,4]
for a,b in zip(data[:-1],data[1:]):
asm.comp1.a = a
asm.comp1.b = b
asm.metamodel.train_next = 1
asm.run()
# now run and get some results
asm.comp1.a = 1.
asm.comp1.b = 2.
asm.run()
assert_rel_error(self, asm.comp2.c, 6, 0.02)
assert_rel_error(self, asm.comp2.d, -2, 0.02)
# set new model and verify disconnect
asm.metamodel.model = Simple2()
self.assertEqual(asm.list_connections(), [])
def test_parameter_groups(self):
self.top = set_as_top(Assembly())
exp1 = ['y = 2.0*x']
deriv1 = ['dy_dx = 2.0']
self.top.add('driver', Driv())
self.top.add('comp1', ExecCompWithDerivatives(exp1, deriv1))
self.top.add('comp2', ExecCompWithDerivatives(exp1, deriv1))
self.top.driver.workflow.add(['comp1', 'comp2'])
# Top driver setup
self.top.driver.differentiator = Analytic()
obj = 'comp1.y+comp2.y'
self.top.driver.add_parameter(['comp1.x', 'comp2.x'], low=-100., high=100., fd_step=.001)
self.top.driver.add_objective(obj)
self.top.comp1.x1 = 1.0
self.top.comp2.x2 = 1.0
self.top.run()
self.top.driver.differentiator.calc_gradient()
grad = self.top.driver.differentiator.get_gradient(obj)
assert_rel_error(self, grad[0], 4.0, .001)
def test_opt1(self):
self.top.driver.add_objective('comp.result')
self.top.driver.add_parameter('comp.x[0]', 0.0, 100.0,
fd_step = .00001)
self.top.driver.add_parameter('comp.x[1]', 0.0, 100.0,
fd_step = .00001)
map(self.top.driver.add_constraint,[
'2.0 * comp.x[0] - comp.x[1] - 1.0 > 0.0',
'comp.x[0] - 2.0 * comp.x[1] + 1.0 > 0.0',
'- comp.x[0]**2 + 2.0 * ( comp.x[0] + comp.x[1]) - 1.0 > 0.0'
])
self.top.run()
assert_rel_error(self,
self.top.driver.eval_objective(),
self.top.comp.opt_objective,
0.005)
self.assertAlmostEqual(self.top.comp.opt_design_vars[0],
self.top.comp.x[0], places=2)
self.assertAlmostEqual(self.top.comp.opt_design_vars[1],
self.top.comp.x[1], places=2)
def test_sellar_Newton_parallel(self):
top = set_as_top(SellarMDFwithDerivs())
top.replace('driver', NewtonSolver())
top.driver.add_parameter('C2.y1', low=-1e99, high=1e99)
top.driver.add_constraint('C1.y1 = C2.y1')
top.driver.add_parameter('C1.y2', low=-1.e99, high=1.e99)
top.driver.add_constraint('C2.y2 = C1.y2')
expected = {'C1.y1': 3.1598617768014536, 'C2.y2': 3.7551999159927316}
top.driver.iprint = 0
top.driver.max_iteration = 20
top.run()
# print top.C1.y1, top.C2.y1
# print top.C1.y2, top.C2.y2
# gather the values back to the rank 0 process and compare to expected
dist_answers = top._system.mpi.comm.gather(
[(k[0], v) for k, v in top._system.vec['u'].items()], root=0)
if self.comm.rank == 0:
for answers in dist_answers:
for name, val in answers:
if name in expected:
#print self.comm.rank, name, val[0]
assert_rel_error(self, val[0], expected[name], 0.001)
del expected[name]
if expected:
self.fail("not all expected values were found")
def test_varTree_on_boundary_subassenbly(self):
top = set_as_top(Assembly())
top.add('comp', AssemblyWithBoundryVarTree())
top.add('driver', SimpleDriver())
top.driver.workflow.add('comp')
top.driver.add_parameter('comp.ins.x1', low=-100, high=100)
top.driver.add_objective('comp.y')
top.run()
# check for invalidation problems
top.comp.ins.x1 = 123.4
top.comp.run()
self.assertEqual(top.comp.ins.x1, top.comp.comp1.ins.x1)
#print top.comp.driver.workflow.calc_gradient(['ins.x1'], ['y'], mode='fd')
inputs = ['comp.ins.x1',]
outputs = ['comp.y']
J_fd = top.driver.workflow.calc_gradient(inputs, outputs, mode='fd')
top.driver.workflow.config_changed()
J_forward = top.driver.workflow.calc_gradient(inputs, outputs, mode="forward")
top.driver.workflow.config_changed()
J_reverse = top.driver.workflow.calc_gradient(inputs, outputs, mode="adjoint")
assert_rel_error(self, linalg.norm(J_fd - J_forward), 0, .00001)
assert_rel_error(self, linalg.norm(J_fd - J_reverse), 0, .00001)
def test_chordProperties(self):
comp = ChordProperties()
comp.yN = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
dtype=np.float64)
comp.c = np.array([
0.2729, 1.3903, 1.1757, 1.0176, 0.8818, 0.7602, 0.6507, 0.5528,
0.4666, 0.3925
])
comp.d = np.array([
0.0843, 0.0780, 0.0718, 0.0655, 0.0592, 0.0530, 0.0477, 0.0431,
0.0384, 0.0338
])
comp.GWing = 1
comp.xtU = np.array([
0.0500, 0.1500, 0.1500, 0.1500, 0.1500, 0.1500, 0.1500, 0.1500,
0.1500, 0.1500
])
comp.run()
tol = 0.001
expected_mChord = [
0.018497, 0.167168, 0.133574, 0.110904, 0.092785, 0.077596,
0.064695, 0.053795, 0.044734, 0.037342
]
expected_xCGChord = [
0.37481, 0.29252, 0.29447, 0.29634, 0.29838, 0.30073, 0.30350,
0.30677, 0.31059, 0.31498
]
for i, (e_mChord, e_xCGChord) in enumerate(
zip(expected_mChord, expected_xCGChord)):
assert_rel_error(self, comp.mChord[i], e_mChord, tol)
assert_rel_error(self, comp.xCGChord[i], e_xCGChord, tol)
def test_splitterBPR(self):
comp = self.comp
comp.BPR = 2.2285
comp.MNexit1_des = 1.00
comp.MNexit2_des = 1.00
comp.design = True
comp.Fl_I = self.fs
comp.run()
self.check(comp)
#run off design
comp.run()
self.check(comp)
#try changing something
TOL = 0.001
comp.Fl_I.W *= .95
comp.run()
assert_rel_error(self,comp.Fl_O1.Mach, .76922 ,TOL)
assert_rel_error(self,comp.Fl_O2.Mach, .76922 ,TOL)
def test_splitterW(self):
comp = self.comp = set_as_top(splitter.SplitterW())
comp.W1_des = 1.08
comp.MNexit1_des = 1.00
comp.MNexit2_des = 1.00
comp.design = True
comp.Fl_I = self.fs
comp.run()
self.check(comp)
#run off design
comp.run()
self.check(comp)
#try changing something
TOL = 0.001
comp.Fl_I.W *= .95
comp.run()
assert_rel_error(self,comp.Fl_O1.Mach, .76922 ,TOL)
assert_rel_error(self,comp.Fl_O2.Mach, .76922 ,TOL)
def test_simple_array(self):
model = set_as_top(Assembly())
model.add('comp', SimpleCompArray())
model.driver.workflow.add('comp')
#model.driver.gradient_options.fd_form = 'complex_step'
model.run()
J = model.driver.workflow.calc_gradient(inputs=['comp.x'],
outputs=['comp.y'])
diff = abs(J - model.comp.J).max()
assert_rel_error(self, diff, 0.0, .0001)
self.assertTrue(J[0, 0] is not complex)
model.add('driver', SimpleDriver())
model.driver.add_parameter('comp.x', low=-10, high=10)
model.driver.add_objective('comp.y - comp.x')
model.run()
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(mode='fd')
diff = abs(J + eye(4) - model.comp.J).max()
assert_rel_error(self, diff, 0.0, .0001)
self.assertTrue(J[0, 0] is not complex)
def test_SolverCO2scalar(self):
sim = set_as_top(SolverCO2scalar())
sim.x = 1.0
sim.run()
J = sim.driver.calc_gradient()
assert_rel_error(self, J[0, 0], 2.0, .001)
def test_simple_float_subassy(self):
model = set_as_top(Assembly())
model.add('sub', Assembly())
model.sub.add('subsub', Assembly())
model.driver.workflow.add('sub')
model.sub.driver.workflow.add('subsub')
model.sub.subsub.add('comp', SimpleCompFloat())
model.sub.subsub.driver.workflow.add('comp')
model.sub.subsub.create_passthrough('comp.x')
model.sub.subsub.create_passthrough('comp.y')
model.sub.create_passthrough('subsub.x')
model.sub.create_passthrough('subsub.y')
model.driver.gradient_options.fd_form = 'complex_step'
model.driver.gradient_options.force_fd = True
model.run()
J = model.driver.workflow.calc_gradient(inputs=['sub.x'],
outputs=['sub.y'])
assert_rel_error(self, J[0, 0], 2.0, .000001)
self.assertTrue(model.sub.subsub.comp.x is not complex)
self.assertTrue(model.sub.subsub.comp.y is not complex)
def test_Abasic_SNOPT_derivatives_linear_constraints(self):
try:
from pyoptsparse import Optimization
except ImportError:
raise SkipTest("this test requires pyoptsparse to be installed")
self.top = OptimizationConstrainedDerivatives()
set_as_top(self.top)
try:
self.top.driver.optimizer = 'SNOPT'
except ValueError:
raise SkipTest("SNOPT not present on this system")
self.top.driver.title = 'Little Test with Gradient'
optdict = {}
self.top.driver.options = optdict
self.top.driver.clear_constraints()
self.top.driver.add_constraint('paraboloid.x-paraboloid.y >= 15.0')
self.top.driver.add_constraint('paraboloid.x > 7.1', linear=True)
self.top.run()
assert_rel_error(self, self.top.paraboloid.x, 7.175775, 0.01)
assert_rel_error(self, self.top.paraboloid.y, -7.824225, 0.01)
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 test_opt1_with_CONMIN_gradient_a(self):
# Scalar parameters, array constraint, CONMIN gradient.
# Note: all other tests use OpenMDAO gradient
self.top.driver.add_objective('10*comp.result')
self.top.driver.add_parameter('comp.x[0]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[1]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[2]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[3]', fd_step=.00001)
self.top.driver.add_constraint('comp.g <= 0')
self.top.driver.conmin_diff = True
self.top.run()
# pylint: disable-msg=E1101
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.01)
assert_rel_error(self, 1 + self.top.comp.opt_design_vars[0],
1 + self.top.comp.x[0], 0.05)
assert_rel_error(self, self.top.comp.opt_design_vars[1],
self.top.comp.x[1], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[2],
self.top.comp.x[2], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[3],
self.top.comp.x[3], 0.05)
def test_vartree_subassy_behavior(self):
class tree(VariableTree):
x = Float(3.0)
y = Float(4.0)
z = Float(5.0)
class MyComp(Component):
ins = VarTree(tree(), iotype='in')
outs = VarTree(tree(), iotype='out')
def execute(self):
self.outs = self.ins.copy()
self.outs.z = 2.0*self.ins.x
top = set_as_top(Assembly())
top.add('sub', Assembly())
top.driver.workflow.add('sub')
top.sub.add('comp1', MyComp())
top.sub.add('comp2', MyComp())
top.sub.driver.workflow.add(['comp1', 'comp2'])
top.sub.create_passthrough('comp1.ins')
top.sub.create_passthrough('comp1.outs')
top.sub.create_passthrough('comp2.outs', 'zzz')
top.sub.connect('ins.z', 'comp2.ins.x')
top.run()
J = top.driver.workflow.calc_gradient(['sub.ins.x'], ['sub.outs.z'])
assert_rel_error(self, J[0, 0], 2.0, .00001)
top.driver.workflow.config_changed()
J = top.driver.workflow.calc_gradient(['sub.ins.z'], ['sub.zzz.z'])
print J
def test_branch_output_in_opaque_system(self):
# This test replicates a bug where an interior output was missing in
# an opaque system.
top = set_as_top(Assembly())
top.add('nest', Assembly())
top.nest.add('comp1', ExecComp(['y=7.0*x1']))
top.nest.add('comp2', ExecComp(['y=5.0*x1 + 2.0*x2']))
top.driver.workflow.add(['nest'])
top.nest.driver.workflow.add(['comp1', 'comp2'])
top.nest.add('x1', Float(3.0, iotype='in'))
top.nest.add('y2', Float(3.0, iotype='out'))
top.nest.connect('comp1.y', 'comp2.x2')
top.nest.connect('x1', 'comp1.x1')
top.nest.connect('x1', 'comp2.x1')
top.nest.create_passthrough('comp1.y')
top.nest.connect('comp2.y', 'y2')
top.run()
J = top.driver.calc_gradient(inputs=['nest.x1'],
outputs=['nest.y', 'nest.y2'],
mode='forward')
assert_rel_error(self, J[0, 0], 7.0, .001)
assert_rel_error(self, J[1, 0], 19.0, .001)
def verify(self, names, case, expected):
for name, value in expected.items():
i = names.index(name)
if isinstance(value, float):
assert_rel_error(self, case[i], value, 0.001)
else:
self.assertEqual(case[i], value)
def compare_derivatives(self, var_in, var_out):
wflow = self.model.driver.workflow
inputs = ['comp.%s' % v for v in var_in]
outputs = ['comp.%s' % v for v in var_out]
# Numeric
self.model.driver.update_parameters()
wflow.config_changed()
Jn = wflow.calc_gradient(inputs=inputs, outputs=outputs, mode="fd")
# Analytic forward
self.model.driver.update_parameters()
wflow.config_changed()
Jf = wflow.calc_gradient(inputs=inputs, outputs=outputs)
diff = abs(Jf - Jn)
assert_rel_error(self, diff.max(), 0.0, 1e-5)
# Analytic adjoint
self.model.driver.update_parameters()
wflow.config_changed()
Ja = wflow.calc_gradient(inputs=inputs,
outputs=outputs,
mode='adjoint')
diff = abs(Ja - Jn)
assert_rel_error(self, diff.max(), 0.0, 1e-5)
def test_optimization(self):
model = set_as_top(OptimizationConstrained())
model.driver.gradient_options.fd_form = 'complex_step'
model.run()
assert_rel_error(self, model.paraboloid.x, 7.175775, 0.01)
assert_rel_error(self, model.paraboloid.y, -7.824225, 0.01)
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 test_rel_error_inf_nan(self):
try:
assert_rel_error(self, float('nan'), 6.5, 0.0001)
except AssertionError, exc:
msg = "actual nan, desired 6.5, rel error nan, tolerance 0.0001"
self.assertEqual(str(exc), msg)
def test_scale_adder(self):
opt_problem = OptimizationUnconstrainedScaleShift()
opt_problem.run()
assert_rel_error(self, opt_problem.paraboloid.x, 0.006667, 0.001)
assert_rel_error(self, opt_problem.paraboloid.y, -1733.333313, 0.001)
def test_opt1(self):
# Run with scalar parameters, scalar constraints, and OpenMDAO gradient.
self.top.driver.add_objective('10*comp.result')
# pylint: disable-msg=C0301
map(self.top.driver.add_parameter,
['comp.x[0]', 'comp.x[1]','comp.x[2]', 'comp.x[3]'])
map(self.top.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.top.driver.recorders = [ListCaseRecorder()]
self.top.driver.printvars = ['comp.opt_objective']
self.top.driver.iprint = 0
self.top.run()
# pylint: disable-msg=E1101
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.01)
assert_rel_error(self, 1 + self.top.comp.opt_design_vars[0],
1 + self.top.comp.x[0], 0.05)
assert_rel_error(self, self.top.comp.opt_design_vars[1],
self.top.comp.x[1], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[2],
self.top.comp.x[2], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[3],
self.top.comp.x[3], 0.05)
cases = self.top.driver.recorders[0].get_iterator()
end_case = cases[-1]
self.assertEqual(self.top.comp.x[1],
end_case.get_input('comp.x[1]'))
self.assertEqual(self.top.comp.opt_objective,
end_case.get_output('comp.opt_objective'))
def test_gauss_seidel(self):
self.top.run()
assert_rel_error(self, self.top.d1.y1, self.top.d2.y1, 1.0e-4)
assert_rel_error(self, self.top.d1.y2, self.top.d2.y2, 1.0e-4)
self.assertTrue(self.top.d1.exec_count < 10)
def test_opt1_with_CONMIN_gradient(self):
# Note: all other tests use OpenMDAO gradient
self.top.driver.add_objective('10*comp.result')
self.top.driver.add_parameter('comp.x[0]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[1]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[2]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[3]', fd_step=.00001)
# pylint: disable-msg=C0301
map(self.top.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.top.driver.conmin_diff = True
self.top.run()
# pylint: disable-msg=E1101
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.01)
assert_rel_error(self, 1 + self.top.comp.opt_design_vars[0],
1 + self.top.comp.x[0], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[1],
self.top.comp.x[1], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[2],
self.top.comp.x[2], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[3],
self.top.comp.x[3], 0.05)
def test_basic_CONMIN(self):
try:
from pyopt_driver.pyopt_driver import pyOptDriver
except ImportError:
raise SkipTest("this test requires pyOpt to be installed")
self.top = OptimizationConstrained()
set_as_top(self.top)
try:
self.top.driver.optimizer = 'CONMIN'
self.top.driver.optimizer = 'COBYLA'
except ValueError:
raise SkipTest("CONMIN not present on this system")
self.top.driver.title = 'Little Test'
optdict = {}
self.top.driver.options = optdict
self.top.driver.pyopt_diff = True
self.top.run()
assert_rel_error(self, self.top.paraboloid.x, 7.175775, 0.01)
assert_rel_error(self, self.top.paraboloid.y, -7.824225, 0.01)
def test_opt1_with_CONMIN_gradient_a(self):
# Scalar parameters, array constraint, CONMIN gradient.
# Note: all other tests use OpenMDAO gradient
self.top.driver.add_objective('10*comp.result')
self.top.driver.add_parameter('comp.x[0]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[1]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[2]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[3]', fd_step=.00001)
self.top.driver.add_constraint('comp.g <= 0')
self.top.driver.conmin_diff = True
self.top.run()
# pylint: disable-msg=E1101
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.01)
assert_rel_error(self, 1 + self.top.comp.opt_design_vars[0],
1 + self.top.comp.x[0], 0.05)
assert_rel_error(self, self.top.comp.opt_design_vars[1],
self.top.comp.x[1], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[2],
self.top.comp.x[2], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[3],
self.top.comp.x[3], 0.05)
def test_gauss_seidel_sub(self):
# Note, Fake Finite Difference is active in this test.
self.top = set_as_top(Sellar_MDA_subbed())
self.top.run()
assert_rel_error(self, self.top.d1.y1,
self.top.d2.y1,
1.0e-4)
assert_rel_error(self, self.top.d1.y2,
self.top.d2.y2,
1.0e-4)
self.assertTrue(self.top.d1.exec_count < 10)
inputs = ['d1.z1', 'd1.z2', 'd2.z1', 'd2.z2']
outputs = ['d1.y1', 'd2.y2']
self.top.driver.workflow.config_changed()
J1 = self.top.driver.workflow.calc_gradient(inputs=inputs,
outputs=outputs)
self.top.run()
J2 = self.top.driver.workflow.calc_gradient(inputs=inputs,
outputs=outputs,
mode='fd')
J = (J1 - J2)
print J.max()
self.assertTrue(J.max() < 1.0e-3)
def test_simple_float(self):
model = set_as_top(Assembly())
model.add('comp', SimpleCompFloat())
model.driver.workflow.add('comp')
model.driver.gradient_options.fd_form = 'complex_step'
model.run()
J = model.driver.workflow.calc_gradient(inputs=['comp.x'],
outputs=['comp.y'])
assert_rel_error(self, J[0, 0], 2.0, .000001)
self.assertTrue(model.comp.x is not complex)
self.assertTrue(model.comp.y is not complex)
# Make sure we can do whole workflows.
model.add('comp2', SimpleCompFloat())
model.driver.workflow.add('comp2')
model.connect('comp.y', 'comp2.x')
model.run()
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(inputs=['comp.x'],
outputs=['comp2.y'])
assert_rel_error(self, J[0, 0], 4.0, .000001)
self.assertTrue(model.comp.x is not complex)
self.assertTrue(model.comp2.y is not complex)
def test_opt1_with_CONMIN_gradient(self):
# Note: all other tests use OpenMDAO gradient
self.top.driver.add_objective('10*comp.result')
self.top.driver.add_parameter('comp.x[0]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[1]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[2]', fd_step=.00001)
self.top.driver.add_parameter('comp.x[3]', fd_step=.00001)
# pylint: disable-msg=C0301
map(self.top.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.top.driver.conmin_diff = True
self.top.run()
# pylint: disable-msg=E1101
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.01)
assert_rel_error(self, 1 + self.top.comp.opt_design_vars[0],
1 + self.top.comp.x[0], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[1],
self.top.comp.x[1], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[2],
self.top.comp.x[2], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[3],
self.top.comp.x[3], 0.05)
def test_simple_float_subassy(self):
model = set_as_top(Assembly())
model.add('sub', Assembly())
model.sub.add('subsub', Assembly())
model.driver.workflow.add('sub')
model.sub.driver.workflow.add('subsub')
model.sub.subsub.add('comp', SimpleCompFloat())
model.sub.subsub.driver.workflow.add('comp')
model.sub.subsub.create_passthrough('comp.x')
model.sub.subsub.create_passthrough('comp.y')
model.sub.create_passthrough('subsub.x')
model.sub.create_passthrough('subsub.y')
model.driver.gradient_options.fd_form = 'complex_step'
model.driver.gradient_options.force_fd = True
model.run()
J = model.driver.workflow.calc_gradient(inputs=['sub.x'],
outputs=['sub.y'])
assert_rel_error(self, J[0, 0], 2.0, .000001)
self.assertTrue(model.sub.subsub.comp.x is not complex)
self.assertTrue(model.sub.subsub.comp.y is not complex)
def test_conmin_gradient_s(self):
# Run with 1D parameter, scalar constraints, and CONMIN gradient.
# pylint: disable-msg=C0301
map(self.top.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.top.driver.conmin_diff = True
self.top.driver.fdch = .000001
self.top.driver.fdchm = .000001
self.top.run()
# pylint: disable-msg=E1101
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.01)
assert_rel_error(self, 1 + self.top.comp.opt_design_vars[0],
1 + self.top.comp.x[0], 0.05)
assert_rel_error(self, self.top.comp.opt_design_vars[1],
self.top.comp.x[1], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[2],
self.top.comp.x[2], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[3],
self.top.comp.x[3], 0.05)
def test_simple_array(self):
model = set_as_top(Assembly())
model.add('comp', SimpleCompArray())
model.driver.workflow.add('comp')
#model.driver.gradient_options.fd_form = 'complex_step'
model.run()
J = model.driver.workflow.calc_gradient(inputs=['comp.x'],
outputs=['comp.y'])
diff = abs(J - model.comp.J).max()
assert_rel_error(self, diff, 0.0, .0001)
self.assertTrue(J[0, 0] is not complex)
model.add('driver', SimpleDriver())
model.driver.add_parameter('comp.x', low=-10, high=10)
model.driver.add_objective('comp.y - comp.x')
model.run()
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(mode='fd')
diff = abs(J + eye(4) - model.comp.J).max()
assert_rel_error(self, diff, 0.0, .0001)
self.assertTrue(J[0, 0] is not complex)
def test_gauss_seidel(self):
self.top.run()
assert_rel_error(self, self.top.d1.y1, self.top.d2.y1, 1.0e-4)
assert_rel_error(self, self.top.d1.y2, self.top.d2.y2, 1.0e-4)
self.assertTrue(self.top.d1.exec_count < 10)
def test_splitterBPR(self):
comp = self.comp
comp.BPR = 2.2285
comp.MNexit1_des = 1.00
comp.MNexit2_des = 1.00
comp.design = True
comp.Fl_I = self.fs
comp.run()
self.check(comp)
#run off design
comp.run()
self.check(comp)
#try changing something
TOL = 0.001
comp.Fl_I.W *= .95
comp.run()
assert_rel_error(self, comp.Fl_O1.Mach, .76922, TOL)
assert_rel_error(self, comp.Fl_O2.Mach, .76922, TOL)
def test_rel_error_inf_nan(self):
try:
assert_rel_error(self, float('nan'), 6.5, 0.0001)
except AssertionError, exc:
msg = "actual nan, desired 6.5, rel error nan, tolerance 0.0001"
self.assertEqual(str(exc), msg)
def test_splitterW(self):
comp = self.comp = set_as_top(splitter.SplitterW())
comp.W1_des = 1.08
comp.MNexit1_des = 1.00
comp.MNexit2_des = 1.00
comp.design = True
comp.Fl_I = self.fs
comp.run()
self.check(comp)
#run off design
comp.run()
self.check(comp)
#try changing something
TOL = 0.001
comp.Fl_I.W *= .95
comp.run()
assert_rel_error(self, comp.Fl_O1.Mach, .76922, TOL)
assert_rel_error(self, comp.Fl_O2.Mach, .76922, TOL)
def test_sparProperties(self):
comp = SparProperties()
comp.yN = np.array([0, 14.5057])
comp.d = np.array([
0.1016,
])
comp.theta = np.array([
0.6109,
])
comp.nTube = np.array([
4,
])
comp.nCap = np.array([0, 0])
comp.lBiscuit = np.array([
0.3048,
])
#comp.CFRPType = 1
comp.CFRPType = 'NCT301-1X HS40 G150 33 +/-2%RW'
comp.run()
tol = 0.0001
assert_rel_error(self, comp.EIx[0], 23704.383, tol)
assert_rel_error(self, comp.EIz[0], 23704.383, tol)
assert_rel_error(self, comp.EA[0], 18167620.0, tol)
assert_rel_error(self, comp.GJ[0], 2.2828e4, tol)
assert_rel_error(self, comp.mSpar[0], 4.7244, tol)
def test_newton(self):
self.top.driver.newton = True
self.top.run()
assert_rel_error(self, self.top.d1.y1, self.top.d2.y1, 1.0e-4)
assert_rel_error(self, self.top.d1.y2, self.top.d2.y2, 1.0e-4)
def test_paramgroup(self):
top = set_as_top(Assembly())
top.add('comp1', GComp_noD())
top.add('driver', SimpleDriver())
top.driver.workflow.add(['comp1'])
top.driver.gradient_options.directional_fd = True
top.run()
J = top.driver.calc_gradient(inputs=[('comp1.x1', 'comp1.x2')],
outputs=['comp1.y1'],
mode='forward')
assert_rel_error(self, J[0, 0], 12.0, .001)
J = top.driver.calc_gradient(inputs=[('comp1.x1', 'comp1.x2')],
outputs=['comp1.y1'],
mode='fd')
assert_rel_error(self, J[0, 0], 12.0, .001)
J = top.driver.calc_gradient(inputs=['comp1.x1', ('comp1.x2')],
outputs=['comp1.y1'],
mode='forward')
assert_rel_error(self, J[0, 0], 5.0, .001)
assert_rel_error(self, J[0, 1], 7.0, .001)
J = top.driver.calc_gradient(inputs=[('comp1.x1', 'comp1.x2', 'comp1.x3')],
outputs=['comp1.y1'],
mode='forward')
assert_rel_error(self, J[0, 0], 9.0, .001)
def test_turbine(self):
self.turbine = set_as_top(turbine_prmap.TurbinePRmap())
self.fs = flowstation.FlowStation()
self.fs._species=[.9816,0,.018355,0,0,0,0]
self.fs.W = 103.47
self.fs.setTotalTP( 2371.94, 119.086 )
self.b1 = flowstation.FlowStation()
self.b1.W = 6.1386
self.b1.setTotalTP( 1211.05, 126.017 )
self.b2 = flowstation.FlowStation()
self.b2.W = 3.9064
self.b2.setTotalTP( 1211.05, 126.017 )
turbine = self.turbine
turbine.eff = .9133
turbine.PR = 2.670
turbine.Nmech = 8000.
turbine.Fl_I = self.fs
turbine.Fl_bld1 = self.b1
turbine.Fl_bld2 = self.b2
turbine.run()
TOL = .001
assert_rel_error( self,turbine.Fl_O.W, 113.51, TOL )
assert_rel_error( self,turbine.Fl_O.Pt, 44.60, TOL )
assert_rel_error( self,turbine.Fl_O.Tt, 1850.6, TOL )
assert_rel_error( self,turbine.pwr, 19684, TOL )
assert_rel_error( self,turbine.trq, 1353.2, TOL )
def test_simple_float(self):
model = set_as_top(Assembly())
model.add('comp', SimpleCompFloat())
model.driver.workflow.add('comp')
model.driver.gradient_options.fd_form = 'complex_step'
model.run()
J = model.driver.calc_gradient(inputs=['comp.x'], outputs=['comp.y'])
assert_rel_error(self, J[0, 0], 2.0, .000001)
self.assertTrue(model.comp.x is not complex)
self.assertTrue(model.comp.y is not complex)
# Make sure we can do whole workflows.
model.add('comp2', SimpleCompFloat())
model.driver.workflow.add('comp2')
model.connect('comp.y', 'comp2.x')
model.run()
J = model.driver.calc_gradient(inputs=['comp.x'], outputs=['comp2.y'])
assert_rel_error(self, J[0, 0], 4.0, .000001)
self.assertTrue(model.comp.x is not complex)
self.assertTrue(model.comp2.y is not complex)
def test_simple_float(self):
model = set_as_top(Assembly())
model.add("comp", SimpleCompFloat())
model.driver.workflow.add("comp")
model.driver.gradient_options.fd_form = "complex_step"
model.run()
J = model.driver.calc_gradient(inputs=["comp.x"], outputs=["comp.y"])
assert_rel_error(self, J[0, 0], 2.0, 0.000001)
self.assertTrue(model.comp.x is not complex)
self.assertTrue(model.comp.y is not complex)
# Make sure we can do whole workflows.
model.add("comp2", SimpleCompFloat())
model.driver.workflow.add("comp2")
model.connect("comp.y", "comp2.x")
model.run()
J = model.driver.calc_gradient(inputs=["comp.x"], outputs=["comp2.y"])
assert_rel_error(self, J[0, 0], 4.0, 0.000001)
self.assertTrue(model.comp.x is not complex)
self.assertTrue(model.comp2.y is not complex)
def test_in_assembly(self):
asm = self._get_assembly()
self.assertEqual(
set(asm.list_connections()),
set([('metamodel.d', 'comp2.b'), ('metamodel.c', 'comp2.a'),
('comp1.c', 'metamodel.a'), ('comp1.d', 'metamodel.b')]))
# do some training
data = [1, 2, 3, 4]
for a, b in zip(data[:-1], data[1:]):
asm.comp1.a = a
asm.comp1.b = b
asm.metamodel.train_next = 1
asm.run()
# now run and get some results
asm.comp1.a = 1.
asm.comp1.b = 2.
asm.run()
assert_rel_error(self, asm.comp2.c, 6, 0.02)
assert_rel_error(self, asm.comp2.d, -2, 0.02)
# set new model and verify disconnect
asm.metamodel.model = Simple2()
self.assertEqual(asm.list_connections(), [])
def test_simple_units(self):
self.top = set_as_top(Assembly())
self.top.add('comp1', CompFoot())
self.top.add('comp2', CompInch())
self.top.connect('comp1.y', 'comp2.x')
self.top.add('driver', Driv())
self.top.driver.workflow.add(['comp1', 'comp2'])
self.top.driver.differentiator = Analytic()
obj = 'comp2.y'
self.top.driver.add_parameter('comp1.x',
low=-50.,
high=50.,
fd_step=.0001)
self.top.driver.add_objective(obj)
self.top.comp1.x = 2.0
self.top.run()
self.top.driver.differentiator.calc_gradient()
grad = self.top.driver.differentiator.get_gradient(obj)
assert_rel_error(self, grad[0], 48.0, .001)
def test_Abasic_SNOPT_derivatives_linear_constraints(self):
try:
from pyoptsparse import Optimization
except ImportError:
raise SkipTest("this test requires pyoptsparse to be installed")
self.top = OptimizationConstrainedDerivatives()
set_as_top(self.top)
try:
self.top.driver.optimizer = 'SNOPT'
except ValueError:
raise SkipTest("SNOPT not present on this system")
self.top.driver.title = 'Little Test with Gradient'
optdict = {}
self.top.driver.options = optdict
self.top.driver.clear_constraints()
self.top.driver.add_constraint('paraboloid.x-paraboloid.y >= 15.0')
self.top.driver.add_constraint('paraboloid.x > 7.1', linear=True)
self.top.run()
assert_rel_error(self, self.top.paraboloid.x, 7.175775, 0.01)
assert_rel_error(self, self.top.paraboloid.y, -7.824225, 0.01)
def test_parameter_groups(self):
self.top = set_as_top(Assembly())
exp1 = ['y = 2.0*x']
deriv1 = ['dy_dx = 2.0']
self.top.add('driver', Driv())
self.top.add('comp1', ExecCompWithDerivatives(exp1, deriv1))
self.top.add('comp2', ExecCompWithDerivatives(exp1, deriv1))
self.top.driver.workflow.add(['comp1', 'comp2'])
# Top driver setup
self.top.driver.differentiator = Analytic()
obj = 'comp1.y+comp2.y'
self.top.driver.add_parameter(['comp1.x', 'comp2.x'],
low=-100.,
high=100.,
fd_step=.001)
self.top.driver.add_objective(obj)
self.top.comp1.x1 = 1.0
self.top.comp2.x2 = 1.0
self.top.run()
self.top.driver.differentiator.calc_gradient()
grad = self.top.driver.differentiator.get_gradient(obj)
assert_rel_error(self, grad[0], 4.0, .001)
def test_MIMO_ExcitingMixing(self):
# Testing Broyden on a 2 input 2 output case
self.prob = MIMOBroyden()
set_as_top(self.prob)
driver = self.prob.driver
driver.add_parameter('dis1.x[0]')
driver.add_parameter('dis1.x[1]')
driver.add_parameter('dis1.x[2]')
driver.add_parameter('dis1.x[3]')
driver.add_parameter('dis1.x[4]')
driver.add_constraint('dis1.f1 = 0.0')
driver.add_constraint('dis1.f2 = 0.0')
driver.add_constraint('dis1.f3 = 0.0')
driver.add_constraint('dis1.f4 = 0.0')
driver.add_constraint('dis1.f5 = 0.0')
self.prob.dis1.x = [1., 1., 1., 1., 1.]
driver.algorithm = "excitingmixing"
driver.alpha = 0.1
self.prob.run()
assert_rel_error(self, 1.0 - self.prob.dis1.x[0], 1.0, 0.0001)
assert_rel_error(self, 1.0 - self.prob.dis1.x[1], 1.0, 0.0001)
assert_rel_error(self, 1.0 - self.prob.dis1.x[2], 1.0, 0.0001)
assert_rel_error(self, 1.0 - self.prob.dis1.x[3], 1.0, 0.0001)
assert_rel_error(self, 1.0 - self.prob.dis1.x[4], 1.0, 0.0001)
def test_MIMO_ExcitingMixing(self):
# Testing Broyden on a 2 input 2 output case
prob = MIMOBroyden()
set_as_top(prob)
driver = prob.driver
driver.add_parameter('dis1.x[0]', low=-9.e99, high=9.e99)
driver.add_parameter('dis1.x[1]', low=-9.e99, high=9.e99)
driver.add_parameter('dis1.x[2]', low=-9.e99, high=9.e99)
driver.add_parameter('dis1.x[3]', low=-9.e99, high=9.e99)
driver.add_parameter('dis1.x[4]', low=-9.e99, high=9.e99)
driver.add_constraint('dis1.f1 = 0.0')
driver.add_constraint('dis1.f2 = 0.0')
driver.add_constraint('dis1.f3 = 0.0')
driver.add_constraint('dis1.f4 = 0.0')
driver.add_constraint('dis1.f5 = 0.0')
prob.dis1.x = [1., 1., 1., 1., 1.]
driver.algorithm = "excitingmixing"
driver.alpha = 0.1
prob.run()
assert_rel_error(self, 1.0 - prob.dis1.x[0], 1.0, 0.0001)
assert_rel_error(self, 1.0 - prob.dis1.x[1], 1.0, 0.0001)
assert_rel_error(self, 1.0 - prob.dis1.x[2], 1.0, 0.0001)
assert_rel_error(self, 1.0 - prob.dis1.x[3], 1.0, 0.0001)
assert_rel_error(self, 1.0 - prob.dis1.x[4], 1.0, 0.0001)
def test_sellar_Newton_parallel(self):
top = set_as_top(SellarMDFwithDerivs())
top.replace('driver', NewtonSolver())
top.driver.add_parameter('C2.y1', low=-1e99, high=1e99)
top.driver.add_constraint('C1.y1 = C2.y1')
top.driver.add_parameter('C1.y2', low=-1.e99, high=1.e99)
top.driver.add_constraint('C2.y2 = C1.y2')
expected = { 'C1.y1': 3.1598617768014536, 'C2.y2': 3.7551999159927316 }
top.driver.iprint = 0
top.driver.max_iteration = 20
top.run()
# print top.C1.y1, top.C2.y1
# print top.C1.y2, top.C2.y2
# gather the values back to the rank 0 process and compare to expected
dist_answers = top._system.mpi.comm.gather([(k[0],v) for k,v in top._system.vec['u'].items()],
root=0)
if self.comm.rank == 0:
for answers in dist_answers:
for name, val in answers:
if name in expected:
#print self.comm.rank, name, val[0]
assert_rel_error(self, val[0], expected[name], 0.001)
del expected[name]
if expected:
self.fail("not all expected values were found")
def test_scale_adder(self):
opt_problem = OptimizationUnconstrainedScaleShift()
opt_problem.run()
assert_rel_error(self, opt_problem.paraboloid.x, 0.006667, 0.001)
assert_rel_error(self, opt_problem.paraboloid.y, -1733.333313, 0.001)
def test_unconstrained(self):
try:
from pyopt_driver.pyopt_driver import pyOptDriver
except ImportError:
raise SkipTest("this test requires pyOpt to be installed")
self.top = OptimizationUnconstrained()
set_as_top(self.top)
for optimizer in [ 'CONMIN', 'COBYLA', 'SNOPT', 'SLSQP' ] :
try:
self.top.driver.optimizer = optimizer
except ValueError:
raise SkipTest("%s not present on this system" % optimizer)
self.top.driver.title = 'Little Test'
optdict = {}
self.top.driver.options = optdict
self.top.driver.pyopt_diff = True
self.top.run()
assert_rel_error(self, self.top.paraboloid.x, 6.6667, 0.01)
assert_rel_error(self, self.top.paraboloid.y, -7.3333, 0.01)
def test_varTree_on_boundary_subassembly(self):
top = set_as_top(Assembly())
top.add('comp', AssemblyWithBoundryVarTree())
top.add('driver', SimpleDriver())
top.driver.workflow.add('comp')
top.driver.add_parameter('comp.ins.x1', low=-100, high=100)
top.driver.add_objective('comp.y')
top.comp.comp1.missing_deriv_policy = 'assume_zero'
top.run()
# check for invalidation problems
top.comp.ins.x1 = 123.4
top.run()
self.assertEqual(top.comp.ins.x1, top.comp.comp1.ins.x1)
#print top.comp.driver.calc_gradient(['ins.x1'], ['y'], mode='fd')
inputs = ['comp.ins.x1', ]
outputs = ['comp.y']
J_fd = top.driver.calc_gradient(inputs, outputs, mode='fd')
J_forward = top.driver.calc_gradient(inputs, outputs, mode="forward")
J_reverse = top.driver.calc_gradient(inputs, outputs, mode="adjoint")
assert_rel_error(self, linalg.norm(J_fd - J_forward), 0, .00001)
assert_rel_error(self, linalg.norm(J_fd - J_reverse), 0, .00001)
def test_branch_output_in_opaque_system(self):
# This test replicates a bug where an interior output was missing in
# an opaque system.
top = set_as_top(Assembly())
top.add('nest', Assembly())
top.nest.add('comp1', ExecComp(['y=7.0*x1']))
top.nest.add('comp2', ExecComp(['y=5.0*x1 + 2.0*x2']))
top.driver.workflow.add(['nest'])
top.nest.driver.workflow.add(['comp1', 'comp2'])
top.nest.add('x1', Float(3.0, iotype='in'))
top.nest.add('y2', Float(3.0, iotype='out'))
top.nest.connect('comp1.y', 'comp2.x2')
top.nest.connect('x1', 'comp1.x1')
top.nest.connect('x1', 'comp2.x1')
top.nest.create_passthrough('comp1.y')
top.nest.connect('comp2.y', 'y2')
top.run()
J = top.driver.calc_gradient(inputs=['nest.x1'],
outputs=['nest.y', 'nest.y2'],
mode='forward')
assert_rel_error(self, J[0, 0], 7.0, .001)
assert_rel_error(self, J[1, 0], 19.0, .001)
def test_vartree_subassy_behavior(self):
class tree(VariableTree):
x = Float(3.0)
y = Float(4.0)
z = Float(5.0)
class MyComp(Component):
ins = VarTree(tree(), iotype='in')
outs = VarTree(tree(), iotype='out')
def execute(self):
self.outs = self.ins.copy()
self.outs.z = 2.0*self.ins.x
top = set_as_top(Assembly())
top.add('sub', Assembly())
top.driver.workflow.add('sub')
top.sub.add('comp1', MyComp())
top.sub.add('comp2', MyComp())
top.sub.driver.workflow.add(['comp1', 'comp2'])
top.sub.create_passthrough('comp1.ins')
top.sub.create_passthrough('comp1.outs')
top.sub.create_passthrough('comp2.outs', 'zzz')
top.sub.connect('ins.z', 'comp2.ins.x')
top.run()
J = top.driver.calc_gradient(['sub.ins.x'], ['sub.outs.z'])
assert_rel_error(self, J[0, 0], 2.0, .00001)
J = top.driver.calc_gradient(['sub.ins.z'], ['sub.zzz.z'])
print J
def test_cascade_opt(self):
top = set_as_top(Assembly())
eq = ["f = (x-3)**2 + x*y + (y+4)**2 - 3"]
deriv = ["df_dx = 2.0*x - 6.0 + y", "df_dy = 2.0*y + 8.0 + x"]
top.add("comp", ExecCompWithDerivatives(eq, deriv))
top.add("driver", SimpleDriver())
top.add("opt1", SLSQPdriver())
top.add("opt2", SLSQPdriver())
top.opt1.workflow.add(["comp"])
top.opt2.workflow.add(["comp"])
top.driver.workflow.add(["opt1", "opt2"])
top.opt1.add_parameter("comp.x", low=-100, high=100)
top.opt1.add_parameter("comp.y", low=-100, high=100)
top.opt1.add_objective("comp.f")
top.opt1.maxiter = 2
top.opt2.add_parameter("comp.x", low=-100, high=100)
top.opt2.add_parameter("comp.y", low=-100, high=100)
top.opt2.add_objective("comp.f")
top.opt2.maxiter = 50
top.run()
assert_rel_error(self, top.comp.x, 6.666309, 0.01)
assert_rel_error(self, top.comp.y, -7.333026, 0.01)
J = top.driver.workflow.calc_gradient(inputs=["comp.x", "comp.y"], outputs=["comp.f"])
edges = top.driver.workflow._edges
print edges
self.assertEqual(set(edges["@in0"]), set(["~opt1.comp|x", "~opt2.comp|x"]))
self.assertEqual(set(edges["@in1"]), set(["~opt1.comp|y", "~opt2.comp|y"]))
self.assertEqual(set(edges["~opt1.comp|f"]), set(["@out0"]))
self.assertEqual(set(edges["~opt2.comp|f"]), set(["@out0"]))
def test_opt1(self):
# Run with scalar parameters, scalar constraints, and OpenMDAO gradient.
self.top.driver.add_objective('10*comp.result')
# pylint: disable-msg=C0301
map(self.top.driver.add_parameter,
['comp.x[0]', 'comp.x[1]', 'comp.x[2]', 'comp.x[3]'])
map(self.top.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.top.driver.recorders = [ListCaseRecorder()]
self.top.driver.printvars = ['comp.opt_objective']
self.top.driver.iprint = 0
self.top.run()
# pylint: disable-msg=E1101
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.01)
assert_rel_error(self, 1 + self.top.comp.opt_design_vars[0],
1 + self.top.comp.x[0], 0.05)
assert_rel_error(self, self.top.comp.opt_design_vars[1],
self.top.comp.x[1], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[2],
self.top.comp.x[2], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[3],
self.top.comp.x[3], 0.05)
cases = self.top.driver.recorders[0].get_iterator()
end_case = cases[-1]
self.assertEqual(self.top.comp.x[1], end_case.get_input('comp.x[1]'))
self.assertEqual(self.top.comp.opt_objective,
end_case.get_output('comp.opt_objective'))
def compare_derivatives(self, var_in, var_out):
wflow = self.model.driver
inputs = ['comp.%s' % v for v in var_in]
outputs = ['comp.%s' % v for v in var_out]
# Numeric
self.model.driver.update_parameters()
Jn = wflow.calc_gradient(inputs=inputs,
outputs=outputs,
mode="fd")
# Analytic forward
self.model.driver.update_parameters()
Jf = wflow.calc_gradient(inputs=inputs,
outputs=outputs)
diff = abs(Jf - Jn)
assert_rel_error(self, diff.max(), 0.0, 1e-5)
# Analytic adjoint
self.model.driver.update_parameters()
Ja = wflow.calc_gradient(inputs=inputs,
outputs=outputs,
mode='adjoint')
diff = abs(Ja - Jn)
assert_rel_error(self, diff.max(), 0.0, 1e-5)
def test_unconstrained(self):
try:
from pyopt_driver.pyopt_driver import pyOptDriver
except ImportError:
raise SkipTest("this test requires pyOpt to be installed")
self.top = OptimizationUnconstrained()
set_as_top(self.top)
for optimizer in ['CONMIN', 'COBYLA', 'SNOPT', 'SLSQP']:
try:
self.top.driver.optimizer = optimizer
except ValueError:
raise SkipTest("%s not present on this system" % optimizer)
self.top.driver.title = 'Little Test'
optdict = {}
self.top.driver.options = optdict
self.top.driver.pyopt_diff = True
self.top.run()
assert_rel_error(self, self.top.paraboloid.x, 6.6667, 0.01)
assert_rel_error(self, self.top.paraboloid.y, -7.3333, 0.01)
