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_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_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_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_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 = 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_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_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_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_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_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_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)
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_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_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_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_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_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_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_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_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_fan_in_parallel_sets(self):
prob = Problem(impl=impl)
prob.root = FanInGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.root.sub.ln_solver = LinearGaussSeidel()
# auto calculated mode is fwd, so we don't have to set it explicitly
# in the ln_solvers in order to have our voi subvecs allocated
# properly.
# Parallel Groups
prob.driver.add_param("p1.x1")
prob.driver.add_param("p2.x2")
prob.driver.add_objective("comp3.y")
# make sure we can't mix inputs and outputs in parallel sets
try:
prob.driver.parallel_derivs(["p1.x1", "comp3.y"])
except Exception as err:
self.assertEqual(
str(err),
"['p1.x1', 'comp3.y'] cannot be grouped because ['p1.x1'] are " "params and ['comp3.y'] are not.",
)
else:
self.fail("Exception expected")
prob.driver.parallel_derivs(["p1.x1", "p2.x2"])
self.assertEqual(prob.driver.params_of_interest(), [("p1.x1", "p2.x2")])
# make sure we can't add a VOI to multiple groups
try:
prob.driver.parallel_derivs(["p1.x1", "p3.x3"])
except Exception as err:
self.assertEqual(
str(err),
"'p1.x1' cannot be added to VOI set ('p1.x1', 'p3.x3') "
"because it already exists in VOI set: ('p1.x1', 'p2.x2')",
)
else:
self.fail("Exception expected")
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_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_sellar_derivs_grouped(self):
prob = Problem()
prob.root = SellarDerivativesGrouped()
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)
param_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(param_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(param_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(param_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(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)
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.ln_solver.options['iprint'] = 1
prob.root.mda.nl_solver.options['atol'] = 1e-12
prob.root.mda.ln_solver = LinearGaussSeidel()
prob.root.mda.ln_solver.options['maxiter'] = 15
#prob.root.mda.ln_solver.options['iprint'] = 1
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_complex_step2(self):
prob = Problem(Group())
comp = prob.root.add('comp', ExecComp('y=x*x + x*2.0'))
prob.root.add('p1', ParamComp('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_simple_matvec(self):
group = Group()
group.add('x_param', ParamComp('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)
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)
def test_simple_jac(self):
group = Group()
group.add('x_param', ParamComp('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_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_simple_jac(self):
group = Group()
group.add('x_param', ParamComp('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_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', IndepVarComp('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_desvar('p.x', indices=[1,2])
prob.driver.add_constraint('c4.y', upper=0.0, indices=[1])
prob.driver.add_constraint('c5.y', upper=0.0, 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_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_in_group_matvec(self):
group = Group()
sub = group.add('sub', Group(), promotes=['x', 'y'])
group.add('x_param', ParamComp('x', 1.0), promotes=['*'])
sub.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y'])
prob = Problem()
prob.root = group
prob.root.ln_solver = ExplicitSolver()
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_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_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_fan_out_grouped(self):
prob = Problem()
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
param_list = ['p.x']
unknown_list = ['sub.comp2.y', "sub.comp3.y"]
J = prob.calc_gradient(param_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)
J = prob.calc_gradient(param_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)
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_no_derivatives(self):
prob = Problem()
prob.root = Group()
comp = prob.root.add('comp', ExecComp('y=x*2.0'))
prob.root.add('p1', ParamComp('x', 2.0))
prob.root.connect('p1.x', 'comp.x')
comp.fd_options['force_fd'] = True
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'][0][0], 2.0, 1e-6)
J = prob.calc_gradient(['p1.x'], ['comp.y'], mode='rev', return_format='dict')
assert_rel_error(self, J['comp.y']['p1.x'][0][0], 2.0, 1e-6)
def test_fan_out_grouped(self):
prob = Problem()
prob.root = FanOutGrouped()
prob.root.ln_solver = LinearGaussSeidel()
prob.setup(check=False)
prob.run()
indep_list = ['p.x']
unknown_list = ['sub.comp2.y', "sub.comp3.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)
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)
def test_fan_in_grouped(self):
prob = Problem()
prob.root = FanInGrouped()
prob.root.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_single_diamond(self):
prob = Problem()
prob.root = SingleDiamond()
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)
def benchmark_cadre_mdp_derivs_full(self):
# These numbers are for the CADRE problem in the paper.
n = 1500
m = 300
npts = 6
# Instantiate
model = Problem(impl=impl)
root = model.root = CADRE_MDP_Group(n=n, m=m, npts=npts)
# Add parameters and constraints to each CADRE instance.
names = ["pt%s" % i for i in range(npts)]
for i, name in enumerate(names):
# add parameters to driver
model.driver.add_desvar("%s.CP_Isetpt" % name, lower=0.0, upper=0.4)
model.driver.add_desvar("%s.CP_gamma" % name, lower=0, upper=np.pi / 2.0)
model.driver.add_desvar("%s.CP_P_comm" % name, lower=0.0, upper=25.0)
model.driver.add_desvar("%s.iSOC" % name, indices=[0], lower=0.2, upper=1.0)
model.driver.add_constraint("%s.ConCh" % name, upper=0.0)
model.driver.add_constraint("%s.ConDs" % name, upper=0.0)
model.driver.add_constraint("%s.ConS0" % name, upper=0.0)
model.driver.add_constraint("%s.ConS1" % name, upper=0.0)
model.driver.add_constraint("%s_con5.val" % name, equals=0.0)
# Add Parameter groups
model.driver.add_desvar("bp1.cellInstd", lower=0.0, upper=1.0)
model.driver.add_desvar("bp2.finAngle", lower=0.0, upper=np.pi / 2.0)
model.driver.add_desvar("bp3.antAngle", lower=-np.pi / 4, upper=np.pi / 4)
# Add objective
model.driver.add_objective("obj.val")
model.root.ln_solver = LinearGaussSeidel()
model.root.parallel.ln_solver = LinearGaussSeidel()
model.root.parallel.pt0.ln_solver = LinearGaussSeidel()
model.root.parallel.pt1.ln_solver = LinearGaussSeidel()
model.root.parallel.pt2.ln_solver = LinearGaussSeidel()
model.root.parallel.pt3.ln_solver = LinearGaussSeidel()
model.root.parallel.pt4.ln_solver = LinearGaussSeidel()
model.root.parallel.pt5.ln_solver = LinearGaussSeidel()
model.setup(check=False)
model.run()
params = list(model.driver.get_desvars().keys())
unks = list(model.driver.get_objectives().keys()) + list(model.driver.get_constraints().keys())
# ----------------------------------------
# This is what we are really profiling
# ----------------------------------------
J = model.calc_gradient(params, unks, mode="rev", return_format="dict")
assert_rel_error(self, J["obj.val"]["bp3.antAngle"], 67.15777407, 1e-4)
assert_rel_error(self, J["obj.val"]["pt1.CP_gamma"][-1][-1], -0.62410223816776056, 1e-4)
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', ParamComp('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)
param_list = ['x1']
unknown_list = ['sub2.tgtF.x3', 'sub2.tgtC.x3', 'sub2.tgtK.x3']
J = prob.calc_gradient(param_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(param_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)
def test_array2D(self):
group = Group()
group.add('x_param', ParamComp('x', np.ones((2, 2))), promotes=['*'])
group.add('mycomp', ArrayComp2D(), 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')
Jbase = prob.root.mycomp._jacobian_cache
diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x'])
assert_rel_error(self, diff, 0.0, 1e-8)
J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict')
diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x'])
assert_rel_error(self, diff, 0.0, 1e-8)
def test_two_simple(self):
group = Group()
group.add('x_param', ParamComp('x', 1.0))
group.add('comp1', ExecComp(['y=2.0*x']))
group.add('comp2', ExecComp(['z=3.0*y']))
prob = Problem()
prob.root = group
prob.root.ln_solver = LinearGaussSeidel()
prob.root.connect('x_param.x', 'comp1.x')
prob.root.connect('comp1.y', 'comp2.y')
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x_param.x'], ['comp2.z'], mode='fwd', return_format='dict')
assert_rel_error(self, J['comp2.z']['x_param.x'][0][0], 6.0, 1e-6)
J = prob.calc_gradient(['x_param.x'], ['comp2.z'], mode='rev', return_format='dict')
assert_rel_error(self, J['comp2.z']['x_param.x'][0][0], 6.0, 1e-6)
def test_array2D(self):
prob = Problem()
prob.root = root = Group()
root.add('x_param', IndepVarComp('x', np.ones((2, 2))), promotes=['*'])
root.add('mycomp', ArrayComp2D(), promotes=['x', 'y'])
root.mycomp.deriv_options['step_size'] = 1.0e-1
root.mycomp.deriv_options['type'] = 'cs'
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict')
Jbase = prob.root.mycomp._jacobian_cache
diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x'])
assert_rel_error(self, diff, 0.0, 1e-8)
J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict')
diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x'])
assert_rel_error(self, diff, 0.0, 1e-8)
def test_calc_gradient_interface_errors(self):
root = Group()
prob = Problem(root=root)
root.add('comp', ExecComp('y=x*2.0'))
try:
prob.calc_gradient(['comp.x'], ['comp.y'], mode='junk')
except Exception as error:
msg = "mode must be 'auto', 'fwd', 'rev', or 'fd'"
self.assertEqual(text_type(error), msg)
else:
self.fail("Error expected")
try:
prob.calc_gradient(['comp.x'], ['comp.y'], return_format='junk')
except Exception as error:
msg = "return_format must be 'array' or 'dict'"
self.assertEqual(text_type(error), msg)
else:
self.fail("Error expected")
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_group_fd(self):
class SimpleComp(Component):
""" A simple component that provides derivatives. """
def __init__(self):
super(SimpleComp, self).__init__()
# Params
self.add_param('x', 2.0)
# Unknowns
self.add_output('y', 0.0)
def solve_nonlinear(self, params, unknowns, resids):
""" Doesn't do much. Just multiply by 3"""
unknowns['y'] = 3.0 * params['x']
def jacobian(self, params, unknowns, resids):
"""Analytical derivatives."""
J = {}
J[('y', 'x')] = 3.0
return J
class Model(Group):
""" Simple model to experiment with finite difference."""
def __init__(self):
super(Model, self).__init__()
self.add('px', ParamComp('x', 2.0))
self.add('comp1', SimpleComp())
sub = self.add('sub', Group())
sub.add('comp2', SimpleComp())
sub.add('comp3', SimpleComp())
self.add('comp4', SimpleComp())
self.connect('px.x', 'comp1.x')
self.connect('comp1.y', 'sub.comp2.x')
self.connect('sub.comp2.y', 'sub.comp3.x')
self.connect('sub.comp3.y', 'comp4.x')
self.sub.fd_options['force_fd'] = True
prob = Problem()
prob.root = Model()
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['px.x'], ['comp4.y'])
assert_rel_error(self, J[0][0], 81.0, 1e-6)
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_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', ParamComp('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)
param_list = ['x1']
unknown_list = ['tgtF.x3', 'tgtC.x3', 'tgtK.x3']
J = prob.calc_gradient(param_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(param_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)
def test_simple_matvec_subbed_like_multipoint(self):
group = Group()
group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y'])
prob = Problem()
prob.root = Group()
prob.root.add('sub', group, promotes=['*'])
prob.root.sub.add('x_param', ParamComp('x', 1.0), promotes=['*'])
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)
J = prob.calc_gradient(['x'], ['y'], mode='fd', return_format='dict')
assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
J = prob.calc_gradient(['x'], ['y'], mode='fd', return_format='array')
assert_rel_error(self, J[0][0], 2.0, 1e-6)
def test_fan_out(self):
prob = Problem()
prob.root = FanOut()
prob.root.ln_solver = ScipyGMRES()
prob.setup(check=False)
prob.run()
param_list = ['p.x']
unknown_list = ['comp2.y', "comp3.y"]
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['comp2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['comp3.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['comp2.y']['p.x'][0][0], -6.0, 1e-6)
assert_rel_error(self, J['comp3.y']['p.x'][0][0], 15.0, 1e-6)
def test_simple_float(self):
prob = Problem()
prob.root = root = Group()
root.add('x_param', IndepVarComp('x', 17.0), promotes=['x'])
root.add('y_param', IndepVarComp('y', 19.0), promotes=['y'])
root.add('mycomp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
# This will give poor FD, but good CS
root.mycomp.fd_options['step_size'] = 1.0e1
root.mycomp.fd_options['force_fd'] = True
root.mycomp.fd_options['form'] = 'complex_step'
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x'], ['f_xy'], mode='fwd', return_format='dict')
assert_rel_error(self, J['f_xy']['x'][0][0], 47.0, 1e-6)
def test_full_model_fd_simple_comp_promoted(self):
prob = Problem()
prob.root = Group()
sub = prob.root.add('sub', Group(), promotes=['*'])
sub.add('comp', SimpleCompDerivMatVec(), promotes=['*'])
prob.root.add('p1', ParamComp('x', 1.0), promotes=['*'])
prob.root.fd_options['force_fd'] = True
prob.setup(check=False)
prob.run()
param_list = ['x']
unknown_list = ['y']
J = prob.calc_gradient(param_list,
unknown_list,
mode='fwd',
return_format='dict')
assert_rel_error(self, J['y']['x'][0][0], 2.0, 1e-6)
self.add('comp4', SimpleComp())
self.connect('px.x', 'comp1.x')
self.connect('comp1.y', 'comp2.x')
self.connect('comp2.y', 'comp3.x')
self.connect('comp3.y', 'comp4.x')
# Tell these components to finite difference
self.comp2.fd_options['force_fd'] = True
self.comp2.fd_options['form'] = 'central'
self.comp2.fd_options['step_size'] = 1.0e-4
self.comp4.fd_options['force_fd'] = True
self.comp4.fd_options['form'] = 'central'
self.comp4.fd_options['step_size'] = 1.0e-4
if __name__ == '__main__':
# Setup and run the model.
top = Problem()
top.root = Model()
top.setup()
top.run()
print('\n\nStart Calc Gradient')
print('-' * 25)
J = top.calc_gradient(['px.x'], ['comp4.y'])
print(J)
