def test_feature_newton_basic(self):
""" Feature test for slotting a Newton solver and using it to solve
Sellar.
"""
import openmdao.api as om
from openmdao.test_suite.components.sellar import SellarDerivatives
prob = om.Problem(model=SellarDerivatives(
nonlinear_solver=om.NewtonSolver()))
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_sellar_grouped(self):
# Tests basic Newton solution on Sellar in a subgroup
prob = om.Problem(model=SellarDerivativesGrouped(
nonlinear_solver=om.NewtonSolver()))
prob.setup()
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)
# Make sure we aren't iterating like crazy
self.assertLess(prob.model.nonlinear_solver._iter_count, 8)
def test_specify_newton_linear_solver_in_system(self):
my_newton = om.NewtonSolver()
my_newton.linear_solver = om.DirectSolver()
prob = om.Problem(model=SellarDerivatives(nonlinear_solver=my_newton))
prob.setup()
self.assertIsInstance(prob.model.nonlinear_solver.linear_solver, om.DirectSolver)
prob.run_model()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)
def test_error_specify_solve_subsystems(self):
# Raise AnalysisError when it fails to converge
prob = om.Problem()
model = prob.model
model.nonlinear_solver = om.NewtonSolver()
prob.setup()
with self.assertRaises(ValueError) as context:
prob.run_model()
msg = "NewtonSolver in <model> <class Group>: solve_subsystems must be set by the user."
self.assertEqual(str(context.exception), msg)
def test_sellar_state_connection(self):
# Sellar model closes loop with state connection instead of a cycle.
prob = om.Problem(model=SellarStateConnection(
nonlinear_solver=om.NewtonSolver(solve_subsystems=False)))
prob.set_solver_print(level=0)
prob.setup()
prob.run_model()
assert_near_equal(prob.get_val('y1'), 25.58830273, .00001)
assert_near_equal(prob['state_eq.y2_command'], 12.05848819, .00001)
# Make sure we aren't iterating like crazy
self.assertLess(prob.model.nonlinear_solver._iter_count, 8)
def test_solve_subsystems_assembled_jac_top_csc(self):
prob = om.Problem(model=DoubleSellar())
model = prob.model
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver(solve_subsystems=False,
rtol=1.0e-5)
g1.linear_solver = om.DirectSolver()
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver(solve_subsystems=False,
rtol=1.0e-5)
g2.linear_solver = om.DirectSolver()
model.nonlinear_solver = om.NewtonSolver(solve_subsystems=True)
model.linear_solver = om.ScipyKrylov(assemble_jac=True)
prob.setup()
prob.run_model()
assert_near_equal(prob['g1.y1'], 0.64, .00001)
assert_near_equal(prob['g1.y2'], 0.80, .00001)
assert_near_equal(prob['g2.y1'], 0.64, .00001)
assert_near_equal(prob['g2.y2'], 0.80, .00001)
def test_feature_newton_basic(self):
""" Feature test for slotting a Newton solver and using it to solve
Sellar.
"""
import openmdao.api as om
from openmdao.test_suite.components.sellar import SellarDerivatives
prob = om.Problem(model=SellarDerivatives(
nonlinear_solver=om.NewtonSolver(solve_subsystems=False)))
prob.setup()
prob.run_model()
assert_near_equal(prob.get_val('y1'), 25.58830273, .00001)
assert_near_equal(prob.get_val('y2'), 12.05848819, .00001)
def setUp(self):
top = om.Problem()
top.model.add_subsystem('px', om.IndepVarComp('x', np.ones((3, 1))))
top.model.add_subsystem('comp', ImplCompTwoStatesArrays())
top.model.connect('px.x', 'comp.x')
top.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = om.ScipyKrylov()
top.set_solver_print(level=0)
top.setup()
self.top = top
self.ub = np.array([2.6, 2.5, 2.65])
def setup(self):
indeps = self.add_subsystem('indeps', om.IndepVarComp(), promotes=['*'])
indeps.add_output('l', 0.01)
indeps.add_output('w', 0.01)
cycle = self.add_subsystem('cycle', om.Group(), promotes=['*'])
cycle.add_subsystem('d1', Structures(), promotes_inputs=['l', 'F'], promotes_outputs=['theta'])
cycle.add_subsystem('d2', Aerodynamics(), promotes_inputs=['l', 'w','theta'], promotes_outputs=['F'])
ns = cycle.nonlinear_solver = om.NewtonSolver(solve_subsystems=True)
ns.options['maxiter'] = 500
self.add_subsystem('obj_cmp', om.ExecComp('obj = (theta - 0.250)**2'), promotes=['theta','obj'])
self.add_subsystem('con_cmp1', om.ExecComp('con1 = F - 7'), promotes=['con1', 'F'])
self.add_subsystem('con_cmp2', om.ExecComp('con2 = l*w - 0.01'), promotes=['con2', 'l','w'])
def test_solve_subsystems_basic_csc(self):
prob = om.Problem(model=DoubleSellar())
model = prob.model
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver(rtol=1.0e-5)
g1.options['assembled_jac_type'] = 'dense'
g1.linear_solver = om.DirectSolver(assemble_jac=True)
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver(rtol=1.0e-5)
g2.linear_solver = om.DirectSolver(assemble_jac=True)
g2.options['assembled_jac_type'] = 'dense'
model.nonlinear_solver = om.NewtonSolver(solve_subsystems=True)
model.linear_solver = om.ScipyKrylov(assemble_jac=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_vectorized_no_normalization(self):
n = 100
prob = om.Problem(model=om.Group(assembled_jac_type='dense'))
bal = om.BalanceComp()
bal.add_balance('x', val=np.ones(n), normalize=False)
tgt = om.IndepVarComp(name='y_tgt', val=1.7 * np.ones(n))
exec_comp = om.ExecComp('y=x**2',
x={'value': np.ones(n)},
y={'value': np.ones(n)})
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = om.DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False,
maxiter=100,
iprint=0)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(1.7), decimal=7)
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_error_handling(self):
# Make sure the debug_print doesn't bomb out.
class Bad(om.ExplicitComponent):
def setup(self):
self.add_input('x', val=0.0)
self.add_input('y', val=0.0)
self.add_output('f_xy', val=0.0, upper=1.0)
self.declare_partials(of='*', wrt='*')
self.count = 0
def compute(self, inputs, outputs):
if self.count < 1:
x = inputs['x']
y = inputs['y']
outputs['f_xy'] = (x - 3.0)**2 + x * y + (y + 4.0)**2 - 3.0
else:
outputs['f_xy'] = np.inf
self.count += 1
def compute_partials(self, inputs, partials):
x = inputs['x']
y = inputs['y']
partials['f_xy', 'x'] = 2.0 * x - 6.0 + y
partials['f_xy', 'y'] = 2.0 * y + 8.0 + x
top = om.Problem()
top.model.add_subsystem('px', om.IndepVarComp('x', 1.0))
top.model.add_subsystem('comp', ImplCompTwoStates())
top.model.add_subsystem('par', Bad())
top.model.connect('px.x', 'comp.x')
top.model.connect('comp.z', 'par.x')
top.model.nonlinear_solver = om.NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 3
top.model.nonlinear_solver.linesearch = om.BoundsEnforceLS(
bound_enforcement='vector')
top.set_solver_print(level=0)
top.setup()
# Make sure we don't raise an error when we reach the final debug print.
top.run_model()
def test_feature_linear_solver(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.sellar import SellarDis1withDerivatives, \
SellarDis2withDerivatives
prob = om.Problem()
model = prob.model
model.add_subsystem('px', om.IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('pz',
om.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',
om.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',
om.ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2',
om.ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
model.linear_solver = om.LinearBlockGS()
newton = model.nonlinear_solver = om.NewtonSolver(
solve_subsystems=False)
newton.linear_solver = om.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 configure_solvers(self, phase):
"""
Configure the solvers.
Parameters
----------
phase : dymos.Phase
The phase object to which this transcription instance applies.
"""
if self.any_solved_segs or self.any_connected_opt_segs:
newton = phase.nonlinear_solver = om.NewtonSolver()
newton.options['solve_subsystems'] = True
newton.options['maxiter'] = 100
newton.options['iprint'] = -1
newton.linesearch = om.BoundsEnforceLS()
phase.linear_solver = om.DirectSolver()
def test_specify_newton_linear_solver_in_system(self):
my_newton = om.NewtonSolver(solve_subsystems=False)
my_newton.linear_solver = om.DirectSolver()
prob = om.Problem(model=SellarDerivatives(nonlinear_solver=my_newton))
prob.setup()
self.assertIsInstance(prob.model.nonlinear_solver.linear_solver,
om.DirectSolver)
prob.run_model()
assert_near_equal(prob.get_val('y1'), 25.58830273, .00001)
assert_near_equal(prob.get_val('y2'), 12.05848819, .00001)
def test_sellar_state_connection_fd_system(self):
# Sellar model closes loop with state connection instead of a cycle.
# This test is just fd.
prob = om.Problem(model=SellarStateConnection(nonlinear_solver=om.NewtonSolver()))
prob.model.approx_totals(method='fd')
prob.setup()
prob.set_solver_print(level=0)
prob.run_model()
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.model.nonlinear_solver._iter_count, 6)
def test_comm_warning(self):
rank = MPI.COMM_WORLD.rank if MPI is not None else 0
prob = om.Problem(model=SellarDerivatives(nonlinear_solver=om.NewtonSolver()))
prob.setup()
msg = 'Deprecation warning: In V 3.0, the default Newton solver setup will change ' + \
'to use the BoundsEnforceLS line search.'
if rank == 0:
with assert_warning(DeprecationWarning, msg):
prob.final_setup()
else:
with assert_no_warning(DeprecationWarning, msg):
prob.final_setup()
def test_feature_err_on_non_converge(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.sellar import SellarDis1withDerivatives, SellarDis2withDerivatives
prob = om.Problem()
model = prob.model
model.add_subsystem('px', om.IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('pz',
om.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',
om.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',
om.ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2',
om.ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
model.linear_solver = om.DirectSolver()
newton = model.nonlinear_solver = om.NewtonSolver(
solve_subsystems=False)
newton.options['maxiter'] = 1
newton.options['err_on_non_converge'] = True
prob.setup()
try:
prob.run_model()
except om.AnalysisError:
pass
def test_vectorized_with_default_mult(self):
"""
solve: 2 * x**2 = 4
expected solution: x=sqrt(2)
"""
n = 100
prob = om.Problem(model=om.Group(assembled_jac_type='dense'))
bal = om.BalanceComp('x', val=np.ones(n), use_mult=True, mult_val=2.0)
tgt = om.IndepVarComp(name='y_tgt', val=4 * np.ones(n))
exec_comp = om.ExecComp('y=x**2',
x={'value': np.ones(n)},
y={'value': np.ones(n)})
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = om.DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False,
maxiter=100,
iprint=0)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
cpd = prob.check_partials(out_stream=None)
assert_check_partials(cpd, atol=1e-5, rtol=1e-5)
def test_scalar_example(self):
prob = om.Problem()
bal = om.BalanceComp()
bal.add_balance('x', val=1.0)
tgt = om.IndepVarComp(name='y_tgt', val=2)
exec_comp = om.ExecComp('y=x**2')
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
# do one test in an unconverged state, to capture accuracy of partials
prob.setup()
prob[
'y_tgt'] = 100000 #set rhs and lhs to very different values. Trying to capture some derivatives wrt
prob['exec.y'] = .001
prob.run_model()
cpd = prob.check_partials(out_stream=None)
assert_check_partials(cpd, atol=2e-5, rtol=2e-5)
# set an actual solver, and re-setup. Then check derivatives at a converged point
prob.model.linear_solver = om.DirectSolver()
prob.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
prob.setup()
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
cpd = prob.check_partials(out_stream=None)
assert_check_partials(cpd, atol=1e-5, rtol=1e-5)
def test_specify_precon_left(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.sellar import SellarDis1withDerivatives, \
SellarDis2withDerivatives
prob = om.Problem()
model = prob.model
model.add_subsystem('px', om.IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('pz',
om.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',
om.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',
om.ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2',
om.ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
model.nonlinear_solver = om.NewtonSolver()
model.linear_solver = om.PETScKrylov()
model.linear_solver.precon = om.DirectSolver()
model.linear_solver.options['precon_side'] = 'left'
model.linear_solver.options['ksp_type'] = 'richardson'
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_scalar_with_guess_func(self):
n = 1
model = om.Group(assembled_jac_type='dense')
def guess_function(inputs, outputs, residuals):
outputs['x'] = np.sqrt(inputs['rhs:x'])
bal = om.BalanceComp(
'x', guess_func=guess_function) # test guess_func as kwarg
tgt = om.IndepVarComp(name='y_tgt', val=4)
exec_comp = om.ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
model.add_subsystem(name='exec', subsys=exec_comp)
model.add_subsystem(name='balance', subsys=bal)
model.connect('y_tgt', 'balance.rhs:x')
model.connect('balance.x', 'exec.x')
model.connect('exec.y', 'balance.lhs:x')
model.linear_solver = om.DirectSolver(assemble_jac=True)
model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False,
maxiter=100,
iprint=0)
prob = om.Problem(model)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], 2.0, decimal=7)
# should converge with no iteration due to the guess function
self.assertEqual(model.nonlinear_solver._iter_count, 1)
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_raise_error_on_singular_with_densejac(self):
prob = om.Problem()
model = prob.model
comp = om.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=om.Group())
teg.add_subsystem('dynamics',
om.ExecComp('z = 2.0*thrust'),
promotes=['*'])
thrust_bal = om.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 = om.DirectSolver(assemble_jac=True)
teg.options['assembled_jac_type'] = 'dense'
teg.nonlinear_solver = om.NewtonSolver()
teg.nonlinear_solver.options['solve_subsystems'] = True
teg.nonlinear_solver.options['max_sub_solves'] = 1
teg.nonlinear_solver.options['atol'] = 1e-4
prob.setup()
prob.set_solver_print(level=0)
with self.assertRaises(RuntimeError) as cm:
prob.run_model()
expected_msg = "Singular entry found in 'thrust_equilibrium_group' for column associated with state/residual 'thrust'."
self.assertEqual(expected_msg, str(cm.exception))
def setup(self):
nn = self.options['num_nodes']
self.add_subsystem('aero',
subsys=AerodynamicsGroup(num_nodes=nn),
promotes_inputs=['alt'])
self.add_subsystem('thrust_eq_comp',
subsys=ThrustEquilibriumComp(num_nodes=nn),
promotes_inputs=['q', 'S', 'gam', 'alpha', 'W_total'],
promotes_outputs=['CT'])
self.add_subsystem('lift_eq_comp',
subsys=LiftEquilibriumComp(num_nodes=nn),
promotes_inputs=['q', 'S', 'gam', 'alpha', 'W_total', 'CT'],
promotes_outputs=['CL_eq'])
bal = self.add_subsystem(name='alpha_eta_balance',
subsys=om.BalanceComp(),
promotes_outputs=['alpha', 'eta'])
self.connect('alpha', ('aero.alpha'))
self.connect('eta', ('aero.eta'))
bal.add_balance('alpha', units='rad', eq_units=None, lhs_name='CL_eq',
rhs_name='CL', val=0.01*np.ones(nn), lower=-20, upper=30, res_ref=1.0)
bal.add_balance('eta', units='rad', val=0.01*np.ones(nn), eq_units=None, lhs_name='CM',
lower=-30, upper=30, res_ref=1.0)
self.connect('aero.CL', 'alpha_eta_balance.CL')
self.connect('aero.CD', 'thrust_eq_comp.CD')
self.connect('aero.CM', 'alpha_eta_balance.CM')
self.connect('CL_eq', ('alpha_eta_balance.CL_eq'))
self.linear_solver = om.DirectSolver()
self.nonlinear_solver = om.NewtonSolver()
self.nonlinear_solver.options['atol'] = 1e-14
self.nonlinear_solver.options['rtol'] = 1e-14
self.nonlinear_solver.options['solve_subsystems'] = True
self.nonlinear_solver.options['err_on_non_converge'] = True
self.nonlinear_solver.options['max_sub_solves'] = 10
self.nonlinear_solver.options['maxiter'] = 150
self.nonlinear_solver.options['iprint'] = -1
self.nonlinear_solver.linesearch = om.BoundsEnforceLS()
self.nonlinear_solver.linesearch.options['print_bound_enforce'] = True
def generate_model(self, nn):
prob = om.Problem()
iv = prob.model.add_subsystem('iv',
om.IndepVarComp(),
promotes_outputs=['*'])
iv.add_output('q_in', val=np.linspace(2000, 5000, nn), units='W')
iv.add_output('mdot_coolant', val=1 * np.ones((nn, )), units='kg/s')
iv.add_output('T_in', val=25 * np.ones((nn, )), units='degC')
iv.add_output('battery_weight', val=100., units='kg')
prob.model.add_subsystem('test',
LiquidCooledBattery(num_nodes=nn,
quasi_steady=True),
promotes=['*'])
prob.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=True)
prob.model.linear_solver = om.DirectSolver()
prob.setup(check=True, force_alloc_complex=True)
return prob
def test_complex_step(self):
n = 1
prob = om.Problem(model=om.Group(assembled_jac_type='dense'))
bal = om.BalanceComp()
bal.add_balance('x')
tgt = om.IndepVarComp(name='y_tgt', val=4)
exec_comp = om.ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = om.DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False,
maxiter=100,
iprint=0)
prob.setup(force_alloc_complex=True)
prob['balance.x'] = np.random.rand(n)
prob.run_model()
with warnings.catch_warnings():
warnings.filterwarnings(action="error", category=np.ComplexWarning)
cpd = prob.check_partials(out_stream=None, method='cs')
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=10)
def runs_successfully(use_scal, coeffs):
prob = om.Problem()
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 = om.NewtonSolver(maxiter=2, atol=1e-5, rtol=0)
prob.model.nonlinear_solver.linear_solver = om.ScipyKrylov(maxiter=1)
prob.set_solver_print(level=0)
prob.setup()
prob.run_model()
return np.linalg.norm(prob.model._residuals._data) < 1e-5
def test_specify_precon(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.sellar import SellarDis1withDerivatives, \
SellarDis2withDerivatives
prob = om.Problem()
model = prob.model
model.add_subsystem('d1',
SellarDis1withDerivatives(),
promotes=['x', 'z', 'y1', 'y2'])
model.add_subsystem('d2',
SellarDis2withDerivatives(),
promotes=['z', 'y1', 'y2'])
model.add_subsystem('obj_cmp',
om.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',
om.ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2',
om.ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
model.linear_solver = om.PETScKrylov()
model.linear_solver.precon = om.LinearBlockGS()
model.linear_solver.precon.options['maxiter'] = 2
prob.setup()
prob.set_val('x', 1.)
prob.set_val('z', np.array([5.0, 2.0]))
prob.run_model()
assert_near_equal(prob.get_val('y1'), 25.58830273, .00001)
assert_near_equal(prob.get_val('y2'), 12.05848819, .00001)
def test_solver_debug_print_feature(self):
from distutils.version import LooseVersion
import numpy as np
import openmdao.api as om
from openmdao.test_suite.scripts.circuit_analysis import Circuit
from openmdao.utils.general_utils import printoptions
p = om.Problem()
model = p.model
model.add_subsystem('ground', om.IndepVarComp('V', 0., units='V'))
model.add_subsystem('source', om.IndepVarComp('I', 0.1, units='A'))
model.add_subsystem('circuit', Circuit())
model.connect('source.I', 'circuit.I_in')
model.connect('ground.V', 'circuit.Vg')
p.setup()
nl = model.circuit.nonlinear_solver = om.NewtonSolver(
solve_subsystems=False)
nl.options['iprint'] = 2
nl.options['debug_print'] = True
nl.options['err_on_non_converge'] = True
# set some poor initial guesses so that we don't converge
p['circuit.n1.V'] = 10.
p['circuit.n2.V'] = 1e-3
opts = {}
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts["legacy"] = '1.13'
with printoptions(**opts):
# run the model
try:
p.run_model()
except om.AnalysisError:
pass
with open(self.filename, 'r') as f:
self.assertEqual(f.read(), self.expected_data)
def setup(self):
self.set_input_defaults('x', 1.0)
self.set_input_defaults('z', np.array([5.0, 2.0]))
cycle = self.add_subsystem('cycle', om.Group(), promotes=['*'])
cycle.add_subsystem('d1',
SellarDis1withDerivatives(),
promotes_inputs=['x', 'z', 'y2'],
promotes_outputs=['y1'])
cycle.add_subsystem('d2',
SellarDis2withDerivatives(),
promotes_inputs=['z', 'y1'],
promotes_outputs=['y2'])
cycle.linear_solver = om.ScipyKrylov()
cycle.nonlinear_solver = om.NewtonSolver(
solve_subsystems=False)
