def test_const_jacobian(self):
import numpy as np
import openmdao.api as om
from openmdao.jacobians.tests.test_jacobian_features import SimpleCompConst
model = om.Group(assembled_jac_type='dense')
problem = om.Problem(model=model)
problem.set_solver_print(0)
model.linear_solver = om.DirectSolver(assemble_jac=True)
model.add_subsystem('simple',
SimpleCompConst(),
promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g'])
problem.setup()
problem.run_model()
totals = problem.compute_totals(['f', 'g'],
['x', 'y1', 'y2', 'y3', 'z'])
assert_near_equal(totals['f', 'x'], [[1.]])
assert_near_equal(totals['f', 'z'], np.ones((1, 4)))
assert_near_equal(totals['f', 'y1'], np.zeros((1, 2)))
assert_near_equal(totals['f', 'y2'], np.zeros((1, 2)))
assert_near_equal(totals['f', 'y3'], np.zeros((1, 2)))
assert_near_equal(totals['g', 'z'], np.zeros((4, 4)))
assert_near_equal(totals['g', 'y1'], [[1, 0], [1, 0], [0, 1], [0, 1]])
assert_near_equal(totals['g', 'y2'], [[1, 0], [0, 1], [1, 0], [0, 1]])
assert_near_equal(totals['g', 'y3'], [[1, 0], [1, 0], [0, 1], [0, 1]])
assert_near_equal(totals['g', 'x'], [[1], [0], [0], [1]])
def test_const_jacobian(self):
model = om.Group()
problem = om.Problem(model=model)
problem.set_solver_print(level=0)
model.linear_solver = om.ScipyKrylov(assemble_jac=True)
model.add_subsystem('simple',
SimpleCompConst(),
promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g'])
problem.setup()
problem.run_model()
totals = problem.compute_totals(['f', 'g'],
['x', 'y1', 'y2', 'y3', 'z'])
jacobian = {}
jacobian['f', 'x'] = [[1.]]
jacobian['f', 'z'] = np.ones((1, 4))
jacobian['f', 'y1'] = np.zeros((1, 2))
jacobian['f', 'y2'] = np.zeros((1, 2))
jacobian['f', 'y3'] = np.zeros((1, 2))
jacobian['g', 'y1'] = [[1, 0], [1, 0], [0, 1], [0, 1]]
jacobian['g', 'y2'] = [[1, 0], [0, 1], [1, 0], [0, 1]]
jacobian['g', 'y3'] = [[1, 0], [1, 0], [0, 1], [0, 1]]
jacobian['g', 'x'] = [[1], [0], [0], [1]]
jacobian['g', 'z'] = np.zeros((4, 4))
assert_near_equal(totals, jacobian)
def test_dependence(self):
problem = self.problem
model = problem.model
model.add_subsystem('simple',
SimpleCompConst(),
promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g'])
problem.setup()
problem.run_model()
# Note: since this test is looking for something not user-facing, it is inherently fragile
# w.r.t. internal implementations.
model._linearize(model._assembled_jac)
jac = model._assembled_jac._int_mtx._matrix
# Testing dependence by examining the number of entries in the Jacobian. If non-zeros are
# removed during array creation (e.g. `eliminate_zeros` function on scipy.sparse matrices),
# then this test will fail since there are zero entries in the sub-Jacobians.
# 16 for outputs w.r.t. themselves
# 1 for df/dx
# 4 for df/dz
# 8 for dg/dy1
# 4 for dg/dy2
# 8 for dg/dy3
# 2 for dg/dx
expected_nnz = 16 + 1 + 4 + 8 + 4 + 8 + 2
self.assertEqual(jac.nnz, expected_nnz)
def test_const_jacobian(self):
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, DirectSolver, DenseJacobian
from openmdao.jacobians.tests.test_jacobian_features import SimpleCompConst
model = Group()
comp = IndepVarComp()
for name, val in (('x', 1.), ('y1', np.ones(2)), ('y2', np.ones(2)),
('y3', np.ones(2)), ('z', np.ones((2, 2)))):
comp.add_output(name, val)
model.add_subsystem('input_comp', comp, promotes=['x', 'y1', 'y2', 'y3', 'z'])
problem = Problem(model=model)
model.suppress_solver_output = True
model.linear_solver = DirectSolver()
model.jacobian = DenseJacobian()
model.add_subsystem('simple', SimpleCompConst(),
promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g'])
problem.setup(check=False)
problem.run_model()
totals = problem.compute_totals(['f', 'g'],
['x', 'y1', 'y2', 'y3', 'z'])
assert_rel_error(self, totals['f', 'x'], [[1.]])
assert_rel_error(self, totals['f', 'z'], np.ones((1, 4)))
assert_rel_error(self, totals['f', 'y1'], np.zeros((1, 2)))
assert_rel_error(self, totals['f', 'y2'], np.zeros((1, 2)))
assert_rel_error(self, totals['f', 'y3'], np.zeros((1, 2)))
assert_rel_error(self, totals['g', 'x'], [[1], [0], [0], [1]])
assert_rel_error(self, totals['g', 'z'], np.zeros((4, 4)))
assert_rel_error(self, totals['g', 'y1'], [[1, 0], [1, 0], [0, 1], [0, 1]])
assert_rel_error(self, totals['g', 'y2'], [[1, 0], [0, 1], [1, 0], [0, 1]])
assert_rel_error(self, totals['g', 'y3'], [[1, 0], [1, 0], [0, 1], [0, 1]])
def test_const_jacobian(self):
model = Group()
comp = IndepVarComp()
for name, val in (('x', 1.), ('y1', np.ones(2)), ('y2', np.ones(2)),
('y3', np.ones(2)), ('z', np.ones((2, 2)))):
comp.add_output(name, val)
model.add_subsystem('input_comp', comp, promotes=['x', 'y1', 'y2', 'y3', 'z'])
problem = Problem(model=model)
problem.set_solver_print(level=0)
model.linear_solver = ScipyKrylov()
model.jacobian = COOJacobian()
model.add_subsystem('simple', SimpleCompConst(),
promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g'])
problem.setup(check=False)
problem.run_model()
totals = problem.compute_totals(['f', 'g'],
['x', 'y1', 'y2', 'y3', 'z'])
jacobian = {}
jacobian['f', 'x'] = [[1.]]
jacobian['f', 'z'] = np.ones((1, 4))
jacobian['f', 'y1'] = np.zeros((1, 2))
jacobian['f', 'y2'] = np.zeros((1, 2))
jacobian['f', 'y3'] = np.zeros((1, 2))
jacobian['g', 'y1'] = [[1, 0], [1, 0], [0, 1], [0, 1]]
jacobian['g', 'y2'] = [[1, 0], [0, 1], [1, 0], [0, 1]]
jacobian['g', 'y3'] = [[1, 0], [1, 0], [0, 1], [0, 1]]
jacobian['g', 'x'] = [[1], [0], [0], [1]]
jacobian['g', 'z'] = np.zeros((4, 4))
assert_rel_error(self, totals, jacobian)
def test_const_jacobian(self):
import numpy as np
import openmdao.api as om
from openmdao.jacobians.tests.test_jacobian_features import SimpleCompConst
model = om.Group(assembled_jac_type='dense')
comp = om.IndepVarComp()
for name, val in (('x', 1.), ('y1', np.ones(2)), ('y2', np.ones(2)),
('y3', np.ones(2)), ('z', np.ones((2, 2)))):
comp.add_output(name, val)
model.add_subsystem('input_comp',
comp,
promotes=['x', 'y1', 'y2', 'y3', 'z'])
problem = om.Problem(model=model)
problem.set_solver_print(0)
model.linear_solver = om.DirectSolver(assemble_jac=True)
model.add_subsystem('simple',
SimpleCompConst(),
promotes=['x', 'y1', 'y2', 'y3', 'z', 'f', 'g'])
problem.setup()
problem.run_model()
totals = problem.compute_totals(['f', 'g'],
['x', 'y1', 'y2', 'y3', 'z'])
assert_rel_error(self, totals['f', 'x'], [[1.]])
assert_rel_error(self, totals['f', 'z'], np.ones((1, 4)))
assert_rel_error(self, totals['f', 'y1'], np.zeros((1, 2)))
assert_rel_error(self, totals['f', 'y2'], np.zeros((1, 2)))
assert_rel_error(self, totals['f', 'y3'], np.zeros((1, 2)))
assert_rel_error(self, totals['g', 'z'], np.zeros((4, 4)))
assert_rel_error(self, totals['g', 'y1'],
[[1, 0], [1, 0], [0, 1], [0, 1]])
assert_rel_error(self, totals['g', 'y2'],
[[1, 0], [0, 1], [1, 0], [0, 1]])
assert_rel_error(self, totals['g', 'y3'],
[[1, 0], [1, 0], [0, 1], [0, 1]])
assert_rel_error(self, totals['g', 'x'], [[1], [0], [0], [1]])