def test_feature_boundsenforcels_basic(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, NewtonSolver, ScipyKrylov, BoundsEnforceLS
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', np.ones((3, 1))))
top.model.add_subsystem('comp', ImplCompTwoStatesArrays())
top.model.connect('px.x', 'comp.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = ScipyKrylov()
top.model.nonlinear_solver.linesearch = BoundsEnforceLS()
top.setup(check=False)
# Test lower bounds: should go to the lower bound and stall
top['px.x'] = 2.0
top['comp.y'] = 0.
top['comp.z'] = 1.6
top.run_model()
assert_rel_error(self, top['comp.z'][0], [1.5], 1e-8)
assert_rel_error(self, top['comp.z'][1], [1.5], 1e-8)
assert_rel_error(self, top['comp.z'][2], [1.5], 1e-8)
def test_feature_boundscheck_scalar(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, NewtonSolver, ScipyKrylov, BoundsEnforceLS
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', np.ones((3, 1))))
top.model.add_subsystem('comp', ImplCompTwoStatesArrays())
top.model.connect('px.x', 'comp.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = BoundsEnforceLS()
ls.options['bound_enforcement'] = 'scalar'
top.setup(check=False)
top.run_model()
# Test lower bounds: should stop just short of the lower bound
top['px.x'] = 2.0
top['comp.y'] = 0.
top['comp.z'] = 1.6
top.run_model()
print(top['comp.z'][0])
print(top['comp.z'][1])
print(top['comp.z'][2])
def test_with_subsolves(self):
prob = Problem()
model = prob.model = DoubleSellar()
g1 = model.g1
g1.nonlinear_solver = NewtonSolver()
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = DirectSolver()
g2 = model.g2
g2.nonlinear_solver = NewtonSolver()
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = DirectSolver()
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyKrylov()
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
prob.set_solver_print(level=0)
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_feature_armijo_print_bound_enforce(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, NewtonSolver, ScipyKrylov, ArmijoGoldsteinLS
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', np.ones((3, 1))))
top.model.add_subsystem('comp', ImplCompTwoStatesArrays())
top.model.connect('px.x', 'comp.x')
newt = top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 2
top.model.linear_solver = ScipyKrylov()
ls = newt.linesearch = ArmijoGoldsteinLS()
ls.options['print_bound_enforce'] = True
top.set_solver_print(level=2)
top.setup()
# Test lower bounds: should go to the lower bound and stall
top['px.x'] = 2.0
top['comp.y'] = 0.
top['comp.z'] = 1.6
top.run_model()
assert_rel_error(self, top['comp.z'][0], [1.5], 1e-8)
assert_rel_error(self, top['comp.z'][1], [1.5], 1e-8)
assert_rel_error(self, top['comp.z'][2], [1.5], 1e-8)
def test_feature_simple(self):
"""Tests feature for adding a Scipy GMRES solver and calculating the
derivatives."""
from openmdao.api import Problem, Group, IndepVarComp, ScipyKrylov
from openmdao.test_suite.components.expl_comp_simple import TestExplCompSimpleDense
# Tests derivatives on a simple comp that defines compute_jacvec.
prob = Problem()
model = prob.model
model.add_subsystem('x_param',
IndepVarComp('length', 3.0),
promotes=['length'])
model.add_subsystem('mycomp',
TestExplCompSimpleDense(),
promotes=['length', 'width', 'area'])
model.linear_solver = ScipyKrylov()
prob.set_solver_print(level=0)
prob.setup(check=False, mode='fwd')
prob['width'] = 2.0
prob.run_model()
of = ['area']
wrt = ['length']
J = prob.compute_totals(of=of, wrt=wrt, return_format='flat_dict')
assert_rel_error(self, J['area', 'length'][0][0], 2.0, 1e-6)
def test_specify_precon(self):
import numpy as np
from openmdao.api import Problem, ScipyKrylov, NewtonSolver, LinearBlockGS, \
DirectSolver
from openmdao.test_suite.components.double_sellar import DoubleSellar
prob = Problem(model=DoubleSellar())
model = prob.model
model.nonlinear_solver = NewtonSolver()
model.nonlinear_solver.linesearch = BoundsEnforceLS()
model.linear_solver = ScipyKrylov()
model.g1.linear_solver = DirectSolver()
model.g2.linear_solver = DirectSolver()
model.linear_solver.precon = LinearBlockGS()
# TODO: This should work with 1 iteration.
#model.linear_solver.precon.options['maxiter'] = 1
prob.setup()
prob.set_solver_print(level=2)
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_read_only_bug(self):
# this tests for a bug in which guess_nonlinear failed due to the output
# vector being left in a read only state after the AnalysisError
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', 7.0))
sub = top.model.add_subsystem('sub', Group())
sub.add_subsystem('comp', ImplCompTwoStatesGuess())
top.model.connect('px.x', 'sub.comp.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 2
top.model.nonlinear_solver.options['solve_subsystems'] = True
top.model.linear_solver = ScipyKrylov()
sub.nonlinear_solver = NewtonSolver()
sub.nonlinear_solver.options['maxiter'] = 2
sub.linear_solver = ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = ArmijoGoldsteinLS(
bound_enforcement='wall')
ls.options['maxiter'] = 5
ls.options['alpha'] = 10.0
ls.options['retry_on_analysis_error'] = True
ls.options['c'] = 10000.0
top.setup(check=False)
top.set_solver_print(level=2)
stdout = sys.stdout
strout = StringIO()
sys.stdout = strout
try:
top.run_model()
finally:
sys.stdout = stdout
output = strout.getvalue().split('\n')
self.assertTrue(output[26].startswith('| LS: AG 3'))
def initialize(self):
self.options.declare('nonlinear_solver', default=NonlinearBlockGS(),
desc='Nonlinear solver for Sellar MDA')
self.options.declare('nl_atol', default=None,
desc='User-specified atol for nonlinear solver.')
self.options.declare('nl_maxiter', default=None,
desc='Iteration limit for nonlinear solver.')
self.options.declare('linear_solver', default=ScipyKrylov(),
desc='Linear solver')
self.options.declare('ln_atol', default=None,
desc='User-specified atol for linear solver.')
self.options.declare('ln_maxiter', default=None,
desc='Iteration limit for linear solver.')
def setUp(self):
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', 1.0))
top.model.add_subsystem('comp', ImplCompTwoStates())
top.model.connect('px.x', 'comp.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = ScipyKrylov()
top.setup(check=False)
self.top = top
def test_specify_solver(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, ScipyKrylov, \
NonlinearBlockGS, ExecComp
from openmdao.test_suite.components.sellar import SellarDis1withDerivatives, \
SellarDis2withDerivatives
prob = Problem()
model = prob.model
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 = NonlinearBlockGS()
model.linear_solver = ScipyKrylov()
prob.setup()
prob.run_model()
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 setUp(self):
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', np.ones((3, 1))))
top.model.add_subsystem('comp', ImplCompTwoStatesArrays())
top.model.connect('px.x', 'comp.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = ScipyKrylov()
top.set_solver_print(level=0)
top.setup(check=False)
self.top = top
self.ub = np.array([2.6, 2.5, 2.65])
def test_specify_precon(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, ScipyKrylov, NewtonSolver, \
LinearBlockGS, ExecComp
from openmdao.test_suite.components.sellar import SellarDis1withDerivatives, \
SellarDis2withDerivatives
prob = Problem()
model = prob.model
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 = ScipyKrylov()
model.linear_solver.precon = LinearBlockGS()
model.linear_solver.precon.options['maxiter'] = 2
prob.setup()
prob.run_model()
assert_rel_error(self, prob['y1'], 25.58830273, .00001)
assert_rel_error(self, prob['y2'], 12.05848819, .00001)
def setup(self):
self.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x'])
self.add_subsystem('pz',
IndepVarComp('z', np.array([5.0, 2.0])),
promotes=['z'])
self.mda = mda = self.add_subsystem('mda',
Group(),
promotes=['x', 'z', 'y1', 'y2'])
mda.add_subsystem('d1',
SellarDis1withDerivatives(),
promotes=['x', 'z', 'y1', 'y2'])
mda.add_subsystem('d2',
SellarDis2withDerivatives(),
promotes=['z', 'y1', 'y2'])
self.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'])
self.add_subsystem('con_cmp1',
ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
self.add_subsystem('con_cmp2',
ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
self.linear_solver = ScipyKrylov()
self.nonlinear_solver = self.options['nonlinear_solver']
if self.options['nl_atol']:
self.nonlinear_solver.options['atol'] = self.options['nl_atol']
if self.options['nl_maxiter']:
self.nonlinear_solver.options['maxiter'] = self.options[
'nl_maxiter']
self.linear_solver = self.options['linear_solver']
if self.options['ln_atol']:
self.linear_solver.options['atol'] = self.options['ln_atol']
if self.options['ln_maxiter']:
self.linear_solver.options['maxiter'] = self.options['ln_maxiter']
def setup(self):
self.add_subsystem('px', IndepVarComp('x', 1.0))
self.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])))
self.add_subsystem('d1', SellarDis1withDerivatives())
self.add_subsystem('d2', SellarDis2withDerivatives())
self.add_subsystem('obj_cmp', ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]), x=0.0))
self.add_subsystem('con_cmp1', ExecComp('con1 = 3.16 - y1'))
self.add_subsystem('con_cmp2', ExecComp('con2 = y2 - 24.0'))
self.connect('px.x', ['d1.x', 'obj_cmp.x'])
self.connect('pz.z', ['d1.z', 'd2.z', 'obj_cmp.z'])
self.connect('d1.y1', ['d2.y1', 'obj_cmp.y1', 'con_cmp1.y1'])
self.connect('d2.y2', ['d1.y2', 'obj_cmp.y2', 'con_cmp2.y2'])
self.nonlinear_solver = NonlinearBlockGS()
self.linear_solver = ScipyKrylov()
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)
def setUp(self):
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', 1.0))
top.model.add_subsystem('comp', ImplCompTwoStates())
top.model.add_subsystem('par', ParaboloidAE())
top.model.connect('px.x', 'comp.x')
top.model.connect('comp.z', 'par.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 1
top.model.linear_solver = ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = ArmijoGoldsteinLS(
bound_enforcement='vector')
ls.options['maxiter'] = 10
ls.options['alpha'] = 1.0
top.set_solver_print(level=0)
self.top = top
self.ls = ls
def test_specify_precon(self):
import numpy as np
from openmdao.api import Problem, Group, ScipyKrylov, NewtonSolver, LinearBlockGS, \
DirectSolver, ExecComp, PETScKrylov
from openmdao.test_suite.components.quad_implicit import QuadraticComp
prob = Problem()
model = prob.model
sub1 = model.add_subsystem('sub1', Group())
sub1.add_subsystem('q1', QuadraticComp())
sub1.add_subsystem('z1', ExecComp('y = -6.0 + .01 * x'))
sub2 = model.add_subsystem('sub2', Group())
sub2.add_subsystem('q2', QuadraticComp())
sub2.add_subsystem('z2', ExecComp('y = -6.0 + .01 * x'))
model.connect('sub1.q1.x', 'sub1.z1.x')
model.connect('sub1.z1.y', 'sub2.q2.c')
model.connect('sub2.q2.x', 'sub2.z2.x')
model.connect('sub2.z2.y', 'sub1.q1.c')
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyKrylov()
prob.setup()
model.sub1.linear_solver = DirectSolver()
model.sub2.linear_solver = DirectSolver()
model.linear_solver.precon = LinearBlockGS()
prob.set_solver_print(level=2)
prob.run_model()
assert_rel_error(self, prob['sub1.q1.x'], 1.996, .0001)
assert_rel_error(self, prob['sub2.q2.x'], 1.996, .0001)
def test_feature_specification(self):
from openmdao.api import Problem, Group, IndepVarComp, NewtonSolver, ScipyKrylov, ArmijoGoldsteinLS
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStates
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', 1.0))
top.model.add_subsystem('comp', ImplCompTwoStates())
top.model.connect('px.x', 'comp.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = ArmijoGoldsteinLS()
ls.options['maxiter'] = 10
top.setup(check=False)
top['px.x'] = 2.0
top['comp.y'] = 0.0
top['comp.z'] = 1.6
top.run_model()
assert_rel_error(self, top['comp.z'], 1.5, 1e-8)
def configure(self):
self.sub.linear_solver = ScipyKrylov()
self.sub.state_eq_group.linear_solver = ScipyKrylov()
def configure(self):
self.mda.linear_solver = ScipyKrylov()
self.mda.nonlinear_solver = NonlinearBlockGS()
var_factory=lambda: numpy.zeros(vec_size))
cname = "C%d" % (num_comps - 1)
self.add_objective("%s.o0" % cname)
self.add_constraint("%s.o1" % cname, lower=0.0)
if 'petsc' in sys.argv:
vec_class = PETScVector
else:
vec_class = DefaultVector
p = Problem()
g = p.model
if 'gmres' in sys.argv:
from openmdao.solvers.linear.scipy_iter_solver import ScipyKrylov
p.root.linear_solver = ScipyKrylov()
g.add_subsystem("P", IndepVarComp('x', numpy.ones(vec_size)))
g.add_design_var("P.x")
par = g.add_subsystem("par", ParallelGroup())
for pt in range(pts):
ptname = "G%d" % pt
ptg = par.add_subsystem(ptname, SubGroup())
#create_dyncomps(ptg, num_comps, 2, 2, 2,
#var_factory=lambda: numpy.zeros(vec_size))
g.connect("P.x", "par.%s.C0.i0" % ptname)
#cname = ptname + '.' + "C%d"%(num_comps-1)
#g.add_objective("par.%s.o0" % cname)
def test_analysis_error(self):
class ParaboloidAE(ExplicitComponent):
""" Evaluates the equation f(x,y) = (x-3)^2 + xy + (y+4)^2 - 3
This version raises an analysis error if x < 2.0
The AE in ParaboloidAE stands for AnalysisError."""
def __init__(self):
super(ParaboloidAE, self).__init__()
self.fail_hard = False
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)
self.declare_partials(of='*', wrt='*')
def compute(self, inputs, outputs):
"""f(x,y) = (x-3)^2 + xy + (y+4)^2 - 3
Optimal solution (minimum): x = 6.6667; y = -7.3333
"""
x = inputs['x']
y = inputs['y']
if x < 1.75:
raise AnalysisError('Try Again.')
outputs['f_xy'] = (x - 3.0)**2 + x * y + (y + 4.0)**2 - 3.0
def compute_partials(self, inputs, partials):
""" Jacobian for our paraboloid."""
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 = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', 1.0))
top.model.add_subsystem('comp', ImplCompTwoStates())
top.model.add_subsystem('par', ParaboloidAE())
top.model.connect('px.x', 'comp.x')
top.model.connect('comp.z', 'par.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 1
top.model.linear_solver = ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = ArmijoGoldsteinLS(
bound_enforcement='vector')
ls.options['maxiter'] = 10
ls.options['alpha'] = 1.0
top.set_solver_print(level=0)
top.setup(check=False)
# Test lower bound: should go as far as it can without going past 1.75 and triggering an
# AnalysisError. It doesn't do a great job, so ends up at 1.8 instead of 1.75
top['px.x'] = 2.0
top['comp.y'] = 0.0
top['comp.z'] = 2.1
top.run_model()
assert_rel_error(self, top['comp.z'], 1.8, 1e-8)
# Test the behavior with the switch turned off.
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', 1.0))
top.model.add_subsystem('comp', ImplCompTwoStates())
top.model.add_subsystem('par', ParaboloidAE())
top.model.connect('px.x', 'comp.x')
top.model.connect('comp.z', 'par.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 1
top.model.linear_solver = ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = ArmijoGoldsteinLS(
bound_enforcement='vector')
ls.options['maxiter'] = 10
ls.options['alpha'] = 1.0
ls.options['retry_on_analysis_error'] = False
top.set_solver_print(level=0)
top.setup(check=False)
top['px.x'] = 2.0
top['comp.y'] = 0.0
top['comp.z'] = 2.1
with self.assertRaises(AnalysisError) as context:
top.run_model()
self.assertEqual(str(context.exception), 'Try Again.')
def test_deep_analysis_error_iprint(self):
class ImplCompTwoStatesAE(ImplicitComponent):
def setup(self):
self.add_input('x', 0.5)
self.add_output('y', 0.0)
self.add_output('z', 2.0, lower=1.5, upper=2.5)
self.maxiter = 10
self.atol = 1.0e-12
self.declare_partials(of='*', wrt='*')
self.counter = 0
def apply_nonlinear(self, inputs, outputs, residuals):
"""
Don't solve; just calculate the residual.
"""
x = inputs['x']
y = outputs['y']
z = outputs['z']
residuals['y'] = y - x - 2.0 * z
residuals['z'] = x * z + z - 4.0
self.counter += 1
if self.counter > 5 and self.counter < 11:
raise AnalysisError('catch me')
def linearize(self, inputs, outputs, jac):
"""
Analytical derivatives.
"""
# Output equation
jac[('y', 'x')] = -1.0
jac[('y', 'y')] = 1.0
jac[('y', 'z')] = -2.0
# State equation
jac[('z', 'z')] = -inputs['x'] + 1.0
jac[('z', 'x')] = -outputs['z']
top = Problem()
top.model = Group()
top.model.add_subsystem('px', IndepVarComp('x', 7.0))
sub = top.model.add_subsystem('sub', Group())
sub.add_subsystem('comp', ImplCompTwoStatesAE())
top.model.connect('px.x', 'sub.comp.x')
top.model.nonlinear_solver = NewtonSolver()
top.model.nonlinear_solver.options['maxiter'] = 2
top.model.nonlinear_solver.options['solve_subsystems'] = True
top.model.linear_solver = ScipyKrylov()
sub.nonlinear_solver = NewtonSolver()
sub.nonlinear_solver.options['maxiter'] = 2
sub.linear_solver = ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = ArmijoGoldsteinLS(
bound_enforcement='wall')
ls.options['maxiter'] = 5
ls.options['alpha'] = 10.0
ls.options['retry_on_analysis_error'] = True
ls.options['c'] = 10000.0
top.setup(check=False)
top.set_solver_print(level=2)
stdout = sys.stdout
strout = StringIO()
sys.stdout = strout
try:
top.run_model()
finally:
sys.stdout = stdout
output = strout.getvalue().split('\n')
self.assertTrue(output[26].startswith('| LS: AG 5'))
def f(junk=None):
return ScipyKrylov(solver=solver)
create_dyncomps(self,
num_comps,
2,
2,
2,
var_factory=lambda: numpy.zeros(vec_size))
cname = "C%d" % (num_comps - 1)
self.add_objective("%s.o0" % cname)
self.add_constraint("%s.o1" % cname, lower=0.0)
p = Problem()
g = p.model
if 'gmres' in sys.argv:
from openmdao.solvers.linear.scipy_iter_solver import ScipyKrylov
g.linear_solver = ScipyKrylov()
g.add_subsystem("P", IndepVarComp('x', numpy.ones(vec_size)))
g.add_design_var("P.x")
par = g.add_subsystem("par", ParallelGroup())
for pt in range(pts):
ptname = "G%d" % pt
ptg = par.add_subsystem(ptname, SubGroup())
#create_dyncomps(ptg, num_comps, 2, 2, 2,
#var_factory=lambda: numpy.zeros(vec_size))
g.connect("P.x", "par.%s.C0.i0" % ptname)
#cname = ptname + '.' + "C%d"%(num_comps-1)
#g.add_objective("par.%s.o0" % cname)
def test_linear_solution_cache(self):
# Test derivatives across a converged Sellar model. When caching
# is performed, the second solve takes less iterations than the
# first one.
# Forward mode
prob = Problem()
model = prob.model
model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('d1', Comp4LinearCacheTest(), promotes=['x', 'y'])
model.nonlinear_solver = NonlinearBlockGS()
model.linear_solver = ScipyKrylov()
model.add_design_var('x', cache_linear_solution=True)
model.add_objective('y', cache_linear_solution=True)
prob.setup(mode='fwd')
prob.set_solver_print(level=0)
prob.run_model()
J = prob.driver._compute_totals(of=['y'],
wrt=['x'],
global_names=False,
return_format='flat_dict')
icount1 = prob.model.linear_solver._iter_count
J = prob.driver._compute_totals(of=['y'],
wrt=['x'],
global_names=False,
return_format='flat_dict')
icount2 = prob.model.linear_solver._iter_count
# Should take less iterations when starting from previous solution.
self.assertTrue(icount2 < icount1)
# Reverse mode
prob = Problem()
model = prob.model
model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x'])
model.add_subsystem('d1', Comp4LinearCacheTest(), promotes=['x', 'y'])
model.nonlinear_solver = NonlinearBlockGS()
model.linear_solver = ScipyKrylov()
model.add_design_var('x', cache_linear_solution=True)
model.add_objective('y', cache_linear_solution=True)
prob.setup(mode='rev')
prob.set_solver_print(level=0)
prob.run_model()
J = prob.driver._compute_totals(of=['y'],
wrt=['x'],
global_names=False,
return_format='flat_dict')
icount1 = prob.model.linear_solver._iter_count
J = prob.driver._compute_totals(of=['y'],
wrt=['x'],
global_names=False,
return_format='flat_dict')
icount2 = prob.model.linear_solver._iter_count
# Should take less iterations when starting from previous solution.
self.assertTrue(icount2 < icount1)