def test_get_child_cases_system(self):
prob = SellarProblem(SellarDerivativesGrouped)
driver = prob.driver = pyOptSparseDriver(optimizer='SLSQP')
driver.options['print_results'] = False
driver.opt_settings['ACC'] = 1e-9
model = prob.model
model.add_recorder(self.recorder)
model.nonlinear_solver.add_recorder(self.recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
coords = [
'rank0:SLSQP|0|root._solve_nonlinear|0|NLRunOnce|0',
'rank0:SLSQP|1|root._solve_nonlinear|1|NLRunOnce|0',
'rank0:SLSQP|2|root._solve_nonlinear|2|NLRunOnce|0',
'rank0:SLSQP|3|root._solve_nonlinear|3|NLRunOnce|0',
'rank0:SLSQP|4|root._solve_nonlinear|4|NLRunOnce|0',
'rank0:SLSQP|5|root._solve_nonlinear|5|NLRunOnce|0',
'rank0:SLSQP|6|root._solve_nonlinear|6|NLRunOnce|0'
]
ind = 0
for c in cr.get_cases(recursive=True):
self.assertEqual(c.iteration_coordinate, coords[ind])
ind += 1
def test_get_child_cases_system(self):
self.setup_sellar_grouped_model()
self.prob.driver = pyOptSparseDriver()
self.prob.driver.options['optimizer'] = OPTIMIZER
if OPTIMIZER == 'SLSQP':
self.prob.driver.opt_settings['ACC'] = 1e-9
self.prob.model.add_recorder(self.recorder)
driver = self.prob.driver
self.prob.model._nonlinear_solver.add_recorder(self.recorder)
self.prob.driver.options['optimizer'] = OPTIMIZER
if OPTIMIZER == 'SLSQP':
self.prob.driver.opt_settings['ACC'] = 1e-9
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
coords = [
'rank0:SLSQP|0|root._solve_nonlinear|0|NLRunOnce|0',
'rank0:SLSQP|1|root._solve_nonlinear|1|NLRunOnce|0',
'rank0:SLSQP|2|root._solve_nonlinear|2|NLRunOnce|0',
'rank0:SLSQP|3|root._solve_nonlinear|3|NLRunOnce|0',
'rank0:SLSQP|4|root._solve_nonlinear|4|NLRunOnce|0',
'rank0:SLSQP|5|root._solve_nonlinear|5|NLRunOnce|0',
'rank0:SLSQP|6|root._solve_nonlinear|6|NLRunOnce|0'
]
ind = 0
for c in cr.get_cases(recursive=True):
self.assertEqual(c.iteration_coordinate, coords[ind])
ind += 1
def test_loading_cases(self):
prob = SellarProblem()
prob.setup()
prob.add_recorder(self.recorder)
prob.driver.add_recorder(self.recorder)
prob.model.add_recorder(self.recorder)
prob.model.nonlinear_solver.add_recorder(self.recorder)
prob.run_driver()
prob.record_iteration('c_1')
prob.record_iteration('c_2')
prob.cleanup()
cr = CaseReader(self.filename)
self.assertEqual(len(cr.driver_cases._cases), 0)
self.assertEqual(len(cr.solver_cases._cases), 0)
self.assertEqual(len(cr.system_cases._cases), 0)
self.assertEqual(len(cr.problem_cases._cases), 0)
cr.load_cases()
# assert that we have now stored each of the cases
self.assertEqual(len(cr.driver_cases._cases), cr.driver_cases.num_cases)
self.assertEqual(len(cr.solver_cases._cases), cr.solver_cases.num_cases)
self.assertEqual(len(cr.system_cases._cases), cr.system_cases.num_cases)
self.assertEqual(len(cr.problem_cases._cases), cr.problem_cases.num_cases)
for case_type in (cr.driver_cases, cr.solver_cases,
cr.system_cases, cr.problem_cases):
for case in case_type.list_cases():
self.assertTrue(case in case_type._cases)
self.assertEqual(case, case_type._cases[case].iteration_coordinate)
def test_list_inputs(self):
prob = SellarProblem()
prob.model.add_recorder(self.recorder)
prob.model.recording_options['record_residuals'] = True
prob.setup()
d1 = prob.model.d1 # SellarDis1withDerivatives (an ExplicitComp)
d1.nonlinear_solver = NonlinearBlockGS(maxiter=5)
d1.add_recorder(self.recorder)
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
inputs = cr.list_inputs(None, True, True, True)
expected_inputs = {
'obj_cmp.x': {'value': [1.]},
'd2.z': {'value': [5., 2.]},
'con_cmp2.y2': {'value': [12.05848815]},
'obj_cmp.y2': {'value': [12.05848815]},
'obj_cmp.z': {'value': [5., 2.]},
'd1.x': {'value': [1.]},
'd1.z': {'value': [5., 2.]},
'd1.y2': {'value': [12.05848815]},
'con_cmp1.y1': {'value': [25.58830237]},
'obj_cmp.y1': {'value': [25.58830237]},
'd2.y1': {'value': [25.58830237]}
}
self.assertEqual(len(inputs), 11)
for o in inputs:
vals = o[1]
name = o[0]
expected = expected_inputs[name]
np.testing.assert_almost_equal(vals['value'], expected['value'])
expected_inputs_case = {
'd1.z': {'value': [5., 2.]},
'd1.x': {'value': [1.]},
'd1.y2': {'value': [12.27257053]}
}
sys_case = cr.system_cases.get_case(1)
inputs_case = cr.list_inputs(sys_case, True, True, True, None)
for o in inputs_case:
vals = o[1]
name = o[0]
expected = expected_inputs_case[name]
np.testing.assert_almost_equal(vals['value'], expected['value'])
def __init__(self, f):
"""
Initialize the case viewer interface.
"""
if mpl is None:
raise RuntimeError('CaseViewer requires matplotlib and ipympl')
if get_ipython is None:
raise RuntimeError('CaseViewer requires jupyter')
if ipw is None:
raise RuntimeError('CaseViewer requires ipywidgets')
if get_ipython() is None:
raise RuntimeError(
'CaseViewer must be run from within a Jupyter notebook.')
try:
import ipympl
except ImportError:
raise RuntimeError('CaseViewer requires ipympl')
get_ipython().run_line_magic('matplotlib', 'widget')
self._case_reader = CaseReader(f) if isinstance(f, str) else f
self._cmap = cm.viridis
self._case_index_str = 'Case Index'
self._filename = self._case_reader._filename
self._make_gui()
self._register_callbacks()
self._fig, self._ax = plt.subplots(1,
1,
figsize=(9, 9 / 1.6),
tight_layout=True)
norm = mpl.colors.Normalize(vmin=0, vmax=1)
self._scalar_mappable = cm.ScalarMappable(norm=norm, cmap=self._cmap)
self._colorbar = self._fig.colorbar(self._scalar_mappable,
label='Case Index')
self._scatters = []
self._lines = []
self._update_source_options()
self._update_case_select_options()
self._update_var_select_options('x')
self._update_var_select_options('y')
self._update_var_info('x')
self._update_var_info('y')
def test_reading_system_metadata_basic(self):
self.setup_sellar_model()
nonlinear_solver = self.prob.model.nonlinear_solver
linear_solver = self.prob.model.linear_solver
d1 = self.prob.model.d1 # instance of SellarDis1withDerivatives, a Group
d1.nonlinear_solver = NonlinearBlockGS()
d1.nonlinear_solver.options['maxiter'] = 5
# declare two options
d1.options.declare('options value 1', 1)
d1.options.declare('options value to ignore', 2)
d1.add_recorder(self.recorder)
# don't record the second option on d1
d1.recording_options['options_excludes'] = ['options value to ignore']
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
d1_options = cr.system_metadata['d1']['component_options']
# option 1 is recorded
self.assertEqual(d1_options['options value 1'], 1)
# option 2 is not recorded
self.assertFalse('options value to ignore' in d1_options)
def test_simple_load_system_cases(self):
self.setup_sellar_model()
prob = self.prob
model = prob.model
model.recording_options['record_inputs'] = True
model.recording_options['record_outputs'] = True
model.recording_options['record_residuals'] = True
model.add_recorder(self.recorder)
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
case = cr.system_cases.get_case(0)
# Add one to all the inputs and outputs just to change the model
# so we can see if loading the case values really changes the model
for name in model._inputs:
model._inputs[name] += 1.0
for name in model._outputs:
model._outputs[name] += 1.0
# Now load in the case we recorded
prob.load_case(case)
_assert_model_matches_case(case, model)
def test_reading_solver_metadata(self):
self.setup_sellar_model()
nonlinear_solver = self.prob.model.nonlinear_solver
nonlinear_solver.add_recorder(self.recorder)
linear_solver = self.prob.model.linear_solver
linear_solver.add_recorder(self.recorder)
d1 = self.prob.model.d1 # instance of SellarDis1withDerivatives, a Group
d1.nonlinear_solver = NonlinearBlockGS()
d1.nonlinear_solver.options['maxiter'] = 5
d1.nonlinear_solver.add_recorder(self.recorder)
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
self.assertEqual(
sorted(cr.solver_metadata.keys()),
sorted(['root.LinearBlockGS', 'root.NonlinearBlockGS', 'd1.NonlinearBlockGS'])
)
self.assertEqual(cr.solver_metadata['d1.NonlinearBlockGS']['solver_options']['maxiter'], 5)
self.assertEqual(cr.solver_metadata['root.NonlinearBlockGS']['solver_options']['maxiter'],10)
self.assertEqual(cr.solver_metadata['root.LinearBlockGS']['solver_class'],'LinearBlockGS')
def test_reading_driver_recording_with_system_vars(self):
prob = SellarProblem(SellarDerivativesGrouped)
driver = prob.driver = pyOptSparseDriver(optimizer='SLSQP')
driver.options['print_results'] = False
driver.opt_settings['ACC'] = 1e-9
driver.recording_options['record_desvars'] = True
driver.recording_options['record_responses'] = True
driver.recording_options['record_objectives'] = True
driver.recording_options['record_constraints'] = True
driver.recording_options['includes'] = ['mda.d2.y2',]
driver.add_recorder(self.recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
# Test values from one case, the last case
last_case = cr.driver_cases.get_case(-1)
np.testing.assert_almost_equal(last_case.outputs['z'], prob['pz.z'],
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('pz.z'))
np.testing.assert_almost_equal(last_case.outputs['x'], prob['px.x'],
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('px.x'))
np.testing.assert_almost_equal(last_case.outputs['y2'], prob['mda.d2.y2'],
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('mda.d2.y2'))
def test_feature_reading_derivatives(self):
prob = SellarProblem(SellarDerivativesGrouped)
driver = prob.driver = ScipyOptimizeDriver(optimizer='SLSQP')
driver.recording_options['record_derivatives'] = True
driver.add_recorder(self.recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
# Get derivatives associated with the first iteration.
deriv_case = cr.driver_derivative_cases.get_case('rank0:SLSQP|1')
# Get all derivatives from that case.
derivs = deriv_case.get_derivatives()
# See what derivatives have been recorded.
self.assertEqual(set(derivs.keys),
set([('obj', 'z'), ('con2', 'z'), ('con1', 'x'), ('obj', 'x'), ('con2', 'x'), ('con1', 'z')]))
# Get specific derivative.
assert_rel_error(self, derivs['obj', 'z'], [[9.61001056, 1.78448534]], 1e-4)
def test_subsystem_load_system_cases(self):
prob = SellarProblem()
prob.setup()
model = prob.model
model.recording_options['record_inputs'] = True
model.recording_options['record_outputs'] = True
model.recording_options['record_residuals'] = True
# Only record a subsystem
model.d2.add_recorder(self.recorder)
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
case = cr.system_cases.get_case(0)
# Add one to all the inputs just to change the model
# so we can see if loading the case values really changes the model
for name in prob.model._inputs:
model._inputs[name] += 1.0
for name in prob.model._outputs:
model._outputs[name] += 1.0
# Now load in the case we recorded
prob.load_case(case)
_assert_model_matches_case(case, model.d2)
def test_load_bad_system_case(self):
prob = SellarProblem(SellarDerivativesGrouped)
prob.model.add_recorder(self.recorder)
driver = prob.driver = ScipyOptimizeDriver()
driver.options['optimizer'] = 'SLSQP'
driver.options['tol'] = 1e-9
driver.options['disp'] = False
driver.recording_options['record_desvars'] = True
driver.recording_options['record_responses'] = True
driver.recording_options['record_objectives'] = True
driver.recording_options['record_constraints'] = True
prob.setup()
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
case = cr.system_cases.get_case(0)
# try to load it into a completely different model
prob = SellarProblem()
prob.setup()
error_msg = "Input variable, '[^']+', recorded in the case is not found in the model"
with assertRaisesRegex(self, KeyError, error_msg):
prob.load_case(case)
def test_load_solver_cases(self):
prob = SellarProblem()
prob.setup()
model = prob.model
model.nonlinear_solver = NewtonSolver()
model.linear_solver = LinearBlockGS()
model.linear_solver.add_recorder(self.recorder)
prob.run_model()
prob.cleanup()
cr = CaseReader(self.filename)
case = cr.solver_cases.get_case(0)
# Add one to all the inputs just to change the model
# so we can see if loading the case values really changes the model
for name in prob.model._inputs:
model._inputs[name] += 1.0
for name in prob.model._outputs:
model._outputs[name] += 1.0
# Now load in the case we recorded
prob.load_case(case)
_assert_model_matches_case(case, model)
def test_load_system_cases_with_units(self):
comp = IndepVarComp()
comp.add_output('distance', val=1., units='m')
comp.add_output('time', val=1., units='s')
prob = Problem()
model = prob.model
model.add_subsystem('c1', comp)
model.add_subsystem('c2', SpeedComp())
model.add_subsystem('c3', ExecComp('f=speed',speed={'units': 'm/s'}))
model.connect('c1.distance', 'c2.distance')
model.connect('c1.time', 'c2.time')
model.connect('c2.speed', 'c3.speed')
model.add_recorder(self.recorder)
prob.setup()
prob.run_model()
cr = CaseReader(self.filename)
case = cr.system_cases.get_case(0)
# Add one to all the inputs just to change the model
# so we can see if loading the case values really changes the model
for name in model._inputs:
model._inputs[name] += 1.0
for name in model._outputs:
model._outputs[name] += 1.0
# Now load in the case we recorded
prob.load_case(case)
_assert_model_matches_case(case, model)
def test_reading_solver_metadata(self):
prob = SellarProblem(linear_solver=LinearBlockGS())
prob.setup()
prob.model.nonlinear_solver.add_recorder(self.recorder)
prob.model.linear_solver.add_recorder(self.recorder)
d1 = prob.model.d1 # SellarDis1withDerivatives (an ExplicitComponent)
d1.nonlinear_solver = NonlinearBlockGS(maxiter=5)
d1.nonlinear_solver.add_recorder(self.recorder)
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
self.assertEqual(
sorted(cr.solver_metadata.keys()),
sorted([
'root.LinearBlockGS', 'root.NonlinearBlockGS',
'd1.NonlinearBlockGS'
]))
self.assertEqual(
cr.solver_metadata['d1.NonlinearBlockGS']['solver_options']
['maxiter'], 5)
self.assertEqual(
cr.solver_metadata['root.NonlinearBlockGS']['solver_options']
['maxiter'], 10)
self.assertEqual(
cr.solver_metadata['root.LinearBlockGS']['solver_class'],
'LinearBlockGS')
def test_system_options_pickle_fail(self):
# simple paraboloid model
model = Group()
ivc = IndepVarComp()
ivc.add_output('x', 3.0)
model.add_subsystem('subs', ivc)
subs = model.subs
# declare two options
subs.options.declare('options value 1', 1)
# Given object which can't be pickled
subs.options.declare('options value to fail', (i for i in []))
subs.add_recorder(self.recorder)
prob = Problem(model)
prob.setup()
with warnings.catch_warnings(record=True) as w:
prob.run_model()
prob.cleanup()
cr = CaseReader(self.filename)
subs_options = cr.system_metadata['subs']['component_options']
# no options should have been recorded for d1
self.assertEqual(len(subs_options._dict), 0)
# make sure we got the warning we expected
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[0].category, RuntimeWarning))
def test_get_vars(self):
prob = SellarProblem()
prob.setup()
prob.model.add_recorder(self.recorder)
prob.model.recording_options['record_residuals'] = True
prob.driver.add_recorder(self.recorder)
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
driver_case = cr.driver_cases.get_case(0)
desvars = driver_case.get_desvars()
objectives = driver_case.get_objectives()
constraints = driver_case.get_constraints()
responses = driver_case.get_responses()
expected_desvars = {"x": 1., "z": [5., 2.]}
expected_objectives = {"obj": 28.58830817, }
expected_constraints = {"con1": -22.42830237, "con2": -11.94151185}
expected_responses = expected_objectives.copy()
expected_responses.update(expected_constraints)
for expected_set, actual_set in ((expected_desvars, desvars),
(expected_objectives, objectives),
(expected_constraints, constraints),
(expected_responses, responses)):
self.assertEqual(len(expected_set), len(actual_set.keys))
for k in actual_set:
np.testing.assert_almost_equal(expected_set[k], actual_set[k])
def test_bad_filetype(self):
# Pass it a plain text file.
fd, filepath = mkstemp()
with os.fdopen(fd, 'w') as tmp:
tmp.write("Lorem ipsum")
tmp.close()
with self.assertRaises(IOError):
_ = CaseReader(filepath)
def test_format_version(self):
self.setup_sellar_model()
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
self.assertEqual(cr.format_version, format_version,
msg='format version not read correctly')
def test_optimization_load_system_cases(self):
self.setup_sellar_grouped_model()
prob = self.prob
model = prob.model
driver = prob.driver = ScipyOptimizeDriver()
driver.options['optimizer'] = 'SLSQP'
driver.options['tol'] = 1e-9
driver.options['disp'] = False
model.add_recorder(self.recorder)
driver.recording_options['record_desvars'] = True
driver.recording_options['record_responses'] = True
driver.recording_options['record_objectives'] = True
driver.recording_options['record_constraints'] = True
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
inputs_before = model.list_inputs(values=True, units=True)
outputs_before = model.list_outputs(values=True, units=True)
cr = CaseReader(self.filename)
# get third case
third_case = cr.system_cases.get_case(2)
iter_count_before = driver.iter_count
# run the model again with a fresh model
self.setup_sellar_grouped_model()
prob = self.prob
model = prob.model
driver = prob.driver = ScipyOptimizeDriver()
driver.options['optimizer'] = 'SLSQP'
driver.options['tol'] = 1e-9
driver.options['disp'] = False
prob.setup(check=False)
prob.load_case(third_case)
prob.run_driver()
prob.cleanup()
inputs_after = model.list_inputs(values=True, units=True)
outputs_after = model.list_outputs(values=True, units=True)
iter_count_after = driver.iter_count
for before, after in zip(inputs_before, inputs_after):
np.testing.assert_almost_equal(before[1]['value'], after[1]['value'])
for before, after in zip(outputs_before, outputs_after):
np.testing.assert_almost_equal(before[1]['value'], after[1]['value'])
# Should take one less iteration since we gave it a head start in the second run
self.assertEqual(iter_count_before, iter_count_after + 1)
def test_reader_instantiates(self):
""" Test that CaseReader returns an SqliteCaseReader. """
self.setup_sellar_model()
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
self.assertTrue(isinstance(cr, SqliteCaseReader), msg='CaseReader not'
' returning the correct subclass.')
def test_format_version(self):
prob = SellarProblem()
prob.model.add_recorder(self.recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
self.assertEqual(cr.format_version, format_version,
msg='format version not read correctly')
def test_reading_system_metadata(self):
if OPT is None:
raise unittest.SkipTest("pyoptsparse is not installed")
if OPTIMIZER is None:
raise unittest.SkipTest("pyoptsparse is not providing SNOPT or SLSQP")
self.setup_sellar_grouped_scaled_model()
self.prob.driver = pyOptSparseDriver()
self.prob.driver.options['optimizer'] = OPTIMIZER
self.prob.model.options.declare("test1", 1)
self.prob.model.mda.d1.options.declare("test2", "2")
self.prob.model.pz.options.declare("test3", True)
self.prob.model.pz.recording_options['options_excludes'] = ['*']
if OPTIMIZER == 'SLSQP':
self.prob.driver.opt_settings['ACC'] = 1e-9
self.prob.model.recording_options['record_inputs'] = True
self.prob.model.recording_options['record_outputs'] = True
self.prob.model.recording_options['record_residuals'] = True
self.prob.model.recording_options['record_metadata'] = True
self.prob.model.add_recorder(self.recorder)
pz = self.prob.model.pz # IndepVarComp which is an ExplicitComponent
pz.add_recorder(self.recorder)
mda = self.prob.model.mda # Group
d1 = mda.d1
d1.add_recorder(self.recorder)
self.prob.setup(check=False, mode='rev')
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
self.assertEqual(
sorted(cr.system_metadata.keys()),
sorted(['root', 'mda.d1', 'pz'])
)
self.assertEqual(cr.system_metadata['root']['component_options']['test1'], 1)
self.assertEqual(cr.system_metadata['mda.d1']['component_options']['test2'], "2")
self.assertFalse('test3' in cr.system_metadata['pz']['component_options'])
assert_rel_error(
self, cr.system_metadata['pz']['scaling_factors']['output']['nonlinear']['phys'][0][1], [2.0, 2.0], 1.0e-3)
def test_reading_solver_cases(self):
self.setup_sellar_model()
self.prob.model._nonlinear_solver.recording_options[
'record_abs_error'] = True
self.prob.model._nonlinear_solver.recording_options[
'record_rel_error'] = True
self.prob.model._nonlinear_solver.recording_options[
'record_solver_residuals'] = True
self.prob.model._nonlinear_solver.add_recorder(self.recorder)
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
# Test to see if we got the correct number of cases
self.assertEqual(cr.driver_cases.num_cases, 0)
self.assertEqual(cr.system_cases.num_cases, 0)
self.assertEqual(cr.solver_cases.num_cases, 7)
# Test values from cases
last_case = cr.solver_cases.get_case(-1)
np.testing.assert_almost_equal(
last_case.abs_err, [
0.0,
],
err_msg='Case reader gives incorrect value for abs_err')
np.testing.assert_almost_equal(
last_case.rel_err, [
0.0,
],
err_msg='Case reader gives incorrect value for rel_err')
np.testing.assert_almost_equal(
last_case.outputs['x'], [
1.0,
],
err_msg='Case reader gives '
'incorrect output value for {0}'.format('x'))
np.testing.assert_almost_equal(
last_case.residuals['con2'], [
0.0,
],
err_msg='Case reader gives '
'incorrect residual value for {0}'.format('con_cmp2.con2'))
# Test to see if the case keys ( iteration coords ) come back correctly
case_keys = cr.system_cases.list_cases()
for i, iter_coord in enumerate(case_keys):
self.assertEqual(
iter_coord,
'rank0:Driver|0|root._solve_nonlinear|0|NonlinearBlockGS|{}'.
format(i))
def test_reader_instantiates(self):
""" Test that CaseReader returns an SqliteCaseReader. """
prob = SellarProblem()
prob.model.add_recorder(self.recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
self.assertTrue(isinstance(cr, SqliteCaseReader),
msg='CaseReader not returning the correct subclass.')
def test_reading_driver_cases(self):
""" Tests that the reader returns params correctly. """
prob = SellarProblem(SellarDerivativesGrouped)
driver = prob.driver = pyOptSparseDriver(optimizer='SLSQP')
driver.options['print_results'] = False
driver.opt_settings['ACC'] = 1e-9
driver.recording_options['record_desvars'] = True
driver.recording_options['record_responses'] = True
driver.recording_options['record_objectives'] = True
driver.recording_options['record_constraints'] = True
driver.add_recorder(self.recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
# Test to see if we got the correct number of cases
self.assertEqual(cr.driver_cases.num_cases, 7)
self.assertEqual(cr.system_cases.num_cases, 0)
self.assertEqual(cr.solver_cases.num_cases, 0)
# Test to see if the access by case keys works:
seventh_slsqp_iteration_case = cr.driver_cases.get_case(
'rank0:SLSQP|5')
np.testing.assert_almost_equal(
seventh_slsqp_iteration_case.outputs['z'],
[1.97846296, -2.21388305e-13],
decimal=2,
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('pz.z'))
# Test values from one case, the last case
last_case = cr.driver_cases.get_case(-1)
np.testing.assert_almost_equal(last_case.outputs['z'],
prob['z'],
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('pz.z'))
np.testing.assert_almost_equal(last_case.outputs['x'], [-0.00309521],
decimal=2,
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('px.x'))
# Test to see if the case keys (iteration coords) come back correctly
case_keys = cr.driver_cases.list_cases()
print(case_keys)
for i, iter_coord in enumerate(case_keys):
self.assertEqual(iter_coord, 'rank0:SLSQP|{}'.format(i))
def test_reading_system_cases(self):
self.setup_sellar_model()
self.prob.model.recording_options['record_inputs'] = True
self.prob.model.recording_options['record_outputs'] = True
self.prob.model.recording_options['record_residuals'] = True
self.prob.model.recording_options['record_metadata'] = False
self.prob.model.add_recorder(self.recorder)
d1 = self.prob.model.d1 # instance of SellarDis1withDerivatives, a Group
d1.add_recorder(self.recorder)
obj_cmp = self.prob.model.obj_cmp # an ExecComp
obj_cmp.add_recorder(self.recorder)
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
# Test to see if we got the correct number of cases
self.assertEqual(cr.driver_cases.num_cases, 0)
self.assertEqual(cr.system_cases.num_cases, 15)
self.assertEqual(cr.solver_cases.num_cases, 0)
# Test values from cases
second_last_case = cr.system_cases.get_case(-2)
np.testing.assert_almost_equal(second_last_case.inputs['y2'], [12.05848815, ],
err_msg='Case reader gives '
'incorrect input value for {0}'.format('obj_cmp.y2'))
np.testing.assert_almost_equal(second_last_case.outputs['obj'], [28.58830817, ],
err_msg='Case reader gives '
'incorrect output value for {0}'.format('obj_cmp.obj'))
np.testing.assert_almost_equal(second_last_case.residuals['obj'], [0.0, ],
err_msg='Case reader gives '
'incorrect residual value for {0}'.format('obj_cmp.obj'))
# Test to see if the case keys ( iteration coords ) come back correctly
case_keys = cr.system_cases.list_cases()[:-1] # Skip the last one
for i, iter_coord in enumerate(case_keys):
if i % 2 == 0:
last_solver = 'd1._solve_nonlinear'
else:
last_solver = 'obj_cmp._solve_nonlinear'
solver_iter_count = i // 2
self.assertEqual(iter_coord,
'rank0:Driver|0|root._solve_nonlinear|0|NonlinearBlockGS|{iter}|'
'{solver}|{iter}'.format(iter=solver_iter_count, solver=last_solver))
def test_reading_driver_cases(self):
""" Tests that the reader returns params correctly. """
self.setup_sellar_model_with_optimization()
self.recorder.options['record_desvars'] = True
self.recorder.options['record_responses'] = True
self.recorder.options['record_objectives'] = True
self.recorder.options['record_constraints'] = True
self.prob.driver.add_recorder(self.recorder)
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
# Test to see if we got the correct number of cases
self.assertEqual(cr.driver_cases.num_cases, 8)
self.assertEqual(cr.system_cases.num_cases, 0)
self.assertEqual(cr.solver_cases.num_cases, 0)
# Test to see if the access by case keys works:
seventh_slsqp_iteration_case = cr.driver_cases.get_case(
'rank0:SLSQP|6')
np.testing.assert_almost_equal(
seventh_slsqp_iteration_case.desvars['pz.z'],
[1.97846296, -2.21388305e-13],
decimal=2,
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('pz.z'))
# Test values from one case, the last case
last_case = cr.driver_cases.get_case(-1)
np.testing.assert_almost_equal(last_case.desvars['pz.z'],
self.prob['z'],
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('pz.z'))
np.testing.assert_almost_equal(last_case.desvars['px.x'],
[-0.00309521],
decimal=2,
err_msg='Case reader gives '
'incorrect Parameter value'
' for {0}'.format('px.x'))
# Test to see if the case keys (iteration coords) come back correctly
case_keys = cr.driver_cases.list_cases()
print(case_keys)
for i, iter_coord in enumerate(case_keys):
self.assertEqual(iter_coord, 'rank0:SLSQP|{}'.format(i))
def test_reading_metadata(self):
prob = Problem()
model = prob.model
# the Sellar problem but with units
model.add_subsystem('px', IndepVarComp('x', 1.0, units='m', lower=-1000, upper=1000), promotes=['x'])
model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z'])
model.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2'])
model.add_subsystem('d2', SellarDis2withDerivatives(), promotes=['z', 'y1', 'y2'])
model.add_subsystem('obj_cmp', ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]), x={'value': 0.0, 'units': 'm'},
y1={'units': 'm'}, y2={'units': 'cm'}),
promotes=['obj', 'x', 'z', 'y1', 'y2'])
model.add_subsystem('con_cmp1', ExecComp('con1 = 3.16 - y1'), promotes=['con1', 'y1'])
model.add_subsystem('con_cmp2', ExecComp('con2 = y2 - 24.0'), promotes=['con2', 'y2'])
model.nonlinear_solver = NonlinearBlockGS()
model.linear_solver = LinearBlockGS()
model.add_design_var('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0]))
model.add_design_var('x', lower=0.0, upper=10.0)
model.add_objective('obj')
model.add_constraint('con1', upper=0.0)
model.add_constraint('con2', upper=0.0)
prob.driver.add_recorder(self.recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
cr = CaseReader(self.filename)
self.assertEqual(cr.output2meta['x']['units'], 'm')
self.assertEqual(cr.input2meta['obj_cmp.y1']['units'], 'm')
self.assertEqual(cr.input2meta['obj_cmp.y2']['units'], 'cm')
self.assertEqual(cr.input2meta['d1.x']['units'], None)
self.assertEqual(cr.input2meta['d1.y1']['units'], None)
self.assertEqual(cr.input2meta['d1.y2']['units'], None)
self.assertEqual(cr.output2meta['x']['explicit'], True)
self.assertEqual(cr.output2meta['x']['type'], {'output', 'desvar'})
self.assertEqual(cr.input2meta['obj_cmp.y1']['explicit'], True)
self.assertEqual(cr.input2meta['obj_cmp.y2']['explicit'], True)
self.assertEqual(cr.output2meta['x']['lower'], -1000)
self.assertEqual(cr.output2meta['x']['upper'], 1000)
self.assertEqual(cr.output2meta['y2']['upper'], None)
self.assertEqual(cr.output2meta['y2']['lower'], None)
def test_reading_driver_metadata(self):
self.setup_sellar_model_with_optimization()
self.recorder.options['record_desvars'] = True
self.recorder.options['record_responses'] = True
self.recorder.options['record_objectives'] = True
self.recorder.options['record_constraints'] = True
self.prob.driver.add_recorder(self.recorder)
self.prob.setup(check=False)
self.prob.run_driver()
self.prob.cleanup()
cr = CaseReader(self.filename)
self.assertEqual(len(cr.driver_metadata['connections_list']), 11)
self.assertEqual(len(cr.driver_metadata['tree']), 4)
