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)