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)
