def test_specify_subgroup_solvers(self): from openmdao.api import Problem, NewtonSolver, ScipyIterativeSolver, DirectSolver, NonlinearBlockGS, LinearBlockGS from openmdao.test_suite.components.double_sellar import DoubleSellar prob = Problem() model = prob.model = DoubleSellar() # each SubSellar group converges itself g1 = model.get_subsystem('g1') g1.nonlinear_solver = NewtonSolver() g1.linear_solver = DirectSolver() # used for derivatives g2 = model.get_subsystem('g2') g2.nonlinear_solver = NewtonSolver() g2.linear_solver = DirectSolver() # Converge the outer loop with Gauss Seidel, with a looser tolerance. model.nonlinear_solver = NonlinearBlockGS() model.nonlinear_solver.options['rtol'] = 1.0e-5 model.linear_solver = ScipyIterativeSolver() model.linear_solver.precon = LinearBlockGS() prob.setup() prob.run_model() assert_rel_error(self, prob['g1.y1'], 0.64, .00001) assert_rel_error(self, prob['g1.y2'], 0.80, .00001) assert_rel_error(self, prob['g2.y1'], 0.64, .00001) assert_rel_error(self, prob['g2.y2'], 0.80, .00001)
def test_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_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 test_feature_boundscheck_basic(self): import numpy as np from openmdao.api import Problem, Group, IndepVarComp, NewtonSolver, ScipyIterativeSolver, 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 = ScipyIterativeSolver() 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): 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 = ScipyIterativeSolver() 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_feature_boundscheck_wall(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 = ScipyIterativeSolver() ls = top.model.nonlinear_solver.linesearch = BoundsEnforceLS() ls.options['bound_enforcement'] = 'wall' top.setup(check=False) # 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_feature_specification(self): from openmdao.api import Problem, IndepVarComp, NewtonSolver, BoundsEnforceLS from openmdao.api import DirectSolver from openmdao.solvers.linesearch.tests.test_backtracking import CompAtan prob = Problem() model = prob.model model.add_subsystem('px', IndepVarComp('x', -100.0)) model.add_subsystem('comp', CompAtan()) model.connect('px.x', 'comp.x') prob.setup() # Initial value for the state: prob['comp.y'] = 12.0 # You can change the NewtonSolver settings after setup is called newton = prob.model.nonlinear_solver = NewtonSolver() prob.model.linear_solver = DirectSolver() newton.options['iprint'] = 2 newton.options['rtol'] = 1e-8 newton.options['solve_subsystems'] = True newton.linesearch = BoundsEnforceLS() newton.linesearch.options['iprint'] = 2 prob.run_model() assert_rel_error(self, prob['comp.y'], 19.68734033, 1e-6)
def test_feature_armijo_boundscheck_scalar(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') top.model.nonlinear_solver = NewtonSolver() top.model.nonlinear_solver.options['maxiter'] = 10 top.model.linear_solver = ScipyKrylov() ls = top.model.nonlinear_solver.linesearch = ArmijoGoldsteinLS( bound_enforcement='scalar') 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_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_promoted_connections_newton_solver(self): p = Problem() p.model = model = Group() model.linear_solver = DirectSolver() model.nonlinear_solver = NewtonSolver(solve_subsystems=False) model.add_subsystem('c1', IndepVarComp('x', 1.0), promotes_outputs=['x']) model.add_subsystem('c2', ReconfComp1(), promotes_inputs=['x'], promotes_outputs=['y']) model.add_subsystem('c3', ReconfComp2(), promotes_inputs=['y'], promotes_outputs=['f']) p.setup() p['x'] = 3. # First run the model once; counter = 1, size of y = 1 p.run_model() self.assertEqual(len(p['y']), 1) # Run the model again, which will trigger reconfiguration; counter = 2, size of y = 2 p.run_model() self.assertEqual(len(p['y']), 2) assert_rel_error(self, p['y'], [6., 6.])
def test_feature_print_bound_enforce(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') newt = top.model.nonlinear_solver = NewtonSolver() top.model.nonlinear_solver.options['maxiter'] = 2 top.model.linear_solver = ScipyKrylov() ls = newt.linesearch = BoundsEnforceLS(bound_enforcement='vector') 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_armijo_boundscheck_wall(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') top.model.nonlinear_solver = NewtonSolver() top.model.nonlinear_solver.options['maxiter'] = 10 top.model.linear_solver = ScipyKrylov() ls = top.model.nonlinear_solver.linesearch = ArmijoGoldsteinLS( bound_enforcement='wall') ls.options['bound_enforcement'] = 'wall' top.setup(check=False) # 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_direct_solver_comp(self): """ Test the direct solver on a component. """ for jac in [None, 'csc', 'dense']: prob = Problem(model=ImplComp4Test()) prob.model.nonlinear_solver = NewtonSolver() if jac in ('csc', 'dense'): prob.model.options['assembled_jac_type'] = jac prob.model.linear_solver = DirectSolver(assemble_jac=jac in ('csc','dense')) prob.set_solver_print(level=0) prob.setup(check=False) prob.run_model() assert_rel_error(self, prob['y'], [-1., 1.]) d_inputs, d_outputs, d_residuals = prob.model.get_linear_vectors() d_residuals.set_const(2.0) d_outputs.set_const(0.0) prob.model.run_solve_linear(['linear'], 'fwd') result = d_outputs.get_data() assert_rel_error(self, result, [-2., 2.]) d_outputs.set_const(2.0) d_residuals.set_const(0.0) prob.model.run_solve_linear(['linear'], 'rev') result = d_residuals.get_data() assert_rel_error(self, result, [2., -2.])
def test_direct_solver_comp(self): """ Test the direct solver on a component. """ for jac in [None, 'csc', 'dense']: prob = Problem(model=ImplComp4Test()) prob.model.nonlinear_solver = NewtonSolver(solve_subsystems=False) if jac in ('csc', 'dense'): prob.model.options['assembled_jac_type'] = jac prob.model.linear_solver = DirectSolver(assemble_jac=jac in ('csc','dense')) prob.set_solver_print(level=0) prob.setup() prob.run_model() assert_near_equal(prob['y'], [-1., 1.]) d_inputs, d_outputs, d_residuals = prob.model.get_linear_vectors() d_residuals.set_val(2.0) d_outputs.set_val(0.0) prob.model.run_solve_linear('fwd') result = d_outputs.asarray() assert_near_equal(result, [-2., 2.]) d_outputs.set_val(2.0) d_residuals.set_val(0.0) prob.model.run_solve_linear('rev') result = d_residuals.asarray() assert_near_equal(result, [2., -2.])
def test_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 test_debug_after_raised_error(self): prob = Problem() model = prob.model comp = IndepVarComp() comp.add_output('dXdt:TAS', val=1.0) comp.add_output('accel_target', val=2.0) model.add_subsystem('des_vars', comp, promotes=['*']) teg = model.add_subsystem('thrust_equilibrium_group', subsys=Group()) teg.add_subsystem('dynamics', ExecComp('z = 2.0*thrust'), promotes=['*']) thrust_bal = BalanceComp() thrust_bal.add_balance(name='thrust', val=1207.1, lhs_name='dXdt:TAS', rhs_name='accel_target', eq_units='m/s**2', lower=-10.0, upper=10000.0) teg.add_subsystem(name='thrust_bal', subsys=thrust_bal, promotes_inputs=['dXdt:TAS', 'accel_target'], promotes_outputs=['thrust']) teg.linear_solver = DirectSolver() teg.nonlinear_solver = NewtonSolver() teg.nonlinear_solver.options['solve_subsystems'] = True teg.nonlinear_solver.options['max_sub_solves'] = 1 teg.nonlinear_solver.options['atol'] = 1e-4 teg.nonlinear_solver.options['debug_print'] = True prob.setup(check=False) prob.set_solver_print(level=0) stdout = sys.stdout strout = StringIO() sys.stdout = strout with self.assertRaises(RuntimeError) as cm: prob.run_model() sys.stdout = stdout output = strout.getvalue() target = "'thrust_equilibrium_group.thrust_bal.thrust'" self.assertTrue(target in output, msg=target + "NOT FOUND IN" + output) # Make sure exception is unchanged. expected_msg = "Singular entry found in 'thrust_equilibrium_group' for row associated with state/residual 'thrust'." self.assertEqual(expected_msg, str(cm.exception))
def __init__(self, units=None, scaling=None, **kwargs): super(DoubleSellarImplicit, self).__init__(**kwargs) self.add_subsystem('g1', SubSellar(units=units, scaling=scaling)) self.add_subsystem('g2', SubSellar(units=units, scaling=scaling)) self.connect('g1.y2', 'g2.x') self.connect('g2.y2', 'g1.x') # Converge the outer loop with Gauss Seidel, with a looser tolerance. self.nonlinear_solver = NewtonSolver() self.linear_solver = DirectSolver()
def initialize(self): self.metadata.declare('nonlinear_solver', default=NewtonSolver(), desc='Nonlinear solver for Sellar MDA') self.metadata.declare('nl_atol', default=None, desc='User-specified atol for nonlinear solver.') self.metadata.declare('nl_maxiter', default=None, desc='Iteration limit for nonlinear solver.') self.metadata.declare('linear_solver', default=ScipyKrylov(), desc='Linear solver') self.metadata.declare('ln_atol', default=None, desc='User-specified atol for linear solver.') self.metadata.declare('ln_maxiter', default=None, desc='Iteration limit for linear solver.')
def test_error_handling(self): # Make sure the debug_print doen't bomb out. class Bad(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 = Problem() top.model = Group() top.model.add_subsystem('px', 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 = NewtonSolver() top.model.nonlinear_solver.options['maxiter'] = 3 ls = top.model.nonlinear_solver.linesearch = BoundsEnforceLS( bound_enforcement='vector') ls.options['maxiter'] = 10 top.set_solver_print(level=0) top.setup(check=False) # Make sure we don't raise an error when we reach the final debug print. top.run_model()
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_direct_solver_comp(self): """ Test the direct solver on a component. """ for jac in ['dict', 'coo', 'csr', 'csc', 'dense']: prob = Problem(model=ImplComp4Test()) prob.model.nonlinear_solver = NewtonSolver() prob.model.linear_solver = DirectSolver() prob.set_solver_print(level=0) if jac == 'dict': pass elif jac == 'csr': prob.model.jacobian = CSRJacobian() elif jac == 'csc': prob.model.jacobian = CSCJacobian() elif jac == 'coo': prob.model.jacobian = COOJacobian() elif jac == 'dense': prob.model.jacobian = DenseJacobian() prob.setup(check=False) if jac == 'coo': with self.assertRaises(Exception) as context: prob.run_model() self.assertEqual( str(context.exception), "Direct solver is not compatible with matrix type COOMatrix in system ''." ) continue prob.run_model() assert_rel_error(self, prob['y'], [-1., 1.]) d_inputs, d_outputs, d_residuals = prob.model.get_linear_vectors() d_residuals.set_const(2.0) d_outputs.set_const(0.0) prob.model.run_solve_linear(['linear'], 'fwd') result = d_outputs.get_data() assert_rel_error(self, result, [-2., 2.]) d_outputs.set_const(2.0) d_residuals.set_const(0.0) prob.model.run_solve_linear(['linear'], 'rev') result = d_residuals.get_data() assert_rel_error(self, result, [2., -2.])
def 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_solver(self): prob = Problem() model = prob.model = SellarDerivatives() model.nonlinear_solver = newton = NewtonSolver() # using a different linear solver for Newton with a looser tolerance newton.linear_solver = ScipyIterativeSolver() newton.linear_solver.options['atol'] = 1e-4 # used for analytic derivatives model.linear_solver = DirectSolver() prob.setup() prob.run_model() assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['y2'], 12.05848819, .00001)
def test_solver_debug_print_feature(self): from distutils.version import LooseVersion import numpy as np from openmdao.api import Problem, IndepVarComp, NewtonSolver, AnalysisError from openmdao.test_suite.scripts.circuit_analysis import Circuit from openmdao.utils.general_utils import printoptions p = Problem() model = p.model model.add_subsystem('ground', IndepVarComp('V', 0., units='V')) model.add_subsystem('source', 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 = NewtonSolver() nl.options['iprint'] = 2 nl.options['debug_print'] = True nl.options['err_on_maxiter'] = 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 AnalysisError: pass with open('rank0_root_0_NLRunOnce_0_circuit_0.dat', 'r') as f: self.assertEqual(f.read(), self.expected_data)
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 test_feature_specification(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 = ScipyIterativeSolver() 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 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 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'))