def test_feature_vectorized_A(self):
import numpy as np
import openmdao.api as om
model = om.Group()
A = np.array([[[5.0, -3.0, 2.0], [1.0, 7.0, -4.0], [1.0, 0.0, 8.0]],
[[2.0, 3.0, 4.0], [1.0, -1.0, -2.0], [3.0, 2.0, -2.0]]])
b = np.array([[-5.0, 2.0, 3.0], [-1.0, 1.0, -3.0]])
model.add_subsystem('p1', om.IndepVarComp('A', A))
model.add_subsystem('p2', om.IndepVarComp('b', b))
lingrp = model.add_subsystem('lingrp', om.Group(), promotes=['*'])
lingrp.add_subsystem(
'lin', om.LinearSystemComp(size=3, vec_size=2, vectorize_A=True))
model.connect('p1.A', 'lin.A')
model.connect('p2.b', 'lin.b')
prob = om.Problem(model)
prob.setup()
lingrp.linear_solver = om.ScipyKrylov()
prob.run_model()
assert_near_equal(
prob['lin.x'],
np.array([[-0.78807947, 0.66887417, 0.47350993], [0.7, -1.8,
0.75]]), .0001)
def test_feature_armijo_boundscheck_scalar(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
top = om.Problem()
top.model.add_subsystem('comp',
ImplCompTwoStatesArrays(),
promotes_inputs=['x'])
top.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = om.ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = om.ArmijoGoldsteinLS(
bound_enforcement='scalar')
top.setup()
top.set_val('x', np.array([2., 2, 2]).reshape(3, 1))
top.run_model()
# Test lower bounds: should stop just short of the lower bound
top.set_val('comp.y', 0.)
top.set_val('comp.z', 1.6)
top.run_model()
def test_feature_boundsenforcels_basic(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
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.model.nonlinear_solver.linesearch = om.BoundsEnforceLS()
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()
for ind in range(3):
assert_near_equal(top['comp.z'][ind], [1.5], 1e-8)
def test_vectorized(self):
"""Check against the scipy solver."""
model = om.Group()
x = np.array([[1, 2, -3], [2, -1, 4]])
A = np.array([[5.0, -3.0, 2.0], [1.0, 7.0, -4.0], [1.0, 0.0, 8.0]])
b = np.einsum('jk,ik->ij', A, x)
model.add_subsystem('p1', om.IndepVarComp('A', A))
model.add_subsystem('p2', om.IndepVarComp('b', b))
lingrp = model.add_subsystem('lingrp', om.Group(), promotes=['*'])
lingrp.add_subsystem('lin', om.LinearSystemComp(size=3, vec_size=2))
model.connect('p1.A', 'lin.A')
model.connect('p2.b', 'lin.b')
prob = om.Problem(model)
prob.setup()
lingrp.linear_solver = om.ScipyKrylov()
prob.set_solver_print(level=0)
prob.run_model()
assert_near_equal(prob['lin.x'], x, .0001)
assert_near_equal(prob.model._residuals.get_norm(), 0.0, 1e-10)
model.run_apply_nonlinear()
with model._scaled_context_all():
val = model.lingrp.lin._residuals['x']
assert_near_equal(val, np.zeros((2, 3)), tolerance=1e-8)
def test_solve_linear_scipy(self):
"""Solve implicit system with ScipyKrylov."""
group = TestImplicitGroup(lnSolverClass=lambda: om.ScipyKrylov(
solver=self.linear_solver_name))
p = om.Problem(group)
p.setup()
p.set_solver_print(level=0)
# Conclude setup but don't run model.
p.final_setup()
d_inputs, d_outputs, d_residuals = group.get_linear_vectors()
# forward
d_residuals.set_val(1.0)
d_outputs.set_val(0.0)
group.run_solve_linear(['linear'], 'fwd')
output = d_outputs.asarray()
assert_near_equal(output, group.expected_solution, 1e-15)
# reverse
d_outputs.set_val(1.0)
d_residuals.set_val(0.0)
group.run_solve_linear(['linear'], 'rev')
output = d_residuals.asarray()
assert_near_equal(output, group.expected_solution, 1e-15)
def test_specify_precon(self):
prob = om.Problem()
model = prob.model
sub1 = model.add_subsystem('sub1', om.Group())
sub1.add_subsystem('q1', QuadraticComp())
sub1.add_subsystem('z1', om.ExecComp('y = -6.0 + .01 * x'))
sub2 = model.add_subsystem('sub2', om.Group())
sub2.add_subsystem('q2', QuadraticComp())
sub2.add_subsystem('z2', om.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 = om.NewtonSolver(solve_subsystems=False)
model.linear_solver = om.ScipyKrylov()
prob.setup()
model.sub1.linear_solver = om.DirectSolver()
model.sub2.linear_solver = om.DirectSolver()
model.linear_solver.precon = om.LinearBlockGS()
prob.set_solver_print(level=2)
prob.run_model()
assert_near_equal(prob.get_val('sub1.q1.x'), 1.996, .0001)
assert_near_equal(prob.get_val('sub2.q2.x'), 1.996, .0001)
def test_const_jacobian(self):
model = om.Group()
problem = om.Problem(model=model)
problem.set_solver_print(level=0)
model.linear_solver = om.ScipyKrylov(assemble_jac=True)
model.add_subsystem('simple', SimpleCompConst(),
promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g'])
problem.setup()
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_near_equal(totals, jacobian)
def test_feature_print_bound_enforce(self):
top = om.Problem()
top.model.add_subsystem('comp',
ImplCompTwoStatesArrays(),
promotes_inputs=['x'])
newt = top.model.nonlinear_solver = om.NewtonSolver(
solve_subsystems=False)
top.model.nonlinear_solver.options['maxiter'] = 2
top.model.linear_solver = om.ScipyKrylov()
ls = newt.linesearch = om.BoundsEnforceLS(bound_enforcement='vector')
ls.options['print_bound_enforce'] = True
top.set_solver_print(level=2)
top.setup()
top.set_val('x', np.array([2., 2, 2]).reshape(3, 1))
# Test lower bounds: should go to the lower bound and stall
top.set_val('comp.y', 0.)
top.set_val('comp.z', 1.6)
top.run_model()
for ind in range(3):
assert_near_equal(top.get_val('comp.z', indices=ind), [1.5], 1e-8)
def setup(self):
self.add_subsystem('px', om.IndepVarComp('x', 1.0), promotes=['x'])
self.add_subsystem('pz',
om.IndepVarComp('z', np.array([5.0, 2.0])),
promotes=['z'])
cycle = self.add_subsystem('cycle',
om.Group(),
promotes=['x', 'z', 'y1', 'y2'])
d1 = cycle.add_subsystem('d1',
SellarDis1CS(),
promotes=['x', 'z', 'y1', 'y2'])
d2 = cycle.add_subsystem('d2',
SellarDis2CS(),
promotes=['z', 'y1', 'y2'])
self.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=['x', 'z', 'y1', 'y2', 'obj'])
self.add_subsystem('con_cmp1',
om.ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
self.add_subsystem('con_cmp2',
om.ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
self.nonlinear_solver = om.NonlinearBlockGS()
self.linear_solver = om.ScipyKrylov()
def test_specify_subgroup_solvers(self):
import openmdao.api as om
from openmdao.test_suite.components.double_sellar import DoubleSellar
prob = om.Problem()
model = prob.model = DoubleSellar()
# each SubSellar group converges itself
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
g1.linear_solver = om.DirectSolver() # used for derivatives
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
g2.linear_solver = om.DirectSolver()
# Converge the outer loop with Gauss Seidel, with a looser tolerance.
model.nonlinear_solver = om.NonlinearBlockGS(rtol=1.0e-5)
model.linear_solver = om.ScipyKrylov()
model.linear_solver.precon = om.LinearBlockGS()
prob.setup()
prob.run_model()
assert_near_equal(prob.get_val('g1.y1'), 0.64, .00001)
assert_near_equal(prob.get_val('g1.y2'), 0.80, .00001)
assert_near_equal(prob.get_val('g2.y1'), 0.64, .00001)
assert_near_equal(prob.get_val('g2.y2'), 0.80, .00001)
def test_feature_goldstein(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()
ls = top.model.nonlinear_solver.linesearch = om.ArmijoGoldsteinLS(
bound_enforcement='vector')
ls.options['method'] = 'Goldstein'
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()
for ind in range(3):
assert_near_equal(top['comp.z'][ind], [1.5], 1e-8)
def test_reraise_child_analysiserror(self):
# Raise AnalysisError when it fails to converge
prob = om.Problem(model=DoubleSellar())
model = prob.model
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver()
g1.nonlinear_solver.options['maxiter'] = 1
g1.nonlinear_solver.options['err_on_non_converge'] = True
g1.nonlinear_solver.options['solve_subsystems'] = True
g1.linear_solver = om.DirectSolver(assemble_jac=True)
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver()
g2.nonlinear_solver.options['maxiter'] = 1
g2.nonlinear_solver.options['err_on_non_converge'] = True
g2.nonlinear_solver.options['solve_subsystems'] = True
g2.linear_solver = om.DirectSolver(assemble_jac=True)
model.nonlinear_solver = om.NewtonSolver()
model.linear_solver = om.ScipyKrylov(assemble_jac=True)
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['err_on_non_converge'] = True
model.nonlinear_solver.options['reraise_child_analysiserror'] = True
prob.setup()
with self.assertRaises(om.AnalysisError) as context:
prob.run_model()
msg = "Solver 'NL: Newton' on system 'g1' failed to converge in 1 iterations."
self.assertEqual(str(context.exception), msg)
def test_solve_subsystems_assembled_jac_subgroup(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(assemble_jac=True)
model.options['assembled_jac_type'] = 'dense'
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=False)
model.linear_solver = om.ScipyKrylov()
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_solve_subsystems_assembled_jac_top_implicit_scaling_units(self):
prob = om.Problem(model=DoubleSellarImplicit(units=True, scaling=True))
model = prob.model
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver(solve_subsystems=False,
rtol=1.0e-5)
g1.nonlinear_solver.linesearch = None
g1.linear_solver = om.DirectSolver()
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver(solve_subsystems=False,
rtol=1.0e-5)
g2.nonlinear_solver.linesearch = None
g2.linear_solver = om.DirectSolver()
model.nonlinear_solver = om.NewtonSolver(solve_subsystems=True)
model.nonlinear_solver.linesearch = None
model.linear_solver = om.ScipyKrylov(assemble_jac=True)
model.options['assembled_jac_type'] = 'dense'
prob.setup()
prob.run_model()
assert_near_equal(prob['g1.y1'], 0.053333333, .00001)
assert_near_equal(prob['g1.y2'], 0.80, .00001)
assert_near_equal(prob['g2.y1'], 0.053333333, .00001)
assert_near_equal(prob['g2.y2'], 0.80, .00001)
def test_feature_boundscheck_wall(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
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.model.nonlinear_solver.linesearch = om.BoundsEnforceLS(
bound_enforcement='wall')
top.setup()
# Test upper bounds: should go to the upper bound and stall
top['px.x'] = 0.5
top['comp.y'] = 0.
top['comp.z'] = 2.4
top.run_model()
assert_rel_error(self, top['comp.z'][0], [2.6], 1e-8)
assert_rel_error(self, top['comp.z'][1], [2.5], 1e-8)
assert_rel_error(self, top['comp.z'][2], [2.65], 1e-8)
def test_list_outputs_resids_tol(self):
prob = om.Problem()
model = prob.model
model.add_subsystem(
"quad_1",
om.ExecComp(
"y = a * x ** 2 + b * x + c",
a={"value": 2.0},
b={"value": 5.0},
c={"value": 3.0},
x={"shape": (2,)},
y={"shape": (2,)},
),
)
balance = model.add_subsystem("balance", om.BalanceComp())
balance.add_balance("x_1", val=np.array([1, -1]), rhs_val=np.array([0., 0.]))
model.connect("balance.x_1", "quad_1.x")
model.connect("quad_1.y", "balance.lhs:x_1")
prob.model.linear_solver = om.ScipyKrylov()
prob.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False, maxiter=100, iprint=2)
prob.setup()
prob.model.nonlinear_solver.options["maxiter"] = 0
prob.run_model()
stream = StringIO()
outputs = prob.model.list_outputs(residuals=True, residuals_tol=1e-5, out_stream=stream)
text = stream.getvalue()
self.assertTrue("balance" in text)
self.assertTrue("x_1" in text)
def test_feature_boundscheck_scalar(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
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.model.nonlinear_solver.linesearch = om.BoundsEnforceLS(
bound_enforcement='scalar')
top.setup()
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()
def test_with_subsolves(self):
prob = om.Problem()
model = prob.model = DoubleSellar()
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver()
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = om.DirectSolver()
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver()
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = om.DirectSolver()
model.nonlinear_solver = om.NewtonSolver()
model.linear_solver = om.ScipyKrylov()
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['max_sub_solves'] = 4
ls = model.nonlinear_solver.linesearch = om.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_implicit_cycle_precon(self):
prob = om.Problem()
model = prob.model
model.add_subsystem('p1', om.IndepVarComp('x', 1.0))
model.add_subsystem('d1', SellarImplicitDis1())
model.add_subsystem('d2', SellarImplicitDis2())
model.connect('d1.y1', 'd2.y1')
model.connect('d2.y2', 'd1.y2')
model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
model.nonlinear_solver.options['maxiter'] = 5
model.nonlinear_solver.linesearch = om.BoundsEnforceLS()
model.linear_solver = om.ScipyKrylov()
model.linear_solver.precon = self.linear_solver_class()
prob.setup()
prob['d1.y1'] = 4.0
prob.set_solver_print()
prob.run_model()
res = model._residuals.get_norm()
# Newton is kinda slow on this for some reason, this is how far it gets with directsolver too.
self.assertLess(res, 2.0e-2)
def test_feature_armijo_boundscheck_vector(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
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()
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = om.ScipyKrylov()
ls = top.model.nonlinear_solver.linesearch = om.ArmijoGoldsteinLS(
bound_enforcement='vector')
ls.options['bound_enforcement'] = 'vector'
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_vectorized_A(self):
model = om.Group()
A = np.array([[[5.0, -3.0, 2.0], [1.0, 7.0, -4.0], [1.0, 0.0, 8.0]],
[[2.0, 3.0, 4.0], [1.0, -1.0, -2.0], [3.0, 2.0, -2.0]]])
b = np.array([[-5.0, 2.0, 3.0], [-1.0, 1.0, -3.0]])
lingrp = model.add_subsystem('lingrp', om.Group(), promotes=['*'])
lingrp.add_subsystem(
'lin', om.LinearSystemComp(size=3, vec_size=2, vectorize_A=True))
prob = om.Problem(model)
prob.setup()
prob.set_val('lin.A', A)
prob.set_val('lin.b', b)
lingrp.linear_solver = om.ScipyKrylov()
prob.run_model()
assert_near_equal(
prob.get_val('lin.x'),
np.array([[-0.78807947, 0.66887417, 0.47350993], [0.7, -1.8,
0.75]]), .0001)
def test_serial_in_mpi(self):
# Tests that we can take an MPI model with a DirectSolver and run it in mpi with more
# procs. This verifies fix of a bug.
prob = om.Problem(model=DoubleSellar())
model = prob.model
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = om.DirectSolver(assemble_jac=True)
g1.options['assembled_jac_type'] = 'dense'
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = om.DirectSolver(assemble_jac=True)
g2.options['assembled_jac_type'] = 'dense'
model.nonlinear_solver = om.NewtonSolver()
model.linear_solver = om.ScipyKrylov(assemble_jac=True)
model.options['assembled_jac_type'] = 'dense'
model.nonlinear_solver.options['solve_subsystems'] = True
prob.set_solver_print(level=0)
prob.setup()
prob.run_model()
assert_near_equal(prob['g1.y1'], 0.64, 1.0e-5)
assert_near_equal(prob['g1.y2'], 0.80, 1.0e-5)
assert_near_equal(prob['g2.y1'], 0.64, 1.0e-5)
assert_near_equal(prob['g2.y2'], 0.80, 1.0e-5)
def test_feature_simple(self):
"""Tests feature for adding a Scipy GMRES solver and calculating the
derivatives."""
import openmdao.api as om
from openmdao.test_suite.components.expl_comp_simple import TestExplCompSimpleDense
# Tests derivatives on a simple comp that defines compute_jacvec.
prob = om.Problem()
model = prob.model
model.add_subsystem('x_param',
om.IndepVarComp('length', 3.0),
promotes=['length'])
model.add_subsystem('mycomp',
TestExplCompSimpleDense(),
promotes=['length', 'width', 'area'])
model.linear_solver = om.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_near_equal(J['area', 'length'][0][0], 2.0, 1e-6)
def test_solve_subsystems_basic(self):
import openmdao.api as om
from openmdao.test_suite.components.double_sellar import DoubleSellar
prob = om.Problem(model=DoubleSellar())
model = prob.model
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver()
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = om.DirectSolver()
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver()
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = om.DirectSolver()
model.nonlinear_solver = om.NewtonSolver()
model.linear_solver = om.ScipyKrylov()
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_feature_armijo_boundscheck_wall(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
top = om.Problem()
top.model.add_subsystem('comp',
ImplCompTwoStatesArrays(),
promotes_inputs=['x'])
top.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = om.ScipyKrylov()
top.model.nonlinear_solver.linesearch = om.ArmijoGoldsteinLS(
bound_enforcement='wall')
top.setup()
top.set_val('x', np.array([0.5, 0.5, 0.5]).reshape(3, 1))
# Test upper bounds: should go to the upper bound and stall
top.set_val('comp.y', 0.)
top.set_val('comp.z', 2.4)
top.run_model()
assert_near_equal(top.get_val('comp.z', indices=0), [2.6], 1e-8)
assert_near_equal(top.get_val('comp.z', indices=1), [2.5], 1e-8)
assert_near_equal(top.get_val('comp.z', indices=2), [2.65], 1e-8)
def test_solve_subsystems_basic(self):
prob = om.Problem(model=DoubleSellar())
model = prob.model
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver()
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = om.DirectSolver(assemble_jac=True)
g1.options['assembled_jac_type'] = 'dense'
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver()
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = om.DirectSolver(assemble_jac=True)
g2.options['assembled_jac_type'] = 'dense'
model.nonlinear_solver = om.NewtonSolver()
model.linear_solver = om.ScipyKrylov(assemble_jac=True)
model.options['assembled_jac_type'] = 'dense'
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_with_subsolves(self):
prob = om.Problem()
model = prob.model = DoubleSellarMod()
g1 = model.g1
g1.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
g1.nonlinear_solver.options['rtol'] = 1.0e-5
g1.linear_solver = om.DirectSolver()
g2 = model.g2
g2.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
g2.nonlinear_solver.options['rtol'] = 1.0e-5
g2.linear_solver = om.DirectSolver()
model.nonlinear_solver = om.NewtonSolver()
model.linear_solver = om.ScipyKrylov()
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['max_sub_solves'] = 4
ls = model.nonlinear_solver.linesearch = om.ArmijoGoldsteinLS(
bound_enforcement='vector')
prob.set_solver_print(level=0)
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_armijo_print_bound_enforce(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
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')
newt = top.model.nonlinear_solver = om.NewtonSolver(
solve_subsystems=False)
top.model.nonlinear_solver.options['maxiter'] = 2
top.model.linear_solver = om.ScipyKrylov()
ls = newt.linesearch = om.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()
for ind in range(3):
assert_rel_error(self, top['comp.z'][ind], [1.5], 1e-8)
def test_feature_boundscheck_vector(self):
import numpy as np
import openmdao.api as om
from openmdao.test_suite.components.implicit_newton_linesearch import ImplCompTwoStatesArrays
top = om.Problem()
top.model.add_subsystem('comp',
ImplCompTwoStatesArrays(),
promotes_inputs=['x'])
top.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
top.model.nonlinear_solver.options['maxiter'] = 10
top.model.linear_solver = om.ScipyKrylov()
top.model.nonlinear_solver.linesearch = om.BoundsEnforceLS(
bound_enforcement='vector')
top.setup()
top.set_val('x', np.array([2., 2, 2]).reshape(3, 1))
# Test lower bounds: should go to the lower bound and stall
top.set_val('comp.y', 0.)
top.set_val('comp.z', 1.6)
top.run_model()
for ind in range(3):
assert_near_equal(top.get_val('comp.z', indices=ind), [1.5], 1e-8)
def test_feature_vectorized(self):
import numpy as np
import openmdao.api as om
model = om.Group()
A = np.array([[5.0, -3.0, 2.0], [1.0, 7.0, -4.0], [1.0, 0.0, 8.0]])
b = np.array([[2.0, -3.0, 4.0], [1.0, 0.0, -1.0]])
model.add_subsystem('p1', om.IndepVarComp('A', A))
model.add_subsystem('p2', om.IndepVarComp('b', b))
lingrp = model.add_subsystem('lingrp', om.Group(), promotes=['*'])
lingrp.add_subsystem('lin', om.LinearSystemComp(size=3, vec_size=2))
model.connect('p1.A', 'lin.A')
model.connect('p2.b', 'lin.b')
prob = om.Problem(model)
prob.setup()
lingrp.linear_solver = om.ScipyKrylov()
prob.run_model()
assert_near_equal(
prob['lin.x'],
np.array([[0.10596026, -0.16556291, 0.48675497],
[0.19205298, -0.11258278, -0.14900662]]), .0001)
