def test_solve_subsystems_assembled_jac_top(self): prob = Problem() model = prob.model = DoubleSellar() model.jacobian = DenseJacobian() g1 = model.get_subsystem('g1') g1.nonlinear_solver = NewtonSolver() g1.nonlinear_solver.options['rtol'] = 1.0e-5 g1.linear_solver = ScipyIterativeSolver() g2 = model.get_subsystem('g2') g2.nonlinear_solver = NewtonSolver() g2.nonlinear_solver.options['rtol'] = 1.0e-5 g2.linear_solver = ScipyIterativeSolver() model.nonlinear_solver = NewtonSolver() model.linear_solver = DirectSolver() 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 _setup_model(self, jac_class, comp_jac_class, nested, lincalls): self.prob = prob = Problem(model=Group()) if nested: top = prob.model.add_subsystem('G1', Group()) else: top = prob.model indep = top.add_subsystem('indep', IndepVarComp()) indep.add_output('a', val=np.ones(3)) indep.add_output('b', val=np.ones(2)) top.add_subsystem('C1', MyExplicitComp(comp_jac_class)) top.add_subsystem('C2', MyExplicitComp2(comp_jac_class)) top.connect('indep.a', 'C1.x', src_indices=[2,0]) top.connect('indep.b', 'C1.y') top.connect('indep.a', 'C2.w', src_indices=[0,2,1]) top.connect('C1.f', 'C2.z', src_indices=[1]) top.jacobian = jac_class() top.nonlinear_solver = NewtonSolver() top.nonlinear_solver.linear_solver = ScipyIterativeSolver(maxiter=100) top.linear_solver = ScipyIterativeSolver( maxiter=200, atol=1e-10, rtol=1e-10) prob.set_solver_print(level=0) prob.setup(check=False) prob.run_model()
def test_hierarchy_iprint(self): prob = Problem() model = prob.model model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0]))) sub1 = model.add_subsystem('sub1', Group()) sub2 = sub1.add_subsystem('sub2', Group()) g1 = sub2.add_subsystem('g1', SubSellar()) g2 = model.add_subsystem('g2', SubSellar()) model.connect('pz.z', 'sub1.sub2.g1.z') model.connect('sub1.sub2.g1.y2', 'g2.x') model.connect('g2.y2', 'sub1.sub2.g1.x') model.nonlinear_solver = NewtonSolver() model.linear_solver = ScipyIterativeSolver() model.nonlinear_solver.options['solve_subsystems'] = True model.nonlinear_solver.options['max_sub_solves'] = 0 g1.nonlinear_solver = NewtonSolver() g1.linear_solver = LinearBlockGS() g2.nonlinear_solver = NewtonSolver() g2.linear_solver = ScipyIterativeSolver() g2.linear_solver.precon = LinearBlockGS() g2.linear_solver.precon.options['maxiter'] = 2 prob.set_solver_print(level=2) prob.setup(check=False) output = run_model(prob)
def test_jacobian_changed_component(self): prob = Problem() model = prob.model = Group() 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 = ScipyIterativeSolver() prob.setup(check=False) prob.final_setup() d1 = prob.model.get_subsystem('d1') d1.jacobian = DenseJacobian() msg = "d1: jacobian has changed and setup was not called." with assertRaisesRegex(self, Exception, msg): prob.run_model()
def test_component_assembled_jac(self): prob = Problem() model = prob.model = Group() 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 = ScipyIterativeSolver() d1 = prob.model.get_subsystem('d1') d1.jacobian = DenseJacobian() prob.set_solver_print(level=0) prob.setup(check=False) prob.run_model() assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['y2'], 12.05848819, .00001)
def test_arrray_comp(self): class DoubleArrayFD(DoubleArrayComp): def compute_partials(self, inputs, partials): """ Override deriv calculation. """ pass prob = Problem() model = prob.model = Group() model.add_subsystem('p1', IndepVarComp('x1', val=np.ones(2))) model.add_subsystem('p2', IndepVarComp('x2', val=np.ones(2))) comp = model.add_subsystem('comp', DoubleArrayFD()) model.connect('p1.x1', 'comp.x1') model.connect('p2.x2', 'comp.x2') model.linear_solver = ScipyIterativeSolver() model.approx_totals() prob.setup(check=False) prob.run_model() model.run_linearize() Jfd = model.jacobian._subjacs assert_rel_error(self, Jfd['comp.y1', 'p1.x1'], -comp.JJ[0:2, 0:2], 1e-6) assert_rel_error(self, Jfd['comp.y1', 'p2.x2'], -comp.JJ[0:2, 2:4], 1e-6) assert_rel_error(self, Jfd['comp.y2', 'p1.x1'], -comp.JJ[2:4, 0:2], 1e-6) assert_rel_error(self, Jfd['comp.y2', 'p2.x2'], -comp.JJ[2:4, 2:4], 1e-6)
def test_solve_subsystems_basic(self): from openmdao.api import Problem, NewtonSolver, DirectSolver, ScipyIterativeSolver from openmdao.test_suite.components.double_sellar import DoubleSellar prob = Problem() model = prob.model = DoubleSellar() g1 = model.get_subsystem('g1') g1.nonlinear_solver = NewtonSolver() g1.nonlinear_solver.options['rtol'] = 1.0e-5 g1.linear_solver = DirectSolver() g2 = model.get_subsystem('g2') g2.nonlinear_solver = NewtonSolver() g2.nonlinear_solver.options['rtol'] = 1.0e-5 g2.linear_solver = DirectSolver() model.nonlinear_solver = NewtonSolver() model.linear_solver = ScipyIterativeSolver() 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_record_line_search_bounds_enforce(self, m): self.setup_endpoints(m) recorder = WebRecorder(self._accepted_token, suppress_output=True) self.setup_sellar_model() model = self.prob.model model.nonlinear_solver = NewtonSolver() model.linear_solver = ScipyIterativeSolver() model.nonlinear_solver.options['solve_subsystems'] = True model.nonlinear_solver.options['max_sub_solves'] = 4 ls = model.nonlinear_solver.linesearch = BoundsEnforceLS( bound_enforcement='vector') ls.add_recorder(recorder) self.prob.setup(check=False) t0, t1 = run_driver(self.prob) self.prob.cleanup() expected_abs_error = 7.02783609310096e-10 expected_rel_error = 8.078674883382422e-07 solver_iteration = json.loads(self.solver_iterations) self.assertAlmostEqual(solver_iteration['abs_err'], expected_abs_error) self.assertAlmostEqual(solver_iteration['rel_err'], expected_rel_error) self.assertEqual(solver_iteration['solver_output'], []) self.assertEqual(solver_iteration['solver_residuals'], [])
def test_record_line_search_armijo_goldstein(self, m): self.setup_endpoints(m) recorder = WebRecorder(self._accepted_token, suppress_output=True) self.setup_sellar_model() model = self.prob.model model.nonlinear_solver = NewtonSolver() model.linear_solver = ScipyIterativeSolver() 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 ls.add_recorder(recorder) self.prob.setup(check=False) t0, t1 = run_driver(self.prob) self.prob.cleanup() expected_abs_error = 3.49773898733e-9 expected_rel_error = expected_abs_error / 2.9086436370499857e-08 solver_iteration = json.loads(self.solver_iterations) self.assertAlmostEqual(solver_iteration['abs_err'], expected_abs_error) self.assertAlmostEqual(solver_iteration['rel_err'], expected_rel_error) self.assertEqual(solver_iteration['solver_output'], []) self.assertEqual(solver_iteration['solver_residuals'], [])
def test_paraboloid_subbed(self, vec_class): if not vec_class: raise unittest.SkipTest("PETSc is not installed") prob = self.prob model = prob.model = Group() model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x']) model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y']) sub = model.add_subsystem('sub', Group(), promotes=['x', 'y', 'f_xy']) sub.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy']) model.linear_solver = ScipyIterativeSolver() sub.approx_totals(method='cs') prob.setup(check=False, vector_class=vec_class, mode='fwd') prob.set_solver_print(level=0) prob.run_model() of = ['f_xy'] wrt = ['x', 'y'] derivs = prob.compute_totals(of=of, wrt=wrt) assert_rel_error(self, derivs['f_xy', 'x'], [[-6.0]], 1e-6) assert_rel_error(self, derivs['f_xy', 'y'], [[8.0]], 1e-6) Jfd = sub.jacobian._subjacs assert_rel_error(self, Jfd['sub.comp.f_xy', 'sub.comp.x'], [[6.0]], 1e-6) assert_rel_error(self, Jfd['sub.comp.f_xy', 'sub.comp.y'], [[-8.0]], 1e-6) # 1 output x 2 inputs sub = model.get_subsystem('sub') self.assertEqual(len(sub._approx_schemes['cs']._exec_list), 2)
def test_implicit_component_fd(self): # Somehow this wasn't tested in the original fd tests (which are mostly feature tests.) class TestImplCompArrayDense(TestImplCompArray): def setup(self): super(TestImplCompArrayDense, self).setup() self.declare_partials('*', '*', method='fd') prob = Problem() model = prob.model = Group() model.add_subsystem('p_rhs', IndepVarComp('rhs', val=np.ones(2))) sub = model.add_subsystem('sub', Group()) comp = sub.add_subsystem('comp', TestImplCompArrayDense()) model.connect('p_rhs.rhs', 'sub.comp.rhs') model.linear_solver = ScipyIterativeSolver() prob.setup(check=False) prob.run_model() model.run_linearize() Jfd = comp.jacobian._subjacs assert_rel_error(self, Jfd['sub.comp.x', 'sub.comp.rhs'], -np.eye(2), 1e-6) assert_rel_error(self, Jfd['sub.comp.x', 'sub.comp.x'], comp.mtx, 1e-6)
def test_around_newton(self): # For a group that is set to FD that has a Newton solver, make sure it doesn't # try to FD itself while solving. class TestImplCompArrayDenseNoSolve(TestImplCompArrayDense): def solve_nonlinear(self, inputs, outputs): """ Disable local solve.""" pass prob = Problem() model = prob.model = Group() model.add_subsystem('p_rhs', IndepVarComp('rhs', val=np.array([2, 4]))) comp = model.add_subsystem('comp', TestImplCompArrayDenseNoSolve()) model.connect('p_rhs.rhs', 'comp.rhs') model.nonlinear_solver = NewtonSolver() model.linear_solver = ScipyIterativeSolver() model.approx_totals() prob.setup(check=False) prob.run_model() model.approx_totals() assert_rel_error(self, prob['comp.x'], [1.97959184, 4.02040816], 1e-5) model.run_linearize() of = ['comp.x'] wrt = ['p_rhs.rhs'] Jfd = prob.compute_totals(of=of, wrt=wrt) assert_rel_error( self, Jfd['comp.x', 'p_rhs.rhs'], [[1.01020408, -0.01020408], [-0.01020408, 1.01020408]], 1e-5)
def test_feature_max_sub_solves(self): prob = Problem() model = prob.model = Group() model.add_subsystem('g1', SubSellar()) model.add_subsystem('g2', SubSellar()) model.connect('g1.y2', 'g2.x') model.connect('g2.y2', 'g1.x') # Converge the outer loop with Gauss Seidel, with a looser tolerance. model.nonlinear_solver = NewtonSolver() model.linear_solver = DirectSolver() g1 = model.get_subsystem('g1') g1.nonlinear_solver = NewtonSolver() g1.nonlinear_solver.options['rtol'] = 1.0e-5 g1.linear_solver = DirectSolver() g2 = model.get_subsystem('g2') g2.nonlinear_solver = NewtonSolver() g2.nonlinear_solver.options['rtol'] = 1.0e-5 g2.linear_solver = DirectSolver() model.nonlinear_solver = NewtonSolver() model.linear_solver = ScipyIterativeSolver() model.nonlinear_solver.options['solve_subsystems'] = True model.nonlinear_solver.options['max_sub_solves'] = 0 prob.setup() prob.run_model()
def test_linear_system(self): """Check against the scipy solver.""" model = Group() x = np.array([1, 2, -3]) A = np.array([[5.0, -3.0, 2.0], [1.0, 7.0, -4.0], [1.0, 0.0, 8.0]]) b = A.dot(x) model.add_subsystem('p1', IndepVarComp('A', A)) model.add_subsystem('p2', IndepVarComp('b', b)) lingrp = model.add_subsystem('lingrp', Group(), promotes=['*']) lingrp.add_subsystem('lin', LinearSystemComp(size=3, partial_type="matrix_free")) model.connect('p1.A', 'lin.A') model.connect('p2.b', 'lin.b') prob = Problem(model) prob.setup() lingrp = prob.model.get_subsystem('lingrp') lingrp.linear_solver = ScipyIterativeSolver() prob.set_solver_print(level=0) prob.run_model() assert_rel_error(self, prob['lin.x'], x, .0001) assert_rel_error(self, prob.model._residuals.get_norm(), 0.0, 1e-10)
def runs_successfully(use_scal, coeffs): prob = Problem(model=Group()) prob.model.add_subsystem( 'row1', ScalingTestComp(row=1, coeffs=coeffs, use_scal=use_scal)) prob.model.add_subsystem( 'row2', ScalingTestComp(row=2, coeffs=coeffs, use_scal=use_scal)) prob.model.connect('row1.y', 'row2.x') prob.model.connect('row2.y', 'row1.x') prob.model.nonlinear_solver = NewtonSolver(maxiter=2, atol=1e-5, rtol=0) prob.model.nonlinear_solver.linear_solver = ScipyIterativeSolver( maxiter=1) prob.set_solver_print(level=0) prob.setup(check=False) result = prob.run_model() success = not result[0] return success
def setup_sellar_grouped_model(self): self.prob = Problem() model = self.prob.model = Group() model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x']) model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z']) mda = model.add_subsystem('mda', Group(), promotes=['x', 'z', 'y1', 'y2']) mda.linear_solver = ScipyIterativeSolver() mda.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2']) mda.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, y1=0.0, y2=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']) mda.nonlinear_solver = NonlinearBlockGS() model.linear_solver = LinearBlockGS() model.add_design_var('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) model.add_design_var('x', lower=0.0, upper=10.0) model.add_objective('obj') model.add_constraint('con1', upper=0.0) model.add_constraint('con2', upper=0.0)
def test_const_jacobian(self): model = Group() comp = IndepVarComp() for name, val in (('x', 1.), ('y1', np.ones(2)), ('y2', np.ones(2)), ('y3', np.ones(2)), ('z', np.ones((2, 2)))): comp.add_output(name, val) model.add_subsystem('input_comp', comp, promotes=['x', 'y1', 'y2', 'y3', 'z']) problem = Problem(model=model) problem.set_solver_print(level=0) model.linear_solver = ScipyIterativeSolver() model.jacobian = COOJacobian() model.add_subsystem('simple', SimpleCompConst(), promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g']) problem.setup(check=False) 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_rel_error(self, totals, jacobian)
def test_paraboloid_subbed(self): prob = Problem() model = prob.model = Group() model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x']) model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y']) sub = model.add_subsystem('sub', Group(), promotes=['x', 'y', 'f_xy']) sub.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy']) model.linear_solver = ScipyIterativeSolver() sub.approx_totals() prob.setup(check=False, mode='fwd') prob.set_solver_print(level=0) prob.run_model() of = ['f_xy'] wrt = ['x', 'y'] derivs = prob.compute_totals(of=of, wrt=wrt) assert_rel_error(self, derivs['f_xy', 'x'], [[-6.0]], 1e-6) assert_rel_error(self, derivs['f_xy', 'y'], [[8.0]], 1e-6) Jfd = sub.jacobian._subjacs assert_rel_error(self, Jfd['sub.comp.f_xy', 'sub.comp.x'], [[6.0]], 1e-6) assert_rel_error(self, Jfd['sub.comp.f_xy', 'sub.comp.y'], [[-8.0]], 1e-6) # 1 output x 2 inputs sub = model.get_subsystem('sub') self.assertEqual(len(sub._approx_schemes['fd']._exec_list), 2)
def __init__(self): super(SellarModified, self).__init__() self.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2']) self.add_subsystem('d2', SellarDis2withDerivatives(), promotes=['z', 'y1', 'y2']) self.nonlinear_solver = NonlinearBlockGS() self.linear_solver = ScipyIterativeSolver()
def test_hierarchy_iprint(self): prob = Problem() model = prob.model model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0]))) sub1 = model.add_subsystem('sub1', Group()) sub2 = sub1.add_subsystem('sub2', Group()) g1 = sub2.add_subsystem('g1', SubSellar()) g2 = model.add_subsystem('g2', SubSellar()) model.connect('pz.z', 'sub1.sub2.g1.z') model.connect('sub1.sub2.g1.y2', 'g2.x') model.connect('g2.y2', 'sub1.sub2.g1.x') model.nonlinear_solver = NewtonSolver() model.linear_solver = ScipyIterativeSolver() model.nonlinear_solver.options['solve_subsystems'] = True model.nonlinear_solver.options['max_sub_solves'] = 0 g1.nonlinear_solver = NewtonSolver() g1.linear_solver = LinearBlockGS() g2.nonlinear_solver = NewtonSolver() g2.linear_solver = ScipyIterativeSolver() g2.linear_solver.precon = LinearBlockGS() g2.linear_solver.precon.options['maxiter'] = 2 prob.set_solver_print(level=2) prob.setup(vector_class=PETScVector, check=False) # Conclude setup but don't run model. prob.final_setup() # if USE_PROC_FILES is not set, solver convergence messages # should only appear on proc 0 output = run_model(prob) if model.comm.rank == 0 or os.environ.get('USE_PROC_FILES'): self.assertTrue(output.count('\nNL: Newton Converged') == 1) else: self.assertTrue(output.count('\nNL: Newton Converged') == 0)
def test_newton_with_densejac_under_full_model_fd(self): # Basic sellar test. prob = Problem() model = prob.model = Group() sub = model.add_subsystem('sub', Group(), promotes=['*']) model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x']) model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z']) sub.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2']) sub.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']) sub.nonlinear_solver = NewtonSolver() sub.linear_solver = ScipyIterativeSolver() model.jacobian = DenseJacobian() model.approx_totals(method='fd', step=1e-5) prob.setup(check=False) prob.set_solver_print(level=0) prob.run_model() assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['y2'], 12.05848819, .00001) 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 test_feature_set_solver_print3(self): import numpy as np from openmdao.api import Problem, Group, IndepVarComp, NewtonSolver, ScipyIterativeSolver, LinearBlockGS from openmdao.test_suite.components.double_sellar import SubSellar prob = Problem() model = prob.model model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0]))) sub1 = model.add_subsystem('sub1', Group()) sub2 = sub1.add_subsystem('sub2', Group()) g1 = sub2.add_subsystem('g1', SubSellar()) g2 = model.add_subsystem('g2', SubSellar()) model.connect('pz.z', 'sub1.sub2.g1.z') model.connect('sub1.sub2.g1.y2', 'g2.x') model.connect('g2.y2', 'sub1.sub2.g1.x') model.nonlinear_solver = NewtonSolver() model.linear_solver = ScipyIterativeSolver() model.nonlinear_solver.options['solve_subsystems'] = True model.nonlinear_solver.options['max_sub_solves'] = 0 g1.nonlinear_solver = NewtonSolver() g1.linear_solver = LinearBlockGS() g2.nonlinear_solver = NewtonSolver() g2.linear_solver = ScipyIterativeSolver() g2.linear_solver.precon = LinearBlockGS() g2.linear_solver.precon.options['maxiter'] = 2 prob.set_solver_print(level=0) prob.set_solver_print(level=2, depth=2) prob.setup() prob.run_model()
def test_reconfigure(self): # In this test, we switch to 'cs' when we reconfigure. class TestImplCompArrayDense(TestImplCompArray): def initialize(self): self.mtx = np.array([ [0.99, 0.01], [0.01, 0.99], ]) self.count = 0 def setup(self): super(TestImplCompArrayDense, self).setup() if self.count > 0: self.declare_partials('*', '*', method='cs') else: self.declare_partials('*', '*', method='fd') self.count += 1 prob = self.prob = Problem() model = prob.model = Group() model.add_subsystem('p_rhs', IndepVarComp('rhs', val=np.ones(2))) sub = model.add_subsystem('sub', Group()) comp = sub.add_subsystem('comp', TestImplCompArrayDense()) model.connect('p_rhs.rhs', 'sub.comp.rhs') model.linear_solver = ScipyIterativeSolver() prob.setup(check=False) prob.run_model() with self.assertRaises(RuntimeError) as context: model.resetup(setup_mode='reconf') msg = 'In order to activate complex step during reconfiguration, you need to set ' + \ '"force_alloc_complex" to True during setup.' self.assertEqual(str(context.exception), msg) # This time, allocate complex in setup. prob.setup(check=False, force_alloc_complex=True) prob.run_model() model.resetup(setup_mode='reconf') prob.run_model() model.run_linearize() Jfd = comp.jacobian._subjacs assert_rel_error(self, Jfd['sub.comp.x', 'sub.comp.rhs'], -np.eye(2), 1e-6) assert_rel_error(self, Jfd['sub.comp.x', 'sub.comp.x'], comp.mtx, 1e-6)
def test_post_setup_solver_configure(self): # Test that we can change solver settings after we have instantiated our model. class ImplSimple(ImplicitComponent): def setup(self): self.add_input('a', val=1.) self.add_output('x', val=0.) def apply_nonlinear(self, inputs, outputs, residuals): residuals['x'] = np.exp(outputs['x']) - \ inputs['a']**2 * outputs['x']**2 def linearize(self, inputs, outputs, jacobian): jacobian['x', 'x'] = np.exp(outputs['x']) - \ 2 * inputs['a']**2 * outputs['x'] jacobian['x', 'a'] = -2 * inputs['a'] * outputs['x']**2 class Sub(Group): def setup(self): self.add_subsystem('comp', ImplSimple()) # This will not solve it self.nonlinear_solver = NonlinearBlockGS() def configure(self): # This will not solve it either. self.nonlinear_solver = NonlinearBlockGS() class Super(Group): def setup(self): self.add_subsystem('sub', Sub()) top = Problem() top.model = Super() top.setup(check=False) # This will solve it. top.model.sub.nonlinear_solver = NewtonSolver() top.model.sub.linear_solver = ScipyIterativeSolver() self.assertTrue(isinstance(top.model.sub.nonlinear_solver, NewtonSolver)) self.assertTrue(isinstance(top.model.sub.linear_solver, ScipyIterativeSolver))
def test_feature_iprint_2(self): prob = Problem() prob.model = SellarDerivatives() newton = prob.model.nonlinear_solver = NewtonSolver() scipy = prob.model.linear_solver = ScipyIterativeSolver() newton.options['maxiter'] = 20 prob.setup(check=False) prob['y1'] = 10000 prob['y2'] = -20 newton.options['iprint'] = 2 scipy.options['iprint'] = 1 prob.run_model()
def test_arguments(self): import numpy as np from openmdao.api import Problem, Group, IndepVarComp, ScipyIterativeSolver, ExplicitComponent class CompOne(ExplicitComponent): def setup(self): self.add_input('x', val=0.0) self.add_output('y', val=np.zeros(25)) self._exec_count = 0 def compute(self, inputs, outputs): x = inputs['x'] outputs['y'] = np.arange(25) * x self._exec_count += 1 class CompTwo(ExplicitComponent): def setup(self): self.add_input('y', val=np.zeros(25)) self.add_output('z', val=0.0) self._exec_count = 0 def compute(self, inputs, outputs): y = inputs['y'] outputs['z'] = np.sum(y) self._exec_count += 1 prob = Problem() model = prob.model = Group() model.add_subsystem('p1', IndepVarComp('x', 1.0), promotes=['x']) model.add_subsystem('comp1', CompOne(), promotes=['x', 'y']) comp2 = model.add_subsystem('comp2', CompTwo(), promotes=['y', 'z']) model.linear_solver = ScipyIterativeSolver() model.approx_totals(method='fd', step=1e-7, form='central', step_calc='rel') prob.setup() prob.run_model() of = ['z'] wrt = ['x'] derivs = prob.compute_totals(of=of, wrt=wrt) assert_rel_error(self, derivs['z', 'x'], [[300.0]], 1e-6)
def setUp(self): self.model = model = Group() comp = IndepVarComp() variables = ( ('x', 1.), ('y1', np.ones(2)), ('y2', np.ones(2)), ('y3', np.ones(2)), ('z', np.ones((2, 2))), ) for name, val in variables: comp.add_output(name, val) model.add_subsystem('input_comp', comp, promotes=['x', 'y1', 'y2', 'y3', 'z']) self.problem = Problem(model=model) self.problem.set_solver_print(level=0) model.linear_solver = ScipyIterativeSolver() model.jacobian = COOJacobian()
def test_feature_iprint_neg1(self): prob = Problem() prob.model = SellarDerivatives() newton = prob.model.nonlinear_solver = NewtonSolver() scipy = prob.model.linear_solver = ScipyIterativeSolver() newton.options['maxiter'] = 2 prob.setup(check=False) # use a real bad initial guess prob['y1'] = 10000 prob['y2'] = -26 newton.options['iprint'] = -1 scipy.options['iprint'] = -1 prob.run_model() print('done')
def test_converge_diverge_groups(self): # Test derivatives for converge-diverge-groups topology. prob = Problem() prob.model = ConvergeDivergeGroups() prob.model.linear_solver = ScipyIterativeSolver() prob.set_solver_print(level=0) prob.model.nonlinear_solver = NonLinearRunOnce() g1 = prob.model.get_subsystem('g1') g2 = g1.get_subsystem('g2') g3 = prob.model.get_subsystem('g3') g1.nonlinear_solver = NonLinearRunOnce() g2.nonlinear_solver = NonLinearRunOnce() g3.nonlinear_solver = NonLinearRunOnce() prob.setup(check=False, mode='fwd') prob.run_model() # Make sure value is fine. assert_rel_error(self, prob['c7.y1'], -102.7, 1e-6)
def test_feature_iprint_2(self): from openmdao.api import Problem, NewtonSolver, ScipyIterativeSolver from openmdao.test_suite.components.sellar import SellarDerivatives prob = Problem() prob.model = SellarDerivatives() prob.setup() newton = prob.model.nonlinear_solver = NewtonSolver() scipy = prob.model.linear_solver = ScipyIterativeSolver() newton.options['maxiter'] = 20 prob['y1'] = 10000 prob['y2'] = -20 newton.options['iprint'] = 2 scipy.options['iprint'] = 1 prob.run_model()