def test_betz_derivatives(self):
from openmdao.api import Problem, IndepVarComp
from openmdao.test_suite.test_examples.test_betz_limit import ActuatorDisc
prob = Problem()
prob.model.add_subsystem('a_disk', ActuatorDisc())
prob.setup()
prob.check_partials(compact_print=True)
def test_check_partials_for_docs(self):
from openmdao.api import Problem
from openmdao.test_suite.components.quad_implicit import QuadraticComp
p = Problem()
p.model.add_subsystem('quad', QuadraticComp())
p.setup()
p.check_partials(compact_print=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)
np.set_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_compute_jacvec_product_inputs_read_only_reset(self):
class BadComp(RectangleJacVec):
def compute_jacvec_product(self, inputs, d_inputs, d_outputs, mode):
super(BadComp, self).compute_jacvec_product(inputs, d_inputs, d_outputs, mode)
raise AnalysisError("It's just a scratch.")
prob = Problem(BadComp())
prob.setup()
prob.run_model()
with self.assertRaises(AnalysisError):
prob.check_partials()
# verify read_only status is reset after AnalysisError
prob['length'] = 111.
def test_compute_partials_inputs_read_only_reset(self):
class BadComp(TestExplCompSimpleDense):
def compute_partials(self, inputs, partials):
super(BadComp, self).compute_partials(inputs, partials)
raise AnalysisError("It's just a scratch.")
prob = Problem(BadComp())
prob.setup()
prob.run_model()
with self.assertRaises(AnalysisError):
prob.check_partials()
# verify read_only status is reset after AnalysisError
prob['length'] = 111.
def test_vectorized(self):
prob = Problem()
prob.model = model = Group()
x = np.zeros((3, 5))
x[0, :] = np.array([3.0, 5.0, 11.0, 13.0, 17.0])
x[1, :] = np.array([13.0, 11.0, 5.0, 17.0, 3.0])*2
x[2, :] = np.array([11.0, 3.0, 17.0, 5.0, 13.0])*3
model.add_subsystem('px', IndepVarComp(name="x", val=x))
model.add_subsystem('ks', KSComp(width=5, vec_size=3))
model.connect('px.x', 'ks.g')
model.add_design_var('px.x')
model.add_constraint('ks.KS', upper=0.0)
prob.setup(check=False)
prob.run_driver()
assert_rel_error(self, prob['ks.KS'][0], 17.0)
assert_rel_error(self, prob['ks.KS'][1], 34.0)
assert_rel_error(self, prob['ks.KS'][2], 51.0)
partials = prob.check_partials(includes=['ks'], out_stream=None)
for (of, wrt) in partials['ks']:
assert_rel_error(self, partials['ks'][of, wrt]['abs error'][0], 0.0, 1e-6)
def test_sellar_idf(self):
prob = Problem(SellarIDF())
prob.driver = ScipyOptimizeDriver(optimizer='SLSQP', disp=False)
prob.setup()
# check derivatives
prob['dv.y1'] = 100
prob['equal.rhs:y1'] = 1
prob.run_model()
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['equal']:
assert_almost_equal(cpd['equal'][of, wrt]['abs error'], 0.0, decimal=5)
assert_check_partials(cpd, atol=1e-5, rtol=1e-5)
# check results
prob.run_driver()
assert_rel_error(self, prob['dv.x'], 0., 1e-5)
assert_rel_error(self, prob['dv.z'], [1.977639, 0.], 1e-5)
assert_rel_error(self, prob['obj_cmp.obj'], 3.18339395045, 1e-5)
assert_almost_equal(prob['dv.y1'], 3.16)
assert_almost_equal(prob['d1.y1'], 3.16)
assert_almost_equal(prob['dv.y2'], 3.7552778)
assert_almost_equal(prob['d2.y2'], 3.7552778)
assert_almost_equal(prob['equal.y1'], 0.0)
assert_almost_equal(prob['equal.y2'], 0.0)
def test_vectorized_rhs_val(self):
prob = Problem()
model = prob.model
n = 100
# find where x^2 == 4, vectorized
model.add_subsystem('indep', IndepVarComp('x', val=np.ones(n)))
model.add_subsystem('f', ExecComp('y=x**2', x=np.ones(n), y=np.ones(n)))
model.add_subsystem('equal', EQConstraintComp('y', val=np.ones(n),
rhs_val=np.ones(n)*4., use_mult=True, mult_val=2.))
model.add_subsystem('obj_cmp', ExecComp('obj=sum(y)', y=np.zeros(n)))
model.connect('indep.x', 'f.x')
model.connect('indep.x', 'equal.lhs:y')
model.connect('f.y', 'obj_cmp.y')
model.add_design_var('indep.x', lower=np.zeros(n), upper=np.ones(n)*10.)
model.add_constraint('equal.y', equals=0.)
model.add_objective('obj_cmp.obj')
prob.setup(mode='fwd')
prob.driver = ScipyOptimizeDriver(disp=False)
prob.run_driver()
assert_rel_error(self, prob['equal.y'], np.zeros(n), 1e-6)
assert_rel_error(self, prob['indep.x'], np.ones(n)*2., 1e-6)
assert_rel_error(self, prob['f.y'], np.ones(n)*4., 1e-6)
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['equal']:
assert_almost_equal(cpd['equal'][of, wrt]['abs error'], 0.0, decimal=5)
def test_rhs_val(self):
prob = Problem()
model = prob.model
# find where x^2 == 4
model.add_subsystem('indep', IndepVarComp('x', val=1.))
model.add_subsystem('f', ExecComp('y=x**2', x=1.))
model.add_subsystem('equal', EQConstraintComp('y', rhs_val=4.))
model.connect('indep.x', 'f.x')
model.connect('f.y', 'equal.lhs:y')
model.add_design_var('indep.x', lower=0., upper=10.)
model.add_constraint('equal.y', equals=0.)
model.add_objective('f.y')
prob.setup(mode='fwd')
prob.driver = ScipyOptimizeDriver(disp=False)
prob.run_driver()
assert_rel_error(self, prob['equal.y'], 0., 1e-6)
assert_rel_error(self, prob['indep.x'], 2., 1e-6)
assert_rel_error(self, prob['f.y'], 4., 1e-6)
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['equal']:
assert_almost_equal(cpd['equal'][of, wrt]['abs error'], 0.0, decimal=5)
assert_check_partials(cpd, atol=1e-5, rtol=1e-5)
def test_detailed(self):
""" This is a longer version of the previous method, with plotting. """
# Load in default lifting surfaces to setup the comparison
surfaces = get_default_surfaces()
# Instantiate an OpenMDAO problem and add the component we want to test
# as asubsystem, giving that component a default lifting surface
prob = Problem()
prob.model.add_subsystem('tube', SectionPropertiesTube(surface=surfaces[0]))
# Set up the problem and ensure it uses complex arrays so we can check
# the derivatives using complex step
prob.setup(force_alloc_complex=True)
# Actually run the model, which is just a component in this case, then
# check the derivatives and store the results in the `check` dict
prob.run_model()
check = prob.check_partials(compact_print=False)
# Loop through this `check` dictionary and visualize the approximated
# and computed derivatives
for key, subjac in iteritems(check[list(check.keys())[0]]):
print()
print(key)
view_mat(subjac['J_fd'],subjac['J_fwd'],key)
# Loop through the `check` dictionary and perform assert that the
# approximated deriv must be very close to the computed deriv
for key, subjac in iteritems(check[list(check.keys())[0]]):
if subjac['magnitude'].fd > 1e-6:
assert_almost_equal(
subjac['rel error'].forward, 0., err_msg='deriv of %s wrt %s' % key)
assert_almost_equal(
subjac['rel error'].reverse, 0., err_msg='deriv of %s wrt %s' % key)
def test_complex_step(self):
prob = Problem()
model = prob.model
# find where 2*x == x^2
model.add_subsystem('indep', IndepVarComp('x', val=1.))
model.add_subsystem('multx', IndepVarComp('m', val=2.))
model.add_subsystem('f', ExecComp('y=x**2', x=1.))
model.add_subsystem('equal', EQConstraintComp('y', use_mult=True))
model.connect('indep.x', 'f.x')
model.connect('indep.x', 'equal.lhs:y')
model.connect('multx.m', 'equal.mult:y')
model.connect('f.y', 'equal.rhs:y')
model.add_design_var('indep.x', lower=0., upper=10.)
model.add_constraint('equal.y', equals=0.)
model.add_objective('f.y')
prob.setup(mode='fwd', force_alloc_complex=True)
prob.driver = ScipyOptimizeDriver(disp=False)
prob.run_driver()
with warnings.catch_warnings():
warnings.filterwarnings(action="error", category=np.ComplexWarning)
cpd = prob.check_partials(out_stream=None, method='cs')
assert_check_partials(cpd, atol=1e-10, rtol=1e-10)
def test_create_on_init_no_normalization(self):
prob = Problem(model=Group())
bal = BalanceComp('x', val=1.0, normalize=False)
tgt = IndepVarComp(name='y_tgt', val=1.5)
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(iprint=0)
prob.setup()
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(1.5), decimal=7)
assert_almost_equal(prob.model.balance._scale_factor, 1.0)
cpd = prob.check_partials(out_stream=None)
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)
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'], 0.0, decimal=5)
def test_rk_with_time_invariant(self):
np.random.seed(1)
indeps = IndepVarComp()
rktest = RKTest(NTIME)
indeps.add_output('yi', np.random.random((2, 3)))
indeps.add_output('yv', np.random.random((2, NTIME)))
indeps.add_output('x0', np.random.random((2,)))
prob = Problem()
prob.model.add_subsystem('indeps', indeps, promotes=['*'])
prob.model.add_subsystem('rktest', rktest, promotes=['*'])
prob.setup()
prob.run_model()
# check partials
partials = prob.check_partials(out_stream=None)
assert_check_partials(partials, atol=6e-5, rtol=6e-5)
# check totals
inputs = ['yi', 'yv', 'x0']
outputs = ['x']
J = prob.check_totals(of=outputs, wrt=inputs, out_stream=None)
for outp in outputs:
for inp in inputs:
Jn = J[outp, inp]['J_fd']
Jf = J[outp, inp]['J_fwd']
diff = abs(Jf - Jn)
assert_rel_error(self, diff.max(), 0.0, 6e-5)
def test_exec_comp_jac(self, f):
test_data = _ufunc_test_data[f]
prob = Problem()
prob.model = model = Group()
if len(test_data['args']) > 1:
ivc = model.add_subsystem(name='ivc', subsys=IndepVarComp())
for arg_name, arg_value in iteritems(test_data['args']):
if arg_name == 'f':
continue
ivc.add_output(name=arg_name, val=arg_value['value'])
model.connect('ivc.{0}'.format(arg_name),
'{0}_comp.{1}'.format(f, arg_name))
model.add_subsystem('{0}_comp'.format(f),
ExecComp(test_data['str'], **test_data['args']),
promotes_outputs=['f'])
prob.setup()
prob.run_model()
if 'check_val' not in test_data:
cpd = prob.check_partials(compact_print=True)
for comp in cpd:
for (var, wrt) in cpd[comp]:
np.testing.assert_almost_equal(cpd[comp][var, wrt]['abs error'], 0, decimal=4)
def test_solve_linear(self):
"""Check against solve_linear."""
x = np.array([1, 2, -3])
A = np.array([[1., 1., 1.], [1., 2., 3.], [0., 1., 3.]])
b = A.dot(x)
b_T = A.T.dot(x)
lin_sys_comp = LinearSystemComp(size=3)
prob = Problem()
prob.model.add_subsystem('p1', IndepVarComp('A', A))
prob.model.add_subsystem('p2', IndepVarComp('b', b))
lingrp = prob.model.add_subsystem('lingrp', Group(), promotes=['*'])
lingrp.add_subsystem('lin', lin_sys_comp)
prob.model.connect('p1.A', 'lin.A')
prob.model.connect('p2.b', 'lin.b')
prob.setup(check=False)
prob.set_solver_print(level=0)
prob.run_model()
prob.model.run_linearize()
# Compare against calculated derivs
Ainv = np.array([[3., -2., 1.],
[-3., 3., -2.],
[1., -1., 1.]])
dx_dA = np.outer(Ainv, -x).reshape(3, 9)
dx_db = Ainv
d_inputs, d_outputs, d_residuals = lingrp.get_linear_vectors()
# Forward mode with RHS of self.b
d_residuals['lin.x'] = b
lingrp.run_solve_linear(['linear'], 'fwd')
sol = d_outputs['lin.x']
assert_rel_error(self, sol, x, .0001)
# Reverse mode with RHS of self.b_T
d_outputs['lin.x'] = b_T
lingrp.run_solve_linear(['linear'], 'rev')
sol = d_residuals['lin.x']
assert_rel_error(self, sol, x, .0001)
J = prob.compute_totals(['lin.x'], ['p1.A', 'p2.b', 'lin.x'], return_format='flat_dict')
assert_rel_error(self, J['lin.x', 'p1.A'], dx_dA, .0001)
assert_rel_error(self, J['lin.x', 'p2.b'], dx_db, .0001)
data = prob.check_partials(out_stream=None)
abs_errors = data['lingrp.lin'][('x', 'x')]['abs error']
self.assertTrue(len(abs_errors) > 0)
for match in abs_errors:
abs_error = float(match)
self.assertTrue(abs_error < 1.e-6)
def test_compute_partials_inputs_read_only(self):
class BadComp(TestExplCompSimpleDense):
def compute_partials(self, inputs, partials):
super(BadComp, self).compute_partials(inputs, partials)
inputs['length'] = 0. # should not be allowed
prob = Problem(BadComp())
prob.setup()
prob.run_model()
with self.assertRaises(ValueError) as cm:
prob.check_partials()
self.assertEqual(str(cm.exception),
"Attempt to set value of 'length' in input vector "
"when it is read only.")
def test_compute_jacvec_product_inputs_read_only(self):
class BadComp(RectangleJacVec):
def compute_jacvec_product(self, inputs, d_inputs, d_outputs, mode):
super(BadComp, self).compute_jacvec_product(inputs, d_inputs, d_outputs, mode)
inputs['length'] = 0. # should not be allowed
prob = Problem(BadComp())
prob.setup()
prob.run_model()
with self.assertRaises(ValueError) as cm:
prob.check_partials()
self.assertEqual(str(cm.exception),
"Attempt to set value of 'length' in input vector "
"when it is read only.")
def test_assert_check_partials_no_exception_expected(self):
import numpy as np
from openmdao.api import Problem, ExplicitComponent
from openmdao.utils.assert_utils import assert_check_partials
class MyComp(ExplicitComponent):
def setup(self):
self.add_input('x1', 3.0)
self.add_input('x2', 5.0)
self.add_output('y', 5.5)
self.declare_partials(of='*', wrt='*')
def compute(self, inputs, outputs):
outputs['y'] = 3.0 * inputs['x1'] + 4.0 * inputs['x2']
def compute_partials(self, inputs, partials):
"""Correct derivative."""
J = partials
J['y', 'x1'] = np.array([3.0])
J['y', 'x2'] = np.array([4.0])
prob = Problem()
prob.model = MyComp()
prob.set_solver_print(level=0)
prob.setup(check=False)
prob.run_model()
data = prob.check_partials(out_stream=None)
atol = 1.e-6
rtol = 1.e-6
assert_check_partials(data, atol, rtol)
def test_derivatives(self):
mm = MetaModelUnStructured()
mm.add_input('x', 0.)
mm.add_output('f', 0.)
mm.default_surrogate = FloatKrigingSurrogate()
prob = Problem()
prob.model.add_subsystem('p', IndepVarComp('x', 0.),
promotes_outputs=['x'])
prob.model.add_subsystem('mm', mm,
promotes_inputs=['x'])
prob.setup()
mm.metadata['train:x'] = [0., .25, .5, .75, 1.]
mm.metadata['train:f'] = [1., .75, .5, .25, 0.]
prob['x'] = 0.125
prob.run_model()
data = prob.check_partials()
Jf = data['mm'][('f', 'x')]['J_fwd']
Jr = data['mm'][('f', 'x')]['J_rev']
assert_rel_error(self, Jf[0][0], -1., 1.e-3)
assert_rel_error(self, Jr[0][0], -1., 1.e-3)
# TODO: complex step not currently supported in check_partial_derivs
# data = prob.check_partials(global_options={'method': 'cs'})
abs_errors = data['mm'][('f', 'x')]['abs error']
self.assertTrue(len(abs_errors) > 0)
for match in abs_errors:
abs_error = float(match)
self.assertTrue(abs_error < 1.e-6)
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)
np.set_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_basic_fd_comps(self):
prob = Problem()
prob.model = Group()
prob.model.add_subsystem('px1', IndepVarComp('x1', 100.0), promotes=['x1'])
prob.model.add_subsystem('src', SrcCompFD())
prob.model.add_subsystem('tgtF', TgtCompFFD())
prob.model.add_subsystem('tgtC', TgtCompCFD())
prob.model.add_subsystem('tgtK', TgtCompKFD())
prob.model.connect('x1', 'src.x1')
prob.model.connect('src.x2', 'tgtF.x2')
prob.model.connect('src.x2', 'tgtC.x2')
prob.model.connect('src.x2', 'tgtK.x2')
prob.setup(check=False)
prob.run_model()
assert_rel_error(self, prob['src.x2'], 100.0, 1e-6)
assert_rel_error(self, prob['tgtF.x3'], 212.0, 1e-6)
assert_rel_error(self, prob['tgtC.x3'], 100.0, 1e-6)
assert_rel_error(self, prob['tgtK.x3'], 373.15, 1e-6)
indep_list = ['x1']
unknown_list = ['tgtF.x3', 'tgtC.x3', 'tgtK.x3']
J = prob.compute_totals(of=unknown_list, wrt=indep_list, return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
prob.setup(check=False, mode='rev')
prob.run_model()
J = prob.compute_totals(of=unknown_list, wrt=indep_list, return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
prob.model.approx_totals(method='fd')
prob.setup(check=False, mode='rev')
prob.run_model()
J = prob.compute_totals(of=unknown_list, wrt=indep_list, return_format='dict')
assert_rel_error(self, J['tgtF.x3']['x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3']['x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3']['x1'][0][0], 1.0, 1e-6)
# Make sure check partials handles conversion
data = prob.check_partials()
for key1, val1 in iteritems(data):
for key2, val2 in iteritems(val1):
assert_rel_error(self, val2['abs error'][0], 0.0, 1e-6)
assert_rel_error(self, val2['abs error'][1], 0.0, 1e-6)
assert_rel_error(self, val2['abs error'][2], 0.0, 1e-6)
assert_rel_error(self, val2['rel error'][0], 0.0, 1e-6)
assert_rel_error(self, val2['rel error'][1], 0.0, 1e-6)
assert_rel_error(self, val2['rel error'][2], 0.0, 1e-6)
class TestCrossProductCompNx3x1(unittest.TestCase):
def setUp(self):
self.nn = 5
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='a', shape=(self.nn, 3, 1))
ivc.add_output(name='b', shape=(self.nn, 3, 1))
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['a', 'b'])
self.p.model.add_subsystem(name='cross_prod_comp',
subsys=CrossProductComp(vec_size=self.nn))
self.p.model.connect('a', 'cross_prod_comp.a')
self.p.model.connect('b', 'cross_prod_comp.b')
self.p.setup(force_alloc_complex=True)
self.p['a'] = np.random.rand(self.nn, 3, 1)
self.p['b'] = np.random.rand(self.nn, 3, 1)
self.p['a'][:, 0, 0] = 2.0
self.p['a'][:, 1, 0] = 3.0
self.p['a'][:, 2, 0] = 4.0
self.p['b'][:, 0, 0] = 5.0
self.p['b'][:, 1, 0] = 6.0
self.p['b'][:, 2, 0] = 7.0
self.p.run_model()
def test_results(self):
for i in range(self.nn):
a_i = self.p['a'][i, :, 0]
b_i = self.p['b'][i, :, 0]
c_i = self.p['cross_prod_comp.c'][i, :]
expected_i = np.cross(a_i, b_i)
np.testing.assert_almost_equal(c_i, expected_i)
def test_partials(self):
cpd = self.p.check_partials(out_stream=None, method='cs')
for comp in cpd:
for (var, wrt) in cpd[comp]:
np.testing.assert_almost_equal(actual=cpd[comp][var, wrt]['J_fwd'],
desired=cpd[comp][var, wrt]['J_fd'],
decimal=6)
def test_exec_comp_value(self, f):
test_data = _ufunc_test_data[f]
prob = Problem()
prob.model = model = Group()
if len(test_data['args']) > 1:
ivc = model.add_subsystem(name='ivc', subsys=IndepVarComp())
for arg_name, arg_value in iteritems(test_data['args']):
if arg_name == 'f':
continue
ivc.add_output(name=arg_name, val=arg_value['value'])
model.connect('ivc.{0}'.format(arg_name), 'comp.{0}'.format(arg_name))
model.add_subsystem('comp', ExecComp(test_data['str'], **test_data['args']),
promotes_outputs=['f'])
prob.setup()
prob.run_model()
if 'check_func' in test_data:
check_args = []
try:
check_args.append(test_data['args']['x']['value'])
except Exception:
pass
try:
check_args.append(test_data['args']['y']['value'])
except Exception:
pass
check_args = tuple(check_args)
expected = test_data['check_func'](*check_args)
else:
expected = test_data['check_val']
np.testing.assert_almost_equal(prob['f'], expected)
if 'check_val' not in test_data:
try:
prob.check_partials(compact_print=True)
except TypeError as e:
print(f, 'does not support complex-step differentiation')
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)
np.set_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())
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)
np.set_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)
class TestUnits(unittest.TestCase):
def setUp(self):
self.nn = 5
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='A', shape=(self.nn, 3, 3), units='ft')
ivc.add_output(name='x', shape=(self.nn, 3), units='lbf')
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['A', 'x'])
self.p.model.add_subsystem(name='mat_vec_product_comp',
subsys=MatrixVectorProductComp(vec_size=self.nn,
A_units='m', x_units='N',
b_units='N*m'))
self.p.model.connect('A', 'mat_vec_product_comp.A')
self.p.model.connect('x', 'mat_vec_product_comp.x')
self.p.setup(force_alloc_complex=True)
self.p['A'] = np.random.rand(self.nn, 3, 3)
self.p['x'] = np.random.rand(self.nn, 3)
self.p.run_model()
def test_results(self):
for i in range(self.nn):
A_i = self.p['A'][i, :, :]
x_i = self.p['x'][i, :]
b_i = self.p.get_val('mat_vec_product_comp.b', units='ft*lbf')[i, :]
expected_i = np.dot(A_i, x_i)
np.testing.assert_almost_equal(b_i, expected_i)
def test_partials(self):
np.set_printoptions(linewidth=1024)
cpd = self.p.check_partials(out_stream=None, method='cs')
for comp in cpd:
for (var, wrt) in cpd[comp]:
np.testing.assert_almost_equal(actual=cpd[comp][var, wrt]['J_fwd'],
desired=cpd[comp][var, wrt]['J_fd'],
decimal=6)
class TestUnits(unittest.TestCase):
def setUp(self):
self.nn = 5
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='a', shape=(self.nn, 3), units='lbf')
ivc.add_output(name='b', shape=(self.nn, 3), units='ft/s')
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['a', 'b'])
self.p.model.add_subsystem(name='dot_prod_comp',
subsys=DotProductComp(vec_size=self.nn,
a_units='N', b_units='m/s',
c_units='W'))
self.p.model.connect('a', 'dot_prod_comp.a')
self.p.model.connect('b', 'dot_prod_comp.b')
self.p.setup()
self.p['a'] = np.random.rand(self.nn, 3)
self.p['b'] = np.random.rand(self.nn, 3)
self.p.run_model()
def test_results(self):
for i in range(self.nn):
a_i = self.p['a'][i, :]
b_i = self.p['b'][i, :]
c_i = self.p.get_val('dot_prod_comp.c', units='hp')[i]
expected_i = np.dot(a_i, b_i) / 550.0
np.testing.assert_almost_equal(c_i, expected_i)
def test_partials(self):
np.set_printoptions(linewidth=1024)
cpd = self.p.check_partials(compact_print=True)
for comp in cpd:
for (var, wrt) in cpd[comp]:
np.testing.assert_almost_equal(actual=cpd[comp][var, wrt]['J_fwd'],
desired=cpd[comp][var, wrt]['J_fd'],
decimal=6)
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)
np.set_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_assert_check_partials_exception_expected(self):
class MyComp(ExplicitComponent):
def setup(self):
self.add_input('x1', 3.0)
self.add_input('x2', 5.0)
self.add_output('y', 5.5)
self.declare_partials(of='*', wrt='*')
def compute(self, inputs, outputs):
outputs['y'] = 3.0 * inputs['x1'] + 4.0 * inputs['x2']
def compute_partials(self, inputs, partials):
"""Intentionally incorrect derivative."""
J = partials
J['y', 'x1'] = np.array([4.0])
J['y', 'x2'] = np.array([40])
prob = Problem()
prob.model = MyComp()
prob.set_solver_print(level=0)
prob.setup(check=False)
prob.run_model()
data = prob.check_partials(out_stream=None)
atol = 1.e-6
rtol = 1.e-6
try:
assert_check_partials(data, atol, rtol)
except ValueError as err:
err_string = str(err)
self.assertEqual(err_string.count('Assert Check Partials failed for the following Components'), 1)
self.assertEqual(err_string.count('1e-06'), 2)
self.assertEqual(err_string.count('Component:'), 1)
self.assertEqual(err_string.count('< output > wrt < variable >'), 1)
self.assertEqual(err_string.count('norm'), 2)
self.assertEqual(err_string.count('y wrt x1'), 4)
self.assertEqual(err_string.count('y wrt x2'), 4)
self.assertEqual(err_string.count('abs'), 6)
self.assertEqual(err_string.count('rel'), 6)
self.assertEqual(err_string.count('fwd-fd'), 4)
self.assertEqual(err_string.count('rev-fd'), 4)
else:
self.fail('Exception expected.')
def test_basic(self):
"""Test that output values and total derivatives are correct."""
prob = Problem(model=UnitConvGroup())
# Check the outputs after running to test the unit conversions
prob.setup(check=False, mode='fwd')
prob.run_model()
assert_rel_error(self, prob['src.x2'], 100.0, 1e-6)
assert_rel_error(self, prob['tgtF.x3'], 212.0, 1e-6)
assert_rel_error(self, prob['tgtC.x3'], 100.0, 1e-6)
assert_rel_error(self, prob['tgtK.x3'], 373.15, 1e-6)
# Check the total derivatives in forward mode
wrt = ['px1.x1']
of = ['tgtF.x3', 'tgtC.x3', 'tgtK.x3']
J = prob.compute_totals(of=of, wrt=wrt, return_format='flat_dict')
assert_rel_error(self, J['tgtF.x3', 'px1.x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3', 'px1.x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3', 'px1.x1'][0][0], 1.0, 1e-6)
# Check the total derivatives in reverse mode
prob.setup(check=False, mode='rev')
prob.run_model()
J = prob.compute_totals(of=of, wrt=wrt, return_format='flat_dict')
assert_rel_error(self, J['tgtF.x3', 'px1.x1'][0][0], 1.8, 1e-6)
assert_rel_error(self, J['tgtC.x3', 'px1.x1'][0][0], 1.0, 1e-6)
assert_rel_error(self, J['tgtK.x3', 'px1.x1'][0][0], 1.0, 1e-6)
# Make sure check partials handles conversion
data = prob.check_partials()
for key1, val1 in iteritems(data):
for key2, val2 in iteritems(val1):
assert_rel_error(self, val2['abs error'][0], 0.0, 1e-6)
assert_rel_error(self, val2['abs error'][1], 0.0, 1e-6)
assert_rel_error(self, val2['abs error'][2], 0.0, 1e-6)
assert_rel_error(self, val2['rel error'][0], 0.0, 1e-6)
assert_rel_error(self, val2['rel error'][1], 0.0, 1e-6)
assert_rel_error(self, val2['rel error'][2], 0.0, 1e-6)
def test_create_on_init_add_constraint(self):
prob = Problem()
model = prob.model
# find intersection of two non-parallel lines
model.add_subsystem('indep', IndepVarComp('x', val=0.))
model.add_subsystem('f', ExecComp('y=3*x-3', x=0.))
model.add_subsystem('g', ExecComp('y=2.3*x+4', x=0.))
model.add_subsystem('equal', EQConstraintComp('y',
add_constraint=True))
model.connect('indep.x', 'f.x')
model.connect('indep.x', 'g.x')
model.connect('f.y', 'equal.lhs:y')
model.connect('g.y', 'equal.rhs:y')
model.add_design_var('indep.x', lower=0., upper=20.)
model.add_objective('f.y')
prob.setup(mode='fwd')
# verify that the constraint has been added as requested
self.assertTrue('equal.y' in model.get_constraints())
prob.driver = ScipyOptimizeDriver(disp=False)
prob.run_driver()
assert_almost_equal(prob['equal.y'], 0.)
assert_almost_equal(prob['indep.x'], 10.)
assert_almost_equal(prob['f.y'], 27.)
assert_almost_equal(prob['g.y'], 27.)
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['equal']:
assert_almost_equal(cpd['equal'][of, wrt]['abs error'],
0.0,
decimal=5)
assert_check_partials(cpd, atol=1e-5, rtol=1e-5)
def test_detailed(self):
""" This is a longer version of the previous method, with plotting. """
# Load in default lifting surfaces to setup the comparison
surfaces = get_default_surfaces()
# Instantiate an OpenMDAO problem and add the component we want to test
# as asubsystem, giving that component a default lifting surface
prob = Problem()
prob.model.add_subsystem('tube',
SectionPropertiesTube(surface=surfaces[0]))
# Set up the problem and ensure it uses complex arrays so we can check
# the derivatives using complex step
prob.setup(force_alloc_complex=True)
# Actually run the model, which is just a component in this case, then
# check the derivatives and store the results in the `check` dict
prob.run_model()
check = prob.check_partials(compact_print=False)
# Loop through this `check` dictionary and visualize the approximated
# and computed derivatives
for key, subjac in iteritems(check[list(check.keys())[0]]):
print()
print(key)
print('Approximated derivative (either fd or cs):')
view_mat(subjac['J_fd'])
print('Computed derivative set by user:'******'J_fwd'])
# Loop through the `check` dictionary and perform assert that the
# approximated deriv must be very close to the computed deriv
for key, subjac in iteritems(check[list(check.keys())[0]]):
if subjac['magnitude'].fd > 1e-6:
assert_almost_equal(subjac['rel error'].forward,
0.,
err_msg='deriv of %s wrt %s' % key)
assert_almost_equal(subjac['rel error'].reverse,
0.,
err_msg='deriv of %s wrt %s' % key)
def test_quadratic_three_phase_units_equal_dt_count_all(self):
n_int_per_seg = self.num_intervals
nn_tot = (n_int_per_seg*2 + 1)
x1 = np.linspace(0, nn_tot-1, nn_tot)
x2 = np.linspace(nn_tot-1, 2*(nn_tot-1), nn_tot)
x3 = np.linspace(2*(nn_tot-1), 3*(nn_tot-1), nn_tot)
x = np.concatenate([x1, x2, x3])
fprime = 4 * x **2 - 8*x + 5
f = 4 * x ** 3 / 3 - 8 * x ** 2 / 2 + 5*x
prob = Problem(MultiPhaseIntegratorTestGroup(segment_names=['climb','cruise','descent'],
segments_to_count=['climb','cruise','descent'],
num_intervals=self.num_intervals, integrator=self.integrator,
quantity_units='kg', diff_units='s'))
prob.setup(check=True, force_alloc_complex=True)
prob['iv.rate_to_integrate'] = fprime
prob.run_model()
assert_rel_error(self, prob.get_val('integral.q', units='kg'), f, tolerance=1e-14)
assert_rel_error(self, prob.get_val('integral.q_final', units='kg'), f[-1], tolerance=1e-14)
partials = prob.check_partials(method='cs',compact_print=True)
assert_check_partials(partials, atol=1e-8, rtol=1e0)
def test_auto_names(self):
num_nodes = self.num_nodes
nn_tot = num_nodes
x = np.linspace(0, nn_tot - 1, nn_tot)
fprime = 4 * x**2 - 8 * x + 5
f = 4 * x**3 / 3 - 8 * x**2 / 2 + 5 * x
prob = Problem(
IntegratorTestGroup(test_auto_names=True,
num_nodes=self.num_nodes,
integrator=self.integrator))
prob.setup(check=True, force_alloc_complex=True)
prob['iv.rate_to_integrate'] = fprime
prob.run_model()
assert_near_equal(prob['integral.q'], f, tolerance=1e-14)
assert_near_equal(prob.get_val('integral.q_final', units=None),
f[-1],
tolerance=1e-14)
partials = prob.check_partials(method='cs', compact_print=True)
assert_check_partials(partials, atol=1e-8, rtol=1e0)
class GroundspeedsTestCase(unittest.TestCase):
def setUp(self):
self.prob = Problem(GroundspeedsTestGroup(num_nodes=15))
self.prob.setup(check=True, force_alloc_complex=True)
self.prob.run_model()
def test_level_flight(self):
assert_near_equal(self.prob['fltcond|groundspeed'][0],50,tolerance=1e-10)
assert_near_equal(self.prob['fltcond|cosgamma'][0],1.,tolerance=1e-10)
assert_near_equal(self.prob['fltcond|singamma'][0],0.,tolerance=1e-10)
def test_climb_flight(self):
gs = np.sqrt(50**2 - 3**2)
assert_near_equal(self.prob['fltcond|groundspeed'][-1],gs,tolerance=1e-10)
assert_near_equal(self.prob['fltcond|cosgamma'][-1],gs/50.,tolerance=1e-10)
assert_near_equal(self.prob['fltcond|singamma'][-1],3./50.,tolerance=1e-10)
def test_partials(self):
partials = self.prob.check_partials(method='cs', out_stream=None)
assert_check_partials(partials)
class ClimbAngleTestCase_Scalar(unittest.TestCase):
def setUp(self):
self.prob = Problem(ClimbAngleCompTestGroup(num_nodes=1))
self.prob.setup(check=True, force_alloc_complex=True)
self.prob.run_model()
def test_level_flight(self):
assert_rel_error(self, self.prob['gamma'][0], 0, tolerance=1e-10)
def test_climb_flight(self):
self.prob['thrust'] = np.ones((1, )) * 1200
self.prob.run_model()
assert_rel_error(self,
self.prob['gamma'][0],
np.arcsin(200 / 1000 / g),
tolerance=1e-10)
def test_partials(self):
partials = self.prob.check_partials(method='cs', out_stream=None)
assert_check_partials(partials)
class ScalarAtmosTestCase(unittest.TestCase):
def setUp(self):
self.prob = Problem(AtmosTestGroup(num_nodes=1))
self.prob.setup(check=True, force_alloc_complex=True)
self.prob.run_model()
def test_sea_level(self):
assert_near_equal(self.prob['fltcond|rho'][0], 1.225, tolerance=1e-4)
assert_near_equal(self.prob['fltcond|p'][0], 101325, tolerance=1e-3)
assert_near_equal(self.prob['fltcond|T'][0], 288.15, tolerance=1e-3)
assert_near_equal(self.prob['fltcond|Utrue'][0],
61.7333,
tolerance=1e-3)
assert_near_equal(self.prob['fltcond|q'][0], 2334.2398, tolerance=1e-3)
assert_near_equal(self.prob['fltcond|M'][0], 0.1814, tolerance=1e-3)
assert_near_equal(self.prob['fltcond|a'][0], 340.294, tolerance=1e-3)
def test_partials(self):
partials = self.prob.check_partials(method='cs', out_stream=None)
assert_check_partials(partials)
def test_scalex(self):
symmetry = False
mesh = get_mesh(symmetry)
prob = Problem()
group = prob.model
val = np.random.random(NY)
comp = ScaleX(val=val, mesh_shape=mesh.shape)
group.add_subsystem('comp', comp)
prob.setup()
prob['comp.in_mesh'] = mesh
prob.run_model()
check = prob.check_partials(compact_print=True, abs_err_tol=1e-5, rel_err_tol=1e-5)
assert_check_partials(check, atol=1e-6, rtol=1e-6)
def test_rk_state_advance_comp_rk4_vector(self):
state_options = {'y': {'shape': (2, ), 'units': 'm'}}
p = Problem(model=Group())
ivc = p.model.add_subsystem('ivc',
IndepVarComp(),
promotes_outputs=['*'])
ivc.add_output('k:y', shape=(2, 4, 2), units='m')
ivc.add_output('y0', shape=(2, 2), units='m')
p.model.add_subsystem(
'c',
RungeKuttaStateAdvanceComp(num_segments=2,
method='RK4',
state_options=state_options))
p.model.connect('k:y', 'c.k:y')
p.model.connect('y0', 'c.initial_states_per_seg:y')
p.setup(check=True, force_alloc_complex=True)
p['y0'] = [[0.5, 1.425130208333333],
[2.639602661132812, 4.006818970044454]]
p['k:y'][0, :, 0] = [0.75, 0.90625, 0.9453125, 1.09765625]
p['k:y'][0, :, 1] = [1.08756510, 1.20320638, 1.23211670, 1.32862345]
p['k:y'][1, :, 0] = [1.31980133, 1.36850166, 1.38067675, 1.38513970]
p['k:y'][1, :, 1] = [1.37840949, 1.31676186, 1.30134995, 1.15408446]
p.run_model()
assert_rel_error(test_case=self,
actual=p.get_val('c.final_states:y'),
desired=[[1.425130208333333, 2.639602661132812],
[4.006818970044454, 5.301605229265987]],
tolerance=1.0E-9)
np.set_printoptions(linewidth=1024)
cpd = p.check_partials(method='cs', out_stream=None)
assert_check_partials(cpd)
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)
class TestSplitMultipleSystems(unittest.TestCase):
def setUp(self):
self.nn = 5
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='input_to_split', shape=(self.nn * 2 + 2, 3))
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['input_to_split'])
splitter = self.p.model.add_subsystem(name='vector_split_comp',
subsys=VectorSplitComp())
splitter.add_relation(['output_a', 'output_b', 'output_c'],
'input_to_split',
vec_sizes=[self.nn, self.nn, 2],
length=3)
self.p.model.connect('input_to_split',
'vector_split_comp.input_to_split')
self.p.setup(force_alloc_complex=True)
self.p['input_to_split'] = np.random.rand(self.nn * 2 + 2, 3)
self.p.run_model()
def test_results(self):
input_to_split = self.p['input_to_split']
out_a = self.p['vector_split_comp.output_a']
out_b = self.p['vector_split_comp.output_b']
out_c = self.p['vector_split_comp.output_c']
expected_a = input_to_split[0:self.nn, :]
expected_b = input_to_split[self.nn:2 * self.nn, :]
expected_c = input_to_split[2 * self.nn:2 * self.nn + 2, :]
assert_near_equal(out_a, expected_a, 1e-16)
assert_near_equal(out_b, expected_b, 1e-16)
assert_near_equal(out_c, expected_c, 1e-16)
def test_partials(self):
partials = self.p.check_partials(method='cs', out_stream=None)
assert_check_partials(partials)
def test_three_inputs(self):
nn = 5
p = Problem()
p.model.add_subsystem('selector',
SelectorComp(num_nodes=nn,
input_names=['A', 'B', 'C'],
units='g'),
promotes=['*'])
p.setup(check=True, force_alloc_complex=True)
p.set_val('A', np.array([5.7, 2.3, -10., 2., 77.]), units='g')
p.set_val('B', np.array([-1., -1., -1., -1., -2.]), units='kg')
p.set_val('C', 42. * np.ones(nn), units='g')
p.set_val('selector', np.array([0, 1, 2, 0, 2]))
p.run_model()
assert_near_equal(p['result'], np.array([5.7, -1000., 42., 2., 42.]))
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
p.set_val('A', 5. * np.ones(nn), units='g')
p.set_val('B', 6. * np.ones(nn), units='g')
p.set_val('C', 7. * np.ones(nn), units='g')
p.set_val('selector', np.zeros(nn))
p.run_model()
assert_near_equal(p['result'], 5. * np.ones(nn))
p.set_val('selector', np.ones(nn))
p.run_model()
assert_near_equal(p['result'], 6. * np.ones(nn))
p.set_val('selector', 2. * np.ones(nn))
p.run_model()
assert_near_equal(p['result'], 7. * np.ones(nn))
p.set_val('selector', np.array([-1, 1, 0, 2, 0]))
with self.assertRaises(RuntimeWarning):
p.run_model()
p.set_val('selector', np.array([0, 1, -1, 2, 3]))
with self.assertRaises(RuntimeWarning):
p.run_model()
def test_simple_explicit_apply(self):
prob = Problem(Group())
prob.model.add_subsystem('px', IndepVarComp('x', 1.0))
prob.model.add_subsystem('py', IndepVarComp('y', 1.0))
prob.model.add_subsystem('comp', ParaboloidApply())
prob.model.connect('px.x', 'comp.x')
prob.model.connect('py.y', 'comp.y')
prob.model.linear_solver = ScipyGMRES()
prob.set_solver_print(level=0)
prob.setup(check=False, mode='fwd')
prob.run_model()
assert_rel_error(self, prob['comp.f_xy'], 27.0, 1e-6)
J = prob.compute_totals(of=['comp.f_xy'], wrt=['px.x', 'py.y'])
assert_rel_error(self, J[('comp.f_xy', 'px.x')][0][0], -3.0, 1e-5)
assert_rel_error(self, J[('comp.f_xy', 'py.y')][0][0], 11.0, 1e-5)
prob.setup(check=False, mode='rev')
prob.run_model()
assert_rel_error(self, prob['comp.f_xy'], 27.0, 1e-6)
J = prob.compute_totals(of=['comp.f_xy'], wrt=['px.x', 'py.y'])
assert_rel_error(self, J[('comp.f_xy', 'px.x')][0][0], -3.0, 1e-5)
assert_rel_error(self, J[('comp.f_xy', 'py.y')][0][0], 11.0, 1e-5)
# Check partials
data = prob.check_partials()
for key1, val1 in iteritems(data):
for key2, val2 in iteritems(val1):
assert_rel_error(self, val2['abs error'][0], 0.0, 1e-5)
assert_rel_error(self, val2['abs error'][1], 0.0, 1e-5)
assert_rel_error(self, val2['abs error'][2], 0.0, 1e-5)
assert_rel_error(self, val2['rel error'][0], 0.0, 1e-5)
assert_rel_error(self, val2['rel error'][1], 0.0, 1e-5)
assert_rel_error(self, val2['rel error'][2], 0.0, 1e-5)
def test_renamed_vars(self):
prob = Problem()
model = prob.model
# find intersection of two non-parallel lines, fx_y and gx_y
equal = EQConstraintComp('y',
lhs_name='fx_y',
rhs_name='gx_y',
add_constraint=True)
model.add_subsystem('indep', IndepVarComp('x', val=0.))
model.add_subsystem('f', ExecComp('y=3*x-3', x=0.))
model.add_subsystem('g', ExecComp('y=2.3*x+4', x=0.))
model.add_subsystem('equal', equal)
model.connect('indep.x', 'f.x')
model.connect('indep.x', 'g.x')
model.connect('f.y', 'equal.fx_y')
model.connect('g.y', 'equal.gx_y')
model.add_design_var('indep.x', lower=0., upper=20.)
model.add_objective('f.y')
prob.setup(mode='fwd')
prob.driver = ScipyOptimizeDriver(disp=False)
prob.run_driver()
assert_almost_equal(prob['equal.y'], 0.)
assert_almost_equal(prob['indep.x'], 10.)
assert_almost_equal(prob['f.y'], 27.)
assert_almost_equal(prob['g.y'], 27.)
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['equal']:
assert_almost_equal(cpd['equal'][of, wrt]['abs error'],
0.0,
decimal=5)
assert_check_partials(cpd, atol=1e-5, rtol=1e-5)
def run_test(test_obj, comp, complex_flag=False, compact_print=True, method='fd', step=1e-6, atol=1e-5, rtol=1e-5, view=False):
prob = Problem()
prob.model.add_subsystem('comp', comp)
prob.setup(force_alloc_complex=complex_flag)
prob.run_model()
if method=='cs':
step = 1e-40
check = prob.check_partials(compact_print=compact_print, method=method, step=step)
if view:
# Loop through this `check` dictionary and visualize the approximated
# and computed derivatives
for key, subjac in iteritems(check[list(check.keys())[0]]):
view_mat(subjac['J_fd'],subjac['J_fwd'],key)
assert_check_partials(check, atol=atol, rtol=rtol)
return prob
def test_feature_assert_check_partials_exception_expected(self):
import numpy as np
from openmdao.api import ExplicitComponent, Problem
from openmdao.utils.assert_utils import assert_check_partials
class MyComp(ExplicitComponent):
def setup(self):
self.add_input('x1', 3.0)
self.add_input('x2', 5.0)
self.add_output('y', 5.5)
self.declare_partials(of='*', wrt='*')
def compute(self, inputs, outputs):
""" Compute outputs. """
outputs['y'] = 3.0 * inputs['x1'] + 4.0 * inputs['x2']
def compute_partials(self, inputs, partials):
"""Intentionally incorrect derivative."""
J = partials
J['y', 'x1'] = np.array([4.0])
J['y', 'x2'] = np.array([40])
prob = Problem()
prob.model = MyComp()
prob.set_solver_print(level=0)
prob.setup(check=False)
prob.run_model()
data = prob.check_partials(out_stream=None)
atol = 1.e-6
rtol = 1.e-6
try:
assert_check_partials(data, atol, rtol)
except ValueError as err:
print(str(err))
class TestElementMultiplyDivideCompNx3(unittest.TestCase):
def setUp(self):
self.nn = 5
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='a', shape=(self.nn, 3))
ivc.add_output(name='b', shape=(self.nn, 3))
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['a', 'b'])
multi = self.p.model.add_subsystem(name='multiply_divide_comp',
subsys=ElementMultiplyDivideComp())
multi.add_equation('multdiv_output', ['input_a', 'input_b'],
vec_size=self.nn,
length=3)
self.p.model.connect('a', 'multiply_divide_comp.input_a')
self.p.model.connect('b', 'multiply_divide_comp.input_b')
self.p.setup()
self.p['a'] = np.random.uniform(low=1, high=2, size=(self.nn, 3))
self.p['b'] = np.random.uniform(low=1, high=2, size=(self.nn, 3))
self.p.run_model()
def test_results(self):
a = self.p['a']
b = self.p['b']
out = self.p['multiply_divide_comp.multdiv_output']
expected = a * b
assert_near_equal(out, expected, 1e-16)
def test_partials(self):
partials = self.p.check_partials(method='fd', out_stream=None)
assert_check_partials(partials)
class TestAddSubtractCompNx3(unittest.TestCase):
def setUp(self):
self.nn = 5
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='a', shape=(self.nn, 3))
ivc.add_output(name='b', shape=(self.nn, 3))
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['a', 'b'])
adder = self.p.model.add_subsystem(name='add_subtract_comp',
subsys=AddSubtractComp())
adder.add_equation('adder_output', ['input_a', 'input_b'],
vec_size=self.nn,
length=3)
self.p.model.connect('a', 'add_subtract_comp.input_a')
self.p.model.connect('b', 'add_subtract_comp.input_b')
self.p.setup()
self.p['a'] = np.random.rand(self.nn, 3)
self.p['b'] = np.random.rand(self.nn, 3)
self.p.run_model()
def test_results(self):
a = self.p['a']
b = self.p['b']
out = self.p['add_subtract_comp.adder_output']
expected = a + b
assert_rel_error(self, out, expected, 1e-16)
def test_partials(self):
partials = self.p.check_partials(method='fd', out_stream=None)
assert_check_partials(partials)
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)
np.set_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)
class TestSplitNx3Units(unittest.TestCase):
def setUp(self):
self.nn = 5
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='input_to_split',
shape=(self.nn * 2, 3),
units='m')
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['input_to_split'])
splitter = self.p.model.add_subsystem(name='vector_split_comp',
subsys=VectorSplitComp())
splitter.add_relation(['output_a', 'output_b'],
'input_to_split',
vec_sizes=[self.nn, self.nn],
length=3,
units='m')
self.p.model.connect('input_to_split',
'vector_split_comp.input_to_split')
self.p.setup()
self.p['input_to_split'] = np.random.rand(self.nn * 2, 3)
self.p.run_model()
def test_results(self):
input_to_split = self.p['input_to_split']
out_a = self.p['vector_split_comp.output_a']
out_b = self.p['vector_split_comp.output_b']
expected_a = input_to_split[0:self.nn, :]
expected_b = input_to_split[self.nn:2 * self.nn, :]
assert_rel_error(self, out_a, expected_a, 1e-16)
assert_rel_error(self, out_b, expected_b, 1e-16)
def test_partials(self):
partials = self.p.check_partials(method='fd', out_stream=None)
assert_check_partials(partials)
def test_nondefault_settings(self):
prob = Problem(
MotorTestGroup(
vec_size=10,
use_defaults=False,
efficiency=0.95,
weight_inc=1 / 3000,
weight_base=2,
cost_inc=1 / 500,
cost_base=3,
))
prob.setup(check=True, force_alloc_complex=True)
prob.run_model()
assert_rel_error(self,
prob.get_val('motor.shaft_power_out', units='kW'),
np.ones(10) * 90 * 0.95,
tolerance=1e-15)
assert_rel_error(self,
prob.get_val('motor.elec_load', units='kW'),
np.ones(10) * 90,
tolerance=1e-15)
assert_rel_error(self,
prob.get_val('motor.heat_out', units='kW'),
np.ones(10) * 90 * 0.05,
tolerance=1e-15)
assert_rel_error(self,
prob.get_val('motor.component_sizing_margin'),
np.ones(10) * 0.90,
tolerance=1e-15)
assert_rel_error(self,
prob.get_val('motor.component_cost', units='USD'),
203,
tolerance=1e-15)
assert_rel_error(self,
prob.get_val('motor.component_weight', units='kg'),
35.333333333333333333,
tolerance=1e-10)
partials = prob.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_vectorized(self):
nn = 5
p = Problem()
p.model = CFM56(num_nodes=nn)
p.setup(force_alloc_complex=True)
p.set_val('throttle', np.linspace(0.0001, 1., nn))
p.set_val('fltcond|h', np.linspace(0, 40e3, nn), units='ft')
p.set_val('fltcond|M', np.linspace(0.1, 0.9, nn))
p.run_model()
assert_near_equal(p.get_val('thrust', units='lbf'), np.array([1445.41349482, 3961.46624224,
5278.43191982, 5441.44404298, 6479.00525867]), tolerance=5e-3)
assert_near_equal(p.get_val('fuel_flow', units='kg/s'), np.array([0.17032429, 0.25496437,
0.35745638, 0.40572545, 0.4924194]), tolerance=5e-3)
assert_near_equal(p.get_val('T4', units='degK'), np.array([1005.38911171, 1207.57548728,
1381.94820904, 1508.07901676, 1665.37063872]), tolerance=5e-3)
partials = p.check_partials(method='cs',compact_print=True)
assert_check_partials(partials)
class TestVectorInitialAndFinalBoundaryValue(unittest.TestCase):
def setUp(self):
self.p = Problem(model=Group())
ivp = self.p.model.add_subsystem('ivc', subsys=IndepVarComp(), promotes_outputs=['*'])
ivp.add_output('pos', val=np.zeros((100, 3)))
self.p.model.add_design_var('pos', lower=0, upper=100)
bv_comp = self.p.model.add_subsystem('bv_comp', BoundaryConstraintComp())
bv_comp._add_initial_constraint(name='pos', shape=(3,))
bv_comp._add_final_constraint(name='pos', shape=(3,))
src_idxs = np.array([[0, 1, 2],
[-3, -2, -1]])
self.p.model.connect('pos', 'bv_comp.boundary_values:pos', src_indices=src_idxs,
flat_src_indices=True)
self.p.setup(force_alloc_complex=True)
self.p['pos'][:, 0] = np.arange(100)
self.p['pos'][:, 1] = 100 + np.arange(100)
self.p['pos'][:, 2] = 200 + np.arange(100)
self.p.run_model()
def test_results(self):
assert_almost_equal(self.p['bv_comp.boundary_values:pos'][0, :], self.p['pos'][0, :])
assert_almost_equal(self.p['bv_comp.boundary_values:pos'][1, :], self.p['pos'][-1, :])
assert_almost_equal(self.p['bv_comp.initial_value:pos'], self.p['pos'][0, :])
assert_almost_equal(self.p['bv_comp.final_value:pos'], self.p['pos'][-1, :])
def test_partials(self):
cpd = self.p.check_partials(compact_print=True, method='cs')
assert_check_partials(cpd)
class TestConcatenateNx3(unittest.TestCase):
def setUp(self):
self.nn = 5
self.length = 3
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='a', shape=(self.nn, self.length))
ivc.add_output(name='b', shape=(self.nn, self.length))
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['a', 'b'])
combiner = self.p.model.add_subsystem(name='vector_concat_comp',
subsys=VectorConcatenateComp())
combiner.add_relation('concat_output', ['input_a', 'input_b'],
vec_sizes=[self.nn, self.nn],
length=self.length)
self.p.model.connect('a', 'vector_concat_comp.input_a')
self.p.model.connect('b', 'vector_concat_comp.input_b')
self.p.setup(force_alloc_complex=False)
self.p['a'] = np.random.rand(self.nn, self.length)
self.p['b'] = np.random.rand(self.nn, self.length)
self.p.run_model()
def test_results(self):
a = self.p['a']
b = self.p['b']
out = self.p['vector_concat_comp.concat_output']
expected = np.concatenate((a, b))
assert_near_equal(out, expected, 1e-16)
def test_partials(self):
partials = self.p.check_partials(method='fd', out_stream=None)
assert_check_partials(partials)
def run_partials_test(self):
from openmdao.api import Problem
ode_function = self.ode_function_class()
initial_conditions, t0, t1 = ode_function.get_test_parameters()
exact_solution = ode_function.get_exact_solution(initial_conditions, t0, t1)
num = 10
times = np.linspace(t0, t1, num)
method_name = 'ImplicitMidpoint'
formulation = 'solver-based'
integrator = ODEIntegrator(ode_function, formulation, method_name,
times=times, initial_conditions=initial_conditions,
)
prob = Problem(integrator)
prob.setup()
prob.run_model()
jac = prob.check_partials(compact_print=True)
for comp_name, jac_comp in iteritems(jac):
for partial_name, jac_partial in iteritems(jac_comp):
mag_fd = jac_partial['magnitude'].fd
mag_fwd = jac_partial['magnitude'].forward
mag_rev = jac_partial['magnitude'].reverse
abs_fwd = jac_partial['abs error'].forward
abs_rev = jac_partial['abs error'].reverse
rel_fwd = jac_partial['rel error'].forward
rel_rev = jac_partial['rel error'].reverse
non_zero = np.max([mag_fd, mag_fwd, mag_rev]) > 1e-12
if non_zero:
self.assertTrue(rel_fwd < 1e-3 or abs_fwd < 1e-3)
self.assertTrue(rel_rev < 1e-3 or abs_rev < 1e-3)
def test_derivs_with_sideslip(self):
surfaces = get_default_surfaces()
# Use Tail since it is not symmetric.
comp = LiftDrag(surface=surfaces[1])
prob = Problem()
prob.model.add_subsystem('comp', comp)
prob.setup(force_alloc_complex=True)
prob['comp.alpha'] = 3.0
prob['comp.beta'] = 15.0
prob['comp.sec_forces'] = 10.0 * np.random.random(
prob['comp.sec_forces'].shape)
prob.run_model()
check = prob.check_partials(compact_print=True,
method='cs',
step=1e-40)
assert_check_partials(check)
class TestSummationNx3AxisNone(unittest.TestCase):
def setUp(self):
self.nn = 5
self.length = 3
self.sf = -2
self.p = Problem(model=Group())
ivc = IndepVarComp()
ivc.add_output(name='a', shape=(self.nn, self.length))
self.p.model.add_subsystem(name='ivc',
subsys=ivc,
promotes_outputs=['a'])
multi = self.p.model.add_subsystem(name='sum_comp',
subsys=SumComp(axis=None))
multi.add_equation('sum_output',
'sum_input',
vec_size=self.nn,
length=self.length,
scaling_factor=self.sf)
self.p.model.connect('a', 'sum_comp.sum_input')
self.p.setup(force_alloc_complex=True)
self.p['a'] = np.random.rand(self.nn, self.length)
self.p.run_model()
def test_results(self):
a = self.p['a']
out = self.p['sum_comp.sum_output']
expected = self.sf * np.sum(a, axis=None)
expected = expected.reshape((1, ))
assert_near_equal(out, expected, 1e-16)
def test_partials(self):
partials = self.p.check_partials(method='cs', out_stream=None)
assert_check_partials(partials)
def test_basic(self):
xcp = np.array([1.0, 2.0, 4.0, 6.0, 10.0, 12.0])
ycp = np.array([5.0, 12.0, 14.0, 16.0, 21.0, 29.0])
ncp = len(xcp)
n = 50
x = np.linspace(1.0, 12.0, n)
prob = Problem()
comp = AkimaSplineComp(num_control_points=ncp, num_points=n,
name='chord', input_x=True, input_xcp=True)
prob.model.add_subsystem('akima', comp)
prob.setup(force_alloc_complex=True)
prob['akima.chord:x_cp'] = xcp
prob['akima.chord:y_cp'] = ycp.reshape((1, ncp))
prob['akima.chord:x'] = x
prob.run_model()
y = np.array([[ 5. , 7.20902005, 9.21276849, 10.81097162, 11.80335574,
12.1278001 , 12.35869145, 12.58588536, 12.81022332, 13.03254681,
13.25369732, 13.47451633, 13.69584534, 13.91852582, 14.14281484,
14.36710105, 14.59128625, 14.81544619, 15.03965664, 15.26399335,
15.48853209, 15.7133486 , 15.93851866, 16.16573502, 16.39927111,
16.63928669, 16.8857123 , 17.1384785 , 17.39751585, 17.66275489,
17.93412619, 18.21156029, 18.49498776, 18.78433915, 19.07954501,
19.38053589, 19.68724235, 19.99959495, 20.31752423, 20.64096076,
20.96983509, 21.47630381, 22.33596028, 23.44002074, 24.67782685,
25.93872026, 27.11204263, 28.0871356 , 28.75334084, 29. ]])
assert_array_almost_equal(y, prob['akima.chord:y'])
derivs = prob.check_partials(compact_print=True, method='cs')
assert_check_partials(derivs, atol=1e-14, rtol=1e-14)
def test_create_on_init_no_normalization(self):
prob = Problem(model=Group())
bal = BalanceComp('x', val=1.0, normalize=False)
tgt = IndepVarComp(name='y_tgt', val=1.5)
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(iprint=0)
prob.setup()
prob.run_model()
assert_almost_equal(prob['balance.x'], np.sqrt(1.5), decimal=7)
assert_almost_equal(prob.model.balance._scale_factor, 1.0)
cpd = prob.check_partials(out_stream=None)
for (of, wrt) in cpd['balance']:
assert_almost_equal(cpd['balance'][of, wrt]['abs error'],
0.0,
decimal=5)
