def test_unconnected_param_access_with_promotes(self):
prob = Problem(root=Group())
G1 = prob.root.add('G1', Group())
G2 = G1.add('G2', Group(), promotes=['x'])
C1 = G2.add('C1', ExecComp(['y=2.0*x', 'z=x*x-2.0']), promotes=['x'])
C2 = G2.add('C2', ExecComp(['y=2.0*x', 'z=x*x-2.0']))
G2.connect('C1.y', 'C2.x')
# ignore warning about the unconnected param
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("ignore")
prob.setup(check=False)
prob.run()
# still must use absolute naming to find params even if they're
# promoted. Promoted names for params can refer to more than one param.
C1.params['x'] = 2.
self.assertEqual(prob['G1.x'], 2.0)
self.assertEqual(prob.root.G1.G2.C1.params['x'], 2.0)
prob['G1.x'] = 99.
self.assertEqual(C1.params['x'], 99.)
prob['G1.x'] = 12.
self.assertEqual(C1.params['x'], 12.)
prob['G1.x'] = 17.
self.assertEqual(prob.root.G1.G2.C1.params['x'], 17.0)
prob.run()
def test_simple_paraboloid_equality(self):
prob = Problem()
root = prob.root = Group()
root.add("p1", ParamComp("x", 50.0), promotes=["*"])
root.add("p2", ParamComp("y", 50.0), promotes=["*"])
root.add("comp", Paraboloid(), promotes=["*"])
root.add("con", ExecComp("c = 15.0 - x + y"), promotes=["*"])
prob.driver = ScipyOptimizer()
prob.driver.options["optimizer"] = "SLSQP"
prob.driver.options["tol"] = 1.0e-8
prob.driver.add_param("x", low=-50.0, high=50.0)
prob.driver.add_param("y", low=-50.0, high=50.0)
prob.driver.add_objective("f_xy")
prob.driver.add_constraint("c", ctype="ineq")
prob.setup(check=False)
prob.run()
# Minimum should be at (7.166667, -7.833334)
assert_rel_error(self, prob["x"], 7.16667, 1e-6)
assert_rel_error(self, prob["y"], -7.833334, 1e-6)
def test_fd_skip_keys(self):
prob = Problem()
root = prob.root = Group()
comp = Component()
comp.add_param('x', 0.)
comp.add_param('y', 0.)
comp.add_output('z', 0.)
comp.solve_nonlinear = lambda p, u, r: u.__setitem__('z', 1.)
comp._get_fd_params = lambda: ['x']
comp.jacobian = lambda a,b,c: {('z', 'x'): 0.}
root.add('comp', comp, promotes=['x', 'y'])
root.add('px', ParamComp('x', 0.), promotes=['*'])
root.add('py', ParamComp('y', 0.), promotes=['*'])
prob.setup(check=False)
prob.run()
try:
prob.check_partial_derivatives()
except KeyError as err:
self.fail('KeyError raised: {0}'.format(str(err)))
def test_fd_skip_keys(self):
prob = Problem()
root = prob.root = Group()
comp = Component()
comp.add_param('x', 0.)
comp.add_param('y', 0.)
comp.add_output('z', 0.)
comp.solve_nonlinear = lambda p, u, r: u.__setitem__('z', 1.)
comp._get_fd_params = lambda: ['x']
comp.jacobian = lambda a, b, c: {('z', 'x'): 0.}
root.add('comp', comp, promotes=['x', 'y'])
root.add('px', ParamComp('x', 0.), promotes=['*'])
root.add('py', ParamComp('y', 0.), promotes=['*'])
prob.setup(check=False)
prob.run()
try:
prob.check_partial_derivatives(out_stream=None)
except KeyError as err:
self.fail('KeyError raised: {0}'.format(str(err)))
def test_byobj_run(self):
prob = Problem(root=ExampleByObjGroup())
prob.setup(check=False)
prob.run()
self.assertEqual(prob['G3.C4.y'], 'fooC2C3C4')
def test_bad_size(self):
class BadComp(SimpleArrayComp):
def jacobian(self, params, unknowns, resids):
"""Analytical derivatives"""
J = {}
J[('y', 'x')] = np.zeros((3, 3))
return J
prob = Problem()
prob.root = Group()
prob.root.add('comp', BadComp())
prob.root.add('p1', ParamComp('x', np.ones([2])))
prob.root.connect('p1.x', 'comp.x')
prob.setup(check=False)
prob.run()
try:
data = prob.check_partial_derivatives(out_stream=None)
except Exception as err:
msg = "Jacobian in component 'comp' between the" + \
" variables 'x' and 'y' is the wrong size. " + \
"It should be 2 by 2"
self.assertEqual(str(err), msg)
else:
self.fail("Error expected")
def test_simple_matvec(self):
class VerificationComp(SimpleCompDerivMatVec):
def jacobian(self, params, unknowns, resids):
raise RuntimeError(
"Derivative functions on this comp should not run.")
def apply_linear(self, params, unknowns, dparams, dunknowns,
dresids, mode):
raise RuntimeError(
"Derivative functions on this comp should not run.")
sub = Group()
sub.add('mycomp', VerificationComp())
prob = Problem()
prob.root = Group()
prob.root.add('sub', sub)
prob.root.add('x_param', ParamComp('x', 1.0))
prob.root.connect('x_param.x', "sub.mycomp.x")
sub.fd_options['force_fd'] = True
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x_param.x'], ['sub.mycomp.y'],
mode='fwd',
return_format='dict')
assert_rel_error(self, J['sub.mycomp.y']['x_param.x'][0][0], 2.0, 1e-6)
J = prob.calc_gradient(['x_param.x'], ['sub.mycomp.y'],
mode='rev',
return_format='dict')
assert_rel_error(self, J['sub.mycomp.y']['x_param.x'][0][0], 2.0, 1e-6)
def test_simple_paraboloid_equality(self):
prob = Problem()
root = prob.root = Group()
root.add('p1', ParamComp('x', 50.0), promotes=['*'])
root.add('p2', ParamComp('y', 50.0), promotes=['*'])
root.add('comp', Paraboloid(), promotes=['*'])
root.add('con', ExecComp('c = 15.0 - x + y'), promotes=['*'])
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1.0e-8
prob.driver.add_param('x', low=-50.0, high=50.0)
prob.driver.add_param('y', low=-50.0, high=50.0)
prob.driver.add_objective('f_xy')
prob.driver.add_constraint('c', ctype='ineq')
prob.driver.options['disp'] = False
prob.setup(check=False)
prob.run()
# Minimum should be at (7.166667, -7.833334)
assert_rel_error(self, prob['x'], 7.16667, 1e-6)
assert_rel_error(self, prob['y'], -7.833334, 1e-6)
def test_simple_array_comp2D(self):
prob = Problem()
root = prob.root = Group()
root.add('p1', ParamComp('x', np.zeros((2, 2))), promotes=['*'])
root.add('comp', ArrayComp2D(), promotes=['*'])
root.add('con',
ExecComp('c = y - 20.0',
c=np.zeros((2, 2)),
y=np.zeros((2, 2))),
promotes=['*'])
root.add('obj',
ExecComp('o = y[0, 0]', y=np.zeros((2, 2))),
promotes=['*'])
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.add_param('x', low=-50.0, high=50.0)
prob.driver.add_objective('o')
prob.driver.add_constraint('c', ctype='eq')
prob.driver.options['disp'] = False
prob.setup(check=False)
prob.run()
obj = prob['o']
assert_rel_error(self, obj, 20.0, 1e-6)
def test_parallel_diamond(self):
size = 3
prob = Problem(Group(), impl=impl)
root = prob.root
root.add('P1', ParamComp('x', np.ones(size, float) * 1.1))
G1 = root.add('G1', ParallelGroup())
G1.add('C1', ABCDArrayComp(size))
G1.add('C2', ABCDArrayComp(size))
root.add('C3', ABCDArrayComp(size))
root.connect('P1.x', 'G1.C1.a')
root.connect('P1.x', 'G1.C2.b')
root.connect('G1.C1.c', 'C3.a')
root.connect('G1.C2.d', 'C3.b')
prob.setup(check=False)
prob.run()
if not MPI or self.comm.rank == 0:
assert_rel_error(self, prob.root.G1.C1.unknowns['c'],
np.ones(size) * 2.1, 1.e-10)
assert_rel_error(self, prob.root.G1.C1.unknowns['d'],
np.ones(size) * .1, 1.e-10)
assert_rel_error(self, prob.root.C3.params['a'],
np.ones(size) * 2.1, 1.e-10)
assert_rel_error(self, prob.root.C3.params['b'],
np.ones(size) * -.1, 1.e-10)
if not MPI or self.comm.rank == 1:
assert_rel_error(self, prob.root.G1.C2.unknowns['c'],
np.ones(size) * 2.1, 1.e-10)
assert_rel_error(self, prob.root.G1.C2.unknowns['d'],
np.ones(size) * -.1, 1.e-10)
def test_simple(self):
prob = Problem(Group(), impl=impl)
size = 5
A1 = prob.root.add('A1', ParamComp('a', np.zeros(size, float)))
B1 = prob.root.add('B1', ParamComp('b', np.zeros(size, float)))
B2 = prob.root.add('B2', ParamComp('b', np.zeros(size, float)))
S1 = prob.root.add('S1', ParamComp('s', ''))
L1 = prob.root.add('L1', ParamComp('l', []))
C1 = prob.root.add('C1', ABCDArrayComp(size))
C2 = prob.root.add('C2', ABCDArrayComp(size))
prob.root.connect('A1.a', 'C1.a')
prob.root.connect('B1.b', 'C1.b')
# prob.root.connect('S1:s', 'C1.in_string')
# prob.root.connect('L1:l', 'C1.in_list')
prob.root.connect('C1.c', 'C2.a')
prob.root.connect('B2.b', 'C2.b')
# prob.root.connect('C1.out_string', 'C2.in_string')
# prob.root.connect('C1.out_list', 'C2.in_list')
prob.setup(check=False)
prob['A1.a'] = np.ones(size, float) * 3.0
prob['B1.b'] = np.ones(size, float) * 7.0
prob['B2.b'] = np.ones(size, float) * 5.0
prob.run()
self.assertTrue(all(prob['C2.a'] == np.ones(size, float) * 10.))
self.assertTrue(all(prob['C2.b'] == np.ones(size, float) * 5.))
self.assertTrue(all(prob['C2.c'] == np.ones(size, float) * 15.))
self.assertTrue(all(prob['C2.d'] == np.ones(size, float) * 5.))
def test_single_diamond_grouped(self):
prob = Problem()
prob.root = SingleDiamondGrouped()
prob.root.ln_solver = ScipyGMRES()
prob.setup(check=False)
prob.run()
param_list = ['p.x']
unknown_list = ['comp4.y1', 'comp4.y2']
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['comp4.y1']['p.x'][0][0], 25, 1e-6)
assert_rel_error(self, J['comp4.y2']['p.x'][0][0], -40.5, 1e-6)
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['comp4.y1']['p.x'][0][0], 25, 1e-6)
assert_rel_error(self, J['comp4.y2']['p.x'][0][0], -40.5, 1e-6)
J = prob.calc_gradient(param_list,
unknown_list,
mode='fd',
return_format='dict')
assert_rel_error(self, J['comp4.y1']['p.x'][0][0], 25, 1e-6)
assert_rel_error(self, J['comp4.y2']['p.x'][0][0], -40.5, 1e-6)
def test_record_derivs_dicts(self):
if OPT is None:
raise unittest.SkipTest("pyoptsparse is not installed")
if OPTIMIZER is None:
raise unittest.SkipTest(
"pyoptsparse is not providing SNOPT or SLSQP")
prob = Problem()
prob.root = SellarDerivativesGrouped()
prob.driver = pyOptSparseDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.opt_settings['ACC'] = 1e-9
prob.driver.options['print_results'] = False
prob.driver.add_desvar('z',
lower=np.array([-10.0, 0.0]),
upper=np.array([10.0, 10.0]))
prob.driver.add_desvar('x', lower=0.0, upper=10.0)
prob.driver.add_objective('obj')
prob.driver.add_constraint('con1', upper=0.0)
prob.driver.add_constraint('con2', upper=0.0)
prob.driver.add_recorder(self.recorder)
self.recorder.options['record_metadata'] = False
self.recorder.options['record_derivs'] = True
prob.setup(check=False)
prob.run()
prob.cleanup()
hdf = h5py.File(self.filename, 'r')
deriv_group = hdf['rank0:SLSQP|1']['Derivs']
self.assertEqual(deriv_group.attrs['success'], 1)
self.assertEqual(deriv_group.attrs['msg'], '')
J1 = deriv_group['Derivatives']
Jbase = {}
Jbase['con1'] = {}
Jbase['con1']['x'] = -0.98061433
Jbase['con1']['z'] = np.array([-9.61002285, -0.78449158])
Jbase['con2'] = {}
Jbase['con2']['x'] = 0.09692762
Jbase['con2']['z'] = np.array([1.94989079, 1.0775421])
Jbase['obj'] = {}
Jbase['obj']['x'] = 2.98061392
Jbase['obj']['z'] = np.array([9.61001155, 1.78448534])
for key1, val1 in Jbase.items():
for key2, val2 in val1.items():
assert_rel_error(self, J1[key1][key2][:], val2, .00001)
hdf.close()
def test_converge_diverge_groups(self):
prob = Problem()
prob.root = ConvergeDivergeGroups()
prob.root.ln_solver = ScipyGMRES()
prob.setup(check=False)
prob.run()
# Make sure value is fine.
assert_rel_error(self, prob['comp7.y1'], -102.7, 1e-6)
param_list = ['p.x']
unknown_list = ['comp7.y1']
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['comp7.y1']['p.x'][0][0], -40.75, 1e-6)
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['comp7.y1']['p.x'][0][0], -40.75, 1e-6)
J = prob.calc_gradient(param_list,
unknown_list,
mode='fd',
return_format='dict')
assert_rel_error(self, J['comp7.y1']['p.x'][0][0], -40.75, 1e-6)
def test_fan_in_grouped(self):
prob = Problem()
prob.root = FanInGrouped()
prob.root.ln_solver = ScipyGMRES()
param_list = ['p1.x1', 'p2.x2']
unknown_list = ['comp3.y']
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
def test_double_arraycomp(self):
# Mainly testing a bug in the array return for multiple arrays
group = Group()
group.add('x_param1', ParamComp('x1', np.ones((2))), promotes=['*'])
group.add('x_param2', ParamComp('x2', np.ones((2))), promotes=['*'])
group.add('mycomp', DoubleArrayComp(), promotes=['*'])
prob = Problem()
prob.root = group
prob.root.ln_solver = ScipyGMRES()
prob.setup(check=False)
prob.run()
Jbase = group.mycomp.JJ
J = prob.calc_gradient(['x1', 'x2'], ['y1', 'y2'],
mode='fwd',
return_format='array')
diff = np.linalg.norm(J - Jbase)
assert_rel_error(self, diff, 0.0, 1e-8)
J = prob.calc_gradient(['x1', 'x2'], ['y1', 'y2'],
mode='fd',
return_format='array')
diff = np.linalg.norm(J - Jbase)
assert_rel_error(self, diff, 0.0, 1e-8)
J = prob.calc_gradient(['x1', 'x2'], ['y1', 'y2'],
mode='rev',
return_format='array')
diff = np.linalg.norm(J - Jbase)
assert_rel_error(self, diff, 0.0, 1e-8)
def test_Sellar_state_SLSQP(self):
prob = Problem()
prob.root = SellarStateConnection()
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1.0e-8
prob.driver.add_param('z',
low=np.array([-10.0, 0.0]),
high=np.array([10.0, 10.0]))
prob.driver.add_param('x', low=0.0, high=10.0)
prob.driver.add_objective('obj')
prob.driver.add_constraint('con1')
prob.driver.add_constraint('con2')
prob.driver.options['disp'] = False
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['z'][0], 1.9776, 1e-3)
assert_rel_error(self, prob['z'][1], 0.0, 1e-3)
assert_rel_error(self, prob['x'], 0.0, 1e-3)
def test_simple_matvec(self):
class VerificationComp(SimpleCompDerivMatVec):
def jacobian(self, params, unknowns, resids):
raise RuntimeError("Derivative functions on this comp should not run.")
def apply_linear(self, params, unknowns, dparams, dunknowns,
dresids, mode):
raise RuntimeError("Derivative functions on this comp should not run.")
sub = Group()
sub.add('mycomp', VerificationComp())
prob = Problem()
prob.root = Group()
prob.root.add('sub', sub)
prob.root.add('x_param', IndepVarComp('x', 1.0))
prob.root.connect('x_param.x', "sub.mycomp.x")
sub.fd_options['force_fd'] = True
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x_param.x'], ['sub.mycomp.y'], mode='fwd',
return_format='dict')
assert_rel_error(self, J['sub.mycomp.y']['x_param.x'][0][0], 2.0, 1e-6)
J = prob.calc_gradient(['x_param.x'], ['sub.mycomp.y'], mode='rev',
return_format='dict')
assert_rel_error(self, J['sub.mycomp.y']['x_param.x'][0][0], 2.0, 1e-6)
def test_byobj_run(self):
prob = Problem(root=ExampleByObjGroup())
prob.setup(check=False)
prob.run()
self.assertEqual(prob['G3.C4.y'], 'fooC2C3C4')
def test_read3(self):
# Parse a single group in a deck with non-unique group names
namelist1 = "Testing\n" + \
"$GROUP\n" + \
" intvar = 99\n" + \
"$END\n" + \
"$GROUP\n" + \
" floatvar = 3.5e-23\n" + \
"$END\n"
outfile = open(self.filename, 'w')
outfile.write(namelist1)
outfile.close()
top = Problem()
top.root = Group()
top.root.add('my_comp', VarComponent())
top.setup(check=False)
top.run()
sb = Namelist(top.root.my_comp)
sb.set_filename(self.filename)
sb.parse_file()
sb.load_model(single_group=1)
# Unchanged
self.assertEqual(top['my_comp.intvar'], 333)
# Changed
self.assertEqual(top['my_comp.floatvar'], 3.5e-23)
def test_inp_inp_promoted_w_explicit_src(self):
p = Problem(root=Group())
root = p.root
G1 = root.add("G1", Group())
G2 = G1.add("G2", Group(), promotes=['x'])
C1 = G2.add("C1", ExecComp('y=x*2.0'))
C2 = G2.add("C2", ParamComp('x', 1.0), promotes=['x'])
G3 = root.add("G3", Group())
G4 = G3.add("G4", Group(), promotes=['x'])
C3 = G4.add("C3", ExecComp('y=x*2.0'), promotes=['x'])
C4 = G4.add("C4", ExecComp('y=x*2.0'), promotes=['x'])
p.root.connect('G1.x', 'G3.x')
p.setup(check=False)
self.assertEqual(p._dangling['G1.G2.C1.x'], set(['G1.G2.C1.x']))
self.assertEqual(len(p._dangling), 1)
# setting promoted name will set the value into the unknowns, but will
# not propagate it to the params. That will happen during run().
p['G1.x'] = 999.
self.assertEqual(p.root.G3.G4.C3.params['x'], 0.)
self.assertEqual(p.root.G3.G4.C4.params['x'], 0.)
p.run()
self.assertEqual(p.root.G3.G4.C3.params['x'], 999.)
self.assertEqual(p.root.G3.G4.C4.params['x'], 999.)
def test_noncontiguous_idxs(self):
# take even input indices in 0 rank and odd ones in 1 rank
size = 11
p = Problem(root=Group(), impl=impl)
top = p.root
top.add("C1", InOutArrayComp(size))
top.add("C2", DistribNoncontiguousComp(size))
top.add("C3", DistribGatherComp(size))
top.connect('C1.outvec', 'C2.invec')
top.connect('C2.outvec', 'C3.invec')
p.setup(check=False)
top.C1.params['invec'] = np.array(range(size), float)
p.run()
if MPI:
if self.comm.rank == 0:
self.assertTrue(all(top.C2.unknowns['outvec'] == np.array(list(take_nth(0, 2, range(size))), 'f')*4))
else:
self.assertTrue(all(top.C2.unknowns['outvec'] == np.array(list(take_nth(1, 2, range(size))), 'f')*4))
full_list = list(take_nth(0, 2, range(size))) + list(take_nth(1, 2, range(size)))
self.assertTrue(all(top.C3.unknowns['outvec'] == np.array(full_list, 'f')*4))
else:
self.assertTrue(all(top.C2.unknowns['outvec']==top.C1.unknowns['outvec']*2.))
self.assertTrue(all(top.C3.unknowns['outvec']==top.C2.unknowns['outvec']))
def test_driver_param_indices_snopt(self):
""" Test driver param indices with pyOptSparse and force_fd=False
"""
prob = Problem()
prob.root = SellarStateConnection()
prob.root.fd_options['force_fd'] = False
prob.driver = pyOptSparseDriver()
prob.driver.add_desvar('z', low=np.array([-10.0]),
high=np.array([10.0]),indices=[0])
prob.driver.add_desvar('x', low=0.0, high=10.0)
prob.driver.add_objective('obj')
prob.driver.add_constraint('con1', upper=0.0)
prob.driver.add_constraint('con2', upper=0.0)
prob.setup(check=False)
prob['z'][1] = 0.0
prob.run()
assert_rel_error(self, prob['z'][0], 1.9776, 1e-3)
assert_rel_error(self, prob['z'][1], 0.0, 1e-3)
assert_rel_error(self, prob['x'], 0.0, 1e-3)
def test_Sellar_state_SLSQP(self):
""" Baseline Sellar test case without specifying indices.
"""
prob = Problem()
prob.root = SellarStateConnection()
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1.0e-8
prob.driver.add_desvar('z', low=np.array([-10.0, 0.0]),
high=np.array([10.0, 10.0]))
prob.driver.add_desvar('x', low=0.0, high=10.0)
prob.driver.add_objective('obj')
prob.driver.add_constraint('con1', upper=0.0)
prob.driver.add_constraint('con2', upper=0.0)
prob.driver.options['disp'] = False
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['z'][0], 1.9776, 1e-3)
assert_rel_error(self, prob['z'][1], 0.0, 1e-3)
assert_rel_error(self, prob['x'], 0.0, 1e-3)
def test_calc_gradient_multiple_params(self):
prob = Problem()
prob.root = FanIn()
prob.setup(check=False)
prob.run()
param_list = ['p1.x1', 'p2.x2']
unknown_list = ['comp3.y']
# check that calc_gradient returns proper dict value when mode is 'fwd'
J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict')
np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[ 35.]]))
np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[ -6.]]))
# check that calc_gradient returns proper array value when mode is 'fwd'
J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='array')
np.testing.assert_almost_equal(J, np.array([[-6., 35.]]))
# check that calc_gradient returns proper dict value when mode is 'rev'
J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict')
np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[ 35.]]))
np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[ -6.]]))
# check that calc_gradient returns proper array value when mode is 'rev'
J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='array')
np.testing.assert_almost_equal(J, np.array([[-6., 35.]]))
# check that calc_gradient returns proper dict value when mode is 'fd'
J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='dict')
np.testing.assert_almost_equal(J['comp3.y']['p2.x2'], np.array([[ 35.]]))
np.testing.assert_almost_equal(J['comp3.y']['p1.x1'], np.array([[ -6.]]))
# check that calc_gradient returns proper array value when mode is 'fd'
J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='array')
np.testing.assert_almost_equal(J, np.array([[-6., 35.]]))
def test_fan_out_serial_sets(self):
prob = Problem(impl=impl)
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# Parallel Groups
prob.driver.add_desvar('p.x')
prob.driver.add_constraint('c2.y', upper=0.0)
prob.driver.add_constraint('c3.y', upper=0.0)
prob.setup(check=False)
prob.run()
unknown_list = ['c2.y', 'c3.y']
indep_list = ['p.x']
J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict')
assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict')
assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
def test_bad_size(self):
class BadComp(SimpleArrayComp):
def jacobian(self, params, unknowns, resids):
"""Analytical derivatives"""
J = {}
J[('y', 'x')] = np.zeros((3, 3))
return J
prob = Problem()
prob.root = Group()
prob.root.add('comp', BadComp())
prob.root.add('p1', ParamComp('x', np.ones([2])))
prob.root.connect('p1.x', 'comp.x')
prob.setup(check=False)
prob.run()
try:
data = prob.check_partial_derivatives(out_stream=None)
except Exception as err:
msg = "Jacobian in component 'comp' between the" + \
" variables 'x' and 'y' is the wrong size. " + \
"It should be 2 by 2"
self.assertEqual(str(err), msg)
else:
self.fail("Error expected")
def test_fan_out_parallel_sets(self):
prob = Problem(impl=impl)
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# need to set mode to rev before setup. Otherwise the sub-vectors
# for the parallel set vars won't get allocated.
prob.root.ln_solver.options["mode"] = "rev"
prob.root.sub.ln_solver.options["mode"] = "rev"
# Parallel Groups
prob.driver.add_param("p.x")
prob.driver.add_constraint("c2.y")
prob.driver.add_constraint("c3.y")
prob.driver.parallel_derivs(["c2.y", "c3.y"])
self.assertEqual(prob.driver.outputs_of_interest(), [("c2.y", "c3.y")])
prob.setup(check=False)
prob.run()
unknown_list = ["c2.y", "c3.y"]
param_list = ["p.x"]
J = prob.calc_gradient(param_list, unknown_list, mode="rev", return_format="dict")
assert_rel_error(self, J["c2.y"]["p.x"][0][0], -6.0, 1e-6)
assert_rel_error(self, J["c3.y"]["p.x"][0][0], 15.0, 1e-6)
J = prob.calc_gradient(param_list, unknown_list, mode="fwd", return_format="dict")
assert_rel_error(self, J["c2.y"]["p.x"][0][0], -6.0, 1e-6)
assert_rel_error(self, J["c3.y"]["p.x"][0][0], 15.0, 1e-6)
def test_inp_inp_promoted_w_explicit_src(self):
p = Problem(root=Group())
root = p.root
G1 = root.add("G1", Group())
G2 = G1.add("G2", Group(), promotes=['x'])
C1 = G2.add("C1", ExecComp('y=x*2.0'))
C2 = G2.add("C2", ParamComp('x', 1.0), promotes=['x'])
G3 = root.add("G3", Group())
G4 = G3.add("G4", Group(), promotes=['x'])
C3 = G4.add("C3", ExecComp('y=x*2.0'), promotes=['x'])
C4 = G4.add("C4", ExecComp('y=x*2.0'), promotes=['x'])
p.root.connect('G1.x', 'G3.x')
p.setup(check=False)
self.assertEqual(p._dangling['G1.G2.C1.x'], set(['G1.G2.C1.x']))
self.assertEqual(len(p._dangling), 1)
# setting promoted name will set the value into the unknowns, but will
# not propagate it to the params. That will happen during run().
p['G1.x'] = 999.
self.assertEqual(p.root.G3.G4.C3.params['x'], 0.)
self.assertEqual(p.root.G3.G4.C4.params['x'], 0.)
p.run()
self.assertEqual(p.root.G3.G4.C3.params['x'], 999.)
self.assertEqual(p.root.G3.G4.C4.params['x'], 999.)
def test_full_model_fd_double_diamond_grouped(self):
prob = Problem()
prob.root = ConvergeDivergeGroups()
prob.setup(check=False)
prob.run()
prob.root.fd_options['force_fd'] = True
param_list = ['sub1.comp1.x1']
unknown_list = ['comp7.y1']
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['comp7.y1']['sub1.comp1.x1'][0][0], -40.75,
1e-6)
prob.root.fd_options['form'] = 'central'
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['comp7.y1']['sub1.comp1.x1'][0][0], -40.75,
1e-6)
def test_simple(self):
prob = Problem(Group(), impl=impl)
size = 5
A1 = prob.root.add('A1', ParamComp('a', np.zeros(size, float)))
B1 = prob.root.add('B1', ParamComp('b', np.zeros(size, float)))
B2 = prob.root.add('B2', ParamComp('b', np.zeros(size, float)))
S1 = prob.root.add('S1', ParamComp('s', ''))
L1 = prob.root.add('L1', ParamComp('l', []))
C1 = prob.root.add('C1', ABCDArrayComp(size))
C2 = prob.root.add('C2', ABCDArrayComp(size))
prob.root.connect('A1.a', 'C1.a')
prob.root.connect('B1.b', 'C1.b')
# prob.root.connect('S1:s', 'C1.in_string')
# prob.root.connect('L1:l', 'C1.in_list')
prob.root.connect('C1.c', 'C2.a')
prob.root.connect('B2.b', 'C2.b')
# prob.root.connect('C1.out_string', 'C2.in_string')
# prob.root.connect('C1.out_list', 'C2.in_list')
prob.setup(check=False)
prob['A1.a'] = np.ones(size, float) * 3.0
prob['B1.b'] = np.ones(size, float) * 7.0
prob['B2.b'] = np.ones(size, float) * 5.0
prob.run()
self.assertTrue(all(prob['C2.a']==np.ones(size, float)*10.))
self.assertTrue(all(prob['C2.b']==np.ones(size, float)*5.))
self.assertTrue(all(prob['C2.c']==np.ones(size, float)*15.))
self.assertTrue(all(prob['C2.d']==np.ones(size, float)*5.))
def test_parallel_diamond(self):
size = 3
prob = Problem(Group(), impl=impl)
root = prob.root
root.add('P1', ParamComp('x', np.ones(size, float) * 1.1))
G1 = root.add('G1', ParallelGroup())
G1.add('C1', ABCDArrayComp(size))
G1.add('C2', ABCDArrayComp(size))
root.add('C3', ABCDArrayComp(size))
root.connect('P1.x', 'G1.C1.a')
root.connect('P1.x', 'G1.C2.b')
root.connect('G1.C1.c', 'C3.a')
root.connect('G1.C2.d', 'C3.b')
prob.setup(check=False)
prob.run()
if not MPI or self.comm.rank == 0:
assert_rel_error(self, prob.root.G1.C1.unknowns['c'],
np.ones(size)*2.1, 1.e-10)
assert_rel_error(self, prob.root.G1.C1.unknowns['d'],
np.ones(size)*.1, 1.e-10)
assert_rel_error(self, prob.root.C3.params['a'],
np.ones(size)*2.1, 1.e-10)
assert_rel_error(self, prob.root.C3.params['b'],
np.ones(size)*-.1, 1.e-10)
if not MPI or self.comm.rank == 1:
assert_rel_error(self, prob.root.G1.C2.unknowns['c'],
np.ones(size)*2.1, 1.e-10)
assert_rel_error(self, prob.root.G1.C2.unknowns['d'],
np.ones(size)*-.1, 1.e-10)
def test_fan_out_serial_sets(self):
prob = Problem(impl=impl)
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# Parallel Groups
prob.driver.add_param('p.x')
prob.driver.add_constraint('c2.y')
prob.driver.add_constraint('c3.y')
prob.setup(check=False)
prob.run()
unknown_list = ['c2.y', 'c3.y']
param_list = ['p.x']
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
def test_2Darray_write(self):
top = Problem()
top.root = Group()
top.root.add('my_comp', VarComponent())
top.setup(check=False)
top.run()
sb = Namelist(top.root.my_comp)
top['my_comp.arrayvar'] = zeros([3, 2], dtype=numpy_float32)
top['my_comp.arrayvar'][0, 1] = 3.7
top['my_comp.arrayvar'][2, 0] = 7.88
sb.set_filename(self.filename)
sb.add_group('Test')
sb.add_var("arrayvar")
sb.generate()
f = open(self.filename, 'r')
contents = f.read()
compare = "\n" + \
"&Test\n" + \
" arrayvar(1,1) = 0.0, 3.700000047683716, \n" + \
"arrayvar(1,2) = 0.0, 0.0, \n" + \
"arrayvar(1,3) = 7.880000114440918, 0.0, \n" + \
"/\n"
self.assertEqual(contents, compare)
def test_fan_in_serial_sets(self):
prob = Problem(impl=impl)
prob.root = FanInGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# Parallel Groups
prob.driver.add_param("p1.x1")
prob.driver.add_param("p2.x2")
prob.driver.add_objective("comp3.y")
prob.setup(check=False)
prob.run()
param_list = ["p1.x1", "p2.x2"]
unknown_list = ["comp3.y"]
J = prob.calc_gradient(param_list, unknown_list, mode="rev", return_format="dict")
assert_rel_error(self, J["comp3.y"]["p1.x1"][0][0], -6.0, 1e-6)
assert_rel_error(self, J["comp3.y"]["p2.x2"][0][0], 35.0, 1e-6)
J = prob.calc_gradient(param_list, unknown_list, mode="fwd", return_format="dict")
assert_rel_error(self, J["comp3.y"]["p1.x1"][0][0], -6.0, 1e-6)
assert_rel_error(self, J["comp3.y"]["p2.x2"][0][0], 35.0, 1e-6)
def test_index_error_messages_con(self):
prob = Problem()
prob.root = Group()
prob.root.fd_options['force_fd'] = True
prob.root.ln_solver.options['mode'] = 'auto'
prob.root.add('myparams', IndepVarComp('x', np.zeros(4)))
prob.root.add('rosen', Rosenbrock(4))
prob.root.connect('myparams.x', 'rosen.x')
prob.driver = MySimpleDriver()
prob.driver.add_desvar('myparams.x')
prob.driver.add_constraint('rosen.xxx', upper=0.0, indices=[4])
prob.setup(check=False)
# Make sure we can't do this
with self.assertRaises(IndexError) as cm:
prob.run()
msg = "Index for constraint 'rosen.xxx' is out of bounds. "
msg += "Requested index: [4], "
msg += "shape: (4,)."
raised_error = str(cm.exception)
raised_error = raised_error.replace('(4L,', '(4,')
self.assertEqual(msg, raised_error)
def test_fan_out_serial_sets(self):
prob = Problem(impl=impl)
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# Parallel Groups
prob.driver.add_param("p.x")
prob.driver.add_constraint("c2.y")
prob.driver.add_constraint("c3.y")
prob.setup(check=False)
prob.run()
unknown_list = ["c2.y", "c3.y"]
param_list = ["p.x"]
J = prob.calc_gradient(param_list, unknown_list, mode="fwd", return_format="dict")
assert_rel_error(self, J["c2.y"]["p.x"][0][0], -6.0, 1e-6)
assert_rel_error(self, J["c3.y"]["p.x"][0][0], 15.0, 1e-6)
J = prob.calc_gradient(param_list, unknown_list, mode="rev", return_format="dict")
assert_rel_error(self, J["c2.y"]["p.x"][0][0], -6.0, 1e-6)
assert_rel_error(self, J["c3.y"]["p.x"][0][0], 15.0, 1e-6)
def test_fan_in_serial_sets(self):
prob = Problem(impl=impl)
prob.root = FanInGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# Parallel Groups
prob.driver.add_param('p1.x1')
prob.driver.add_param('p2.x2')
prob.driver.add_objective('comp3.y')
prob.setup(check=False)
prob.run()
param_list = ['p1.x1', 'p2.x2']
unknown_list = ['comp3.y']
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
def test_converge_diverge_groups(self):
prob = Problem()
prob.root = Group()
prob.root.add('sub', ConvergeDivergeGroups())
param_list = ['sub.p.x']
unknown_list = ['sub.comp7.y1']
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['sub.comp7.y1']['sub.p.x'][0][0], -40.75,
1e-6)
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['sub.comp7.y1']['sub.p.x'][0][0], -40.75,
1e-6)
def test_includes_and_excludes(self):
prob = Problem()
prob.root = ConvergeDiverge()
prob.driver.add_recorder(self.recorder)
self.recorder.options['includes'] = ['comp1.*']
self.recorder.options['excludes'] = ["*.y2"]
prob.setup(check=False)
prob.run()
expected_params = [
("comp1.x1", 2.0)
]
expected_unknowns = [
("comp1.y1", 8.0)
]
expected_resids = [
("comp1.y1", 0.0)
]
expected = (expected_params, expected_unknowns, expected_resids)
self.assertDatasetEquals(
[(['Driver', (1,)], expected)],
self.eps
)
def test_basic_run(self):
prob = Problem(root=ExampleGroup())
prob.setup(check=False)
prob.run()
self.assertAlmostEqual(prob['G3.C4.y'], 40.)
def test_driver_param_indices_snopt_force_fd_shift(self):
""" Testt driver param indices with pyOptSparse and force_fd=True
"""
prob = Problem()
prob.root = SellarStateConnection()
prob.root.fd_options['force_fd'] = True
prob.driver.add_desvar('z', low=np.array([-10.0, -10.0]),
high=np.array([10.0, 10.0]), indices=[1])
prob.driver.add_desvar('x', low=0.0, high=10.0)
prob.driver.add_objective('obj')
prob.driver.add_constraint('con1', upper=0.0)
prob.driver.add_constraint('con2', upper=0.0)
#prob.driver.options['disp'] = False
prob.setup(check=False)
prob['z'][1] = 0.0
prob.run()
J = prob.calc_gradient(['x', 'z'], ['obj'], mode='fd',
return_format='array')
assert_rel_error(self, J[0][1], 1.78402, 1e-3)
def test_mode_auto(self):
# Make sure mode=auto chooses correctly for all prob sizes as well
# as for abs/rel/etc paths
prob = Problem()
root = prob.root = Group()
root.add('p1', ParamComp('a', 1.0), promotes=['*'])
root.add('p2', ParamComp('b', 1.0), promotes=['*'])
root.add('comp', ExecComp(['x = 2.0*a + 3.0*b', 'y=4.0*a - 1.0*b']), promotes=['*'])
root.ln_solver.options['mode'] = 'auto'
prob.setup(check=False)
prob.run()
mode = prob._mode('auto', ['a'], ['x'])
self.assertEqual(mode, 'fwd')
mode = prob._mode('auto', ['a', 'b'], ['x'])
self.assertEqual(mode, 'rev')
# make sure _check function does it too
#try:
#mode = prob._check_for_matrix_matrix(['a'], ['x'])
#except Exception as err:
#msg = "Group '' must have the same mode as root to use Matrix Matrix."
#self.assertEqual(text_type(err), msg)
#else:
#self.fail('Exception expected')
root.ln_solver.options['mode'] = 'fwd'
mode = prob._check_for_matrix_matrix(['a', 'b'], ['x'])
self.assertEqual(mode, 'fwd')
def test_driver_param_indices_slsqp_force_fd(self):
""" Test driver param indices with ScipyOptimizer SLSQP and force_fd=True
"""
prob = Problem()
prob.root = SellarStateConnection()
prob.root.fd_options['force_fd'] = True
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1.0e-8
prob.driver.add_desvar('z', low=np.array([-10.0]),
high=np.array([10.0]),indices=[0])
prob.driver.add_desvar('x', low=0.0, high=10.0)
prob.driver.add_objective('obj')
prob.driver.add_constraint('con1', upper=0.0)
prob.driver.add_constraint('con2', upper=0.0)
#prob.driver.options['disp'] = False
prob.setup(check=False)
prob['z'][1] = 0.0
prob.run()
assert_rel_error(self, prob['z'][0], 1.9776, 1e-3)
assert_rel_error(self, prob['z'][1], 0.0, 1e-3)
assert_rel_error(self, prob['x'], 0.0, 1e-3)
def test_index_error_messages_con(self):
prob = Problem()
prob.root = Group()
prob.root.fd_options['force_fd'] = True
prob.root.ln_solver.options['mode'] = 'auto'
prob.root.add('myparams', ParamComp('x', np.zeros(4)))
prob.root.add('rosen', Rosenbrock(4))
prob.root.connect('myparams.x', 'rosen.x')
prob.driver = MySimpleDriver()
prob.driver.add_param('myparams.x')
prob.driver.add_constraint('rosen.xxx', indices=[4])
prob.setup(check=False)
# Make sure we can't do this
with self.assertRaises(IndexError) as cm:
prob.run()
msg = "Index for constraint 'rosen.xxx' is out of bounds. "
msg += "Requested index: [4], "
msg += "Parameter shape: (4,)."
raised_error = str(cm.exception)
raised_error = raised_error.replace('(4L,', '(4,')
self.assertEqual(msg, raised_error)
def test_array2D_index_connection(self):
group = Group()
group.add('x_param', IndepVarComp('x', np.ones((2, 2))), promotes=['*'])
sub = group.add('sub', Group(), promotes=['*'])
sub.add('mycomp', ArrayComp2D(), promotes=['x', 'y'])
group.add('obj', ExecComp('b = a'))
group.connect('y', 'obj.a', src_indices=[3])
prob = Problem()
prob.root = group
prob.root.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x'], ['obj.b'], mode='fwd', return_format='dict')
Jbase = prob.root.sub.mycomp._jacobian_cache
assert_rel_error(self, Jbase[('y', 'x')][3][0], J['obj.b']['x'][0][0], 1e-8)
assert_rel_error(self, Jbase[('y', 'x')][3][1], J['obj.b']['x'][0][1], 1e-8)
assert_rel_error(self, Jbase[('y', 'x')][3][2], J['obj.b']['x'][0][2], 1e-8)
assert_rel_error(self, Jbase[('y', 'x')][3][3], J['obj.b']['x'][0][3], 1e-8)
J = prob.calc_gradient(['x'], ['obj.b'], mode='rev', return_format='dict')
Jbase = prob.root.sub.mycomp._jacobian_cache
assert_rel_error(self, Jbase[('y', 'x')][3][0], J['obj.b']['x'][0][0], 1e-8)
assert_rel_error(self, Jbase[('y', 'x')][3][1], J['obj.b']['x'][0][1], 1e-8)
assert_rel_error(self, Jbase[('y', 'x')][3][2], J['obj.b']['x'][0][2], 1e-8)
assert_rel_error(self, Jbase[('y', 'x')][3][3], J['obj.b']['x'][0][3], 1e-8)
def test_fan_out_parallel_sets(self):
prob = Problem(impl=impl)
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# need to set mode to rev before setup. Otherwise the sub-vectors
# for the parallel set vars won't get allocated.
prob.root.ln_solver.options['mode'] = 'rev'
prob.root.sub.ln_solver.options['mode'] = 'rev'
# Parallel Groups
prob.driver.add_param('p.x')
prob.driver.add_constraint('c2.y')
prob.driver.add_constraint('c3.y')
prob.driver.parallel_derivs(['c2.y','c3.y'])
self.assertEqual(prob.driver.outputs_of_interest(),
[('c2.y','c3.y')])
prob.setup(check=False)
prob.run()
unknown_list = ['c2.y', 'c3.y']
param_list = ['p.x']
J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict')
assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict')
assert_rel_error(self, J['c2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['c3.y']['p.x'][0][0], 15.0, 1e-6)
def test_overlapping_inputs_idxs(self):
# distrib comp with src_indices that overlap, i.e. the same
# entries are distributed to multiple processes
size = 11
p = Problem(root=Group(), impl=impl)
top = p.root
top.add("C1", InOutArrayComp(size))
top.add("C2", DistribOverlappingInputComp(size))
top.connect('C1.outvec', 'C2.invec')
p.setup(check=False)
top.C1.params['invec'] = np.array(range(size, 0, -1), float)
p.run()
self.assertTrue(
all(top.C2.unknowns['outvec'][:4] ==
np.array(range(size, 0, -1), float)[:4] * 4))
self.assertTrue(
all(top.C2.unknowns['outvec'][8:] ==
np.array(range(size, 0, -1), float)[8:] * 4))
# overlapping part should be double size of the rest
self.assertTrue(
all(top.C2.unknowns['outvec'][4:8] ==
np.array(range(size, 0, -1), float)[4:8] * 8))
def test_basic_run(self):
prob = Problem(root=ExampleGroup())
prob.setup(check=False)
prob.run()
self.assertAlmostEqual(prob['G3.C4.y'], 40.)
def test_2Darray_read(self):
namelist1 = "Testing\n" + \
"$GROUP\n" + \
" arrayvartwod(1,1) = 12, 24, 36\n" + \
" arrayvartwod(1,2) = 33, 66, 99\n" + \
"$END\n"
outfile = open(self.filename, 'w')
outfile.write(namelist1)
outfile.close()
top = Problem()
top.root = Group()
top.root.add('my_comp', VarComponent())
top.setup(check=False)
top.run()
sb = Namelist(top.root.my_comp)
sb.set_filename(self.filename)
sb.parse_file()
sb.load_model()
# Unchanged
self.assertEqual(top['my_comp.arrayvartwod'][0][0], 12)
self.assertEqual(top['my_comp.arrayvartwod'][1][2], 99)
def test_array_values(self):
prob = Problem()
prob.root = Group()
prob.root.add('pc',
ParamComp('x', np.zeros((2, 3)), units='degC'),
promotes=['x'])
prob.root.add('uc',
UnitComp(shape=(2, 3),
param_name='x',
out_name='x_out',
units='degF'),
promotes=['x', 'x_out'])
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['x_out'],
np.array([[32., 32., 32.], [32., 32., 32.]]), 1e-6)
param_list = ['x']
unknown_list = ['x_out']
# Forward Mode
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['x_out']['x'], 1.8 * np.eye(6), 1e-6)
# Reverse Mode
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['x_out']['x'], 1.8 * np.eye(6), 1e-6)
def test_unsupported_array(self):
top = Problem()
top.root = Group()
top.root.add('my_comp', VarComponent())
top.setup(check=False)
top.run()
sb = Namelist(top.root.my_comp)
top['my_comp.arrayvar'] = zeros([2, 2, 2], dtype=numpy_float32)
sb.set_filename(self.filename)
sb.add_group('Test')
sb.add_var("arrayvar")
try:
sb.generate()
except RuntimeError as err:
self.assertEqual(str(err),
"Don't know how to handle array of" + \
" 3 dimensions")
else:
self.fail('RuntimeError expected')
def test_simple_array_comp(self):
prob = Problem()
root = prob.root = Group()
root.add('p1', ParamComp('x', np.zeros([2])), promotes=['*'])
root.add('comp', SimpleArrayComp(), promotes=['*'])
root.add('con',
ExecComp('c = y - 20.0',
c=np.array([0.0, 0.0]),
y=np.array([0.0, 0.0])),
promotes=['*'])
root.add('obj',
ExecComp('o = y[0]', y=np.array([0.0, 0.0])),
promotes=['*'])
prob.driver = pyOptSparseDriver()
prob.driver.add_param('x', low=-50.0, high=50.0)
prob.driver.add_objective('o')
prob.driver.add_constraint('c', ctype='eq')
prob.setup(check=False)
prob.run()
obj = prob['o']
assert_rel_error(self, obj, 20.0, 1e-6)
def test_unconnected_param_access_with_promotes(self):
prob = Problem(root=Group())
G1 = prob.root.add('G1', Group())
G2 = G1.add('G2', Group(), promotes=['x'])
C1 = G2.add('C1', ExecComp(['y=2.0*x',
'z=x*x-2.0']), promotes=['x'])
C2 = G2.add('C2', ExecComp(['y=2.0*x',
'z=x*x-2.0']))
G2.connect('C1.y', 'C2.x')
# ignore warning about the unconnected param
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("ignore")
prob.setup(check=False)
prob.run()
# still must use absolute naming to find params even if they're
# promoted. Promoted names for params can refer to more than one param.
C1.params['x'] = 2.
self.assertEqual(prob['G1.x'], 2.0)
self.assertEqual(prob.root.G1.G2.C1.params['x'], 2.0)
prob['G1.x'] = 99.
self.assertEqual(C1.params['x'], 99.)
prob['G1.x'] = 12.
self.assertEqual(C1.params['x'], 12.)
prob['G1.x'] = 17.
self.assertEqual(prob.root.G1.G2.C1.params['x'], 17.0)
prob.run()
def test_fan_in_serial_sets(self):
prob = Problem(impl=impl)
prob.root = FanInGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# Parallel Groups
prob.driver.add_desvar('p1.x1')
prob.driver.add_desvar('p2.x2')
prob.driver.add_objective('comp3.y')
prob.setup(check=False)
prob.run()
indep_list = ['p1.x1', 'p2.x2']
unknown_list = ['comp3.y']
J = prob.calc_gradient(indep_list, unknown_list, mode='rev', return_format='dict')
assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
J = prob.calc_gradient(indep_list, unknown_list, mode='fwd', return_format='dict')
assert_rel_error(self, J['comp3.y']['p1.x1'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['comp3.y']['p2.x2'][0][0], 35.0, 1e-6)
def test_calc_gradient_multiple_params(self):
prob = Problem()
prob.root = FanIn()
prob.setup(check=False)
prob.run()
param_list = ['p1.x1', 'p2.x2']
unknown_list = ['comp3.y']
# check that calc_gradient returns proper dict value when mode is 'fwd'
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
np.testing.assert_almost_equal(J['comp3.y']['p2.x2'],
np.array([[35.]]))
np.testing.assert_almost_equal(J['comp3.y']['p1.x1'],
np.array([[-6.]]))
# check that calc_gradient returns proper array value when mode is 'fwd'
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='array')
np.testing.assert_almost_equal(J, np.array([[-6., 35.]]))
# check that calc_gradient returns proper dict value when mode is 'rev'
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='dict')
np.testing.assert_almost_equal(J['comp3.y']['p2.x2'],
np.array([[35.]]))
np.testing.assert_almost_equal(J['comp3.y']['p1.x1'],
np.array([[-6.]]))
# check that calc_gradient returns proper array value when mode is 'rev'
J = prob.calc_gradient(param_list,
unknown_list,
mode='rev',
return_format='array')
np.testing.assert_almost_equal(J, np.array([[-6., 35.]]))
# check that calc_gradient returns proper dict value when mode is 'fd'
J = prob.calc_gradient(param_list,
unknown_list,
mode='fd',
return_format='dict')
np.testing.assert_almost_equal(J['comp3.y']['p2.x2'],
np.array([[35.]]))
np.testing.assert_almost_equal(J['comp3.y']['p1.x1'],
np.array([[-6.]]))
# check that calc_gradient returns proper array value when mode is 'fd'
J = prob.calc_gradient(param_list,
unknown_list,
mode='fd',
return_format='array')
np.testing.assert_almost_equal(J, np.array([[-6., 35.]]))
def test_unknown_vec(self):
top = Problem()
top.root = Group()
top.root.add('comp', ArrayComp2D(), promotes=['x', 'y'])
top.root.add('p1',
IndepVarComp('x', np.array([[1.0, 2.0], [3.0, 4.0]])),
promotes=['x'])
top.root.add('comp2', SimpleComp())
top.root.add('p2', IndepVarComp('x', 3.0))
top.root.connect('p2.x', 'comp2.x')
top.setup(check=False)
top.run()
unknowns = ComplexStepSrcVecWrapper(top.root.comp.unknowns)
# Unknowns are always complex
y = unknowns['y']
self.assertTrue(y.dtype == np.complex)
self.assertEquals(y[0, 1], 46.0 + 0j)
# Set an unknown
unknowns['y'][0, 1] = 13.0 + 17.0j
self.assertEquals(unknowns['y'][0, 1], 13.0 + 17.0j)
# Extract flat var
cval = unknowns.flat('y')
self.assertEquals(cval[1], 13.0 + 17.0j)
self.assertEquals(cval.shape[0], 4)
unknowns = ComplexStepSrcVecWrapper(top.root.comp2.unknowns)
# Unknowns are always complex
y = unknowns['y']
self.assertTrue(y.dtype == np.complex)
self.assertEquals(y, 6.0 + 0j)
# Set an unknown
unknowns['y'] = 13.0 + 17.0j
self.assertEquals(unknowns['y'], 13.0 + 17.0j)
# Extract flat var
cval = unknowns.flat('y')
self.assertEquals(cval, 13.0 + 17.0j)
self.assertEquals(cval.shape[0], 1)
# Make sure all other functions work for coverage
self.assertEquals(len(unknowns), 1)
self.assertTrue('y' in unknowns)
plist = [z for z in unknowns]
self.assertEquals(plist, ['y'])
self.assertEquals(unknowns.keys(), top.root.comp2.unknowns.keys())
self.assertEquals(unknowns.metadata('y'),
top.root.comp2.unknowns.metadata('y'))
plist1 = [z for z in unknowns.iterkeys()]
plist2 = [z for z in top.root.comp2.unknowns.iterkeys()]
def test_indices(self):
asize = 3
prob = Problem(root=Group(), impl=impl)
root = prob.root
root.ln_solver = LinearGaussSeidel()
root.ln_solver.options['mode'] = 'rev'
p = root.add('p', ParamComp('x', np.arange(asize, dtype=float) + 1.0))
G1 = root.add('G1', ParallelGroup())
G1.ln_solver = LinearGaussSeidel()
G1.ln_solver.options['mode'] = 'rev'
c2 = G1.add(
'c2',
ExecComp4Test('y = x * 2.0', x=np.zeros(asize), y=np.zeros(asize)))
c3 = G1.add(
'c3',
ExecComp4Test('y = numpy.ones(3).T*x.dot(numpy.arange(3.,6.))',
x=np.zeros(asize),
y=np.zeros(asize)))
c4 = root.add(
'c4',
ExecComp4Test('y = x * 4.0', x=np.zeros(asize), y=np.zeros(asize)))
c5 = root.add(
'c5',
ExecComp4Test('y = x * 5.0', x=np.zeros(asize), y=np.zeros(asize)))
prob.driver.add_param('p.x', indices=[1, 2])
prob.driver.add_constraint('c4.y', indices=[1])
prob.driver.add_constraint('c5.y', indices=[2])
prob.driver.parallel_derivs(['c4.y', 'c5.y'])
root.connect('p.x', 'G1.c2.x')
root.connect('p.x', 'G1.c3.x')
root.connect('G1.c2.y', 'c4.x')
root.connect('G1.c3.y', 'c5.x')
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['p.x'], ['c4.y', 'c5.y'],
mode='fwd',
return_format='dict')
assert_rel_error(self, J['c5.y']['p.x'][0], np.array([20., 25.]), 1e-6)
assert_rel_error(self, J['c4.y']['p.x'][0], np.array([8., 0.]), 1e-6)
J = prob.calc_gradient(['p.x'], ['c4.y', 'c5.y'],
mode='rev',
return_format='dict')
assert_rel_error(self, J['c5.y']['p.x'][0], np.array([20., 25.]), 1e-6)
assert_rel_error(self, J['c4.y']['p.x'][0], np.array([8., 0.]), 1e-6)
def test_sellar_derivs(self):
prob = Problem()
prob.root = SellarDerivatives()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.ln_solver.options['maxiter'] = 4
prob.root.nl_solver.options['atol'] = 1e-12
prob.setup(check=False)
prob.run()
# Just make sure we are at the right answer
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)
param_list = ['x', 'z']
param_list = ['x']
unknown_list = ['obj', 'con1', 'con2']
Jbase = {}
Jbase['con1'] = {}
Jbase['con1']['x'] = -0.98061433
Jbase['con1']['z'] = np.array([-9.61002285, -0.78449158])
Jbase['con2'] = {}
Jbase['con2']['x'] = 0.09692762
Jbase['con2']['z'] = np.array([1.94989079, 1.0775421 ])
Jbase['obj'] = {}
Jbase['obj']['x'] = 2.98061392
Jbase['obj']['z'] = np.array([9.61001155, 1.78448534])
J = prob.calc_gradient(param_list, unknown_list, mode='fwd', return_format='dict')
print(J)
#for key1, val1 in Jbase.items():
#for key2, val2 in val1.items():
#assert_rel_error(self, J[key1][key2], val2, .00001)
J = prob.calc_gradient(param_list, unknown_list, mode='rev', return_format='dict')
print(J)
#for key1, val1 in Jbase.items():
#for key2, val2 in val1.items():
#assert_rel_error(self, J[key1][key2], val2, .00001)
prob.root.fd_options['form'] = 'central'
J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='dict')
print(J)
#for key1, val1 in Jbase.items():
#for key2, val2 in val1.items():
#assert_rel_error(self, J[key1][key2], val2, .00001)
# Obviously this test doesn't do much right now, but I need to verify
# we don't get a keyerror here.
J = prob.calc_gradient(param_list, unknown_list, mode='fd', return_format='array')
def test_scaler_adder(self):
class ScaleAddDriver(Driver):
def run(self, problem):
""" Save away scaled info."""
params = self.get_params()
param_meta = self.get_param_metadata()
self.set_param('x', 0.5)
problem.root.solve_nonlinear()
objective = self.get_objectives()
constraint = self.get_constraints()
# Stuff we saved should be in the scaled coordinates.
self.param = params['x']
self.obj_scaled = objective['f_xy']
self.con_scaled = constraint['con']
self.param_high = param_meta['x']['high']
self.param_low = param_meta['x']['low']
prob = Problem()
root = prob.root = Group()
driver = prob.driver = ScaleAddDriver()
root.add('p1',
ParamComp([('x', 60000.0, {
'desc': 'my x'
}), ('y', 60000.0, {
'desc': 'my y'
})]),
promotes=['*'])
root.add('comp', Paraboloid(), promotes=['*'])
root.add('constraint', ExecComp('con=f_xy + x + y'), promotes=['*'])
driver.add_param('x',
low=59000.0,
high=61000.0,
adder=-60000.0,
scaler=1 / 1000.0)
driver.add_objective('f_xy', adder=-10890367002.0, scaler=1.0 / 20)
driver.add_constraint('con', adder=-10890487502.0, scaler=1.0 / 20)
prob.setup(check=False)
prob.run()
self.assertEqual(driver.param_high, 1.0)
self.assertEqual(driver.param_low, -1.0)
self.assertEqual(driver.param, 0.0)
self.assertEqual(prob['x'], 60500.0)
self.assertEqual(driver.obj_scaled[0], 1.0)
self.assertEqual(driver.con_scaled[0], 1.0)
