def test_solve_subsystems_assembled_jac_top(self):
prob = Problem()
model = prob.model = DoubleSellar()
model.jacobian = DenseJacobian()
g1 = model.get_subsystem('g1')
g1.nonlinear_solver = NewtonSolver()
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = ScipyIterativeSolver()
g2 = model.get_subsystem('g2')
g2.nonlinear_solver = NewtonSolver()
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = ScipyIterativeSolver()
model.nonlinear_solver = NewtonSolver()
model.linear_solver = DirectSolver()
model.nonlinear_solver.options['solve_subsystems'] = True
prob.setup()
prob.run_model()
assert_rel_error(self, prob['g1.y1'], 0.64, .00001)
assert_rel_error(self, prob['g1.y2'], 0.80, .00001)
assert_rel_error(self, prob['g2.y1'], 0.64, .00001)
assert_rel_error(self, prob['g2.y2'], 0.80, .00001)
def _setup_model(self, jac_class, comp_jac_class, nested, lincalls):
self.prob = prob = Problem(model=Group())
if nested:
top = prob.model.add_subsystem('G1', Group())
else:
top = prob.model
indep = top.add_subsystem('indep', IndepVarComp())
indep.add_output('a', val=np.ones(3))
indep.add_output('b', val=np.ones(2))
top.add_subsystem('C1', MyExplicitComp(comp_jac_class))
top.add_subsystem('C2', MyExplicitComp2(comp_jac_class))
top.connect('indep.a', 'C1.x', src_indices=[2,0])
top.connect('indep.b', 'C1.y')
top.connect('indep.a', 'C2.w', src_indices=[0,2,1])
top.connect('C1.f', 'C2.z', src_indices=[1])
top.jacobian = jac_class()
top.nonlinear_solver = NewtonSolver()
top.nonlinear_solver.linear_solver = ScipyIterativeSolver(maxiter=100)
top.linear_solver = ScipyIterativeSolver(
maxiter=200, atol=1e-10, rtol=1e-10)
prob.set_solver_print(level=0)
prob.setup(check=False)
prob.run_model()
def test_hierarchy_iprint(self):
prob = Problem()
model = prob.model
model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])))
sub1 = model.add_subsystem('sub1', Group())
sub2 = sub1.add_subsystem('sub2', Group())
g1 = sub2.add_subsystem('g1', SubSellar())
g2 = model.add_subsystem('g2', SubSellar())
model.connect('pz.z', 'sub1.sub2.g1.z')
model.connect('sub1.sub2.g1.y2', 'g2.x')
model.connect('g2.y2', 'sub1.sub2.g1.x')
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['max_sub_solves'] = 0
g1.nonlinear_solver = NewtonSolver()
g1.linear_solver = LinearBlockGS()
g2.nonlinear_solver = NewtonSolver()
g2.linear_solver = ScipyIterativeSolver()
g2.linear_solver.precon = LinearBlockGS()
g2.linear_solver.precon.options['maxiter'] = 2
prob.set_solver_print(level=2)
prob.setup(check=False)
output = run_model(prob)
def test_jacobian_changed_component(self):
prob = Problem()
model = prob.model = Group()
model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z'])
model.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2'])
model.add_subsystem('d2', SellarDis2withDerivatives(), promotes=['z', 'y1', 'y2'])
model.add_subsystem('obj_cmp', ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]), x=0.0),
promotes=['obj', 'x', 'z', 'y1', 'y2'])
model.add_subsystem('con_cmp1', ExecComp('con1 = 3.16 - y1'), promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2', ExecComp('con2 = y2 - 24.0'), promotes=['con2', 'y2'])
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
prob.setup(check=False)
prob.final_setup()
d1 = prob.model.get_subsystem('d1')
d1.jacobian = DenseJacobian()
msg = "d1: jacobian has changed and setup was not called."
with assertRaisesRegex(self, Exception, msg):
prob.run_model()
def test_component_assembled_jac(self):
prob = Problem()
model = prob.model = Group()
model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z'])
model.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2'])
model.add_subsystem('d2', SellarDis2withDerivatives(), promotes=['z', 'y1', 'y2'])
model.add_subsystem('obj_cmp', ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]), x=0.0),
promotes=['obj', 'x', 'z', 'y1', 'y2'])
model.add_subsystem('con_cmp1', ExecComp('con1 = 3.16 - y1'), promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2', ExecComp('con2 = y2 - 24.0'), promotes=['con2', 'y2'])
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
d1 = prob.model.get_subsystem('d1')
d1.jacobian = DenseJacobian()
prob.set_solver_print(level=0)
prob.setup(check=False)
prob.run_model()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)
def test_arrray_comp(self):
class DoubleArrayFD(DoubleArrayComp):
def compute_partials(self, inputs, partials):
"""
Override deriv calculation.
"""
pass
prob = Problem()
model = prob.model = Group()
model.add_subsystem('p1', IndepVarComp('x1', val=np.ones(2)))
model.add_subsystem('p2', IndepVarComp('x2', val=np.ones(2)))
comp = model.add_subsystem('comp', DoubleArrayFD())
model.connect('p1.x1', 'comp.x1')
model.connect('p2.x2', 'comp.x2')
model.linear_solver = ScipyIterativeSolver()
model.approx_totals()
prob.setup(check=False)
prob.run_model()
model.run_linearize()
Jfd = model.jacobian._subjacs
assert_rel_error(self, Jfd['comp.y1', 'p1.x1'], -comp.JJ[0:2, 0:2],
1e-6)
assert_rel_error(self, Jfd['comp.y1', 'p2.x2'], -comp.JJ[0:2, 2:4],
1e-6)
assert_rel_error(self, Jfd['comp.y2', 'p1.x1'], -comp.JJ[2:4, 0:2],
1e-6)
assert_rel_error(self, Jfd['comp.y2', 'p2.x2'], -comp.JJ[2:4, 2:4],
1e-6)
def test_solve_subsystems_basic(self):
from openmdao.api import Problem, NewtonSolver, DirectSolver, ScipyIterativeSolver
from openmdao.test_suite.components.double_sellar import DoubleSellar
prob = Problem()
model = prob.model = DoubleSellar()
g1 = model.get_subsystem('g1')
g1.nonlinear_solver = NewtonSolver()
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = DirectSolver()
g2 = model.get_subsystem('g2')
g2.nonlinear_solver = NewtonSolver()
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = DirectSolver()
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
model.nonlinear_solver.options['solve_subsystems'] = True
prob.setup()
prob.run_model()
assert_rel_error(self, prob['g1.y1'], 0.64, .00001)
assert_rel_error(self, prob['g1.y2'], 0.80, .00001)
assert_rel_error(self, prob['g2.y1'], 0.64, .00001)
assert_rel_error(self, prob['g2.y2'], 0.80, .00001)
def test_record_line_search_bounds_enforce(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
model = self.prob.model
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['max_sub_solves'] = 4
ls = model.nonlinear_solver.linesearch = BoundsEnforceLS(
bound_enforcement='vector')
ls.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
expected_abs_error = 7.02783609310096e-10
expected_rel_error = 8.078674883382422e-07
solver_iteration = json.loads(self.solver_iterations)
self.assertAlmostEqual(solver_iteration['abs_err'], expected_abs_error)
self.assertAlmostEqual(solver_iteration['rel_err'], expected_rel_error)
self.assertEqual(solver_iteration['solver_output'], [])
self.assertEqual(solver_iteration['solver_residuals'], [])
def test_record_line_search_armijo_goldstein(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
model = self.prob.model
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
model._nonlinear_solver.options['solve_subsystems'] = True
model._nonlinear_solver.options['max_sub_solves'] = 4
ls = model._nonlinear_solver.linesearch = ArmijoGoldsteinLS(
bound_enforcement='vector')
# This is pretty bogus, but it ensures that we get a few LS iterations.
ls.options['c'] = 100.0
ls.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
expected_abs_error = 3.49773898733e-9
expected_rel_error = expected_abs_error / 2.9086436370499857e-08
solver_iteration = json.loads(self.solver_iterations)
self.assertAlmostEqual(solver_iteration['abs_err'], expected_abs_error)
self.assertAlmostEqual(solver_iteration['rel_err'], expected_rel_error)
self.assertEqual(solver_iteration['solver_output'], [])
self.assertEqual(solver_iteration['solver_residuals'], [])
def test_paraboloid_subbed(self, vec_class):
if not vec_class:
raise unittest.SkipTest("PETSc is not installed")
prob = self.prob
model = prob.model = Group()
model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y'])
sub = model.add_subsystem('sub', Group(), promotes=['x', 'y', 'f_xy'])
sub.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.linear_solver = ScipyIterativeSolver()
sub.approx_totals(method='cs')
prob.setup(check=False, vector_class=vec_class, mode='fwd')
prob.set_solver_print(level=0)
prob.run_model()
of = ['f_xy']
wrt = ['x', 'y']
derivs = prob.compute_totals(of=of, wrt=wrt)
assert_rel_error(self, derivs['f_xy', 'x'], [[-6.0]], 1e-6)
assert_rel_error(self, derivs['f_xy', 'y'], [[8.0]], 1e-6)
Jfd = sub.jacobian._subjacs
assert_rel_error(self, Jfd['sub.comp.f_xy', 'sub.comp.x'], [[6.0]],
1e-6)
assert_rel_error(self, Jfd['sub.comp.f_xy', 'sub.comp.y'], [[-8.0]],
1e-6)
# 1 output x 2 inputs
sub = model.get_subsystem('sub')
self.assertEqual(len(sub._approx_schemes['cs']._exec_list), 2)
def test_implicit_component_fd(self):
# Somehow this wasn't tested in the original fd tests (which are mostly feature tests.)
class TestImplCompArrayDense(TestImplCompArray):
def setup(self):
super(TestImplCompArrayDense, self).setup()
self.declare_partials('*', '*', method='fd')
prob = Problem()
model = prob.model = Group()
model.add_subsystem('p_rhs', IndepVarComp('rhs', val=np.ones(2)))
sub = model.add_subsystem('sub', Group())
comp = sub.add_subsystem('comp', TestImplCompArrayDense())
model.connect('p_rhs.rhs', 'sub.comp.rhs')
model.linear_solver = ScipyIterativeSolver()
prob.setup(check=False)
prob.run_model()
model.run_linearize()
Jfd = comp.jacobian._subjacs
assert_rel_error(self, Jfd['sub.comp.x', 'sub.comp.rhs'], -np.eye(2),
1e-6)
assert_rel_error(self, Jfd['sub.comp.x', 'sub.comp.x'], comp.mtx, 1e-6)
def test_around_newton(self):
# For a group that is set to FD that has a Newton solver, make sure it doesn't
# try to FD itself while solving.
class TestImplCompArrayDenseNoSolve(TestImplCompArrayDense):
def solve_nonlinear(self, inputs, outputs):
""" Disable local solve."""
pass
prob = Problem()
model = prob.model = Group()
model.add_subsystem('p_rhs', IndepVarComp('rhs', val=np.array([2, 4])))
comp = model.add_subsystem('comp', TestImplCompArrayDenseNoSolve())
model.connect('p_rhs.rhs', 'comp.rhs')
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
model.approx_totals()
prob.setup(check=False)
prob.run_model()
model.approx_totals()
assert_rel_error(self, prob['comp.x'], [1.97959184, 4.02040816], 1e-5)
model.run_linearize()
of = ['comp.x']
wrt = ['p_rhs.rhs']
Jfd = prob.compute_totals(of=of, wrt=wrt)
assert_rel_error(
self, Jfd['comp.x', 'p_rhs.rhs'],
[[1.01020408, -0.01020408], [-0.01020408, 1.01020408]], 1e-5)
def test_feature_max_sub_solves(self):
prob = Problem()
model = prob.model = Group()
model.add_subsystem('g1', SubSellar())
model.add_subsystem('g2', SubSellar())
model.connect('g1.y2', 'g2.x')
model.connect('g2.y2', 'g1.x')
# Converge the outer loop with Gauss Seidel, with a looser tolerance.
model.nonlinear_solver = NewtonSolver()
model.linear_solver = DirectSolver()
g1 = model.get_subsystem('g1')
g1.nonlinear_solver = NewtonSolver()
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = DirectSolver()
g2 = model.get_subsystem('g2')
g2.nonlinear_solver = NewtonSolver()
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = DirectSolver()
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['max_sub_solves'] = 0
prob.setup()
prob.run_model()
def test_linear_system(self):
"""Check against the scipy solver."""
model = Group()
x = np.array([1, 2, -3])
A = np.array([[5.0, -3.0, 2.0], [1.0, 7.0, -4.0], [1.0, 0.0, 8.0]])
b = A.dot(x)
model.add_subsystem('p1', IndepVarComp('A', A))
model.add_subsystem('p2', IndepVarComp('b', b))
lingrp = model.add_subsystem('lingrp', Group(), promotes=['*'])
lingrp.add_subsystem('lin', LinearSystemComp(size=3, partial_type="matrix_free"))
model.connect('p1.A', 'lin.A')
model.connect('p2.b', 'lin.b')
prob = Problem(model)
prob.setup()
lingrp = prob.model.get_subsystem('lingrp')
lingrp.linear_solver = ScipyIterativeSolver()
prob.set_solver_print(level=0)
prob.run_model()
assert_rel_error(self, prob['lin.x'], x, .0001)
assert_rel_error(self, prob.model._residuals.get_norm(), 0.0, 1e-10)
def runs_successfully(use_scal, coeffs):
prob = Problem(model=Group())
prob.model.add_subsystem(
'row1', ScalingTestComp(row=1,
coeffs=coeffs,
use_scal=use_scal))
prob.model.add_subsystem(
'row2', ScalingTestComp(row=2,
coeffs=coeffs,
use_scal=use_scal))
prob.model.connect('row1.y', 'row2.x')
prob.model.connect('row2.y', 'row1.x')
prob.model.nonlinear_solver = NewtonSolver(maxiter=2,
atol=1e-5,
rtol=0)
prob.model.nonlinear_solver.linear_solver = ScipyIterativeSolver(
maxiter=1)
prob.set_solver_print(level=0)
prob.setup(check=False)
result = prob.run_model()
success = not result[0]
return success
def setup_sellar_grouped_model(self):
self.prob = Problem()
model = self.prob.model = Group()
model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z'])
mda = model.add_subsystem('mda', Group(), promotes=['x', 'z', 'y1', 'y2'])
mda.linear_solver = ScipyIterativeSolver()
mda.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2'])
mda.add_subsystem('d2', SellarDis2withDerivatives(), promotes=['z', 'y1', 'y2'])
model.add_subsystem('obj_cmp', ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]), x=0.0, y1=0.0, y2=0.0),
promotes=['obj', 'x', 'z', 'y1', 'y2'])
model.add_subsystem('con_cmp1', ExecComp('con1 = 3.16 - y1'), promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2', ExecComp('con2 = y2 - 24.0'), promotes=['con2', 'y2'])
mda.nonlinear_solver = NonlinearBlockGS()
model.linear_solver = LinearBlockGS()
model.add_design_var('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0]))
model.add_design_var('x', lower=0.0, upper=10.0)
model.add_objective('obj')
model.add_constraint('con1', upper=0.0)
model.add_constraint('con2', upper=0.0)
def test_const_jacobian(self):
model = Group()
comp = IndepVarComp()
for name, val in (('x', 1.), ('y1', np.ones(2)), ('y2', np.ones(2)),
('y3', np.ones(2)), ('z', np.ones((2, 2)))):
comp.add_output(name, val)
model.add_subsystem('input_comp', comp, promotes=['x', 'y1', 'y2', 'y3', 'z'])
problem = Problem(model=model)
problem.set_solver_print(level=0)
model.linear_solver = ScipyIterativeSolver()
model.jacobian = COOJacobian()
model.add_subsystem('simple', SimpleCompConst(),
promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g'])
problem.setup(check=False)
problem.run_model()
totals = problem.compute_totals(['f', 'g'],
['x', 'y1', 'y2', 'y3', 'z'])
jacobian = {}
jacobian['f', 'x'] = [[1.]]
jacobian['f', 'z'] = np.ones((1, 4))
jacobian['f', 'y1'] = np.zeros((1, 2))
jacobian['f', 'y2'] = np.zeros((1, 2))
jacobian['f', 'y3'] = np.zeros((1, 2))
jacobian['g', 'y1'] = [[1, 0], [1, 0], [0, 1], [0, 1]]
jacobian['g', 'y2'] = [[1, 0], [0, 1], [1, 0], [0, 1]]
jacobian['g', 'y3'] = [[1, 0], [1, 0], [0, 1], [0, 1]]
jacobian['g', 'x'] = [[1], [0], [0], [1]]
jacobian['g', 'z'] = np.zeros((4, 4))
assert_rel_error(self, totals, jacobian)
def test_paraboloid_subbed(self):
prob = Problem()
model = prob.model = Group()
model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y'])
sub = model.add_subsystem('sub', Group(), promotes=['x', 'y', 'f_xy'])
sub.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.linear_solver = ScipyIterativeSolver()
sub.approx_totals()
prob.setup(check=False, mode='fwd')
prob.set_solver_print(level=0)
prob.run_model()
of = ['f_xy']
wrt = ['x', 'y']
derivs = prob.compute_totals(of=of, wrt=wrt)
assert_rel_error(self, derivs['f_xy', 'x'], [[-6.0]], 1e-6)
assert_rel_error(self, derivs['f_xy', 'y'], [[8.0]], 1e-6)
Jfd = sub.jacobian._subjacs
assert_rel_error(self, Jfd['sub.comp.f_xy', 'sub.comp.x'], [[6.0]],
1e-6)
assert_rel_error(self, Jfd['sub.comp.f_xy', 'sub.comp.y'], [[-8.0]],
1e-6)
# 1 output x 2 inputs
sub = model.get_subsystem('sub')
self.assertEqual(len(sub._approx_schemes['fd']._exec_list), 2)
def __init__(self):
super(SellarModified, self).__init__()
self.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2'])
self.add_subsystem('d2', SellarDis2withDerivatives(), promotes=['z', 'y1', 'y2'])
self.nonlinear_solver = NonlinearBlockGS()
self.linear_solver = ScipyIterativeSolver()
def test_hierarchy_iprint(self):
prob = Problem()
model = prob.model
model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])))
sub1 = model.add_subsystem('sub1', Group())
sub2 = sub1.add_subsystem('sub2', Group())
g1 = sub2.add_subsystem('g1', SubSellar())
g2 = model.add_subsystem('g2', SubSellar())
model.connect('pz.z', 'sub1.sub2.g1.z')
model.connect('sub1.sub2.g1.y2', 'g2.x')
model.connect('g2.y2', 'sub1.sub2.g1.x')
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['max_sub_solves'] = 0
g1.nonlinear_solver = NewtonSolver()
g1.linear_solver = LinearBlockGS()
g2.nonlinear_solver = NewtonSolver()
g2.linear_solver = ScipyIterativeSolver()
g2.linear_solver.precon = LinearBlockGS()
g2.linear_solver.precon.options['maxiter'] = 2
prob.set_solver_print(level=2)
prob.setup(vector_class=PETScVector, check=False)
# Conclude setup but don't run model.
prob.final_setup()
# if USE_PROC_FILES is not set, solver convergence messages
# should only appear on proc 0
output = run_model(prob)
if model.comm.rank == 0 or os.environ.get('USE_PROC_FILES'):
self.assertTrue(output.count('\nNL: Newton Converged') == 1)
else:
self.assertTrue(output.count('\nNL: Newton Converged') == 0)
def test_newton_with_densejac_under_full_model_fd(self):
# Basic sellar test.
prob = Problem()
model = prob.model = Group()
sub = model.add_subsystem('sub', Group(), promotes=['*'])
model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('pz',
IndepVarComp('z', np.array([5.0, 2.0])),
promotes=['z'])
sub.add_subsystem('d1',
SellarDis1withDerivatives(),
promotes=['x', 'z', 'y1', 'y2'])
sub.add_subsystem('d2',
SellarDis2withDerivatives(),
promotes=['z', 'y1', 'y2'])
model.add_subsystem('obj_cmp',
ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]),
x=0.0),
promotes=['obj', 'x', 'z', 'y1', 'y2'])
model.add_subsystem('con_cmp1',
ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2',
ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
sub.nonlinear_solver = NewtonSolver()
sub.linear_solver = ScipyIterativeSolver()
model.jacobian = DenseJacobian()
model.approx_totals(method='fd', step=1e-5)
prob.setup(check=False)
prob.set_solver_print(level=0)
prob.run_model()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)
wrt = ['z']
of = ['obj']
J = prob.compute_totals(of=of, wrt=wrt, return_format='flat_dict')
assert_rel_error(self, J['obj', 'z'][0][0], 9.61001056, .00001)
assert_rel_error(self, J['obj', 'z'][0][1], 1.78448534, .00001)
def test_feature_set_solver_print3(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, NewtonSolver, ScipyIterativeSolver, LinearBlockGS
from openmdao.test_suite.components.double_sellar import SubSellar
prob = Problem()
model = prob.model
model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])))
sub1 = model.add_subsystem('sub1', Group())
sub2 = sub1.add_subsystem('sub2', Group())
g1 = sub2.add_subsystem('g1', SubSellar())
g2 = model.add_subsystem('g2', SubSellar())
model.connect('pz.z', 'sub1.sub2.g1.z')
model.connect('sub1.sub2.g1.y2', 'g2.x')
model.connect('g2.y2', 'sub1.sub2.g1.x')
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyIterativeSolver()
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['max_sub_solves'] = 0
g1.nonlinear_solver = NewtonSolver()
g1.linear_solver = LinearBlockGS()
g2.nonlinear_solver = NewtonSolver()
g2.linear_solver = ScipyIterativeSolver()
g2.linear_solver.precon = LinearBlockGS()
g2.linear_solver.precon.options['maxiter'] = 2
prob.set_solver_print(level=0)
prob.set_solver_print(level=2, depth=2)
prob.setup()
prob.run_model()
def test_reconfigure(self):
# In this test, we switch to 'cs' when we reconfigure.
class TestImplCompArrayDense(TestImplCompArray):
def initialize(self):
self.mtx = np.array([
[0.99, 0.01],
[0.01, 0.99],
])
self.count = 0
def setup(self):
super(TestImplCompArrayDense, self).setup()
if self.count > 0:
self.declare_partials('*', '*', method='cs')
else:
self.declare_partials('*', '*', method='fd')
self.count += 1
prob = self.prob = Problem()
model = prob.model = Group()
model.add_subsystem('p_rhs', IndepVarComp('rhs', val=np.ones(2)))
sub = model.add_subsystem('sub', Group())
comp = sub.add_subsystem('comp', TestImplCompArrayDense())
model.connect('p_rhs.rhs', 'sub.comp.rhs')
model.linear_solver = ScipyIterativeSolver()
prob.setup(check=False)
prob.run_model()
with self.assertRaises(RuntimeError) as context:
model.resetup(setup_mode='reconf')
msg = 'In order to activate complex step during reconfiguration, you need to set ' + \
'"force_alloc_complex" to True during setup.'
self.assertEqual(str(context.exception), msg)
# This time, allocate complex in setup.
prob.setup(check=False, force_alloc_complex=True)
prob.run_model()
model.resetup(setup_mode='reconf')
prob.run_model()
model.run_linearize()
Jfd = comp.jacobian._subjacs
assert_rel_error(self, Jfd['sub.comp.x', 'sub.comp.rhs'], -np.eye(2),
1e-6)
assert_rel_error(self, Jfd['sub.comp.x', 'sub.comp.x'], comp.mtx, 1e-6)
def test_post_setup_solver_configure(self):
# Test that we can change solver settings after we have instantiated our model.
class ImplSimple(ImplicitComponent):
def setup(self):
self.add_input('a', val=1.)
self.add_output('x', val=0.)
def apply_nonlinear(self, inputs, outputs, residuals):
residuals['x'] = np.exp(outputs['x']) - \
inputs['a']**2 * outputs['x']**2
def linearize(self, inputs, outputs, jacobian):
jacobian['x', 'x'] = np.exp(outputs['x']) - \
2 * inputs['a']**2 * outputs['x']
jacobian['x', 'a'] = -2 * inputs['a'] * outputs['x']**2
class Sub(Group):
def setup(self):
self.add_subsystem('comp', ImplSimple())
# This will not solve it
self.nonlinear_solver = NonlinearBlockGS()
def configure(self):
# This will not solve it either.
self.nonlinear_solver = NonlinearBlockGS()
class Super(Group):
def setup(self):
self.add_subsystem('sub', Sub())
top = Problem()
top.model = Super()
top.setup(check=False)
# This will solve it.
top.model.sub.nonlinear_solver = NewtonSolver()
top.model.sub.linear_solver = ScipyIterativeSolver()
self.assertTrue(isinstance(top.model.sub.nonlinear_solver, NewtonSolver))
self.assertTrue(isinstance(top.model.sub.linear_solver, ScipyIterativeSolver))
def test_feature_iprint_2(self):
prob = Problem()
prob.model = SellarDerivatives()
newton = prob.model.nonlinear_solver = NewtonSolver()
scipy = prob.model.linear_solver = ScipyIterativeSolver()
newton.options['maxiter'] = 20
prob.setup(check=False)
prob['y1'] = 10000
prob['y2'] = -20
newton.options['iprint'] = 2
scipy.options['iprint'] = 1
prob.run_model()
def test_arguments(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, ScipyIterativeSolver, ExplicitComponent
class CompOne(ExplicitComponent):
def setup(self):
self.add_input('x', val=0.0)
self.add_output('y', val=np.zeros(25))
self._exec_count = 0
def compute(self, inputs, outputs):
x = inputs['x']
outputs['y'] = np.arange(25) * x
self._exec_count += 1
class CompTwo(ExplicitComponent):
def setup(self):
self.add_input('y', val=np.zeros(25))
self.add_output('z', val=0.0)
self._exec_count = 0
def compute(self, inputs, outputs):
y = inputs['y']
outputs['z'] = np.sum(y)
self._exec_count += 1
prob = Problem()
model = prob.model = Group()
model.add_subsystem('p1', IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('comp1', CompOne(), promotes=['x', 'y'])
comp2 = model.add_subsystem('comp2', CompTwo(), promotes=['y', 'z'])
model.linear_solver = ScipyIterativeSolver()
model.approx_totals(method='fd',
step=1e-7,
form='central',
step_calc='rel')
prob.setup()
prob.run_model()
of = ['z']
wrt = ['x']
derivs = prob.compute_totals(of=of, wrt=wrt)
assert_rel_error(self, derivs['z', 'x'], [[300.0]], 1e-6)
def setUp(self):
self.model = model = Group()
comp = IndepVarComp()
variables = (
('x', 1.),
('y1', np.ones(2)),
('y2', np.ones(2)),
('y3', np.ones(2)),
('z', np.ones((2, 2))),
)
for name, val in variables:
comp.add_output(name, val)
model.add_subsystem('input_comp', comp, promotes=['x', 'y1', 'y2', 'y3', 'z'])
self.problem = Problem(model=model)
self.problem.set_solver_print(level=0)
model.linear_solver = ScipyIterativeSolver()
model.jacobian = COOJacobian()
def test_feature_iprint_neg1(self):
prob = Problem()
prob.model = SellarDerivatives()
newton = prob.model.nonlinear_solver = NewtonSolver()
scipy = prob.model.linear_solver = ScipyIterativeSolver()
newton.options['maxiter'] = 2
prob.setup(check=False)
# use a real bad initial guess
prob['y1'] = 10000
prob['y2'] = -26
newton.options['iprint'] = -1
scipy.options['iprint'] = -1
prob.run_model()
print('done')
def test_converge_diverge_groups(self):
# Test derivatives for converge-diverge-groups topology.
prob = Problem()
prob.model = ConvergeDivergeGroups()
prob.model.linear_solver = ScipyIterativeSolver()
prob.set_solver_print(level=0)
prob.model.nonlinear_solver = NonLinearRunOnce()
g1 = prob.model.get_subsystem('g1')
g2 = g1.get_subsystem('g2')
g3 = prob.model.get_subsystem('g3')
g1.nonlinear_solver = NonLinearRunOnce()
g2.nonlinear_solver = NonLinearRunOnce()
g3.nonlinear_solver = NonLinearRunOnce()
prob.setup(check=False, mode='fwd')
prob.run_model()
# Make sure value is fine.
assert_rel_error(self, prob['c7.y1'], -102.7, 1e-6)
def test_feature_iprint_2(self):
from openmdao.api import Problem, NewtonSolver, ScipyIterativeSolver
from openmdao.test_suite.components.sellar import SellarDerivatives
prob = Problem()
prob.model = SellarDerivatives()
prob.setup()
newton = prob.model.nonlinear_solver = NewtonSolver()
scipy = prob.model.linear_solver = ScipyIterativeSolver()
newton.options['maxiter'] = 20
prob['y1'] = 10000
prob['y2'] = -20
newton.options['iprint'] = 2
scipy.options['iprint'] = 1
prob.run_model()
