def test_debug_print_response_physical(self):
prob = om.Problem()
model = prob.model
size = 3
model.add_subsystem('p1', om.IndepVarComp('x',
np.array([50.0] * size)))
model.add_subsystem('p2', om.IndepVarComp('y',
np.array([50.0] * size)))
model.add_subsystem(
'comp',
om.ExecComp('f_xy = (x-3.0)**2 + x*y + (y+4.0)**2 - 3.0',
x=np.zeros(size),
y=np.zeros(size),
f_xy=np.zeros(size)))
model.add_subsystem(
'con',
om.ExecComp('c = - x + y + 1',
c=np.zeros(size),
x=np.zeros(size),
y=np.zeros(size)))
model.connect('p1.x', 'comp.x')
model.connect('p2.y', 'comp.y')
model.connect('p1.x', 'con.x')
model.connect('p2.y', 'con.y')
prob.set_solver_print(level=0)
prob.driver = om.ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1e-9
prob.driver.options['disp'] = False
model.add_design_var('p1.x', indices=[1], lower=-50.0, upper=50.0)
model.add_design_var('p2.y', indices=[1], lower=-50.0, upper=50.0)
model.add_objective('comp.f_xy', index=1, ref=1.5)
model.add_constraint('con.c', indices=[1], upper=-15.0, ref=1.02)
prob.setup()
prob.driver.options['debug_print'] = ['objs', 'nl_cons']
stdout = sys.stdout
strout = StringIO()
sys.stdout = strout
try:
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
with printoptions(precision=2, legacy="1.13"):
prob.run_driver()
else:
with printoptions(precision=2):
prob.run_driver()
finally:
sys.stdout = stdout
output = strout.getvalue().split('\n')
# should see unscaled (physical) and the full arrays, not just what is indicated by indices
self.assertEqual(output[3], "{'con.c': array([ 1.])}")
self.assertEqual(output[6], "{'comp.f_xy': array([ 7622.])}")
def test_debug_desvar_shape(self):
# Desvar should always be printed un-flattened.
prob = Problem()
model = prob.model
model.add_subsystem(
'p', IndepVarComp('x', val=np.array([[1.0, 3, 4], [7, 2, 5]])))
model.add_design_var('p.x', np.array([[1.0, 3, 4], [7, 2, 5]]))
prob.driver.options['debug_print'] = ['desvars']
prob.setup()
stdout = sys.stdout
strout = StringIO()
sys.stdout = strout
try:
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
with printoptions(precision=2, legacy="1.13"):
prob.run_driver()
else:
with printoptions(precision=2):
prob.run_driver()
finally:
sys.stdout = stdout
output = strout.getvalue().split('\n')
self.assertEqual(output[3], "{'p.x': array([[ 1., 3., 4.],")
self.assertEqual(output[4], ' [ 7., 2., 5.]])}')
def test_solver_debug_print(self, name, solver):
p = om.Problem()
model = p.model
model.add_subsystem('ground', om.IndepVarComp('V', 0., units='V'))
model.add_subsystem('source', om.IndepVarComp('I', 0.1, units='A'))
model.add_subsystem('circuit', Circuit())
model.connect('source.I', 'circuit.I_in')
model.connect('ground.V', 'circuit.Vg')
p.setup()
nl = model.circuit.nonlinear_solver = solver()
nl.options['debug_print'] = True
nl.options['err_on_non_converge'] = True
if name == 'NonlinearBlockGS':
nl.options['use_apply_nonlinear'] = True
# suppress solver output for test
nl.options['iprint'] = model.circuit.linear_solver.options[
'iprint'] = -1
# For Broydensolver, don't calc Jacobian
try:
nl.options['compute_jacobian'] = False
except KeyError:
pass
# set some poor initial guesses so that we don't converge
p['circuit.n1.V'] = 10.
p['circuit.n2.V'] = 1e-3
opts = {}
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts["legacy"] = '1.13'
with printoptions(**opts):
# run the model and check for expected output file
output = run_model(p, ignore_exception=True)
expected_output = '\n'.join([
self.expected_data,
"Inputs and outputs at start of iteration "
"have been saved to '%s'.\n" % self.filename
])
self.assertEqual(output, expected_output)
with open(self.filename, 'r') as f:
self.assertEqual(f.read(), self.expected_data)
# setup & run again to make sure there is no error due to existing file
p.setup()
with printoptions(**opts):
run_model(p, ignore_exception=False)
def test_debug_print_response_physical(self):
prob = Problem()
model = prob.model = Group()
size = 3
model.add_subsystem('p1', IndepVarComp('x', np.array([50.0] * size)))
model.add_subsystem('p2', IndepVarComp('y', np.array([50.0] * size)))
model.add_subsystem('comp', ExecComp('f_xy = (x-3.0)**2 + x*y + (y+4.0)**2 - 3.0',
x=np.zeros(size), y=np.zeros(size),
f_xy=np.zeros(size)))
model.add_subsystem('con', ExecComp('c = - x + y + 1',
c=np.zeros(size), x=np.zeros(size),
y=np.zeros(size)))
model.connect('p1.x', 'comp.x')
model.connect('p2.y', 'comp.y')
model.connect('p1.x', 'con.x')
model.connect('p2.y', 'con.y')
prob.set_solver_print(level=0)
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1e-9
prob.driver.options['disp'] = False
model.add_design_var('p1.x', indices=[1], lower=-50.0, upper=50.0)
model.add_design_var('p2.y', indices=[1], lower=-50.0, upper=50.0)
model.add_objective('comp.f_xy', index=1, ref=1.5)
model.add_constraint('con.c', indices=[1], upper=-15.0, ref=1.02)
prob.setup(check=False)
prob.driver.options['debug_print'] = ['objs', 'nl_cons']
stdout = sys.stdout
strout = StringIO()
sys.stdout = strout
try:
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
with printoptions(precision=2, legacy="1.13"):
prob.run_driver()
else:
with printoptions(precision=2):
prob.run_driver()
finally:
sys.stdout = stdout
output = strout.getvalue().split('\n')
# should see unscaled (physical) and the full arrays, not just what is indicated by indices
self.assertEqual(output[3], "{'con.c': array([ 1.])}")
self.assertEqual(output[6], "{'comp.f_xy': array([ 7622.])}")
def test_bsplines_vectorized(self):
prob = om.Problem()
model = prob.model
n_cp = 5
n_point = 10
t = np.linspace(0, 0.5 * np.pi, n_cp)
tt = np.linspace(0, 0.5 * np.pi, n_point)
x = np.empty((2, n_cp))
x[0, :] = np.sin(t)
x[1, :] = 2.0 * np.sin(t)
t_sin = (0.5 * (1.0 + np.sin(-0.5 * np.pi + 2.0 * tt))) * np.pi * 0.5
model.add_subsystem('px', om.IndepVarComp('x', val=x))
bspline_options = {'order': 4}
comp = om.SplineComp(method='bsplines',
x_interp_val=t_sin,
num_cp=n_cp,
vec_size=2,
interp_options=bspline_options)
prob.model.add_subsystem('interp', comp)
comp.add_spline(y_cp_name='h_cp',
y_interp_name='h',
y_cp_val=x,
y_units='km')
model.connect('px.x', 'interp.h_cp')
prob.setup(force_alloc_complex=True)
prob.run_model()
xx = prob['interp.h']
with printoptions(precision=3, floatmode='fixed'):
assert_near_equal(
x[0, :], np.array([0., 0.38268343, 0.70710678, 0.92387953,
1.]), 1e-5)
assert_near_equal(
x[1, :],
2.0 * np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]),
1e-5)
assert_near_equal(
xx[0, :],
np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
assert_near_equal(
xx[1, :], 2.0 * np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
derivs = prob.check_partials(out_stream=None, method='cs')
assert_check_partials(derivs, atol=1e-14, rtol=1e-14)
def test_renamed_vars(self):
n = 1
prob = Problem(model=Group())
bal = BalanceComp()
bal.add_balance('x',
use_mult=True,
mult_name='MUL',
lhs_name='XSQ',
rhs_name='TARGETXSQ')
tgt = IndepVarComp(name='y_tgt', val=4)
mult_ivc = IndepVarComp(name='mult', val=2.0)
exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='mult_comp',
subsys=mult_ivc,
promotes_outputs=['mult'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.TARGETXSQ')
prob.model.connect('mult', 'balance.MUL')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.XSQ')
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.model.nonlinear_solver.options['maxiter'] = 100
prob.model.nonlinear_solver.options['iprint'] = 0
prob.model.jacobian = DenseJacobian()
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def _trim_str(obj, size):
"""
Truncate given string if it's longer than the given size.
For arrays, use the norm if the size is exceeded.
Parameters
----------
obj : object
Object to be stringified and trimmed.
size : int
Max allowable size of the returned string.
Returns
-------
str
The trimmed string.
"""
if isinstance(obj, np.ndarray):
with printoptions(**_npy_print_opts):
s = str(obj)
else:
s = str(obj)
if len(s) > size:
if isinstance(obj, np.ndarray) and np.issubdtype(obj.dtype, np.floating):
s = 'shape={}, norm={:<.3}'.format(obj.shape, np.linalg.norm(obj))
else:
s = s[:size - 4] + ' ...'
return s
def test_partials(self):
p = self.make_problem(transcription=Radau, optimizer='SLSQP')
p.run_model()
with printoptions(linewidth=1024, edgeitems=100):
cpd = p.check_partials(method='fd',
compact_print=True,
out_stream=None)
def test_for_docs_array_list_vars_options(self):
class ArrayAdder(om.ExplicitComponent):
"""
Just a simple component that has array inputs and outputs
"""
def __init__(self, size):
super().__init__()
self.size = size
def setup(self):
self.add_input('x', val=np.zeros(self.size), units='inch')
self.add_output('y', val=np.zeros(self.size), units='ft')
def compute(self, inputs, outputs):
outputs['y'] = inputs['x'] + 10.0
size = 30
prob = om.Problem()
prob.model.add_subsystem('des_vars', om.IndepVarComp('x', np.ones(size), units='inch'),
promotes=['x'])
prob.model.add_subsystem('mult', ArrayAdder(size), promotes=['x', 'y'])
prob.setup()
prob['x'] = np.arange(size)
prob.run_driver()
prob.model.list_inputs(values=True,
units=True,
hierarchical=True,
print_arrays=True)
with printoptions(edgeitems=3, infstr='inf',
linewidth=75, nanstr='nan', precision=8,
suppress=False, threshold=1000, formatter=None):
prob.model.list_outputs(values=True,
implicit=False,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=False,
print_arrays=True)
prob.model.list_outputs(values=True,
implicit=False,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=True,
print_arrays=True)
def test_scalar_example(self):
prob = Problem(model=Group())
bal = BalanceComp()
bal.add_balance('x', val=1.0)
tgt = IndepVarComp(name='y_tgt', val=2)
exec_comp = ExecComp('y=x**2')
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
# do one test in an unconverged state, to capture accuracy of partials
prob.setup()
prob[
'y_tgt'] = 100000 #set rhs and lhs to very different values. Trying to capture some derivatives wrt
prob['exec.y'] = .001
prob.run_model()
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
# set an actual solver, and re-setup. Then check derivatives at a converged point
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.setup()
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_bsplines_2to3doc(self):
from openmdao.utils.spline_distributions import sine_distribution
prob = om.Problem()
model = prob.model
n_cp = 5
n_point = 10
t = np.linspace(0, 0.5 * np.pi, n_cp)
x = np.empty((2, n_cp))
x[0, :] = np.sin(t)
x[1, :] = 2.0 * np.sin(t)
# In 2.x, the BsplinesComp had a built-in sinusoidal distribution.
t_sin = sine_distribution(n_point) * np.pi * 0.5
bspline_options = {'order': 4}
comp = om.SplineComp(method='bsplines',
x_interp_val=t_sin,
num_cp=n_cp,
vec_size=2,
interp_options=bspline_options)
prob.model.add_subsystem('interp', comp)
comp.add_spline(y_cp_name='h_cp',
y_interp_name='h',
y_cp_val=x,
y_units='km')
prob.setup()
prob.run_model()
xx = prob['interp.h']
with printoptions(precision=3, floatmode='fixed'):
assert_near_equal(
x[0, :], np.array([0., 0.38268343, 0.70710678, 0.92387953,
1.]), 1e-5)
assert_near_equal(
x[1, :],
2.0 * np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]),
1e-5)
assert_near_equal(
xx[0, :],
np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
assert_near_equal(
xx[1, :], 2.0 * np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
def test_scalar_with_guess_func_additional_input(self):
n = 1
prob = Problem(model=Group())
bal = BalanceComp()
bal.add_balance('x',
guess_func=lambda inputs, resids: inputs['guess_x'])
bal.add_input('guess_x', val=0.0)
ivc = IndepVarComp()
ivc.add_output(name='y_tgt', val=4)
ivc.add_output(name='guess_x', val=2.5)
exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
prob.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['y_tgt', 'guess_x'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('guess_x', 'balance.guess_x')
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.model.nonlinear_solver.options['maxiter'] = 100
prob.model.nonlinear_solver.options['iprint'] = 0
prob.model.jacobian = DenseJacobian()
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], 2.0, decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_vectorized(self):
import numpy as np
from openmdao.api import Problem, IndepVarComp
from openmdao.components.bsplines_comp import BsplinesComp
from openmdao.utils.general_utils import printoptions
prob = Problem()
model = prob.model
n_cp = 5
n_point = 10
t = np.linspace(0, 0.5 * np.pi, n_cp)
x = np.empty((2, n_cp))
x[0, :] = np.sin(t)
x[1, :] = 2.0 * np.sin(t)
model.add_subsystem('px', IndepVarComp('x', val=x))
model.add_subsystem(
'interp',
BsplinesComp(num_control_points=n_cp,
num_points=n_point,
vec_size=2,
in_name='h_cp',
out_name='h'))
model.connect('px.x', 'interp.h_cp')
prob.setup(check=False)
prob.run_model()
xx = prob['interp.h']
with printoptions(precision=3, floatmode='fixed'):
self.assertEqual('Control Points:', 'Control Points:')
assert_rel_error(
self, x[0, :],
np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]), 1e-5)
assert_rel_error(
self, x[1, :],
2.0 * np.array([0., 0.38268343, 0.70710678, 0.92387953, 1.]),
1e-5)
self.assertEqual('Output Points:', 'Output Points:')
assert_rel_error(
self, xx[0, :],
np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
assert_rel_error(
self, xx[1, :], 2.0 * np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
def test_vectorized_with_default_mult(self):
"""
solve: 2 * x**2 = 4
expected solution: x=sqrt(2)
"""
n = 100
prob = Problem(model=Group())
bal = BalanceComp('x', val=np.ones(n), use_mult=True, mult_val=2.0)
tgt = IndepVarComp(name='y_tgt', val=4 * np.ones(n))
exec_comp = ExecComp('y=x**2',
x={'value': np.ones(n)},
y={'value': np.ones(n)})
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.model.nonlinear_solver.options['maxiter'] = 100
prob.model.nonlinear_solver.options['iprint'] = 0
prob.model.jacobian = DenseJacobian()
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_vectorized_with_mult(self):
n = 100
prob = Problem(model=Group(assembled_jac_type='dense'))
bal = BalanceComp()
bal.add_balance('x', val=np.ones(n), use_mult=True)
tgt = IndepVarComp(name='y_tgt', val=4 * np.ones(n))
mult_ivc = IndepVarComp(name='mult', val=2.0 * np.ones(n))
exec_comp = ExecComp('y=x**2',
x={'value': np.ones(n)},
y={'value': np.ones(n)})
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='mult_comp',
subsys=mult_ivc,
promotes_outputs=['mult'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('mult', 'balance.mult:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_linesearch_vector_bound_enforcement(self):
top = self.top
ls = top.model.nonlinear_solver.linesearch = om.BoundsEnforceLS(
bound_enforcement='vector')
ls.options['print_bound_enforce'] = True
# Setup again because we assigned a new linesearch
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()
for ind in range(3):
assert_near_equal(top['comp.z'][ind], [1.5], 1e-8)
with printoptions(precision=3):
msg = (
f"'comp.z' exceeds lower bounds\n Val: [1.333 1.333 1.333]\n Lower: [1.5 1.5 1.5]\n"
)
with assert_warning(om.SolverWarning, msg):
top.run_model()
top.setup()
# Test upper bounds: should go to the minimum upper bound and stall
top['px.x'] = 0.5
top['comp.y'] = 0.
top['comp.z'] = 2.4
with printoptions(precision=3):
msg = (
f"'comp.z' exceeds upper bounds\n Val: [2.667 2.667 2.667]\n Upper: [2.6 2.5 2.65]\n"
)
with assert_warning(om.SolverWarning, msg):
top.run_model()
for ind in range(3):
assert_near_equal(top['comp.z'][ind], [2.5], 1e-8)
def test_solver_debug_print(self, name, solver):
p = Problem()
model = p.model
model.add_subsystem('ground', IndepVarComp('V', 0., units='V'))
model.add_subsystem('source', IndepVarComp('I', 0.1, units='A'))
model.add_subsystem('circuit', Circuit())
model.connect('source.I', 'circuit.I_in')
model.connect('ground.V', 'circuit.Vg')
p.setup()
nl = model.circuit.nonlinear_solver = solver()
nl.options['debug_print'] = True
nl.options['err_on_maxiter'] = True
if name == 'NonlinearBlockGS':
nl.options['use_apply_nonlinear'] = True
# suppress solver output for test
nl.options['iprint'] = model.circuit.linear_solver.options['iprint'] = -1
# For Broydensolver, don't calc Jacobian
try:
nl.options['compute_jacobian'] = False
except KeyError:
pass
# set some poor initial guesses so that we don't converge
p['circuit.n1.V'] = 10.
p['circuit.n2.V'] = 1e-3
opts = {}
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts["legacy"] = '1.13'
with printoptions(**opts):
# run the model and check for expected output file
output = run_model(p, ignore_exception=True)
expected_output = '\n'.join([
self.expected_data,
"Inputs and outputs at start of iteration "
"have been saved to '%s'.\n" % self.filename
])
self.assertEqual(output, expected_output)
with open(self.filename, 'r') as f:
self.assertEqual(f.read(), self.expected_data)
def test_scalar_example(self):
prob = Problem(model=Group())
bal = BalanceComp()
bal.add_balance('x', val=1.0)
tgt = IndepVarComp(name='y_tgt', val=2)
exec_comp = ExecComp('y=x**2')
prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
# do one test in an unconverged state, to capture accuracy of partials
prob.setup()
prob['y_tgt'] = 100000 #set rhs and lhs to very different values. Trying to capture some derivatives wrt
prob['exec.y'] = .001
prob.run_model()
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
# set an actual solver, and re-setup. Then check derivatives at a converged point
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.setup()
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_vectorized(self):
import numpy as np
from openmdao.api import Problem, IndepVarComp
from openmdao.components.bsplines_comp import BsplinesComp
from openmdao.utils.general_utils import printoptions
prob = Problem()
model = prob.model
n_cp = 5
n_point = 10
t = np.linspace(0, 0.5*np.pi, n_cp)
x = np.empty((2, n_cp))
x[0, :] = np.sin(t)
x[1, :] = 2.0*np.sin(t)
model.add_subsystem('px', IndepVarComp('x', val=x))
model.add_subsystem('interp', BsplinesComp(num_control_points=n_cp,
num_points=n_point,
vec_size=2,
in_name='h_cp',
out_name='h'))
model.connect('px.x', 'interp.h_cp')
prob.setup(check=False)
prob.run_model()
xx = prob['interp.h']
with printoptions(precision=3, floatmode='fixed'):
self.assertEqual('Control Points:', 'Control Points:')
assert_rel_error(self, x[0, :], np.array([
0., 0.38268343, 0.70710678, 0.92387953, 1.
]), 1e-5)
assert_rel_error(self, x[1, :], 2.0*np.array([
0., 0.38268343, 0.70710678, 0.92387953, 1.
]), 1e-5)
self.assertEqual('Output Points:', 'Output Points:')
assert_rel_error(self, xx[0, :], np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
assert_rel_error(self, xx[1, :], 2.0*np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
def test_scalar_with_guess_func(self):
n = 1
prob = Problem(model=Group(assembled_jac_type='dense'))
bal = BalanceComp()
bal.add_balance(
'x', guess_func=lambda inputs, resids: np.sqrt(inputs['rhs:x']))
tgt = IndepVarComp(name='y_tgt', val=4)
exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], 2.0, decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_scalar_with_guess_func_additional_input(self):
n = 1
prob = Problem(model=Group(assembled_jac_type='dense'))
bal = BalanceComp()
bal.add_balance('x', guess_func=lambda inputs, resids: inputs['guess_x'])
bal.add_input('guess_x', val=0.0)
ivc = IndepVarComp()
ivc.add_output(name='y_tgt', val=4)
ivc.add_output(name='guess_x', val=2.5)
exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
prob.model.add_subsystem(name='ivc', subsys=ivc, promotes_outputs=['y_tgt', 'guess_x'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('guess_x', 'balance.guess_x')
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], 2.0, decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_renamed_vars(self):
n = 1
prob = Problem(model=Group(assembled_jac_type='dense'))
bal = BalanceComp()
bal.add_balance('x', use_mult=True, mult_name='MUL', lhs_name='XSQ', rhs_name='TARGETXSQ')
tgt = IndepVarComp(name='y_tgt', val=4)
mult_ivc = IndepVarComp(name='mult', val=2.0)
exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='mult_comp', subsys=mult_ivc, promotes_outputs=['mult'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.TARGETXSQ')
prob.model.connect('mult', 'balance.MUL')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.XSQ')
prob.model.linear_solver = DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_solver_debug_print_feature(self):
from distutils.version import LooseVersion
import numpy as np
import openmdao.api as om
from openmdao.test_suite.scripts.circuit_analysis import Circuit
from openmdao.utils.general_utils import printoptions
p = om.Problem()
model = p.model
model.add_subsystem('ground', om.IndepVarComp('V', 0., units='V'))
model.add_subsystem('source', om.IndepVarComp('I', 0.1, units='A'))
model.add_subsystem('circuit', Circuit())
model.connect('source.I', 'circuit.I_in')
model.connect('ground.V', 'circuit.Vg')
p.setup()
nl = model.circuit.nonlinear_solver = om.NewtonSolver(
solve_subsystems=False)
nl.options['iprint'] = 2
nl.options['debug_print'] = True
nl.options['err_on_non_converge'] = True
# set some poor initial guesses so that we don't converge
p['circuit.n1.V'] = 10.
p['circuit.n2.V'] = 1e-3
opts = {}
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts["legacy"] = '1.13'
with printoptions(**opts):
# run the model
try:
p.run_model()
except om.AnalysisError:
pass
with open(self.filename, 'r') as f:
self.assertEqual(f.read(), self.expected_data)
def test_vectorized_with_default_mult(self):
"""
solve: 2 * x**2 = 4
expected solution: x=sqrt(2)
"""
n = 100
prob = Problem(model=Group(assembled_jac_type='dense'))
bal = BalanceComp('x', val=np.ones(n), use_mult=True, mult_val=2.0)
tgt = IndepVarComp(name='y_tgt', val=4 * np.ones(n))
exec_comp = ExecComp('y=x**2', x={'value': np.ones(n)}, y={'value': np.ones(n)})
prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_solver_debug_print_feature(self):
from distutils.version import LooseVersion
import numpy as np
from openmdao.api import Problem, IndepVarComp, NewtonSolver, AnalysisError
from openmdao.test_suite.scripts.circuit_analysis import Circuit
from openmdao.utils.general_utils import printoptions
p = Problem()
model = p.model
model.add_subsystem('ground', IndepVarComp('V', 0., units='V'))
model.add_subsystem('source', IndepVarComp('I', 0.1, units='A'))
model.add_subsystem('circuit', Circuit())
model.connect('source.I', 'circuit.I_in')
model.connect('ground.V', 'circuit.Vg')
p.setup()
nl = model.circuit.nonlinear_solver = NewtonSolver()
nl.options['iprint'] = 2
nl.options['debug_print'] = True
nl.options['err_on_maxiter'] = True
# set some poor initial guesses so that we don't converge
p['circuit.n1.V'] = 10.
p['circuit.n2.V'] = 1e-3
opts = {}
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts["legacy"] = '1.13'
with printoptions(**opts):
# run the model
try:
p.run_model()
except AnalysisError:
pass
with open('rank0_root_0_NLRunOnce_0_circuit_0.dat', 'r') as f:
self.assertEqual(f.read(), self.expected_data)
def test_solver_debug_print(self, name, solver):
p = Problem()
model = p.model
model.add_subsystem('ground', IndepVarComp('V', 0., units='V'))
model.add_subsystem('source', IndepVarComp('I', 0.1, units='A'))
model.add_subsystem('circuit', Circuit())
model.connect('source.I', 'circuit.I_in')
model.connect('ground.V', 'circuit.Vg')
p.setup()
nl = model.circuit.nonlinear_solver = solver()
nl.options['debug_print'] = True
# suppress solver output for test
nl.options['iprint'] = model.circuit.linear_solver.options['iprint'] = -1
# set some poor initial guesses so that we don't converge
p['circuit.n1.V'] = 10.
p['circuit.n2.V'] = 1e-3
opts = {}
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts["legacy"] = '1.13'
with printoptions(**opts):
# run the model and check for expected output file
output = run_model(p)
expected_output = '\n'.join([
self.expected_data,
"Inputs and outputs at start of iteration "
"have been saved to '%s'.\n" % self.filename
])
self.assertEqual(output, expected_output)
with open(self.filename, 'r') as f:
self.assertEqual(f.read(), self.expected_data)
def test_basic(self):
import numpy as np
import openmdao.api as om
from openmdao.utils.general_utils import printoptions
prob = om.Problem()
model = prob.model
n_cp = 5
n_point = 10
t = np.linspace(0, 0.5 * np.pi, n_cp)
x = np.sin(t)
model.add_subsystem('px', om.IndepVarComp('x', val=x))
model.add_subsystem(
'interp',
om.BsplinesComp(num_control_points=n_cp,
num_points=n_point,
in_name='h_cp',
out_name='h'))
model.connect('px.x', 'interp.h_cp')
prob.setup()
prob.run_model()
xx = prob['interp.h'].flatten()
with printoptions(precision=3, floatmode='fixed'):
self.assertEqual('Control Points:', 'Control Points:')
assert_rel_error(
self, x, np.array([0., 0.38268343, 0.70710678, 0.92387953,
1.]), 1e-5)
self.assertEqual('Output Points:', 'Output Points:')
assert_rel_error(
self, xx,
np.array([
0., 0.06687281, 0.23486869, 0.43286622, 0.6062628,
0.74821484, 0.86228902, 0.94134389, 0.98587725, 1.
]), 1e-5)
def test_rhs_val(self):
""" Test solution with a default RHS value and no connected RHS variable. """
n = 1
prob = Problem(model=Group())
bal = BalanceComp('x', rhs_val=4.0)
exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.model.nonlinear_solver.options['maxiter'] = 100
prob.model.nonlinear_solver.options['iprint'] = 0
prob.model.jacobian = DenseJacobian()
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], 2.0, decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_solver_debug_print_feature(self):
from openmdao.api import Problem, IndepVarComp, NewtonSolver, AnalysisError
from openmdao.test_suite.test_examples.test_circuit_analysis import Circuit
from openmdao.utils.general_utils import printoptions
p = Problem()
model = p.model
model.add_subsystem('ground', IndepVarComp('V', 0., units='V'))
model.add_subsystem('source', IndepVarComp('I', 0.1, units='A'))
model.add_subsystem('circuit', Circuit())
model.connect('source.I', 'circuit.I_in')
model.connect('ground.V', 'circuit.Vg')
p.setup()
nl = model.circuit.nonlinear_solver = NewtonSolver()
nl.options['iprint'] = 2
nl.options['debug_print'] = True
nl.options['err_on_maxiter'] = True
# set some poor initial guesses so that we don't converge
p['circuit.n1.V'] = 10.
p['circuit.n2.V'] = 1e-3
opts = {}
# formatting has changed in numpy 1.14 and beyond.
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts["legacy"] = '1.13'
with printoptions(**opts):
# run the model
try:
p.run_model()
except AnalysisError:
pass
with open('rank0_root_0_NLRunOnce_0_circuit_0.dat', 'r') as f:
self.assertEqual(f.read(), self.expected_data)
def test_create_on_init(self):
prob = Problem(model=Group())
bal = BalanceComp('x', val=1.0)
tgt = IndepVarComp(name='y_tgt', val=2)
exec_comp = ExecComp('y=x**2')
prob.model.add_subsystem(name='target',
subsys=tgt,
promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.setup()
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
# Assert that normalization is happening
assert_almost_equal(prob.model.balance._scale_factor, 1.0 / np.abs(2))
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
def test_create_on_init(self):
prob = Problem(model=Group())
bal = BalanceComp('x', val=1.0)
tgt = IndepVarComp(name='y_tgt', val=2)
exec_comp = ExecComp('y=x**2')
prob.model.add_subsystem(name='target', subsys=tgt, promotes_outputs=['y_tgt'])
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('y_tgt', 'balance.rhs:x')
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.setup()
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(2), decimal=7)
# Assert that normalization is happening
assert_almost_equal(prob.model.balance._scale_factor, 1.0 / np.abs(2))
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_rhs_val(self):
""" Test solution with a default RHS value and no connected RHS variable. """
n = 1
prob = Problem(model=Group(assembled_jac_type='dense'))
bal = BalanceComp('x', rhs_val=4.0)
exec_comp = ExecComp('y=x**2', x={'value': 1}, y={'value': 1})
prob.model.add_subsystem(name='exec', subsys=exec_comp)
prob.model.add_subsystem(name='balance', subsys=bal)
prob.model.connect('balance.x', 'exec.x')
prob.model.connect('exec.y', 'balance.lhs:x')
prob.model.linear_solver = DirectSolver(assemble_jac=True)
prob.model.nonlinear_solver = NewtonSolver(maxiter=100, iprint=0)
prob.setup()
prob['balance.x'] = np.random.rand(n)
prob.run_model()
assert_almost_equal(prob['balance.x'], 2.0, decimal=7)
with printoptions(linewidth=1024):
cpd = prob.check_partials()
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
if __name__ == '__main__':
import openmdao.utils.mpi # this will activate use_proc_files
try:
module_path = os.environ.get("OPENMDAO_CURRENT_MODULE", "").strip()
if module_path:
stdout_save = sys.stdout
# send any output to dev/null during the import so it doesn't clutter our embedded code output
with open(os.devnull, "w") as f:
sys.stdout = f
mod = importlib.import_module(module_path)
sys.stdout = stdout_save
else:
raise RuntimeError("OPENMDAO_CURRENT_MODULE was not specified.")
code_to_run = os.environ.get("OPENMDAO_CODE_TO_RUN", "").strip()
if not code_to_run:
raise RuntimeError("OPENMDAO_CODE_TO_RUN has not been set.")
with printoptions(precision=8):
exec(code_to_run, mod.__dict__)
except Exception:
traceback.print_exc()
sys.exit(-1)
sys.exit(0)
def test_distribcomp_list_vars(self):
from openmdao.test_suite.components.distributed_components import DistribComp, Summer
print_opts = {'linewidth': 1024}
from distutils.version import LooseVersion
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
print_opts['legacy'] = '1.13'
size = 15
model = om.Group()
model.add_subsystem("indep", om.IndepVarComp('x', np.zeros(size)))
model.add_subsystem("C2", DistribComp(size=size))
model.add_subsystem("C3", Summer(size=size))
model.connect('indep.x', 'C2.invec')
model.connect('C2.outvec', 'C3.invec')
prob = om.Problem(model)
prob.setup()
# prior to model execution, the global shape of a distributed variable is not available
# and only the local portion of the value is available
stream = cStringIO()
with printoptions(**print_opts):
model.C2.list_inputs(hierarchical=False,
shape=True,
global_shape=True,
print_arrays=True,
out_stream=stream)
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"1 Input(s) in 'C2'", '------------------', '',
'varname value shape global_shape',
'------- --------------- ----- ------------',
'invec |2.82842712475| (8,) Unavailable ',
' value:',
' array([1., 1., 1., 1., 1., 1., 1., 1.])'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(
remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
stream = cStringIO()
with printoptions(**print_opts):
model.C2.list_outputs(hierarchical=False,
shape=True,
global_shape=True,
print_arrays=True,
out_stream=stream)
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"1 Explicit Output(s) in 'C2'", '----------------------------',
'', 'varname value shape global_shape',
'------- --------------- ----- ------------',
'outvec |2.82842712475| (8,) Unavailable ',
' value:',
' array([1., 1., 1., 1., 1., 1., 1., 1.])'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(
remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
# run the model
prob['indep.x'] = np.ones(size)
prob.run_model()
# after model execution, the global shape of a distributed variable is available
# and the complete global value is available
stream = cStringIO()
with printoptions(**print_opts):
model.C2.list_inputs(hierarchical=False,
shape=True,
global_shape=True,
print_arrays=True,
out_stream=stream)
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"1 Input(s) in 'C2'", '------------------', '',
'varname value shape global_shape',
'-------- --------------- ----- ------------',
'C2.invec |3.87298334621| (8,) (15,) ',
' value:',
' array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(
remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
stream = cStringIO()
with printoptions(**print_opts):
model.C2.list_outputs(hierarchical=False,
shape=True,
global_shape=True,
print_arrays=True,
out_stream=stream)
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"1 Explicit Output(s) in 'C2'", '----------------------------',
'', 'varname value shape global_shape',
'--------- -------------- ----- ------------',
'C2.outvec |9.74679434481| (8,) (15,) ',
' value:',
' array([ 2., 2., 2., 2., 2., 2., 2., 2., -3., -3., -3., -3., -3., -3., -3.])'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(
remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
# note that the shape of the input variable for the non-distributed Summer component
# is different on each processor, use the all_procs argument to display on all processors
stream = cStringIO()
with printoptions(**print_opts):
model.C3.list_inputs(hierarchical=False,
shape=True,
global_shape=True,
all_procs=True,
print_arrays=True,
out_stream=stream)
text = stream.getvalue().split('\n')
if prob.comm.rank == 0:
norm = '|5.65685424949|'
shape = (8, )
value = '[2., 2., 2., 2., 2., 2., 2., 2.]'
else:
norm = '|7.93725393319|'
shape = (7, )
value = '[-3., -3., -3., -3., -3., -3., -3.]'
expected = [
"1 Input(s) in 'C3'",
'------------------',
'',
'varname value shape global_shape',
'-------- ------------------- ----- ------------',
'C3.invec {} {} {} '.format(norm, shape, shape),
' value:',
' array({})'.format(value),
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(
remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
assert_rel_error(self, prob['C3.out'], -5.)
def assert_partials(self, p):
with printoptions(linewidth=1024, edgeitems=100):
cpd = p.check_partials(method='cs')
assert_check_partials(cpd)
def test_array_list_vars_options(self):
class ArrayAdder(om.ExplicitComponent):
"""
Just a simple component that has array inputs and outputs
"""
def __init__(self, size):
super().__init__()
self.size = size
def setup(self):
self.add_input('x', val=np.zeros(self.size), units='inch')
self.add_output('y', val=np.zeros(self.size), units='ft')
def compute(self, inputs, outputs):
outputs['y'] = inputs['x'] + 10.0
size = 100 # how many items in the array
prob = om.Problem()
prob.model.add_subsystem('des_vars',
om.IndepVarComp('x',
np.ones(size),
units='inch'),
promotes=['x'])
prob.model.add_subsystem('mult', ArrayAdder(size), promotes=['x', 'y'])
prob.setup()
prob['x'] = np.ones(size)
prob.run_driver()
# logging inputs
# out_stream - not hierarchical - extras - no print_arrays
stream = StringIO()
prob.model.list_inputs(values=True,
units=True,
hierarchical=False,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(1, text.count("1 Input(s) in 'model'"))
self.assertEqual(1, text.count('mult.x'))
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(5, num_non_empty_lines)
# out_stream - hierarchical - extras - no print_arrays
stream = StringIO()
prob.model.list_inputs(values=True,
units=True,
hierarchical=True,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(1, text.count("1 Input(s) in 'model'"))
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(6, num_non_empty_lines)
self.assertEqual(1, text.count('\nmult'))
self.assertEqual(1, text.count('\n x'))
# logging outputs
# out_stream - not hierarchical - extras - no print_arrays
stream = StringIO()
prob.model.list_outputs(values=True,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=False,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count('2 Explicit Output'), 1)
# make sure they are in the correct order
self.assertTrue(text.find("des_vars.x") < text.find('mult.y'))
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(8, num_non_empty_lines)
# Promoted names - no print arrays
stream = StringIO()
prob.model.list_outputs(values=True,
prom_name=True,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count(' x |10.0| x'), 1)
self.assertEqual(text.count(' y |110.0| y'), 1)
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(num_non_empty_lines, 10)
# Hierarchical - no print arrays
stream = StringIO()
prob.model.list_outputs(values=True,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=True,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count('\ndes_vars'), 1)
self.assertEqual(text.count('\n x'), 1)
self.assertEqual(text.count('\nmult'), 1)
self.assertEqual(text.count('\n y'), 1)
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(num_non_empty_lines, 10)
# Need to explicitly set this to make sure all ways of running this test
# result in the same format of the output. When running this test from the
# top level via testflo, the format comes out different than if the test is
# run individually
opts = {
'edgeitems': 3,
'infstr': 'inf',
'linewidth': 75,
'nanstr': 'nan',
'precision': 8,
'suppress': False,
'threshold': 1000,
}
from distutils.version import LooseVersion
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts['legacy'] = '1.13'
with printoptions(**opts):
# logging outputs
# out_stream - not hierarchical - extras - print_arrays
stream = StringIO()
prob.model.list_outputs(values=True,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=False,
print_arrays=True,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count('2 Explicit Output'), 1)
self.assertEqual(text.count('value:'), 2)
self.assertEqual(text.count('resids:'), 2)
self.assertEqual(text.count('['), 4)
# make sure they are in the correct order
self.assertTrue(text.find("des_vars.x") < text.find('mult.y'))
num_non_empty_lines = sum(
[1 for s in text.splitlines() if s.strip()])
self.assertEqual(46, num_non_empty_lines)
# Hierarchical
stream = StringIO()
prob.model.list_outputs(values=True,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=True,
print_arrays=True,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count('2 Explicit Output'), 1)
self.assertEqual(text.count('value:'), 2)
self.assertEqual(text.count('resids:'), 2)
self.assertEqual(text.count('['), 4)
self.assertEqual(text.count('\ndes_vars'), 1)
self.assertEqual(text.count('\n x'), 1)
self.assertEqual(text.count('\nmult'), 1)
self.assertEqual(text.count('\n y'), 1)
num_non_empty_lines = sum(
[1 for s in text.splitlines() if s.strip()])
self.assertEqual(num_non_empty_lines, 48)
def test_for_docs_array_list_vars_options(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, ExplicitComponent
from openmdao.utils.general_utils import printoptions
class ArrayAdder(ExplicitComponent):
"""
Just a simple component that has array inputs and outputs
"""
def __init__(self, size):
super(ArrayAdder, self).__init__()
self.size = size
def setup(self):
self.add_input('x', val=np.zeros(self.size), units='inch')
self.add_output('y', val=np.zeros(self.size), units='ft')
def compute(self, inputs, outputs):
outputs['y'] = inputs['x'] + 10.0
size = 30
prob = Problem()
prob.model = Group()
prob.model.add_subsystem('des_vars', IndepVarComp('x', np.ones(size), units='inch'),
promotes=['x'])
prob.model.add_subsystem('mult', ArrayAdder(size), promotes=['x', 'y'])
prob.setup(check=False)
prob['x'] = np.arange(size)
prob.run_driver()
prob.model.list_inputs(values=True,
units=True,
hierarchical=True,
print_arrays=True)
with printoptions(edgeitems=3, infstr='inf',
linewidth=75, nanstr='nan', precision=8,
suppress=False, threshold=1000, formatter=None):
prob.model.list_outputs(values=True,
implicit=False,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=False,
print_arrays=True)
prob.model.list_outputs(values=True,
implicit=False,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=True,
print_arrays=True)
def test_parallel_list_vars(self):
print_opts = {'linewidth': 1024, 'precision': 1}
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
print_opts['legacy'] = '1.13'
prob = om.Problem(FanOutGrouped())
# add another subsystem with similar prefix
prob.model.add_subsystem('sub2', om.ExecComp(['y=x']))
prob.model.connect('iv.x', 'sub2.x')
prob.setup()
prob.run_model()
#
# list inputs, not hierarchical
#
stream = StringIO()
with printoptions(**print_opts):
prob.model.list_inputs(values=True, hierarchical=False, out_stream=stream)
with multi_proc_exception_check(prob.comm):
if prob.comm.rank == 0: # Only rank 0 prints
text = stream.getvalue().split('\n')
expected = [
"6 Input(s) in 'model'",
'',
'varname val',
'-------- -----',
'c1.x',
'sub.c2.x',
'sub.c3.x',
'c2.x',
'c3.x',
'sub2.x'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertTrue(text[i].startswith(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
#
# list inputs, hierarchical
#
stream = StringIO()
with printoptions(**print_opts):
prob.model.list_inputs(values=True, hierarchical=True, out_stream=stream)
with multi_proc_exception_check(prob.comm):
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"6 Input(s) in 'model'",
'',
'varname val',
'------- -----',
'c1',
' x',
'sub',
' c2',
' x',
' c3',
' x',
'c2',
' x',
'c3',
' x',
'sub2',
' x'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertTrue(text[i].startswith(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
#
# list outputs, not hierarchical
#
stream = StringIO()
with printoptions(**print_opts):
prob.model.list_outputs(values=True, residuals=True, hierarchical=False, out_stream=stream)
with multi_proc_exception_check(prob.comm):
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"7 Explicit Output(s) in 'model'",
'',
'varname val resids',
'-------- ---- ------',
'iv.x',
'c1.y',
'sub.c2.y',
'sub.c3.y',
'c2.y',
'c3.y',
'sub2.y',
'',
'',
"0 Implicit Output(s) in 'model'",
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertTrue(text[i].startswith(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
#
# list outputs, hierarchical
#
stream = StringIO()
with printoptions(**print_opts):
prob.model.list_outputs(values=True, residuals=True, hierarchical=True, out_stream=stream)
with multi_proc_exception_check(prob.comm):
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"7 Explicit Output(s) in 'model'",
'',
'varname val resids',
'------- ----- ------',
'iv',
' x',
'c1',
' y',
'sub',
' c2',
' y',
' c3',
' y',
'c2',
' y',
'c3',
' y',
'sub2',
' y',
'',
'',
"0 Implicit Output(s) in 'model'",
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertTrue(text[i].startswith(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
def view_connections(root, outfile='connections.html', show_browser=True,
src_filter='', tgt_filter='', precision=6):
"""
Generates a self-contained html file containing a detailed connection
viewer. Optionally pops up a web browser to view the file.
Parameters
----------
root : system or Problem
The root for the desired tree.
outfile : str, optional
The name of the output html file. Defaults to 'connections.html'.
show_browser : bool, optional
If True, pop up a browser to view the generated html file.
Defaults to True.
src_filter : str, optional
If defined, use this as the initial value for the source system filter.
tgt_filter : str, optional
If defined, use this as the initial value for the target system filter.
precision : int, optional
Sets the precision for displaying array values.
"""
if MPI and MPI.COMM_WORLD.rank != 0:
return
# since people will be used to passing the Problem as the first arg to
# the N2 diagram funct, allow them to pass a Problem here as well.
if isinstance(root, Problem):
system = root.model
else:
system = root
input_srcs = system._conn_global_abs_in2out
connections = {
tgt: src for tgt, src in iteritems(input_srcs) if src is not None
}
src2tgts = defaultdict(list)
units = {n: data.get('units','')
for n, data in iteritems(system._var_allprocs_abs2meta)}
vals = {}
with printoptions(precision=precision, suppress=True, threshold=10000):
for t in system._var_abs_names['input']:
tmeta = system._var_abs2meta[t]
idxs = tmeta['src_indices']
if t in connections:
s = connections[t]
val = _get_output(system, s, idxs)
# if there's a unit conversion, express the value in the
# units of the target
if units[t] and val != "<on remote_proc>":
val = convert_units(val, units[s], units[t])
src2tgts[s].append(t)
else: # unconnected param
val = _get_input(system, t, None)
if isinstance(val, np.ndarray):
val = np.array2string(val)
else:
val = str(val)
vals[t] = val
noconn_srcs = sorted((n for n in system._var_abs_names['output']
if n not in src2tgts), reverse=True)
for s in noconn_srcs:
vals[s] = str(system._outputs[s])
vals['NO CONNECTION'] = ''
src_systems = set()
tgt_systems = set()
for s in system._var_abs_names['output']:
parts = s.split('.')
for i in range(len(parts)):
src_systems.add('.'.join(parts[:i]))
for t in system._var_abs_names['input']:
parts = t.split('.')
for i in range(len(parts)):
tgt_systems.add('.'.join(parts[:i]))
# reverse sort so that "NO CONNECTION" shows up at the bottom
src2tgts['NO CONNECTION'] = sorted([t for t in system._var_abs_names['input']
if t not in connections], reverse=True)
src_systems = [{'name':n} for n in sorted(src_systems)]
src_systems.insert(1, {'name': "NO CONNECTION"})
tgt_systems = [{'name':n} for n in sorted(tgt_systems)]
tgt_systems.insert(1, {'name': "NO CONNECTION"})
data = {
'src2tgts': sorted(iteritems(src2tgts)),
'proms': None,
'units': units,
'vals': vals,
'src_systems': src_systems,
'tgt_systems': tgt_systems,
'noconn_srcs': noconn_srcs,
'src_filter': src_filter,
'tgt_filter': tgt_filter,
}
viewer = 'connect_table.html'
code_dir = os.path.dirname(os.path.abspath(__file__))
with open(os.path.join(code_dir, viewer), "r") as f:
template = f.read()
graphjson = json.dumps(data)
with open(outfile, 'w') as f:
s = template.replace("<connection_data>", graphjson)
f.write(s)
if show_browser:
webview(outfile)
def test_distribcomp_list_vars(self):
print_opts = {'linewidth': 1024}
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
print_opts['legacy'] = '1.13'
size = 15
model = om.Group()
model.add_subsystem("indep", om.IndepVarComp('x', np.zeros(size)))
model.add_subsystem("C2", DistribComp(size=size))
model.add_subsystem("C3", Summer(size=size))
model.connect('indep.x', 'C2.invec')
model.connect('C2.outvec', 'C3.invec', src_indices=om.slicer[:])
prob = om.Problem(model)
prob.setup()
# prior to model execution, the global shape of a distributed variable is not available
# and only the local portion of the value is available
stream = StringIO()
with printoptions(**print_opts):
model.C2.list_inputs(hierarchical=False, shape=True, global_shape=True,
print_arrays=True, out_stream=stream)
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"1 Input(s) in 'C2'",
'',
'varname val shape global_shape',
'------- --------------- ----- ------------',
'invec |3.87298334621| (8,) (15,)',
' val:',
' array([ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
stream = StringIO()
with printoptions(**print_opts):
model.C2.list_outputs(hierarchical=False, shape=True, global_shape=True,
print_arrays=True, out_stream=stream)
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"1 Explicit Output(s) in 'C2'",
'',
'varname val shape global_shape',
'------- --------------- ----- ------------',
'outvec |3.87298334621| (8,) (15,)',
' val:',
' array([ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
# run the model
prob['indep.x'] = np.ones(size)
prob.run_model()
# after model execution, the global shape of a distributed variable is available
# and the complete global value is available
stream = StringIO()
with printoptions(**print_opts):
model.C2.list_inputs(hierarchical=False, shape=True, global_shape=True,
print_arrays=True, out_stream=stream)
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"1 Input(s) in 'C2'",
'',
'varname val shape global_shape',
'------- --------------- ----- ------------',
'invec |3.87298334621| (8,) (15,)',
' val:',
' array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
stream = StringIO()
with printoptions(**print_opts):
model.C2.list_outputs(hierarchical=False, shape=True, global_shape=True,
print_arrays=True, out_stream=stream)
if prob.comm.rank == 0:
text = stream.getvalue().split('\n')
expected = [
"1 Explicit Output(s) in 'C2'",
'',
'varname val shape global_shape',
'------- -------------- ----- ------------',
'outvec |9.74679434481| (8,) (15,)',
' val:',
' array([ 2., 2., 2., 2., 2., 2., 2., 2., -3., -3., -3., -3., -3., -3., -3.])'
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
stream = StringIO()
with printoptions(**print_opts):
model.C3.list_inputs(hierarchical=False, shape=True, global_shape=True, all_procs=True,
print_arrays=True, out_stream=stream)
text = stream.getvalue().split('\n')
print('\n'.join(text))
norm = '|9.74679434481|'
shape = (15,)
value = '[2., 2., 2., 2., 2., 2., 2., 2., -3., -3., -3., -3., -3., -3., -3.]'
expected = [
"1 Input(s) in 'C3'",
'',
'varname val shape global_shape',
'------- ------------------- ----- ------------',
'invec {} {} {} '.format(norm, shape, shape),
' val:',
' array({})'.format(value),
]
for i, line in enumerate(expected):
if line and not line.startswith('-'):
self.assertEqual(remove_whitespace(text[i]), remove_whitespace(line),
'\nExpected: %s\nReceived: %s\n' % (line, text[i]))
assert_near_equal(prob['C3.sum'], -5.)
def run_code(code_to_run, path, module=None, cls=None, shows_plot=False, imports_not_required=False):
"""
Run the given code chunk and collect the output.
"""
skipped = False
failed = False
if cls is None:
use_mpi = False
else:
try:
import mpi4py
except ImportError:
use_mpi = False
else:
N_PROCS = getattr(cls, 'N_PROCS', 1)
use_mpi = N_PROCS > 1
try:
# use subprocess to run code to avoid any nasty interactions between codes
# Move to the test directory in case there are files to read.
save_dir = os.getcwd()
if module is None:
code_dir = os.path.dirname(os.path.abspath(path))
else:
code_dir = os.path.dirname(os.path.abspath(module.__file__))
os.chdir(code_dir)
if use_mpi:
env = os.environ.copy()
# output will be written to one file per process
env['USE_PROC_FILES'] = '1'
env['OPENMDAO_CURRENT_MODULE'] = module.__name__
env['OPENMDAO_CODE_TO_RUN'] = code_to_run
p = subprocess.Popen(['mpirun', '-n', str(N_PROCS), 'python', _sub_runner],
env=env)
p.wait()
# extract output blocks from all output files & merge them
output = []
for i in range(N_PROCS):
with open('%d.out' % i) as f:
output.append(f.read())
os.remove('%d.out' % i)
elif shows_plot:
if module is None:
# write code to a file so we can run it.
fd, code_to_run_path = tempfile.mkstemp()
with os.fdopen(fd, 'w') as tmp:
tmp.write(code_to_run)
try:
p = subprocess.Popen(['python', code_to_run_path],
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=os.environ)
output, _ = p.communicate()
if p.returncode != 0:
failed = True
finally:
os.remove(code_to_run_path)
else:
env = os.environ.copy()
env['OPENMDAO_CURRENT_MODULE'] = module.__name__
env['OPENMDAO_CODE_TO_RUN'] = code_to_run
p = subprocess.Popen(['python', _sub_runner],
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env)
output, _ = p.communicate()
if p.returncode != 0:
failed = True
output = output.decode('utf-8', 'ignore')
else:
# just exec() the code for serial tests.
# capture all output
stdout = sys.stdout
stderr = sys.stderr
strout = cStringIO()
sys.stdout = strout
sys.stderr = strout
# We need more precision from numpy
with printoptions(precision=8):
if module is None:
globals_dict = {
'__file__': path,
'__name__': '__main__',
'__package__': None,
'__cached__': None,
}
else:
if imports_not_required:
# code does not need to include all imports
# Get from module
globals_dict = module.__dict__
else:
globals_dict = {}
try:
exec(code_to_run, globals_dict)
except Exception:
# print code (with line numbers) to facilitate debugging
for n, line in enumerate(code_to_run.split('\n')):
print('%4d: %s' % (n, line), file=stderr)
raise
finally:
sys.stdout = stdout
sys.stderr = stderr
output = strout.getvalue()
except subprocess.CalledProcessError as e:
output = e.output.decode('utf-8', 'ignore')
# Get a traceback.
if 'raise unittest.SkipTest' in output:
reason_for_skip = output.splitlines()[-1][len('unittest.case.SkipTest: '):]
output = reason_for_skip
skipped = True
else:
output = "Running of embedded code {} in docs failed due to: \n\n{}".format(path, output)
failed = True
except unittest.SkipTest as skip:
output = str(skip)
skipped = True
except Exception as exc:
output = "Running of embedded code {} in docs failed due to: \n\n{}".format(path, traceback.format_exc())
failed = True
finally:
os.chdir(save_dir)
return skipped, failed, output
def view_connections(root, outfile='connections.html', show_browser=True,
show_values=True, precision=6, title=None):
"""
Generate a self-contained html file containing a detailed connection viewer.
Optionally pops up a web browser to view the file.
Parameters
----------
root : system or Problem
The root for the desired tree.
outfile : str, optional
The name of the output html file. Defaults to 'connections.html'.
show_browser : bool, optional
If True, pop up a browser to view the generated html file.
Defaults to True.
show_values : bool, optional
If True, retrieve the values and display them.
precision : int, optional
Sets the precision for displaying array values.
title : str, optional
Sets the title of the web page.
"""
if MPI and MPI.COMM_WORLD.rank != 0:
return
# since people will be used to passing the Problem as the first arg to
# the N2 diagram funct, allow them to pass a Problem here as well.
if isinstance(root, Problem):
system = root.model
else:
system = root
connections = system._problem_meta['model_ref']()._conn_global_abs_in2out
src2tgts = defaultdict(list)
units = defaultdict(lambda: '')
for io in ('input', 'output'):
for n, data in system._var_allprocs_abs2meta[io].items():
u = data.get('units', '')
if u is not None:
units[n] = u
vals = {}
prefix = system.pathname + '.' if system.pathname else ''
all_vars = {}
for io in ('input', 'output'):
all_vars[io] = chain(system._var_abs2meta[io].items(),
[(prefix + n, m) for n, m in system._var_discrete[io].items()])
with printoptions(precision=precision, suppress=True, threshold=10000):
for t, meta in all_vars['input']:
s = connections[t]
if show_values:
if s.startswith('_auto_ivc.'):
val = system.get_val(t, flat=True, get_remote=True,
from_src=False)
else:
val = system.get_val(t, flat=True, get_remote=True)
# if there's a unit conversion, express the value in the
# units of the target
if units[t] and s in system._outputs:
val = system.get_val(t, flat=True, units=units[t], get_remote=True)
else:
val = system.get_val(t, flat=True, get_remote=True)
else:
val = ''
src2tgts[s].append(t)
vals[t] = val
NOCONN = '[NO CONNECTION]'
vals[NOCONN] = ''
src_systems = set()
tgt_systems = set()
for s, _ in all_vars['output']:
parts = s.split('.')
for i in range(len(parts)):
src_systems.add('.'.join(parts[:i]))
for t, _ in all_vars['input']:
parts = t.split('.')
for i in range(len(parts)):
tgt_systems.add('.'.join(parts[:i]))
src_systems = [{'name': n} for n in sorted(src_systems)]
src_systems.insert(1, {'name': NOCONN})
tgt_systems = [{'name': n} for n in sorted(tgt_systems)]
tgt_systems.insert(1, {'name': NOCONN})
tprom = system._var_allprocs_abs2prom['input']
sprom = system._var_allprocs_abs2prom['output']
table = []
idx = 1 # unique ID for use by Tabulator
for tgt, src in connections.items():
usrc = units[src]
utgt = units[tgt]
if usrc != utgt:
# prepend these with '!' so they'll be colored red
if usrc:
usrc = '!' + units[src]
if utgt:
utgt = '!' + units[tgt]
row = {'id': idx, 'src': src, 'sprom': sprom[src], 'sunits': usrc,
'val': _val2str(vals[tgt]), 'tunits': utgt,
'tprom': tprom[tgt], 'tgt': tgt}
table.append(row)
idx += 1
# add rows for unconnected sources
for src, _ in all_vars['output']:
if src not in src2tgts:
if show_values:
v = _val2str(system._abs_get_val(src))
else:
v = ''
row = {'id': idx, 'src': src, 'sprom': sprom[src], 'sunits': units[src],
'val': v, 'tunits': '', 'tprom': NOCONN, 'tgt': NOCONN}
table.append(row)
idx += 1
if title is None:
title = ''
data = {
'title': title,
'table': table,
'show_values': show_values,
}
viewer = 'connect_table.html'
code_dir = os.path.dirname(os.path.abspath(__file__))
libs_dir = os.path.join(os.path.dirname(code_dir), 'common', 'libs')
style_dir = os.path.join(os.path.dirname(code_dir), 'common', 'style')
with open(os.path.join(code_dir, viewer), "r") as f:
template = f.read()
with open(os.path.join(libs_dir, 'tabulator.min.js'), "r") as f:
tabulator_src = f.read()
with open(os.path.join(style_dir, 'tabulator.min.css'), "r") as f:
tabulator_style = f.read()
jsontxt = json.dumps(data)
with open(outfile, 'w') as f:
s = template.replace("<connection_data>", jsontxt)
s = s.replace("<tabulator_src>", tabulator_src)
s = s.replace("<tabulator_style>", tabulator_style)
f.write(s)
if notebook:
# display in Jupyter Notebook
if not colab:
display(IFrame(src=outfile, width=1000, height=1000))
else:
display(HTML(outfile))
elif show_browser:
# open it up in the browser
from openmdao.utils.webview import webview
webview(outfile)
def test_array_list_vars_options(self):
class ArrayAdder(ExplicitComponent):
"""
Just a simple component that has array inputs and outputs
"""
def __init__(self, size):
super(ArrayAdder, self).__init__()
self.size = size
def setup(self):
self.add_input('x', val=np.zeros(self.size), units='inch')
self.add_output('y', val=np.zeros(self.size), units='ft')
def compute(self, inputs, outputs):
outputs['y'] = inputs['x'] + 10.0
size = 100 # how many items in the array
prob = Problem()
prob.model = Group()
prob.model.add_subsystem('des_vars', IndepVarComp('x', np.ones(size), units='inch'),
promotes=['x'])
prob.model.add_subsystem('mult', ArrayAdder(size), promotes=['x', 'y'])
prob.setup(check=False)
prob['x'] = np.ones(size)
prob.run_driver()
# logging inputs
# out_stream - not hierarchical - extras - no print_arrays
stream = cStringIO()
prob.model.list_inputs(values=True,
units=True,
hierarchical=False,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(1, text.count("1 Input(s) in 'model'"))
self.assertEqual(1, text.count('mult.x'))
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(5, num_non_empty_lines)
# out_stream - hierarchical - extras - no print_arrays
stream = cStringIO()
prob.model.list_inputs(values=True,
units=True,
hierarchical=True,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(1, text.count("1 Input(s) in 'model'"))
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(7, num_non_empty_lines)
self.assertEqual(1, text.count('top'))
self.assertEqual(1, text.count(' mult'))
self.assertEqual(1, text.count(' x'))
# logging outputs
# out_stream - not hierarchical - extras - no print_arrays
stream = cStringIO()
prob.model.list_outputs(values=True,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=False,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count('2 Explicit Output'), 1)
# make sure they are in the correct order
self.assertTrue(text.find("des_vars.x") < text.find('mult.y'))
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(8, num_non_empty_lines)
# Promoted names - no print arrays
stream = cStringIO()
prob.model.list_outputs(values=True,
prom_name=True,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count(' x |10.0| x'), 1)
self.assertEqual(text.count(' y |110.0| y'), 1)
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(num_non_empty_lines, 11)
# Hierarchical - no print arrays
stream = cStringIO()
prob.model.list_outputs(values=True,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=True,
print_arrays=False,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count('top'), 1)
self.assertEqual(text.count(' des_vars'), 1)
self.assertEqual(text.count(' x'), 1)
self.assertEqual(text.count(' mult'), 1)
self.assertEqual(text.count(' y'), 1)
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(num_non_empty_lines, 11)
# Need to explicitly set this to make sure all ways of running this test
# result in the same format of the output. When running this test from the
# top level via testflo, the format comes out different than if the test is
# run individually
opts = {
'edgeitems': 3,
'infstr': 'inf',
'linewidth': 75,
'nanstr': 'nan',
'precision': 8,
'suppress': False,
'threshold': 1000,
}
from distutils.version import LooseVersion
if LooseVersion(np.__version__) >= LooseVersion("1.14"):
opts['legacy'] = '1.13'
with printoptions(**opts):
# logging outputs
# out_stream - not hierarchical - extras - print_arrays
stream = cStringIO()
prob.model.list_outputs(values=True,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=False,
print_arrays=True,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count('2 Explicit Output'), 1)
self.assertEqual(text.count('value:'), 2)
self.assertEqual(text.count('resids:'), 2)
self.assertEqual(text.count('['), 4)
# make sure they are in the correct order
self.assertTrue(text.find("des_vars.x") < text.find('mult.y'))
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(37, num_non_empty_lines)
# Hierarchical
stream = cStringIO()
prob.model.list_outputs(values=True,
units=True,
shape=True,
bounds=True,
residuals=True,
scaling=True,
hierarchical=True,
print_arrays=True,
out_stream=stream)
text = stream.getvalue()
self.assertEqual(text.count('2 Explicit Output'), 1)
self.assertEqual(text.count('value:'), 2)
self.assertEqual(text.count('resids:'), 2)
self.assertEqual(text.count('['), 4)
self.assertEqual(text.count('top'), 1)
self.assertEqual(text.count(' des_vars'), 1)
self.assertEqual(text.count(' x'), 1)
self.assertEqual(text.count(' mult'), 1)
self.assertEqual(text.count(' y'), 1)
num_non_empty_lines = sum([1 for s in text.splitlines() if s.strip()])
self.assertEqual(num_non_empty_lines, 40)
def run_code(code_to_run,
path,
module=None,
cls=None,
shows_plot=False,
imports_not_required=False):
"""
Run the given code chunk and collect the output.
"""
skipped = False
failed = False
if cls is None:
use_mpi = False
else:
try:
import mpi4py
except ImportError:
use_mpi = False
else:
N_PROCS = getattr(cls, 'N_PROCS', 1)
use_mpi = N_PROCS > 1
try:
# use subprocess to run code to avoid any nasty interactions between codes
# Move to the test directory in case there are files to read.
save_dir = os.getcwd()
if module is None:
code_dir = os.path.dirname(os.path.abspath(path))
else:
code_dir = os.path.dirname(os.path.abspath(module.__file__))
os.chdir(code_dir)
if use_mpi:
env = os.environ.copy()
# output will be written to one file per process
env['USE_PROC_FILES'] = '1'
env['OPENMDAO_CURRENT_MODULE'] = module.__name__
env['OPENMDAO_CODE_TO_RUN'] = code_to_run
p = subprocess.Popen(
['mpirun', '-n',
str(N_PROCS), sys.executable, _sub_runner],
env=env)
p.wait()
# extract output blocks from all output files & merge them
output = []
for i in range(N_PROCS):
with open('%d.out' % i) as f:
output.append(f.read())
os.remove('%d.out' % i)
elif shows_plot:
if module is None:
# write code to a file so we can run it.
fd, code_to_run_path = tempfile.mkstemp()
with os.fdopen(fd, 'w') as tmp:
tmp.write(code_to_run)
try:
p = subprocess.Popen([sys.executable, code_to_run_path],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=os.environ)
output, _ = p.communicate()
if p.returncode != 0:
failed = True
finally:
os.remove(code_to_run_path)
else:
env = os.environ.copy()
env['OPENMDAO_CURRENT_MODULE'] = module.__name__
env['OPENMDAO_CODE_TO_RUN'] = code_to_run
p = subprocess.Popen([sys.executable, _sub_runner],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=env)
output, _ = p.communicate()
if p.returncode != 0:
failed = True
output = output.decode('utf-8', 'ignore')
else:
# just exec() the code for serial tests.
# capture all output
stdout = sys.stdout
stderr = sys.stderr
strout = cStringIO()
sys.stdout = strout
sys.stderr = strout
# We need more precision from numpy
with printoptions(precision=8):
if module is None:
globals_dict = {
'__file__': path,
'__name__': '__main__',
'__package__': None,
'__cached__': None,
}
else:
if imports_not_required:
# code does not need to include all imports
# Get from module
globals_dict = module.__dict__
else:
globals_dict = {}
try:
exec(code_to_run, globals_dict)
except Exception as err:
# for actual errors, print code (with line numbers) to facilitate debugging
if not isinstance(err, unittest.SkipTest):
for n, line in enumerate(code_to_run.split('\n')):
print('%4d: %s' % (n, line), file=stderr)
raise
finally:
sys.stdout = stdout
sys.stderr = stderr
output = strout.getvalue()
except subprocess.CalledProcessError as e:
output = e.output.decode('utf-8', 'ignore')
# Get a traceback.
if 'raise unittest.SkipTest' in output:
reason_for_skip = output.splitlines(
)[-1][len('unittest.case.SkipTest: '):]
output = reason_for_skip
skipped = True
else:
output = "Running of embedded code {} in docs failed due to: \n\n{}".format(
path, output)
failed = True
except unittest.SkipTest as skip:
output = str(skip)
skipped = True
except Exception as exc:
output = "Running of embedded code {} in docs failed due to: \n\n{}".format(
path, traceback.format_exc())
failed = True
finally:
os.chdir(save_dir)
return skipped, failed, output
module_path = os.environ.get("OPENMDAO_CURRENT_MODULE", "").strip()
if module_path:
stdout_save = sys.stdout
# send any output to dev/null during the import so it doesn't clutter our embedded code output
with open(os.devnull, "w") as f:
sys.stdout = f
mod = importlib.import_module(module_path)
sys.stdout = stdout_save
else:
raise RuntimeError("OPENMDAO_CURRENT_MODULE was not specified.")
if os.environ.get("USE_PROC_FILES"):
from openmdao.utils.mpi import use_proc_files
use_proc_files()
code_to_run = os.environ.get("OPENMDAO_CODE_TO_RUN", "").strip()
if not code_to_run:
raise RuntimeError("OPENMDAO_CODE_TO_RUN has not been set.")
with printoptions(precision=8):
exec(code_to_run, mod.__dict__)
except Exception:
traceback.print_exc()
sys.exit(-1)
sys.exit(0)
