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)