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)