def test_fan_out_parallel_sets_rev(self): prob = Problem() prob.model = FanOutGrouped() prob.model.linear_solver = LinearBlockGS() prob.model.sub.linear_solver = LinearBlockGS() prob.model.add_design_var('iv.x') prob.model.add_constraint('c2.y', upper=0.0, parallel_deriv_color='par_resp') prob.model.add_constraint('c3.y', upper=0.0, parallel_deriv_color='par_resp') prob.setup(vector_class=vector_class, check=False, mode='rev') prob.run_driver() unknown_list = ['c2.y', 'c3.y'] indep_list = ['iv.x'] J = prob.compute_totals(unknown_list, indep_list, return_format='flat_dict') assert_rel_error(self, J['c2.y', 'iv.x'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y', 'iv.x'][0][0], 15.0, 1e-6)
def setup_model(self): asize = self.asize prob = Problem() #import wingdbstub root = prob.model root.linear_solver = LinearBlockGS() Indep1 = root.add_subsystem('Indep1', IndepVarComp('x', np.arange(asize, dtype=float)+1.0)) Indep2 = root.add_subsystem('Indep2', IndepVarComp('x', np.arange(asize+2, dtype=float)+1.0)) G1 = root.add_subsystem('G1', ParallelGroup()) G1.linear_solver = LinearBlockGS() c1 = G1.add_subsystem('c1', ExecComp('y = ones(3).T*x.dot(arange(3.,6.))', x=np.zeros(asize), y=np.zeros(asize))) c2 = G1.add_subsystem('c2', ExecComp('y = x[:%d] * 2.0' % asize, x=np.zeros(asize+2), y=np.zeros(asize))) Con1 = root.add_subsystem('Con1', ExecComp('y = x * 5.0', x=np.zeros(asize), y=np.zeros(asize))) Con2 = root.add_subsystem('Con2', ExecComp('y = x * 4.0', x=np.zeros(asize), y=np.zeros(asize))) root.connect('Indep1.x', 'G1.c1.x') root.connect('Indep2.x', 'G1.c2.x') root.connect('G1.c1.y', 'Con1.x') root.connect('G1.c2.y', 'Con2.x') return prob
def test_debug_print_option_totals_color(self): prob = Problem() prob.model = FanInGrouped() prob.model.linear_solver = LinearBlockGS() prob.model.sub.linear_solver = LinearBlockGS() prob.model.add_design_var('iv.x1', parallel_deriv_color='par_dv') prob.model.add_design_var('iv.x2', parallel_deriv_color='par_dv') prob.model.add_design_var('iv.x3') prob.model.add_objective('c3.y') prob.driver.options['debug_print'] = ['totals'] prob.setup(check=False, mode='fwd') prob.set_solver_print(level=0) prob.run_driver() indep_list = ['iv.x1', 'iv.x2', 'iv.x3'] unknown_list = ['c3.y'] stdout = sys.stdout strout = StringIO() sys.stdout = strout try: _ = prob.compute_totals(unknown_list, indep_list, return_format='flat_dict', debug_print=not prob.comm.rank) finally: sys.stdout = stdout output = strout.getvalue() if not prob.comm.rank: self.assertTrue('Solving color: par_dv (iv.x1, iv.x2)' in output) self.assertTrue('Solving variable: iv.x3' in output)
def setup_model(self): asize = self.asize prob = Problem() root = prob.model root.linear_solver = LinearBlockGS() p1 = root.add_subsystem('p1', IndepVarComp('x', np.arange(asize, dtype=float)+1.0)) p2 = root.add_subsystem('p2', IndepVarComp('x', np.arange(asize, dtype=float)+1.0)) G1 = root.add_subsystem('G1', ParallelGroup()) G1.linear_solver = LinearBlockGS() c1 = G1.add_subsystem('c1', ExecComp('y = ones(3).T*x.dot(arange(3.,6.))', x=np.zeros(asize), y=np.zeros(asize))) c2 = G1.add_subsystem('c2', ExecComp('y = x * 2.0', x=np.zeros(asize), y=np.zeros(asize))) c3 = root.add_subsystem('c3', ExecComp('y = x * 5.0', x=np.zeros(asize), y=np.zeros(asize))) c4 = root.add_subsystem('c4', ExecComp('y = x * 4.0', x=np.zeros(asize), y=np.zeros(asize))) root.connect('p1.x', 'G1.c1.x') root.connect('p2.x', 'G1.c2.x') root.connect('G1.c1.y', 'c3.x') root.connect('G1.c2.y', 'c4.x') return prob
def setup(self): size = 4 Indep1 = self.add_subsystem( 'Indep1', IndepVarComp('x', np.arange(size, dtype=float) + 1.0)) Comp1 = self.add_subsystem('Comp1', SumComp(size)) pargroup = self.add_subsystem('ParallelGroup1', ParallelGroup()) self.linear_solver = LinearBlockGS() self.linear_solver.options['iprint'] = -1 pargroup.linear_solver = LinearBlockGS() pargroup.linear_solver.options['iprint'] = -1 delay = .1 Con1 = pargroup.add_subsystem('Con1', SlowComp(delay=delay, size=2, mult=2.0)) Con2 = pargroup.add_subsystem('Con2', SlowComp(delay=delay, size=2, mult=-3.0)) self.connect('Indep1.x', 'Comp1.x') self.connect('Comp1.y', 'ParallelGroup1.Con1.x') self.connect('Comp1.y', 'ParallelGroup1.Con2.x') color = 'parcon' self.add_design_var('Indep1.x') self.add_constraint('ParallelGroup1.Con1.y', lower=0.0, parallel_deriv_color=color) self.add_constraint('ParallelGroup1.Con2.y', upper=0.0, parallel_deriv_color=color)
def setup_model(self, mode): asize = 3 prob = Problem() root = prob.model root.linear_solver = LinearBlockGS() p = root.add_subsystem('p', IndepVarComp('x', np.arange(asize, dtype=float)+1.0)) G1 = root.add_subsystem('G1', ParallelGroup()) G1.linear_solver = LinearBlockGS() c2 = G1.add_subsystem('c2', ExecComp('y = x * 2.0', x=np.zeros(asize), y=np.zeros(asize))) c3 = G1.add_subsystem('c3', ExecComp('y = ones(3).T*x.dot(arange(3.,6.))', x=np.zeros(asize), y=np.zeros(asize))) c4 = root.add_subsystem('c4', ExecComp('y = x * 4.0', x=np.zeros(asize), y=np.zeros(asize))) c5 = root.add_subsystem('c5', ExecComp('y = x * 5.0', x=np.zeros(asize), y=np.zeros(asize))) prob.model.add_design_var('p.x', indices=[1, 2]) prob.model.add_constraint('c4.y', upper=0.0, indices=[1], parallel_deriv_color='par_resp') prob.model.add_constraint('c5.y', upper=0.0, indices=[2], parallel_deriv_color='par_resp') root.connect('p.x', 'G1.c2.x') root.connect('p.x', 'G1.c3.x') root.connect('G1.c2.y', 'c4.x') root.connect('G1.c3.y', 'c5.x') prob.setup(vector_class=vector_class, check=False, mode=mode) prob.run_driver() return prob
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_fan_in_grouped(self): size = 3 prob = Problem() prob.model = root = Group() root.add_subsystem('P1', IndepVarComp('x', numpy.ones(size, dtype=float))) root.add_subsystem('P2', IndepVarComp('x', numpy.ones(size, dtype=float))) sub = root.add_subsystem('sub', ParallelGroup()) sub.add_subsystem('C1', ExecComp(['y=-2.0*x'], x=numpy.zeros(size, dtype=float), y=numpy.zeros(size, dtype=float))) sub.add_subsystem('C2', ExecComp(['y=5.0*x'], x=numpy.zeros(size, dtype=float), y=numpy.zeros(size, dtype=float))) root.add_subsystem('C3', DistribExecComp(['y=3.0*x1+7.0*x2', 'y=1.5*x1+3.5*x2'], arr_size=size, x1=numpy.zeros(size, dtype=float), x2=numpy.zeros(size, dtype=float), y=numpy.zeros(size, dtype=float))) root.add_subsystem('C4', ExecComp(['y=x'], x=numpy.zeros(size, dtype=float), y=numpy.zeros(size, dtype=float))) root.connect("sub.C1.y", "C3.x1") root.connect("sub.C2.y", "C3.x2") root.connect("P1.x", "sub.C1.x") root.connect("P2.x", "sub.C2.x") root.connect("C3.y", "C4.x") root.linear_solver = LinearBlockGS() sub.linear_solver = LinearBlockGS() prob.model.suppress_solver_output = True sub.suppress_solver_output = True prob.setup(vector_class=PETScVector, check=False, mode='fwd') prob.run_driver() diag1 = numpy.diag([-6.0, -6.0, -3.0]) diag2 = numpy.diag([35.0, 35.0, 17.5]) J = prob.compute_totals(of=['C4.y'], wrt=['P1.x', 'P2.x']) assert_rel_error(self, J['C4.y', 'P1.x'], diag1, 1e-6) assert_rel_error(self, J['C4.y', 'P2.x'], diag2, 1e-6) prob.setup(vector_class=PETScVector, check=False, mode='rev') prob.run_driver() J = prob.compute_totals(of=['C4.y'], wrt=['P1.x', 'P2.x']) assert_rel_error(self, J['C4.y', 'P1.x'], diag1, 1e-6) assert_rel_error(self, J['C4.y', 'P2.x'], diag2, 1e-6)
def test_implicit(self): prob = Problem() model = prob.model comp1 = model.add_subsystem('p', IndepVarComp()) comp1.add_output('a', np.array([1.0, 2.0, 3.0])) comp1.add_output('b', np.array([2.0, 3.0, 4.0])) comp1.add_output('c', np.array([-1.0, -2.0, -3.0])) model.add_subsystem('comp', QuadraticCompVectorized()) model.connect('p.a', 'comp.a') model.connect('p.b', 'comp.b') model.connect('p.c', 'comp.c') model.add_design_var('p.a', vectorize_derivs=True) model.add_design_var('p.b', vectorize_derivs=True) model.add_design_var('p.c', vectorize_derivs=True) model.add_constraint('comp.x', vectorize_derivs=True) model.linear_solver = LinearBlockGS() prob.setup(check=False, mode='fwd') prob.set_solver_print(level=0) prob.run_model() J = prob.compute_totals(of=['comp.x'], wrt=['p.a', 'p.b', 'p.c']) assert_rel_error(self, J['comp.x', 'p.a'], np.diag(np.array([-0.06066017, -0.05, -0.03971954])), 1e-4) assert_rel_error(self, J['comp.x', 'p.b'], np.diag(np.array([-0.14644661, -0.1, -0.07421663])), 1e-4) assert_rel_error(self, J['comp.x', 'p.c'], np.diag(np.array([-0.35355339, -0.2, -0.13867505])), 1e-4)
def test_cycle_iter_subgroup(self): prob = Problem() model = prob.model G1 = model.add_subsystem("G1", Group()) C1 = G1.add_subsystem("C1", ExecComp('y=2.0*x')) C2 = G1.add_subsystem("C2", ExecComp('y=2.0*x')) C3 = G1.add_subsystem("C3", ExecComp('y=2.0*x')) G1.connect('C1.y', 'C2.x') G1.connect('C2.y', 'C3.x') G1.connect('C3.y', 'C1.x') # provide iterative solvers to handle cycle model.linear_solver = LinearBlockGS() model.nonlinear_solver = NonlinearBlockGS() # perform setup with checks but don't run model testlogger = TestLogger() prob.setup(check=True, logger=testlogger) prob.final_setup() # should not trigger solver warning because iterates in parent group # but one warning exists due to problem not having a recorder warnings = testlogger.get('warning') self.assertEqual(len(warnings), 1)
def test_implicit_iter_subgroups(self): prob = Problem() model = prob.model model.add_subsystem('indep', IndepVarComp('y', 1.0)) model.add_subsystem("G1", Group()) model.G1.add_subsystem('statecomp1', StateConnection(), promotes_inputs=['y2_actual']) model.add_subsystem("G2", Group()) model.G2.add_subsystem('statecomp2', StateConnection(), promotes_inputs=['y2_actual']) model.connect('indep.y', ['G1.y2_actual', 'G2.y2_actual']) # do not provide iterative linear solver for G2 model.nonlinear_solver = NonlinearBlockGS() model.G1.linear_solver = LinearBlockGS() # perform setup with checks but don't run model testlogger = TestLogger() prob.setup(check=True, logger=testlogger) prob.final_setup() # should trigger a linear solver warning only for group 2 self.assertTrue( testlogger.contains( 'warning', "StateConnection 'G2.statecomp2' contains implicit " "variables, but does not have an iterative linear solver " "and does not implement 'solve_linear'."))
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 = ScipyKrylov() 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_specify_solver(self): import numpy as np from openmdao.api import Problem, Group, IndepVarComp, ExecComp, LinearBlockGS, NonlinearBlockGS from openmdao.test_suite.components.sellar import SellarDis1withDerivatives, SellarDis2withDerivatives 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.linear_solver = LinearBlockGS() model.nonlinear_solver = NonlinearBlockGS() 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 test_multi_cycles_non_default(self): p = Problem() root = p.model root.add_subsystem("indep", IndepVarComp('x', 1.0)) def make_cycle(root, start, end): # systems within a cycle will be declared out of order, but # should not be reported since they're internal to a cycle. for i in range(end, start - 1, -1): root.add_subsystem("C%d" % i, MyComp()) for i in range(start, end): root.connect("C%d.y" % i, "C%d.a" % (i + 1)) root.connect("C%d.y" % end, "C%d.a" % start) G1 = root.add_subsystem('G1', Group()) make_cycle(G1, 1, 3) G1.add_subsystem("N1", MyComp()) make_cycle(G1, 11, 13) G1.add_subsystem("N2", MyComp()) make_cycle(G1, 21, 23) G1.add_subsystem("N3", MyComp()) G1.connect("N1.z", "C12.b") G1.connect("C13.z", "N2.b") G1.connect("N2.z", "C21.b") G1.connect("C23.z", "N3.b") G1.connect("N3.z", "C2.b") G1.connect("C11.z", "C3.b") # set iterative solvers since we have cycles root.linear_solver = LinearBlockGS() root.nonlinear_solver = NonlinearBlockGS() testlogger = TestLogger() p.setup(check=['cycles', 'out_of_order', 'unconnected_inputs'], logger=testlogger) p.final_setup() expected_info = ( "The following groups contain cycles:\n" " Group 'G1' has the following cycles: " "[['C13', 'C12', 'C11'], ['C23', 'C22', 'C21'], ['C3', 'C2', 'C1']]\n" ) expected_warning_1 = ( "The following systems are executed out-of-order:\n" " System 'G1.C2' executes out-of-order with respect to its source systems ['G1.N3']\n" " System 'G1.C3' executes out-of-order with respect to its source systems ['G1.C11']\n" ) testlogger.find_in('info', expected_info) testlogger.find_in('warning', expected_warning_1)
def test_feature_atol(self): import numpy as np from openmdao.api import Problem, Group, IndepVarComp, 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.linear_solver = LinearBlockGS() nlgbs = model.nonlinear_solver = NewtonSolver() nlgbs.options['atol'] = 1e-4 prob.setup() prob.run_model() assert_rel_error(self, prob['y1'], 25.5882856302, .00001) assert_rel_error(self, prob['y2'], 12.05848819, .00001)
def test_feature_err_on_maxiter(self): import numpy as np from openmdao.api import Problem, Group, IndepVarComp, NewtonSolver, LinearBlockGS, ExecComp, AnalysisError 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.linear_solver = LinearBlockGS() nlgbs = model.nonlinear_solver = NewtonSolver() nlgbs.options['maxiter'] = 1 nlgbs.options['err_on_maxiter'] = True prob.setup() try: prob.run_model() except AnalysisError: pass
def test_too_few_procs(self): size = 3 group = Group() group.add_subsystem('P', IndepVarComp('x', numpy.ones(size))) group.add_subsystem( 'C1', DistribExecComp(['y=2.0*x'], arr_size=size, x=numpy.zeros(size), y=numpy.zeros(size))) group.add_subsystem( 'C2', ExecComp(['z=3.0*y'], y=numpy.zeros(size), z=numpy.zeros(size))) prob = Problem() prob.model = group prob.model.linear_solver = LinearBlockGS() prob.model.connect('P.x', 'C1.x') prob.model.connect('C1.y', 'C2.y') try: prob.setup(vector_class=PETScVector, check=False) except Exception as err: self.assertEqual( str(err), "C1 needs 2 MPI processes, but was given only 1.") else: if MPI: self.fail("Exception expected")
def test_feature_rtol(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.linear_solver = LinearBlockGS() nlgbs = model.nonlinear_solver = NonlinearBlockJac() nlgbs.options['rtol'] = 1e-3 prob.setup() prob.run_model() assert_rel_error(self, prob['y1'], 25.5891491526, .00001) assert_rel_error(self, prob['y2'], 12.0569142166, .00001)
def test_implicit_iter_subgroup(self): prob = Problem() model = prob.model model.add_subsystem('indep', IndepVarComp('y', 1.0)) model.add_subsystem("G1", Group()) model.G1.add_subsystem('statecomp', StateConnection(), promotes_inputs=['y2_actual']) model.connect('indep.y', 'G1.y2_actual') # provide iterative solvers for implicit group model.linear_solver = LinearBlockGS() model.nonlinear_solver = NonlinearBlockGS() # perform setup with checks but don't run model testlogger = TestLogger() prob.setup(check=True, logger=testlogger) prob.final_setup() # should not trigger solver warning because iterates in parent group # but will have recorder warning warnings = testlogger.get('warning') self.assertEqual(len(warnings), 1)
def test_two_simple(self): size = 3 group = Group() # import pydevd # pydevd.settrace('localhost', port=10000+MPI.COMM_WORLD.rank, # stdoutToServer=True, stderrToServer=True) group.add_subsystem('P', IndepVarComp('x', numpy.arange(size))) group.add_subsystem('C1', DistribExecComp(['y=2.0*x', 'y=3.0*x'], arr_size=size, x=numpy.zeros(size), y=numpy.zeros(size))) group.add_subsystem('C2', ExecComp(['z=3.0*y'], y=numpy.zeros(size), z=numpy.zeros(size))) prob = Problem() prob.model = group prob.model.linear_solver = LinearBlockGS() prob.model.connect('P.x', 'C1.x') prob.model.connect('C1.y', 'C2.y') prob.setup(vector_class=PETScVector, check=False, mode='fwd') prob.run_model() J = prob.compute_totals(['C2.z'], ['P.x']) assert_rel_error(self, J['C2.z', 'P.x'], numpy.diag([6.0, 6.0, 9.0]), 1e-6) prob.setup(vector_class=PETScVector, check=False, mode='rev') prob.run_model() J = prob.compute_totals(['C2.z'], ['P.x']) assert_rel_error(self, J['C2.z', 'P.x'], numpy.diag([6.0, 6.0, 9.0]), 1e-6)
def test_specify_precon(self): import numpy as np from openmdao.api import Problem, Group, IndepVarComp, LinearBlockGS, PETScKrylov, \ NewtonSolver, ExecComp from openmdao.test_suite.components.sellar import SellarDis1withDerivatives, \ SellarDis2withDerivatives 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 = PETScKrylov() 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_reading_solver_metadata(self): prob = SellarProblem(linear_solver=LinearBlockGS()) prob.setup() prob.model.nonlinear_solver.add_recorder(self.recorder) prob.model.linear_solver.add_recorder(self.recorder) d1 = prob.model.d1 # SellarDis1withDerivatives (an ExplicitComponent) d1.nonlinear_solver = NonlinearBlockGS(maxiter=5) d1.nonlinear_solver.add_recorder(self.recorder) prob.run_driver() prob.cleanup() cr = CaseReader(self.filename) self.assertEqual( sorted(cr.solver_metadata.keys()), sorted([ 'root.LinearBlockGS', 'root.NonlinearBlockGS', 'd1.NonlinearBlockGS' ])) self.assertEqual( cr.solver_metadata['d1.NonlinearBlockGS']['solver_options'] ['maxiter'], 5) self.assertEqual( cr.solver_metadata['root.NonlinearBlockGS']['solver_options'] ['maxiter'], 10) self.assertEqual( cr.solver_metadata['root.LinearBlockGS']['solver_class'], 'LinearBlockGS')
def test_load_solver_cases(self): prob = SellarProblem() prob.setup() model = prob.model model.nonlinear_solver = NewtonSolver() model.linear_solver = LinearBlockGS() model.linear_solver.add_recorder(self.recorder) prob.run_model() prob.cleanup() cr = CaseReader(self.filename) case = cr.solver_cases.get_case(0) # Add one to all the inputs just to change the model # so we can see if loading the case values really changes the model for name in prob.model._inputs: model._inputs[name] += 1.0 for name in prob.model._outputs: model._outputs[name] += 1.0 # Now load in the case we recorded prob.load_case(case) _assert_model_matches_case(case, model)
def test_record_solver_linear_block_gs(self, m): self.setup_endpoints(m) self.setup_sellar_model() self.prob.model.nonlinear_solver = NewtonSolver() # used for analytic derivatives self.prob.model.nonlinear_solver.linear_solver = LinearBlockGS() self.recorder.options['record_abs_error'] = True self.recorder.options['record_rel_error'] = True self.recorder.options['record_solver_output'] = True self.recorder.options['record_solver_residuals'] = True self.prob.model.nonlinear_solver.linear_solver.add_recorder( self.recorder) self.prob.setup(check=False) t0, t1 = run_driver(self.prob) upload(self.filename, self._accepted_token) solver_iteration = json.loads(self.solver_iterations) expected_abs_error = 9.109083208861876e-11 expected_rel_error = 9.114367543620551e-12 expected_solver_output = [ { 'name': 'px.x', 'values': [0.0] }, { 'name': 'pz.z', 'values': [0.0, 0.0] }, { 'name': 'd1.y1', 'values': [0.00045069] }, { 'name': 'd2.y2', 'values': [-0.00225346] }, { 'name': 'obj_cmp.obj', 'values': [0.00045646] }, { 'name': 'con_cmp1.con1', 'values': [-0.00045069] }, { 'name': 'con_cmp2.con2', 'values': [-0.00225346] }, ] self.assertAlmostEqual(expected_abs_error, solver_iteration['abs_err']) self.assertAlmostEqual(expected_rel_error, solver_iteration['rel_err']) for o in expected_solver_output: self.assert_array_close(o, solver_iteration['solver_output'])
def setUp(self): group = GroupG() self.p = Problem(group) self.p.model.linear_solver = LinearBlockGS() self.p.setup(check=False) # Conclude setup but don't run model. self.p.final_setup()
def setup(self): self.linear_solver = LinearBlockGS() readAtm = self.add_subsystem('readAtmTable', USatm1976Comp(), promotes=('alt', 'Ps', 'rhos')) self.add_subsystem('dTs', DeltaTs(), promotes=('dTs', 'Ts')) self.connect('readAtmTable.Ts', 'dTs.Ts_in')
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_fan_in_serial_sets_rev(self): prob = Problem() prob.model = FanInGrouped() prob.model.linear_solver = LinearBlockGS() prob.model.sub.linear_solver = LinearBlockGS() prob.model.add_design_var('iv.x1') prob.model.add_design_var('iv.x2') prob.model.add_objective('c3.y') prob.setup(vector_class=vector_class, check=False, mode='rev') prob.run_driver() indep_list = ['iv.x1', 'iv.x2'] unknown_list = ['c3.y'] J = prob.compute_totals(unknown_list, indep_list, return_format='dict') assert_rel_error(self, J['c3.y']['iv.x1'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y']['iv.x2'][0][0], 35.0, 1e-6)
def test_dataflow_multi_level(self): p = Problem(model=Group()) root = p.model indep = root.add_subsystem("indep", IndepVarComp('x', 1.0)) G1 = root.add_subsystem("G1", Group()) C1 = G1.add_subsystem("C1", MyComp()) C2 = G1.add_subsystem("C2", MyComp()) C3 = root.add_subsystem("C3", MyComp()) C4 = root.add_subsystem("C4", MyComp()) root.connect("C4.y", "G1.C2.a") root.connect("C4.y", "C3.a") root.connect("G1.C2.y", "G1.C1.a") root.connect("G1.C1.y", "C4.a") # make sure no system has dangling inputs so we avoid that warning root.connect("indep.x", "G1.C1.b") root.connect("indep.x", "G1.C2.b") root.connect("indep.x", "C3.b") root.connect("indep.x", "C4.b") # set iterative solvers since we have cycles root.linear_solver = LinearBlockGS() root.nonlinear_solver = NonlinearBlockGS() testlogger = TestLogger() p.setup(check=True, logger=testlogger) # Conclude setup but don't run model. p.final_setup() warnings = testlogger.get('warning') self.assertEqual(len(warnings), 1) info = testlogger.get('info') self.assertEqual( info[0], "The following groups contain cycles:\n Group '' has the following cycles: [['G1', 'C4']]\n" ) self.assertEqual( warnings[0], "The following systems are executed out-of-order:\n System 'C3' executes out-of-order with respect to its source systems ['C4']\n System 'G1.C1' executes out-of-order with respect to its source systems ['G1.C2']\n" ) # test comps_only cycle check graph = root.compute_sys_graph(comps_only=True) sccs = [sorted(s) for s in get_sccs_topo(graph) if len(s) > 1] self.assertEqual([['C4', 'G1.C1', 'G1.C2']], sccs)
def test_fan_in_parallel_sets_fwd(self): prob = Problem() prob.model = FanInGrouped() prob.model.linear_solver = LinearBlockGS() prob.model.get_subsystem('sub').linear_solver = LinearBlockGS() prob.model.add_design_var('iv.x1', parallel_deriv_color='par_dv') prob.model.add_design_var('iv.x2', parallel_deriv_color='par_dv') prob.model.add_design_var('iv.x3') prob.model.add_objective('c3.y') prob.setup(vector_class=vector_class, check=False, mode='fwd') prob.run_driver() indep_list = ['iv.x1', 'iv.x2'] unknown_list = ['c3.y'] J = prob.compute_totals(unknown_list, indep_list, return_format='flat_dict') assert_rel_error(self, J['c3.y', 'iv.x1'][0][0], -6.0, 1e-6) assert_rel_error(self, J['c3.y', 'iv.x2'][0][0], 35.0, 1e-6)