def test_specify_subgroup_solvers(self):
from openmdao.api import Problem, NewtonSolver, ScipyIterativeSolver, DirectSolver, NonlinearBlockGS, LinearBlockGS
from openmdao.test_suite.components.double_sellar import DoubleSellar
prob = Problem()
model = prob.model = DoubleSellar()
# each SubSellar group converges itself
g1 = model.get_subsystem('g1')
g1.nonlinear_solver = NewtonSolver()
g1.linear_solver = DirectSolver() # used for derivatives
g2 = model.get_subsystem('g2')
g2.nonlinear_solver = NewtonSolver()
g2.linear_solver = DirectSolver()
# Converge the outer loop with Gauss Seidel, with a looser tolerance.
model.nonlinear_solver = NonlinearBlockGS()
model.nonlinear_solver.options['rtol'] = 1.0e-5
model.linear_solver = ScipyIterativeSolver()
model.linear_solver.precon = LinearBlockGS()
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_test_promoted_connections_nlbgs_solver(self):
p = Problem()
p.model = model = Group()
model.linear_solver = DirectSolver()
model.nonlinear_solver = NonlinearBlockGS()
model.nonlinear_solver.options['reraise_child_analysiserror'] = True
model.add_subsystem('c1',
IndepVarComp('x', 1.0),
promotes_outputs=['x'])
model.add_subsystem('c2',
ReconfComp1(),
promotes_inputs=['x'],
promotes_outputs=['y'])
model.add_subsystem('c3',
ReconfComp2(),
promotes_inputs=['y'],
promotes_outputs=['f'])
p.setup()
p['x'] = 3.
# First run the model once; counter = 1, size of y = 1
p.run_model()
self.assertEqual(len(p['y']), 1)
# Run the model again, which will trigger reconfiguration; counter = 2, size of y = 2
p.run_model()
self.assertEqual(len(p['y']), 2)
assert_rel_error(self, p['y'], [6., 6.])
def test_direct_solver_comp(self):
"""
Test the direct solver on a component.
"""
for jac in [None, 'csc', 'dense']:
prob = Problem(model=ImplComp4Test())
prob.model.nonlinear_solver = NewtonSolver(solve_subsystems=False)
if jac in ('csc', 'dense'):
prob.model.options['assembled_jac_type'] = jac
prob.model.linear_solver = DirectSolver(assemble_jac=jac in ('csc','dense'))
prob.set_solver_print(level=0)
prob.setup()
prob.run_model()
assert_near_equal(prob['y'], [-1., 1.])
d_inputs, d_outputs, d_residuals = prob.model.get_linear_vectors()
d_residuals.set_val(2.0)
d_outputs.set_val(0.0)
prob.model.run_solve_linear('fwd')
result = d_outputs.asarray()
assert_near_equal(result, [-2., 2.])
d_outputs.set_val(2.0)
d_residuals.set_val(0.0)
prob.model.run_solve_linear('rev')
result = d_residuals.asarray()
assert_near_equal(result, [2., -2.])
def test_direct_solver_comp(self):
"""
Test the direct solver on a component.
"""
for jac in [None, 'csc', 'dense']:
prob = Problem(model=ImplComp4Test())
prob.model.nonlinear_solver = NewtonSolver()
if jac in ('csc', 'dense'):
prob.model.options['assembled_jac_type'] = jac
prob.model.linear_solver = DirectSolver(assemble_jac=jac in ('csc','dense'))
prob.set_solver_print(level=0)
prob.setup(check=False)
prob.run_model()
assert_rel_error(self, prob['y'], [-1., 1.])
d_inputs, d_outputs, d_residuals = prob.model.get_linear_vectors()
d_residuals.set_const(2.0)
d_outputs.set_const(0.0)
prob.model.run_solve_linear(['linear'], 'fwd')
result = d_outputs.get_data()
assert_rel_error(self, result, [-2., 2.])
d_outputs.set_const(2.0)
d_residuals.set_const(0.0)
prob.model.run_solve_linear(['linear'], 'rev')
result = d_residuals.get_data()
assert_rel_error(self, result, [2., -2.])
def test_reconf_comp_connections_newton_solver(self):
p = Problem()
p.model = model = Group()
model.linear_solver = DirectSolver()
model.nonlinear_solver = NewtonSolver(solve_subsystems=False)
model.add_subsystem('c1',
IndepVarComp('x', 1.0),
promotes_outputs=['x'])
model.add_subsystem('c2', ReconfComp1(), promotes_inputs=['x'])
model.add_subsystem('c3', ReconfComp2(), promotes_outputs=['f'])
model.connect('c2.y', 'c3.y')
p.setup()
p['x'] = 3.
# First run the model once; counter = 1, size of y = 1
p.run_model()
self.assertEqual(len(p['c2.y']), 1)
self.assertEqual(len(p['c3.y']), 1)
# Run the model again, which will trigger reconfiguration; counter = 2, size of y = 2
p.run_model()
self.assertEqual(len(p['c2.y']), 2)
self.assertEqual(len(p['c3.y']), 2)
assert_rel_error(self, p['c3.y'], [6., 6.])
def test_debug_after_raised_error(self):
prob = Problem()
model = prob.model
comp = IndepVarComp()
comp.add_output('dXdt:TAS', val=1.0)
comp.add_output('accel_target', val=2.0)
model.add_subsystem('des_vars', comp, promotes=['*'])
teg = model.add_subsystem('thrust_equilibrium_group', subsys=Group())
teg.add_subsystem('dynamics',
ExecComp('z = 2.0*thrust'),
promotes=['*'])
thrust_bal = BalanceComp()
thrust_bal.add_balance(name='thrust',
val=1207.1,
lhs_name='dXdt:TAS',
rhs_name='accel_target',
eq_units='m/s**2',
lower=-10.0,
upper=10000.0)
teg.add_subsystem(name='thrust_bal',
subsys=thrust_bal,
promotes_inputs=['dXdt:TAS', 'accel_target'],
promotes_outputs=['thrust'])
teg.linear_solver = DirectSolver()
teg.nonlinear_solver = NewtonSolver()
teg.nonlinear_solver.options['solve_subsystems'] = True
teg.nonlinear_solver.options['max_sub_solves'] = 1
teg.nonlinear_solver.options['atol'] = 1e-4
teg.nonlinear_solver.options['debug_print'] = True
prob.setup(check=False)
prob.set_solver_print(level=0)
stdout = sys.stdout
strout = StringIO()
sys.stdout = strout
with self.assertRaises(RuntimeError) as cm:
prob.run_model()
sys.stdout = stdout
output = strout.getvalue()
target = "'thrust_equilibrium_group.thrust_bal.thrust'"
self.assertTrue(target in output, msg=target + "NOT FOUND IN" + output)
# Make sure exception is unchanged.
expected_msg = "Singular entry found in 'thrust_equilibrium_group' for row associated with state/residual 'thrust'."
self.assertEqual(expected_msg, str(cm.exception))
def __init__(self, units=None, scaling=None, **kwargs):
super(DoubleSellarImplicit, self).__init__(**kwargs)
self.add_subsystem('g1', SubSellar(units=units, scaling=scaling))
self.add_subsystem('g2', SubSellar(units=units, scaling=scaling))
self.connect('g1.y2', 'g2.x')
self.connect('g2.y2', 'g1.x')
# Converge the outer loop with Gauss Seidel, with a looser tolerance.
self.nonlinear_solver = NewtonSolver()
self.linear_solver = DirectSolver()
def test_direct_solver_comp(self):
"""
Test the direct solver on a component.
"""
for jac in ['dict', 'coo', 'csr', 'csc', 'dense']:
prob = Problem(model=ImplComp4Test())
prob.model.nonlinear_solver = NewtonSolver()
prob.model.linear_solver = DirectSolver()
prob.set_solver_print(level=0)
if jac == 'dict':
pass
elif jac == 'csr':
prob.model.jacobian = CSRJacobian()
elif jac == 'csc':
prob.model.jacobian = CSCJacobian()
elif jac == 'coo':
prob.model.jacobian = COOJacobian()
elif jac == 'dense':
prob.model.jacobian = DenseJacobian()
prob.setup(check=False)
if jac == 'coo':
with self.assertRaises(Exception) as context:
prob.run_model()
self.assertEqual(
str(context.exception),
"Direct solver is not compatible with matrix type COOMatrix in system ''."
)
continue
prob.run_model()
assert_rel_error(self, prob['y'], [-1., 1.])
d_inputs, d_outputs, d_residuals = prob.model.get_linear_vectors()
d_residuals.set_const(2.0)
d_outputs.set_const(0.0)
prob.model.run_solve_linear(['linear'], 'fwd')
result = d_outputs.get_data()
assert_rel_error(self, result, [-2., 2.])
d_outputs.set_const(2.0)
d_residuals.set_const(0.0)
prob.model.run_solve_linear(['linear'], 'rev')
result = d_residuals.get_data()
assert_rel_error(self, result, [2., -2.])
def test_specify_solver(self):
prob = Problem()
model = prob.model = SellarDerivatives()
model.nonlinear_solver = newton = NewtonSolver()
# using a different linear solver for Newton with a looser tolerance
newton.linear_solver = ScipyIterativeSolver()
newton.linear_solver.options['atol'] = 1e-4
# used for analytic derivatives
model.linear_solver = DirectSolver()
prob.setup()
prob.run_model()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)
def test_specify_solver(self):
from openmdao.api import Problem, NewtonSolver, ScipyKrylov, DirectSolver
from openmdao.test_suite.components.sellar import SellarDerivatives
prob = Problem()
model = prob.model = SellarDerivatives()
model.nonlinear_solver = newton = NewtonSolver()
# using a different linear solver for Newton with a looser tolerance
newton.linear_solver = ScipyKrylov(atol=1e-4)
# used for analytic derivatives
model.linear_solver = DirectSolver()
prob.setup()
prob.run_model()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)