def test_array_values(self):
prob = Problem()
prob.root = Group()
prob.root.add('pc',
IndepVarComp('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)
indep_list = ['x']
unknown_list = ['x_out']
# Forward Mode
J = prob.calc_gradient(indep_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(indep_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_array_values_diff_shape_no_units(self):
prob = Problem()
prob.root = Group()
prob.root.add('pc', IndepVarComp('x', np.zeros((2, 3))), promotes=['x'])
prob.root.add('uc', ExecComp('x_out = 1.8*x', x=np.zeros((2, 3)), x_out=np.zeros((2, 3))),
promotes=['x', 'x_out'])
prob.root.fd_options['force_fd'] = True
prob.root.fd_options['form'] = 'complex_step'
prob.setup(check=False)
prob.run()
indep_list = ['x']
unknown_list = ['x_out']
# Forward Mode
J = prob.calc_gradient(indep_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(indep_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_double_arraycomp(self):
# Mainly testing a bug in the array return for multiple arrays
group = Group()
group.add('x_param1', IndepVarComp('x1', np.ones((2))), promotes=['*'])
group.add('x_param2', IndepVarComp('x2', np.ones((2))), promotes=['*'])
group.add('mycomp', DoubleArrayComp(), promotes=['*'])
prob = Problem(impl=impl)
prob.root = group
prob.root.ln_solver = PetscKSP()
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_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_converge_diverge_compfd(self):
prob = Problem(impl=impl)
prob.root = ConvergeDivergePar()
prob.root.ln_solver = PetscKSP()
# fd comp2 and comp5. each is under a par group
prob.root.par1.comp2.fd_options['force_fd'] = True
prob.root.par2.comp5.fd_options['force_fd'] = True
prob.setup(check=False)
prob.run()
# Make sure value is fine.
assert_rel_error(self, prob['comp7.y1'], -102.7, 1e-6)
indep_list = ['p.x']
unknown_list = ['comp7.y1']
J = prob.calc_gradient(indep_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(indep_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(indep_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_two_simple(self):
size = 3
group = Group()
group.add('P', IndepVarComp('x', numpy.ones(size)))
group.add('C1', DistribExecComp(['y=2.0*x'], arr_size=size,
x=numpy.zeros(size),
y=numpy.zeros(size)))
group.add('C2', ExecComp(['z=3.0*y'],
y=numpy.zeros(size),
z=numpy.zeros(size)))
prob = Problem(impl=impl)
prob.root = group
prob.root.ln_solver = LinearGaussSeidel()
prob.root.connect('P.x', 'C1.x')
prob.root.connect('C1.y', 'C2.y')
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['P.x'], ['C2.z'], mode='fwd', return_format='dict')
assert_rel_error(self, J['C2.z']['P.x'], numpy.eye(size)*6.0, 1e-6)
J = prob.calc_gradient(['P.x'], ['C2.z'], mode='rev', return_format='dict')
assert_rel_error(self, J['C2.z']['P.x'], numpy.eye(size)*6.0, 1e-6)
def test_simple_matvec(self):
class VerificationComp(SimpleCompDerivMatVec):
def linearize(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_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_converge_diverge_groups(self):
prob = Problem()
prob.root = ConvergeDivergeGroups()
prob.root.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
# Make sure value is fine.
assert_rel_error(self, prob['comp7.y1'], -102.7, 1e-6)
indep_list = ['p.x']
unknown_list = ['comp7.y1']
J = prob.calc_gradient(indep_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(indep_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(indep_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_single_diamond_grouped(self):
prob = Problem()
prob.root = SingleDiamondGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
indep_list = ['p.x']
unknown_list = ['comp4.y1', 'comp4.y2']
J = prob.calc_gradient(indep_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(indep_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(indep_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_array_values_diff_shape_no_units(self):
prob = Problem()
prob.root = Group()
prob.root.add('pc',
IndepVarComp('x', np.zeros((2, 3))),
promotes=['x'])
prob.root.add('uc',
ExecComp('x_out = 1.8*x',
x=np.zeros((2, 3)),
x_out=np.zeros((2, 3))),
promotes=['x', 'x_out'])
prob.root.fd_options['force_fd'] = True
prob.root.fd_options['form'] = 'complex_step'
prob.setup(check=False)
prob.run()
indep_list = ['x']
unknown_list = ['x_out']
# Forward Mode
J = prob.calc_gradient(indep_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(indep_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_converge_diverge_groups(self):
prob = Problem()
prob.root = ConvergeDivergeGroups()
prob.root.ln_solver = ScipyGMRES()
prob.root.ln_solver.options['precondition'] = True
prob.root.sub1.ln_solver = DirectSolver()
prob.root.sub3.ln_solver = DirectSolver()
prob.setup(check=False)
prob.run()
# Make sure value is fine.
assert_rel_error(self, prob['comp7.y1'], -102.7, 1e-6)
indep_list = ['p.x']
unknown_list = ['comp7.y1']
J = prob.calc_gradient(indep_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(indep_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(indep_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_double_arraycomp(self):
# Mainly testing a bug in the array return for multiple arrays
group = Group()
group.add("x_param1", IndepVarComp("x1", np.ones((2))), promotes=["*"])
group.add("x_param2", IndepVarComp("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_converge_diverge_groups(self):
prob = Problem()
prob.root = ConvergeDivergeGroups()
prob.root.ln_solver = ScipyGMRES()
prob.root.ln_solver.preconditioner = LinearGaussSeidel()
prob.root.sub1.ln_solver = DirectSolver()
prob.root.sub3.ln_solver = DirectSolver()
prob.setup(check=False)
prob.run()
# Make sure value is fine.
assert_rel_error(self, prob["comp7.y1"], -102.7, 1e-6)
indep_list = ["p.x"]
unknown_list = ["comp7.y1"]
J = prob.calc_gradient(indep_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(indep_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(indep_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_out_all_grouped(self):
prob = Problem(impl=impl)
prob.root = FanOutAllGrouped()
prob.root.ln_solver = PetscKSP()
prob.root.ln_solver.preconditioner = LinearGaussSeidel()
prob.root.sub1.ln_solver = DirectSolver()
prob.root.sub2.ln_solver = DirectSolver()
prob.root.sub3.ln_solver = DirectSolver()
prob.setup(check=False)
prob.run()
indep_list = ['p.x']
unknown_list = ['sub2.comp2.y', "sub3.comp3.y"]
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['sub2.comp2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['sub3.comp3.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['sub2.comp2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['sub3.comp3.y']['p.x'][0][0], 15.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', IndepVarComp('x1', np.ones((2))), promotes=['*'])
group.add('x_param2', IndepVarComp('x2', np.ones((2))), promotes=['*'])
group.add('mycomp', DoubleArrayComp(), promotes=['*'])
prob = Problem(impl=impl)
prob.root = group
prob.root.ln_solver = PetscKSP()
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_converge_diverge_compfd(self):
prob = Problem(impl=impl)
prob.root = ConvergeDivergePar()
prob.root.ln_solver = PetscKSP()
# fd comp2 and comp5. each is under a par group
prob.root.par1.comp2.deriv_options["type"] = "fd"
prob.root.par2.comp5.deriv_options["type"] = "fd"
prob.setup(check=False)
prob.run()
# Make sure value is fine.
assert_rel_error(self, prob["comp7.y1"], -102.7, 1e-6)
indep_list = ["p.x"]
unknown_list = ["comp7.y1"]
J = prob.calc_gradient(indep_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(indep_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(indep_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_sellar_state_connection_force_fd(self):
prob = Problem()
prob.root = SellarStateConnection(resid_scaler=10.0)
prob.root.nl_solver = Newton()
prob.root.sub.state_eq_group.state_eq.deriv_options['type'] = 'fd'
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['state_eq.y2_command'], 12.05848819, .00001)
# Make sure we aren't iterating like crazy
self.assertLess(prob.root.nl_solver.iter_count, 8)
# Correct total derivatives (we can do this one manually)
# [9.61001155, 1.78448534]
J = prob.calc_gradient(['z'], ['obj'], mode='fwd')
assert_rel_error(self, J[0][0], 9.61001155, 1e-5)
assert_rel_error(self, J[0][1], 1.78448534, 1e-5)
J = prob.calc_gradient(['z'], ['obj'], mode='rev')
assert_rel_error(self, J[0][0], 9.61001155, 1e-5)
assert_rel_error(self, J[0][1], 1.78448534, 1e-5)
def test_two_simple(self):
size = 3
group = Group()
group.add('P', IndepVarComp('x', numpy.ones(size)))
group.add(
'C1',
DistribExecComp(['y=2.0*x'],
arr_size=size,
x=numpy.zeros(size),
y=numpy.zeros(size)))
group.add(
'C2',
ExecComp(['z=3.0*y'], y=numpy.zeros(size), z=numpy.zeros(size)))
prob = Problem(impl=impl)
prob.root = group
prob.root.ln_solver = LinearGaussSeidel()
prob.root.connect('P.x', 'C1.x')
prob.root.connect('C1.y', 'C2.y')
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['P.x'], ['C2.z'],
mode='fwd',
return_format='dict')
assert_rel_error(self, J['C2.z']['P.x'], numpy.eye(size) * 6.0, 1e-6)
J = prob.calc_gradient(['P.x'], ['C2.z'],
mode='rev',
return_format='dict')
assert_rel_error(self, J['C2.z']['P.x'], numpy.eye(size) * 6.0, 1e-6)
def test_converge_diverge_compfd(self):
prob = Problem(impl=impl)
prob.root = ConvergeDivergePar()
prob.root.ln_solver = PetscKSP()
# fd comp2 and comp5. each is under a par group
prob.root.par1.comp2.fd_options['force_fd'] = True
prob.root.par2.comp5.fd_options['force_fd'] = True
prob.setup(check=False)
prob.run()
# Make sure value is fine.
assert_rel_error(self, prob['comp7.y1'], -102.7, 1e-6)
indep_list = ['p.x']
unknown_list = ['comp7.y1']
J = prob.calc_gradient(indep_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(indep_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(indep_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_basic_grouped(self):
prob = Problem()
prob.root = Group()
sub1 = prob.root.add('sub1', Group())
sub2 = prob.root.add('sub2', Group())
sub1.add('src', SrcComp())
sub2.add('tgtF', TgtCompF())
sub2.add('tgtC', TgtCompC())
sub2.add('tgtK', TgtCompK())
prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1'])
prob.root.connect('x1', 'sub1.src.x1')
prob.root.connect('sub1.src.x2', 'sub2.tgtF.x2')
prob.root.connect('sub1.src.x2', 'sub2.tgtC.x2')
prob.root.connect('sub1.src.x2', 'sub2.tgtK.x2')
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['sub1.src.x2'], 100.0, 1e-6)
assert_rel_error(self, prob['sub2.tgtF.x3'], 212.0, 1e-6)
assert_rel_error(self, prob['sub2.tgtC.x3'], 100.0, 1e-6)
assert_rel_error(self, prob['sub2.tgtK.x3'], 373.15, 1e-6)
# Make sure we don't convert equal units
self.assertEqual(
prob.root.sub2.params.metadata('tgtC.x2').get('unit_conv'), None)
indep_list = ['x1']
unknown_list = ['sub2.tgtF.x3', 'sub2.tgtC.x3', 'sub2.tgtK.x3']
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fd',
return_format='dict')
assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6)
stream = cStringIO()
conv = prob.root.sub1.list_unit_conv(stream=stream)
self.assertTrue(len(conv) == 0)
def test_array_values_same_shape_units(self):
prob = Problem()
prob.root = Group()
prob.root.add('pc', IndepVarComp('x', np.zeros((2, )), units='degC'), promotes=['x'])
prob.root.add('uc', UnitComp(shape=(2, ), param_name='x', out_name='x_out', units='degF'),
promotes=['x', 'x_out'])
prob.root.fd_options['force_fd'] = True
prob.root.fd_options['form'] = 'complex_step'
prob.setup(check=False)
prob.run()
indep_list = ['x']
unknown_list = ['x_out']
# Forward Mode
J = prob.calc_gradient(indep_list, unknown_list, mode='fwd',
return_format='dict')
assert_rel_error(self, J['x_out']['x'],1.8*np.eye(2), 1e-6)
# Reverse Mode
J = prob.calc_gradient(indep_list, unknown_list, mode='rev',
return_format='dict')
assert_rel_error(self, J['x_out']['x'],1.8*np.eye(2), 1e-6)
def test_fan_in_grouped_GS_GS(self):
prob = Problem()
prob.root = FanInGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
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='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(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)
def test_converge_diverge(self):
prob = Problem()
prob.root = ConvergeDiverge()
prob.root.ln_solver = DirectSolver()
prob.root.ln_solver.options['jacobian_method'] = 'assemble'
prob.setup(check=False)
prob.run()
indep_list = ['p.x']
unknown_list = ['comp7.y1']
prob.run()
# Make sure value is fine.
assert_rel_error(self, prob['comp7.y1'], -102.7, 1e-6)
J = prob.calc_gradient(indep_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(indep_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(indep_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_out_grouped(self):
prob = Problem(impl=impl)
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
indep_list = ['p.x']
#unknown_list = ['sub.comp2.y', "sub.comp3.y"]
unknown_list = ['c2.y', "c3.y"]
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
#assert_rel_error(self, J['sub.comp2.y']['p.x'][0][0], -6.0, 1e-6)
#assert_rel_error(self, J['sub.comp3.y']['p.x'][0][0], 15.0, 1e-6)
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['sub.comp2.y']['p.x'][0][0], -6.0, 1e-6)
#assert_rel_error(self, J['sub.comp3.y']['p.x'][0][0], 15.0, 1e-6)
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_converge_diverge_groups(self):
prob = Problem()
root = prob.root = Group()
root.add('sub', ConvergeDivergeGroups())
indep_list = ['sub.p.x']
unknown_list = ['sub.comp7.y1']
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(indep_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(indep_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)
# Piggyback here to test out user calls to group.assemble_jacobian.
J, idx_dict = root.assemble_jacobian()
rs, re, cs, ce = idx_dict[('sub.sub1.comp1', ('y1', 'x1'))]
self.assertEqual(J[rs:re, cs:ce], 8)
def test_converge_diverge_groups(self):
prob = Problem()
root = prob.root = Group()
root.add('sub', ConvergeDivergeGroups())
root.fd_options['force_fd'] = True
root.fd_options['form'] = 'complex_step'
# We can't reach our desired accuracy with this step size in fd, but
# we can with cs (where step size is irrelevant.)
root.fd_options['step_size'] = 1.0e-4
prob.setup(check=False)
prob.run()
indep_list = ['sub.p.x']
unknown_list = ['sub.comp7.y1']
J = prob.calc_gradient(indep_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(indep_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_array_values_same_shape_units(self):
prob = Problem()
prob.root = Group()
prob.root.add('pc',
IndepVarComp('x', np.zeros((2, )), units='degC'),
promotes=['x'])
prob.root.add('uc',
UnitComp(shape=(2, ),
param_name='x',
out_name='x_out',
units='degF'),
promotes=['x', 'x_out'])
prob.root.fd_options['force_fd'] = True
prob.root.fd_options['form'] = 'complex_step'
prob.setup(check=False)
prob.run()
indep_list = ['x']
unknown_list = ['x_out']
# Forward Mode
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['x_out']['x'], 1.8 * np.eye(2), 1e-6)
# Reverse Mode
J = prob.calc_gradient(indep_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['x_out']['x'], 1.8 * np.eye(2), 1e-6)
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
indep_list = ['sub1.comp1.x1']
unknown_list = ['comp7.y1']
J = prob.calc_gradient(indep_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(indep_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_matvec(self):
class VerificationComp(SimpleCompDerivMatVec):
def linearize(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_converge_diverge_groups(self):
prob = Problem()
prob.root = Group()
prob.root.add('sub', ConvergeDivergeGroups())
indep_list = ['sub.p.x']
unknown_list = ['sub.comp7.y1']
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(indep_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(indep_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_simple_implicit(self):
prob = Problem()
prob.root = Group()
prob.root.ln_solver = ScipyGMRES()
prob.root.add('comp', SimpleImplicitComp())
prob.root.add('p1', IndepVarComp('x', 0.5))
prob.root.connect('p1.x', 'comp.x')
prob.root.comp.deriv_options['check_type'] = 'cs'
prob.setup(check=False)
prob.run()
# Correct total derivatives (we can do this one manually)
J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='fwd')
assert_rel_error(self, J[0][0], -2.5555511, 1e-5)
J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='rev')
assert_rel_error(self, J[0][0], -2.5555511, 1e-5)
J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='fd')
assert_rel_error(self, J[0][0], -2.5555511, 1e-5)
# Clean up old FD
prob.run()
# Partials
data = prob.check_partial_derivatives(out_stream=None)
#data = prob.check_partial_derivatives()
for key1, val1 in iteritems(data):
for key2, val2 in iteritems(val1):
assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5)
assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5)
assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5)
assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5)
assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5)
assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
assert_rel_error(self, data['comp'][('y', 'x')]['J_fwd'][0][0], 1.0, 1e-6)
assert_rel_error(self, data['comp'][('y', 'z')]['J_fwd'][0][0], 2.0, 1e-6)
assert_rel_error(self, data['comp'][('z', 'x')]['J_fwd'][0][0], 2.66666667, 1e-6)
assert_rel_error(self, data['comp'][('z', 'z')]['J_fwd'][0][0], 1.5, 1e-6)
# Clean up old FD
prob.run()
# Make sure check_totals works too
data = prob.check_total_derivatives(out_stream=None)
for key1, val1 in iteritems(data):
assert_rel_error(self, val1['abs error'][0], 0.0, 1e-5)
assert_rel_error(self, val1['abs error'][1], 0.0, 1e-5)
assert_rel_error(self, val1['abs error'][2], 0.0, 1e-5)
assert_rel_error(self, val1['rel error'][0], 0.0, 1e-5)
assert_rel_error(self, val1['rel error'][1], 0.0, 1e-5)
assert_rel_error(self, val1['rel error'][2], 0.0, 1e-5)
def test_simple_implicit(self):
prob = Problem()
prob.root = Group()
prob.root.ln_solver = ScipyGMRES()
prob.root.add("comp", SimpleImplicitComp())
prob.root.add("p1", IndepVarComp("x", 0.5))
prob.root.connect("p1.x", "comp.x")
prob.root.comp.fd_options["extra_check_partials_form"] = "complex_step"
prob.setup(check=False)
prob.run()
# Correct total derivatives (we can do this one manually)
J = prob.calc_gradient(["p1.x"], ["comp.y"], mode="fwd")
assert_rel_error(self, J[0][0], -2.5555511, 1e-5)
J = prob.calc_gradient(["p1.x"], ["comp.y"], mode="rev")
assert_rel_error(self, J[0][0], -2.5555511, 1e-5)
J = prob.calc_gradient(["p1.x"], ["comp.y"], mode="fd")
assert_rel_error(self, J[0][0], -2.5555511, 1e-5)
# Clean up old FD
prob.run()
# Partials
data = prob.check_partial_derivatives(out_stream=None)
# data = prob.check_partial_derivatives()
for key1, val1 in iteritems(data):
for key2, val2 in iteritems(val1):
assert_rel_error(self, val2["abs error"][0], 0.0, 1e-5)
assert_rel_error(self, val2["abs error"][1], 0.0, 1e-5)
assert_rel_error(self, val2["abs error"][2], 0.0, 1e-5)
assert_rel_error(self, val2["rel error"][0], 0.0, 1e-5)
assert_rel_error(self, val2["rel error"][1], 0.0, 1e-5)
assert_rel_error(self, val2["rel error"][2], 0.0, 1e-5)
assert_rel_error(self, data["comp"][("y", "x")]["J_fwd"][0][0], 1.0, 1e-6)
assert_rel_error(self, data["comp"][("y", "z")]["J_fwd"][0][0], 20.0, 1e-6)
assert_rel_error(self, data["comp"][("z", "x")]["J_fwd"][0][0], 2.66666667, 1e-6)
assert_rel_error(self, data["comp"][("z", "z")]["J_fwd"][0][0], 15.0, 1e-6)
# Clean up old FD
prob.run()
# Make sure check_totals works too
data = prob.check_total_derivatives(out_stream=None)
for key1, val1 in iteritems(data):
assert_rel_error(self, val1["abs error"][0], 0.0, 1e-5)
assert_rel_error(self, val1["abs error"][1], 0.0, 1e-5)
assert_rel_error(self, val1["abs error"][2], 0.0, 1e-5)
assert_rel_error(self, val1["rel error"][0], 0.0, 1e-5)
assert_rel_error(self, val1["rel error"][1], 0.0, 1e-5)
assert_rel_error(self, val1["rel error"][2], 0.0, 1e-5)
def test_sellar_derivs_grouped_GSnested(self):
prob = Problem()
prob.root = SellarDerivativesGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.ln_solver.options['maxiter'] = 15
prob.root.mda.nl_solver.options['atol'] = 1e-12
prob.root.mda.ln_solver = LinearGaussSeidel()
prob.root.mda.ln_solver.options['maxiter'] = 15
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)
indep_list = ['x', 'z']
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(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
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(indep_list,
unknown_list,
mode='rev',
return_format='dict')
for key1, val1 in Jbase.items():
for key2, val2 in val1.items():
assert_rel_error(self, J[key1][key2], val2, .00001)
# Cheat a bit so I can twiddle mode
OptionsDictionary.locked = False
prob.root.deriv_options['form'] = 'central'
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fd',
return_format='dict')
for key1, val1 in Jbase.items():
for key2, val2 in val1.items():
assert_rel_error(self, J[key1][key2], val2, .00001)
def test_fan_in_grouped(self):
size = 3
prob = Problem(impl=impl)
prob.root = root = Group()
root.add('P1', IndepVarComp('x', numpy.ones(size, dtype=float)))
root.add('P2', IndepVarComp('x', numpy.ones(size, dtype=float)))
sub = root.add('sub', ParallelGroup())
sub.add(
'C1',
ExecComp(['y=-2.0*x'],
x=numpy.zeros(size, dtype=float),
y=numpy.zeros(size, dtype=float)))
sub.add(
'C2',
ExecComp(['y=5.0*x'],
x=numpy.zeros(size, dtype=float),
y=numpy.zeros(size, dtype=float)))
root.add(
'C3',
DistribExecComp(['y=3.0*x1+7.0*x2'],
arr_size=size,
x1=numpy.zeros(size, dtype=float),
x2=numpy.zeros(size, dtype=float),
y=numpy.zeros(size, dtype=float)))
root.add(
'C4',
ExecComp(['y=x'],
x=numpy.zeros(size, dtype=float),
y=numpy.zeros(size, dtype=float)))
root.connect("sub.C1.y", "C3.x1")
root.connect("sub.C2.y", "C3.x2")
root.connect("P1.x", "sub.C1.x")
root.connect("P2.x", "sub.C2.x")
root.connect("C3.y", "C4.x")
root.ln_solver = LinearGaussSeidel()
root.sub.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['P1.x', 'P2.x'], ['C4.y'],
mode='fwd',
return_format='dict')
assert_rel_error(self, J['C4.y']['P1.x'], numpy.eye(size) * -6.0, 1e-6)
assert_rel_error(self, J['C4.y']['P2.x'], numpy.eye(size) * 35.0, 1e-6)
J = prob.calc_gradient(['P1.x', 'P2.x'], ['C4.y'],
mode='rev',
return_format='dict')
assert_rel_error(self, J['C4.y']['P1.x'], numpy.eye(size) * -6.0, 1e-6)
assert_rel_error(self, J['C4.y']['P2.x'], numpy.eye(size) * 35.0, 1e-6)
def test_basic_gmres(self):
top = Problem()
root = top.root = Group()
root.add("p", IndepVarComp("x", 2000.0))
root.add("comp1", BasicComp())
root.add("comp2", ExecComp(["y = 2.0*x"]))
root.connect("p.x", "comp1.x")
root.connect("comp1.y", "comp2.x")
top.driver.add_desvar("p.x", 2000.0)
top.driver.add_objective("comp2.y")
root.ln_solver = ScipyGMRES()
top.setup(check=False)
top.run()
# correct execution
assert_rel_error(self, top["comp2.y"], 12000.0, 1e-6)
# in-component query is unscaled
assert_rel_error(self, root.comp1.store_y, 6000.0, 1e-6)
# afterwards direct query is unscaled
assert_rel_error(self, root.unknowns["comp1.y"], 6000.0, 1e-6)
# OpenMDAO behind-the-scenes query is scaled
# (So, internal storage is scaled)
assert_rel_error(self, root.unknowns._dat["comp1.y"].val, 6.0, 1e-6)
# Correct derivatives
J = top.calc_gradient(["p.x"], ["comp2.y"], mode="fwd")
assert_rel_error(self, J[0][0], 6.0, 1e-6)
J = top.calc_gradient(["p.x"], ["comp2.y"], mode="rev")
assert_rel_error(self, J[0][0], 6.0, 1e-6)
J = top.calc_gradient(["p.x"], ["comp2.y"], mode="fd")
assert_rel_error(self, J[0][0], 6.0, 1e-6)
# Clean up old FD
top.run()
# Make sure check_partials works too
data = top.check_partial_derivatives(out_stream=None)
# data = top.check_partial_derivatives()
for key1, val1 in iteritems(data):
for key2, val2 in iteritems(val1):
assert_rel_error(self, val2["abs error"][0], 0.0, 1e-5)
assert_rel_error(self, val2["abs error"][1], 0.0, 1e-5)
assert_rel_error(self, val2["abs error"][2], 0.0, 1e-5)
assert_rel_error(self, val2["rel error"][0], 0.0, 1e-5)
assert_rel_error(self, val2["rel error"][1], 0.0, 1e-5)
assert_rel_error(self, val2["rel error"][2], 0.0, 1e-5)
def test_basic_grouped(self):
prob = Problem()
prob.root = Group()
sub1 = prob.root.add('sub1', Group())
sub2 = prob.root.add('sub2', Group())
sub1.add('src', SrcComp())
sub2.add('tgtF', TgtCompF())
sub2.add('tgtC', TgtCompC())
sub2.add('tgtK', TgtCompK())
prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1'])
prob.root.connect('x1', 'sub1.src.x1')
prob.root.connect('sub1.src.x2', 'sub2.tgtF.x2')
prob.root.connect('sub1.src.x2', 'sub2.tgtC.x2')
prob.root.connect('sub1.src.x2', 'sub2.tgtK.x2')
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['sub1.src.x2'], 100.0, 1e-6)
assert_rel_error(self, prob['sub2.tgtF.x3'], 212.0, 1e-6)
assert_rel_error(self, prob['sub2.tgtC.x3'], 100.0, 1e-6)
assert_rel_error(self, prob['sub2.tgtK.x3'], 373.15, 1e-6)
# Make sure we don't convert equal units
self.assertEqual(prob.root.sub2.params.metadata('tgtC.x2').get('unit_conv'),
None)
indep_list = ['x1']
unknown_list = ['sub2.tgtF.x3', 'sub2.tgtC.x3', 'sub2.tgtK.x3']
J = prob.calc_gradient(indep_list, unknown_list, mode='fwd',
return_format='dict')
assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list, unknown_list, mode='rev',
return_format='dict')
assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list, unknown_list, mode='fd',
return_format='dict')
assert_rel_error(self, J['sub2.tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['sub2.tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['sub2.tgtK.x3']['x1'][0][0], 1.0, 1e-6)
stream = cStringIO()
conv = prob.root.sub1.list_unit_conv(stream=stream)
self.assertTrue(len(conv) == 0)
def test_sellar_derivs(self):
prob = Problem()
prob.root = SellarDerivatives()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.ln_solver.options['maxiter'] = 10
prob.root.ln_solver.options['atol'] = 1e-12
prob.root.ln_solver.options['rtol'] = 1e-12
#prob.root.ln_solver.options['iprint'] = 1
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)
indep_list = ['x', 'z']
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(indep_list, unknown_list, mode='fwd', return_format='dict')
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(indep_list, unknown_list, mode='rev', return_format='dict')
for key1, val1 in Jbase.items():
for key2, val2 in val1.items():
assert_rel_error(self, J[key1][key2], val2, .00001)
# Cheat a bit so I can twiddle mode
OptionsDictionary.locked = False
prob.root.fd_options['form'] = 'central'
J = prob.calc_gradient(indep_list, unknown_list, mode='fd', return_format='dict')
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(indep_list, unknown_list, mode='fd', return_format='array')
def test_sellar_derivs_grouped(self):
prob = Problem(impl=petsc_impl)
prob.root = SellarDerivativesGrouped()
prob.root.fd_options['force_fd'] = True
prob.root.fd_options['form'] = 'complex_step'
prob.root.mda.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)
indep_list = ['x', 'z']
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(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
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(indep_list,
unknown_list,
mode='rev',
return_format='dict')
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(indep_list,
unknown_list,
mode='fd',
return_format='dict')
for key1, val1 in Jbase.items():
for key2, val2 in val1.items():
assert_rel_error(self, J[key1][key2], val2, .00001)
def test_basic_grouped_bug_from_pycycle(self):
prob = Problem()
root = prob.root = Group()
sub1 = prob.root.add('sub1', Group(), promotes=['x2'])
sub1.add('src', SrcComp(), promotes=['x2'])
root.add('tgtF', TgtCompFMulti())
root.add('tgtC', TgtCompC())
root.add('tgtK', TgtCompK())
prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1'])
prob.root.connect('x1', 'sub1.src.x1')
prob.root.connect('x2', 'tgtF.x2')
prob.root.connect('x2', 'tgtC.x2')
prob.root.connect('x2', 'tgtK.x2')
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['x2'], 100.0, 1e-6)
assert_rel_error(self, prob['tgtF.x3'], 212.0, 1e-6)
assert_rel_error(self, prob['tgtC.x3'], 100.0, 1e-6)
assert_rel_error(self, prob['tgtK.x3'], 373.15, 1e-6)
indep_list = ['x1']
unknown_list = ['tgtF.x3', 'tgtC.x3', 'tgtK.x3']
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fd',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
def test_basic_implicit_conn(self):
prob = Problem()
prob.root = Group()
prob.root.add('src', SrcComp(), promotes=['x1', 'x2'])
prob.root.add('tgtF', TgtCompF(), promotes=['x2'])
prob.root.add('tgtC', TgtCompC(), promotes=['x2'])
prob.root.add('tgtK', TgtCompK(), promotes=['x2'])
prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1'])
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['x2'], 100.0, 1e-6)
assert_rel_error(self, prob['tgtF.x3'], 212.0, 1e-6)
assert_rel_error(self, prob['tgtC.x3'], 100.0, 1e-6)
assert_rel_error(self, prob['tgtK.x3'], 373.15, 1e-6)
# Make sure we don't convert equal units
self.assertEqual(
prob.root.params.metadata('tgtC.x2').get('unit_conv'), None)
indep_list = ['x1']
unknown_list = ['tgtF.x3', 'tgtC.x3', 'tgtK.x3']
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fd',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
def test_sellar_derivs_grouped(self):
prob = Problem()
prob.root = SellarDerivativesGrouped()
prob.root.fd_options['force_fd'] = True
prob.root.fd_options['form'] = 'complex_step'
prob.root.mda.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)
indep_list = ['x', 'z']
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(indep_list, unknown_list, mode='fwd', return_format='dict')
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(indep_list, unknown_list, mode='rev', return_format='dict')
for key1, val1 in Jbase.items():
for key2, val2 in val1.items():
assert_rel_error(self, J[key1][key2], val2, .00001)
# Cheat a bit so I can twiddle mode
OptionsDictionary.locked = False
prob.root.fd_options['form'] = 'central'
J = prob.calc_gradient(indep_list, unknown_list, mode='fd', return_format='dict')
for key1, val1 in Jbase.items():
for key2, val2 in val1.items():
assert_rel_error(self, J[key1][key2], val2, .00001)
def test_fan_out_grouped(self):
prob = Problem(impl=impl)
prob.root = root = Group()
root.add('p', IndepVarComp('x', 1.0))
root.add('comp1', ExecComp(['y=3.0*x']))
sub = root.add('sub', ParallelGroup())
sub.add('comp2', ExecComp(['y=-2.0*x']))
sub.add('comp3', ExecComp(['y=5.0*x']))
root.add('c2', ExecComp(['y=-x']))
root.add('c3', ExecComp(['y=3.0*x']))
root.connect('sub.comp2.y', 'c2.x')
root.connect('sub.comp3.y', 'c3.x')
root.connect("comp1.y", "sub.comp2.x")
root.connect("comp1.y", "sub.comp3.x")
root.connect("p.x", "comp1.x")
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
param = 'p.x'
unknown_list = ['sub.comp2.y', "sub.comp3.y"]
J = prob.calc_gradient([param], unknown_list, mode='fwd', return_format='dict')
assert_rel_error(self, J[unknown_list[0]][param][0][0], -6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 15.0, 1e-6)
J = prob.calc_gradient([param], unknown_list, mode='rev', return_format='dict')
assert_rel_error(self, J[unknown_list[0]][param][0][0], -6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 15.0, 1e-6)
unknown_list = ['c2.y', "c3.y"]
J = prob.calc_gradient([param], unknown_list, mode='fwd', return_format='dict')
assert_rel_error(self, J[unknown_list[0]][param][0][0], 6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 45.0, 1e-6)
J = prob.calc_gradient([param], unknown_list, mode='rev', return_format='dict')
assert_rel_error(self, J[unknown_list[0]][param][0][0], 6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 45.0, 1e-6)
def test_fan_out_grouped(self):
prob = Problem(impl=impl)
prob.root = root = Group()
root.add('p', IndepVarComp('x', 1.0))
root.add('comp1', ExecComp(['y=3.0*x']))
sub = root.add('sub', ParallelGroup())
sub.add('comp2', ExecComp(['y=-2.0*x']))
sub.add('comp3', ExecComp(['y=5.0*x']))
root.add('c2', ExecComp(['y=-x']))
root.add('c3', ExecComp(['y=3.0*x']))
root.connect('sub.comp2.y', 'c2.x')
root.connect('sub.comp3.y', 'c3.x')
root.connect("comp1.y", "sub.comp2.x")
root.connect("comp1.y", "sub.comp3.x")
root.connect("p.x", "comp1.x")
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
param = 'p.x'
unknown_list = ['sub.comp2.y', "sub.comp3.y"]
J = prob.calc_gradient([param], unknown_list, mode='fwd', return_format='dict')
assert_rel_error(self, J[unknown_list[0]][param][0][0], -6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 15.0, 1e-6)
J = prob.calc_gradient([param], unknown_list, mode='rev', return_format='dict')
assert_rel_error(self, J[unknown_list[0]][param][0][0], -6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 15.0, 1e-6)
unknown_list = ['c2.y', "c3.y"]
J = prob.calc_gradient([param], unknown_list, mode='fwd', return_format='dict')
assert_rel_error(self, J[unknown_list[0]][param][0][0], 6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 45.0, 1e-6)
J = prob.calc_gradient([param], unknown_list, mode='rev', return_format='dict')
assert_rel_error(self, J[unknown_list[0]][param][0][0], 6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 45.0, 1e-6)
def test_fan_out_grouped(self):
prob = Problem(impl=impl)
prob.root = root = Group()
root.add("p", IndepVarComp("x", 1.0))
root.add("comp1", ExecComp(["y=3.0*x"]))
sub = root.add("sub", ParallelGroup())
sub.add("comp2", ExecComp(["y=-2.0*x"]))
sub.add("comp3", ExecComp(["y=5.0*x"]))
root.add("c2", ExecComp(["y=-x"]))
root.add("c3", ExecComp(["y=3.0*x"]))
root.connect("sub.comp2.y", "c2.x")
root.connect("sub.comp3.y", "c3.x")
root.connect("comp1.y", "sub.comp2.x")
root.connect("comp1.y", "sub.comp3.x")
root.connect("p.x", "comp1.x")
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
param = "p.x"
unknown_list = ["sub.comp2.y", "sub.comp3.y"]
J = prob.calc_gradient([param], unknown_list, mode="fwd", return_format="dict")
assert_rel_error(self, J[unknown_list[0]][param][0][0], -6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 15.0, 1e-6)
J = prob.calc_gradient([param], unknown_list, mode="rev", return_format="dict")
assert_rel_error(self, J[unknown_list[0]][param][0][0], -6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 15.0, 1e-6)
unknown_list = ["c2.y", "c3.y"]
J = prob.calc_gradient([param], unknown_list, mode="fwd", return_format="dict")
assert_rel_error(self, J[unknown_list[0]][param][0][0], 6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 45.0, 1e-6)
J = prob.calc_gradient([param], unknown_list, mode="rev", return_format="dict")
assert_rel_error(self, J[unknown_list[0]][param][0][0], 6.0, 1e-6)
assert_rel_error(self, J[unknown_list[1]][param][0][0], 45.0, 1e-6)
def test_unit_conversion(self):
prob = Problem()
prob.root = Group()
prob.root.add('src', SrcComp())
prob.root.add('tgtF', TgtCompF())
prob.root.add('tgtC', TgtCompC())
prob.root.add('tgtK', TgtCompK())
prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1'])
prob.root.connect('x1', 'src.x1')
prob.root.connect('src.x2', 'tgtF.x2')
prob.root.connect('src.x2', 'tgtC.x2')
prob.root.connect('src.x2', 'tgtK.x2')
prob.root.fd_options['force_fd'] = True
prob.root.fd_options['form'] = 'complex_step'
prob.setup(check=False)
prob.run()
indep_list = ['x1']
unknown_list = ['tgtF.x3', 'tgtC.x3', 'tgtK.x3']
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list,
unknown_list,
mode='rev',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fd',
return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
def test_fan_in_parallel_sets_rev(self):
prob = Problem(impl=impl)
prob.root = FanInGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
prob.root.ln_solver.options['mode'] = 'rev'
prob.root.sub.ln_solver.options['mode'] = 'rev'
prob.driver.add_desvar('p1.x1')
prob.driver.add_desvar('p2.x2')
prob.driver.add_desvar('p3.x3')
prob.driver.add_objective('comp3.y')
prob.driver.parallel_derivs(['p1.x1', 'p2.x2'])
if MPI:
expected = [('p1.x1', 'p2.x2'), ('p3.x3',)]
else:
expected = [('p1.x1',), ('p2.x2',), ('p3.x3',)]
self.assertEqual(prob.driver.desvars_of_interest(),
expected)
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)
def test_fd_options_form_precedence(self):
class MyComp(Component):
def __init__(self):
super(MyComp, self).__init__()
# Params
self.add_param("x1", 3.0)
self.add_param("x2", 3.0, form="central")
# Unknowns
self.add_output("y", 5.5)
def solve_nonlinear(self, params, unknowns, resids):
""" Doesn't do much. """
unknowns["y"] = 7.0 * params["x1"] ** 2 + 7.0 * params["x2"] ** 2
prob = Problem()
prob.root = Group()
comp = prob.root.add("comp", MyComp())
prob.root.add("p1", IndepVarComp([("x1", 3.0), ("x2", 3.0)]))
prob.root.connect("p1.x1", "comp.x1")
prob.root.connect("p1.x2", "comp.x2")
comp.fd_options["force_fd"] = True
comp.fd_options["form"] = "forward"
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(["p1.x1", "p1.x2"], ["comp.y"], return_format="dict")
x1_err = J["comp.y"]["p1.x1"] - 42.0
x2_err = J["comp.y"]["p1.x2"] - 42.0
assert_rel_error(self, x1_err, 7e-6, 1e-1)
assert_rel_error(self, x2_err, 5.4e-10, 1e-1)
def test_simple(self):
group = Group()
group.add('x_param', IndepVarComp('x', 1.0), promotes=['*'])
group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y'])
prob = Problem(impl=impl)
prob.root = group
prob.root.ln_solver = PetscKSP()
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict')
assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict')
assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
def test_complex_step2_colons(self):
prob = Problem(Group())
comp = prob.root.add('comp', ExecComp('foo:y=foo:x*foo:x + foo:x*2.0'))
prob.root.add('p1', IndepVarComp('x', 2.0))
prob.root.connect('p1.x', 'comp.foo:x')
comp.deriv_options['type'] = 'user'
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['p1.x'], ['comp.foo:y'], mode='fwd', return_format='dict')
assert_rel_error(self, J['comp.foo:y']['p1.x'], np.array([6.0]), 0.00001)
J = prob.calc_gradient(['p1.x'], ['comp.foo:y'], mode='rev', return_format='dict')
assert_rel_error(self, J['comp.foo:y']['p1.x'], np.array([6.0]), 0.00001)
def test_fan_out_parallel_sets_fwd(self):
prob = Problem(impl=impl)
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
prob.root.ln_solver.options['mode'] = 'fwd'
prob.root.sub.ln_solver.options['mode'] = 'fwd'
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.driver.parallel_derivs(['c2.y', 'c3.y']) # ignored in fwd
if MPI:
expected = [('c2.y', 'c3.y')]
else:
expected = [('c2.y',), ('c3.y',)]
self.assertEqual(prob.driver.outputs_of_interest(),
expected)
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)
def test_complex_step2(self):
prob = Problem(Group())
comp = prob.root.add('comp', ExecComp('y=x*x + x*2.0'))
prob.root.add('p1', IndepVarComp('x', 2.0))
prob.root.connect('p1.x', 'comp.x')
comp.fd_options['force_fd'] = False
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='fwd', return_format='dict')
assert_rel_error(self, J['comp.y']['p1.x'], np.array([6.0]), 0.00001)
J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='rev', return_format='dict')
assert_rel_error(self, J['comp.y']['p1.x'], np.array([6.0]), 0.00001)
def test_driver_param_indices_force_fd_shift(self):
""" Test driver param indices with shifted indices and force_fd=True
"""
prob = Problem()
prob.root = SellarStateConnection()
prob.root.fd_options['force_fd'] = True
prob.driver.add_desvar('z', lower=np.array([-10.0, -10.0]),
upper=np.array([10.0, 10.0]), indices=[1])
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.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_simple_jac(self):
group = Group()
group.add('x_param', IndepVarComp('x', 1.0), promotes=['*'])
group.add('mycomp', ExecComp(['y=2.0*x']), promotes=['x', 'y'])
prob = Problem()
prob.root = group
prob.root.ln_solver = ScipyGMRES()
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict')
assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict')
assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
def test_fan_out_parallel_sets_rev(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'
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.driver.parallel_derivs(['c2.y', 'c3.y'])
if MPI:
expected = [('c2.y', 'c3.y')]
else:
expected = [('c2.y',), ('c3.y',)]
self.assertEqual(prob.driver.outputs_of_interest(),
expected)
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='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_simple_matvec(self):
group = Group()
group.add('x_param', IndepVarComp('x', 1.0), promotes=['*'])
group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y'])
prob = Problem()
prob.root = group
prob.root.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict')
assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict')
assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
