def test_simple_paraboloid_equality(self):
prob = Problem()
root = prob.root = Group()
root.add('p1', ParamComp('x', 50.0), promotes=['*'])
root.add('p2', ParamComp('y', 50.0), promotes=['*'])
root.add('comp', Paraboloid(), promotes=['*'])
root.add('con', ExecComp('c = 15.0 - x + y'), promotes=['*'])
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1.0e-8
prob.driver.add_param('x', low=-50.0, high=50.0)
prob.driver.add_param('y', low=-50.0, high=50.0)
prob.driver.add_objective('f_xy')
prob.driver.add_constraint('c', ctype='ineq')
prob.driver.options['disp'] = False
prob.setup(check=False)
prob.run()
# Minimum should be at (7.166667, -7.833334)
assert_rel_error(self, prob['x'], 7.16667, 1e-6)
assert_rel_error(self, prob['y'], -7.833334, 1e-6)
def test_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_simple_paraboloid_equality(self):
prob = Problem()
root = prob.root = Group()
root.add("p1", ParamComp("x", 50.0), promotes=["*"])
root.add("p2", ParamComp("y", 50.0), promotes=["*"])
root.add("comp", Paraboloid(), promotes=["*"])
root.add("con", ExecComp("c = 15.0 - x + y"), promotes=["*"])
prob.driver = ScipyOptimizer()
prob.driver.options["optimizer"] = "SLSQP"
prob.driver.options["tol"] = 1.0e-8
prob.driver.add_param("x", low=-50.0, high=50.0)
prob.driver.add_param("y", low=-50.0, high=50.0)
prob.driver.add_objective("f_xy")
prob.driver.add_constraint("c", ctype="ineq")
prob.setup(check=False)
prob.run()
# Minimum should be at (7.166667, -7.833334)
assert_rel_error(self, prob["x"], 7.16667, 1e-6)
assert_rel_error(self, prob["y"], -7.833334, 1e-6)
def test_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_array(self):
prob = Problem(root=Group())
C1 = prob.root.add('C1', ExecComp('y=x[1]', x=np.array([1.,2.,3.]), y=0.0))
self.assertTrue('x' in C1._params_dict)
self.assertTrue('y' in C1._unknowns_dict)
prob.setup(check=False)
prob.run()
assert_rel_error(self, C1.unknowns['y'], 2.0, 0.00001)
def test_math(self):
prob = Problem(root=Group())
C1 = prob.root.add('C1', ExecComp('y=sin(x)', x=2.0))
self.assertTrue('x' in C1._params_dict)
self.assertTrue('y' in C1._unknowns_dict)
prob.setup(check=False)
prob.run()
assert_rel_error(self, C1.unknowns['y'], math.sin(2.0), 0.00001)
def test_array_lhs(self):
prob = Problem(root=Group())
C1 = prob.root.add('C1', ExecComp(['y[0]=x[1]', 'y[1]=x[0]'],
x=np.array([1.,2.,3.]), y=np.array([0.,0.])))
self.assertTrue('x' in C1._params_dict)
self.assertTrue('y' in C1._unknowns_dict)
prob.setup(check=False)
prob.run()
assert_rel_error(self, C1.unknowns['y'], np.array([2.,1.]), 0.00001)
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_sellar_group(self):
prob = Problem()
prob.root = SellarDerivativesGrouped()
prob.root.nl_solver = NLGaussSeidel()
prob.root.nl_solver.options['atol'] = 1e-9
prob.root.mda.nl_solver.options['atol'] = 1e-3
prob.root.nl_solver.options['iprint'] = 1 # so that print_norm is in coverage
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)
def test_sellar(self):
prob = Problem()
prob.root = SellarNoDerivatives()
prob.root.nl_solver = NLGaussSeidel()
prob.setup(check=False)
prob.run()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)
# Make sure we aren't iterating like crazy
self.assertLess(prob.root.nl_solver.iter_count, 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_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_sellar_state_connection(self):
prob = Problem()
prob.root = SellarStateConnection()
prob.root.nl_solver = Newton()
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)
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_complex_step(self):
prob = Problem(root=Group())
C1 = prob.root.add('C1', ExecComp(['y=2.0*x+1.'], x=2.0))
self.assertTrue('x' in C1._params_dict)
self.assertTrue('y' in C1._unknowns_dict)
prob.setup(check=False)
prob.run()
assert_rel_error(self, C1.unknowns['y'], 5.0, 0.00001)
J = C1.jacobian(C1.params, C1.unknowns, C1.resids)
assert_rel_error(self, J[('y','x')], 2.0, 0.00001)
def test_rel_error_array(self):
try:
assert_rel_error(self, 1e-2 * np.ones(3), np.zeros(3), 1e-3)
except AssertionError as exc:
msg = "arrays do not match, rel error 1.732e-02 > tol (1.000e-03)"
self.assertEqual(msg, str(exc))
else:
self.fail("Expected Assertion Error")
err = assert_rel_error(self, 1e-2 * np.ones(3), 1e-2 * np.ones(3), 1e-10)
self.assertEqual(err, 0.0)
err = assert_rel_error(self, 1e-2 * np.ones(3), 1.00001e-2 * np.ones(3), 1e-3)
self.assertLessEqual(err, 1e-5)
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_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_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_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_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_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)
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)
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_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 assertDatasetEquals(self, expected, tolerance):
# Close the file to ensure it is written to disk.
self.recorder.out.close()
self.recorder.out = None
sentinel = object()
f = shelve.open(self.filename)
order = f['order']
del f['order']
for coord, expect in expected:
iter_coord = format_iteration_coordinate(coord)
self.assertEqual(order.pop(0), iter_coord)
groupings = (
("Parameters", expect[0]),
("Unknowns", expect[1]),
("Residuals", expect[2])
)
actual_group = f[iter_coord]
for label, values in groupings:
actual = actual_group[label]
# If len(actual) == len(expected) and actual <= expected, then
# actual == expected.
self.assertEqual(len(actual), len(values))
for key, val in values:
found_val = actual.get(key, sentinel)
if found_val is sentinel:
self.fail("Did not find key '{0}'".format(key))
assert_rel_error(self, found_val, val, tolerance)
del f[iter_coord]
# Having deleted all found values, the file should now be empty.
self.assertEqual(len(f), 0)
# As should the ordering.
self.assertEqual(len(order), 0)
f.close()
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 assertDatasetEquals(self, expected, tolerance):
for coord, expect in expected:
icoord = format_iteration_coordinate(coord)
f = self.recorder.out[icoord]
params = f['Parameters']
unknowns = f['Unknowns']
resids = f['Residuals']
sentinel = object()
# If len(actual) == len(expected) and actual <= expected, then
# actual == expected.
for actual, exp in zip((params, unknowns, resids), expect):
self.assertEqual(len(actual), len(exp))
for key, val in exp:
found_val = actual.get(key, sentinel)
if found_val is sentinel:
self.fail("Did not find key '{0}'.".format(key))
assert_rel_error(self, found_val[()], val, tolerance)
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_fan_out(self):
prob = Problem()
root = prob.root = Group()
root.add('p1', ParamComp('x', 1.0))
root.add('p2', ParamComp('x', 1.0))
root.add('comp1', ExecComp('y = 3.0*x'))
root.add('comp2', ExecComp('y = 5.0*x'))
root.add('obj', ExecComp('o = i1 + i2'))
root.add('con1', ExecComp('c = 15.0 - x'))
root.add('con2', ExecComp('c = 15.0 - x'))
# hook up non explicitly
root.connect('p1.x', 'comp1.x')
root.connect('p2.x', 'comp2.x')
root.connect('comp1.y', 'obj.i1')
root.connect('comp2.y', 'obj.i2')
root.connect('comp1.y', 'con1.x')
root.connect('comp2.y', 'con2.x')
prob.driver = pyOptSparseDriver()
prob.driver.add_param('p1.x', low=-50.0, high=50.0)
prob.driver.add_param('p2.x', low=-50.0, high=50.0)
prob.driver.add_objective('obj.o')
prob.driver.add_constraint('con1.c', ctype='eq')
prob.driver.add_constraint('con2.c', ctype='eq')
prob.setup(check=False)
prob.run()
obj = prob['obj.o']
assert_rel_error(self, obj, 30.0, 1e-6)
# Verify that pyOpt has the correct wrt names
con1 = prob.driver.pyopt_solution.constraints['con1.c']
self.assertEqual(con1.wrt, ['p1.x'])
con2 = prob.driver.pyopt_solution.constraints['con2.c']
self.assertEqual(con2.wrt, ['p2.x'])
