def test_nested_relevancy_gmres(self):
# This test is just to make sure that values in the dp vector from
# higher scopes aren't sitting there converting themselves during sub
# iterations.
prob = Problem(impl=impl)
root = prob.root = Group()
root.add('p1', IndepVarComp('xx', 3.0))
root.add(
'c1',
ExecComp(['y1=0.5*x + 1.0*xx', 'y2=0.3*x - 1.0*xx'],
units={'y2': 'km'}))
root.add('c2', ExecComp(['y=0.5*x']))
sub = root.add('sub', Group())
sub.add('cc1', ExecComp(['y=1.01*x1 + 1.01*x2'], units={'x1': 'fm'}))
sub.add('cc2', ExecComp(['y=1.01*x']))
root.connect('p1.xx', 'c1.xx')
root.connect('c1.y1', 'c2.x')
root.connect('c2.y', 'c1.x')
root.connect('c1.y2', 'sub.cc1.x1')
root.connect('sub.cc1.y', 'sub.cc2.x')
root.connect('sub.cc2.y', 'sub.cc1.x2')
root.nl_solver = Newton()
root.nl_solver.options['maxiter'] = 1
root.ln_solver = PetscKSP()
root.ln_solver.options['maxiter'] = 1
sub.nl_solver = Newton()
#sub.nl_solver.options['maxiter'] = 7
sub.ln_solver = PetscKSP()
prob.driver.add_desvar('p1.xx')
prob.driver.add_objective('sub.cc2.y')
prob.setup(check=False)
prob.print_all_convergence()
prob.run()
# GMRES doesn't cause a successive build-up in the value of an out-of
# scope param, but the linear solver doesn't converge. We can test to
# make sure it does.
iter_count = sub.ln_solver.iter_count
self.assertTrue(iter_count < 20)
self.assertTrue(not np.isnan(prob['sub.cc2.y']))
def test_analysis_error(self):
prob = Problem(impl=impl)
prob.root = ConvergeDiverge()
prob.root.ln_solver = PetscKSP()
prob.root.ln_solver.options['maxiter'] = 2
prob.root.ln_solver.options['err_on_maxiter'] = True
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)
try:
J = prob.calc_gradient(indep_list,
unknown_list,
mode='fwd',
return_format='dict')
except AnalysisError as err:
self.assertEqual(
str(err),
"Solve in '': PetscKSP FAILED to converge in 6 iterations")
else:
self.fail("expected AnalysisError")
def test_fan_in_grouped(self):
prob = Problem(impl=impl)
prob.root = FanInGrouped()
prob.root.ln_solver = PetscKSP()
indep_list = ['p1.x1', 'p2.x2']
unknown_list = ['comp3.y']
prob.setup(check=False)
prob.run()
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_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_single_diamond_grouped(self):
prob = Problem(impl=impl)
prob.root = SingleDiamondGrouped()
prob.root.ln_solver = PetscKSP()
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_fan_out_grouped(self):
prob = Problem(impl=impl)
prob.root = FanOutGrouped()
prob.root.ln_solver = PetscKSP()
prob.setup(check=False)
prob.run()
param = 'sub.pgroup.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)
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_converge_diverge_groups(self):
prob = Problem(impl=impl)
prob.root = ConvergeDivergeGroups()
prob.root.ln_solver = PetscKSP()
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_KSP_under_relevance_reduction(self):
# Test for a bug reported by NREL, where KSP in a subgroup would bomb
# out during top-level gradients under relevance reduction.
nProblems = 4
top = Problem(impl=impl)
top.root = SellarDerivativesSuperGroup(nProblems=nProblems)
top.root.manySellars.Sellar0.add('extra_con_cmp3',
ExecComp('con3 = 3.16 - y1_0'),
promotes=['*'])
top.driver.add_desvar('z',
lower=np.array([-10.0, 0.0]),
upper=np.array([10.0, 10.0]))
top.driver.add_desvar('x', lower=0.0, upper=10.0)
top.driver.add_objective('obj')
top.driver.add_constraint('y1_0', upper=0.0)
top.driver.add_constraint('y1_1', upper=0.0)
top.driver.add_constraint('y2_2', upper=0.0)
top.driver.add_constraint('y2_3', upper=0.0)
top.driver.add_constraint('con3', upper=0.0)
top.root.ln_solver.options['single_voi_relevance_reduction'] = True
top.root.ln_solver.options['mode'] = 'rev'
if impl is not None:
top.root.manySellars.Sellar0.ln_solver = PetscKSP()
top.root.manySellars.Sellar1.ln_solver = PetscKSP()
top.root.manySellars.Sellar2.ln_solver = PetscKSP()
top.root.manySellars.Sellar3.ln_solver = PetscKSP()
top.setup(check=False)
# Setting initial values for design variables
top['x'] = 1.0
top['z'] = np.array([5.0, 2.0])
top.run()
# Should get no error
J = top.calc_gradient(['x', 'z'], ['obj', 'con3'])
def test_sellar_derivs_grouped(self):
prob = Problem(impl=impl)
prob.root = SellarDerivativesGrouped()
prob.root.ln_solver = PetscKSP()
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.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 __init__(self, problem_id=0):
super(SellarDerivativesSubGroup, self).__init__()
self.add('d1', SellarDis1(problem_id=problem_id), promotes=['*'])
self.add('d2', SellarDis2(problem_id=problem_id), promotes=['*'])
self.nl_solver = NLGaussSeidel()
self.nl_solver.options['atol'] = 1.0e-12
if impl is not None:
self.ln_solver = PetscKSP()
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_array2D(self):
group = Group()
group.add('x_param', ParamComp('x', np.ones((2, 2))), promotes=['*'])
group.add('mycomp', ArrayComp2D(), 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')
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_converge_diverge_comp_cs(self):
prob = Problem(impl=impl)
prob.root = ConvergeDivergePar()
prob.root.ln_solver = PetscKSP()
# fd the whole model
prob.root.fd_options['force_fd'] = True
prob.root.fd_options['form'] = 'complex_step'
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='fd', return_format='dict')
assert_rel_error(self, J['comp7.y1']['p.x'][0][0], -40.75, 1e-6)
def test_fan_out(self):
prob = Problem(impl=impl)
prob.root = FanOut()
prob.root.ln_solver = PetscKSP()
prob.setup(check=False)
prob.run()
indep_list = ['p.x']
unknown_list = ['comp2.y', "comp3.y"]
J = prob.calc_gradient(indep_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(indep_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_matvec_subbed_like_multipoint(self):
group = Group()
group.add('mycomp', SimpleCompDerivMatVec(), promotes=['x', 'y'])
prob = Problem(impl=impl)
prob.root = Group()
prob.root.add('sub', group, promotes=['*'])
prob.root.sub.add('x_param', ParamComp('x', 1.0), promotes=['*'])
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)
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)
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", low=0., high=1.0)
model.driver.add_desvar("bp2.finAngle", low=0., high=np.pi/2.)
model.driver.add_desvar("bp3.antAngle", low=-np.pi/4, high=np.pi/4)
# Add objective
model.driver.add_objective('obj.val')
# For Parallel exeuction, we must use KSP
model.root.ln_solver = PetscKSP()
#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.setup()
model.run()
#----------------------------------------------------------------
# Below this line, code I was using for verifying and profiling.
#----------------------------------------------------------------
params = model.driver.get_desvars().keys()
unks = model.driver.get_objectives().keys() + model.driver.get_constraints().keys()
import cProfile
def test_CADRE_MDP(self):
n = 1500
m = 300
npts = 2
# 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, low=0., high=0.4)
model.driver.add_desvar("%s.CP_gamma" % name, low=0, high=np.pi/2.)
model.driver.add_desvar("%s.CP_P_comm" % name, low=0., high=25.)
model.driver.add_desvar("%s.iSOC" % name, indices=[0], low=0.2, high=1.)
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", low=0., high=1.0)
model.driver.add_desvar("bp2.finAngle", low=0., high=np.pi/2.)
model.driver.add_desvar("bp3.antAngle", low=-np.pi/4, high=np.pi/4)
# Add objective
model.driver.add_objective('obj.val')
# For Parallel exeuction, we must use KSP
if MPI:
model.root.ln_solver = PetscKSP()
model.setup()
model.run()
# Read pickle
fpath = os.path.dirname(os.path.realpath(__file__))
data = pickle.load(open(fpath + "/mdp_execute.pkl", 'rb'))
for var in data:
# We changed constraint names
xvar = var
if '_con1' in xvar:
xvar = xvar.replace('_con1.val', '.ConCh')
if '_con2' in xvar:
xvar = xvar.replace('_con2.val', '.ConDs')
if '_con3' in xvar:
xvar = xvar.replace('_con3.val', '.ConS0')
if '_con4' in xvar:
xvar = xvar.replace('_con4.val', '.ConS1')
computed = model[xvar]
actual = data[var]
if isinstance(computed, np.ndarray):
rel = np.linalg.norm(actual - computed)/np.linalg.norm(actual)
else:
rel = np.abs(actual - computed)/np.abs(actual)
print(xvar)
print(computed)
print(actual)
if np.mean(actual) > 1e-3 or np.mean(computed) > 1e-3:
assert rel <= 1e-3
# Now do derivatives
params = model.driver.get_desvars().keys()
unks = model.driver.get_objectives().keys() + model.driver.get_constraints().keys()
Jb = model.calc_gradient(params, unks, mode='rev', return_format='dict')
# Read pickle
fpath = os.path.dirname(os.path.realpath(__file__))
Ja = pickle.load(open(fpath + "/mdp_derivs.pkl", 'rb'))
for key1, value in sorted(Ja.items()):
for key2 in sorted(value.keys()):
# We changed constraint names
xkey1 = key1
if '_con1' in xkey1:
xkey1 = xkey1.replace('_con1.val', '.ConCh')
if '_con2' in xkey1:
xkey1 = xkey1.replace('_con2.val', '.ConDs')
if '_con3' in xkey1:
xkey1 = xkey1.replace('_con3.val', '.ConS0')
if '_con4' in xkey1:
xkey1 = xkey1.replace('_con4.val', '.ConS1')
computed = Jb[xkey1][key2]
actual = Ja[key1][key2]
if isinstance(computed, np.ndarray):
rel = np.linalg.norm(actual - computed)/np.linalg.norm(actual)
else:
rel = np.abs(actual - computed)/np.abs(actual)
print(xkey1, 'wrt', key2)
print(computed)
print(actual)
if np.mean(actual) > 1e-3 or np.mean(computed) > 1e-3:
assert rel <= 1e-3
def test_newton_backtrack_MPI(self):
#------------------------------------------------------
# Test that Newton doesn't drive it past lower bounds
#------------------------------------------------------
top = Problem(impl=impl)
top.root = Group()
par = top.root.add('par', ParallelGroup())
par.add('comp1', SimpleImplicitComp1())
par.add('comp2', SimpleImplicitComp2())
top.root.ln_solver = PetscKSP()
top.root.nl_solver = Newton()
top.root.nl_solver.options['maxiter'] = 5
top.root.add('px', IndepVarComp('x', np.ones((3, 1))))
top.root.connect('px.x', 'par.comp1.x')
top.root.connect('px.x', 'par.comp2.x')
top.setup(check=False)
top['px.x'] = np.array([2.0, 2.0, 2.0])
top.run()
if not MPI or self.comm.rank == 0:
self.assertEqual(top['par.comp1.z'][0], 1.5)
self.assertEqual(top['par.comp1.z'][1], 1.5)
self.assertEqual(top['par.comp1.z'][2], 1.5)
if not MPI or self.comm.rank == 1:
self.assertEqual(top['par.comp2.z'][0], -1.5)
self.assertEqual(top['par.comp2.z'][1], -1.5)
self.assertEqual(top['par.comp2.z'][2], -1.5)
#------------------------------------------------------
# Test that Newton doesn't drive it past upper bounds
#------------------------------------------------------
top = Problem(impl=impl)
top.root = Group()
par = top.root.add('par', ParallelGroup())
par.add('comp1', SimpleImplicitComp1())
par.add('comp2', SimpleImplicitComp2())
top.root.ln_solver = PetscKSP()
top.root.nl_solver = Newton()
top.root.nl_solver.options['maxiter'] = 5
top.root.add('px', IndepVarComp('x', np.ones((3, 1))))
top.root.connect('px.x', 'par.comp1.x')
top.root.connect('px.x', 'par.comp2.x')
top.setup(check=False)
top['px.x'] = 0.5*np.ones((3, 1))
top.run()
# Each bound is observed
if top.root.par.comp1.is_active():
self.assertEqual(top['par.comp1.z'][0], 2.6)
self.assertEqual(top['par.comp1.z'][1], 2.5)
self.assertEqual(top['par.comp1.z'][2], 2.65)
if top.root.par.comp2.is_active():
self.assertEqual(top['par.comp2.z'][0], -2.6)
self.assertEqual(top['par.comp2.z'][1], -2.5)
self.assertEqual(top['par.comp2.z'][2], -2.65)
