def test_sellar_state_connection_densejac(self): # Test derivatives across a converged Sellar model. prob = Problem() prob.model = SellarStateConnection( linear_solver=self.linear_solver_class(), nl_atol=1e-12) prob.set_solver_print(level=0) prob.setup(check=False, mode='fwd') prob.model.sub.d1.jacobian = DenseJacobian() prob.model.sub.d2.jacobian = DenseJacobian() prob.model.sub.state_eq_group.state_eq.jacobian = DenseJacobian() prob.model.obj_cmp.jacobian = DenseJacobian() prob.model.con_cmp1.jacobian = DenseJacobian() prob.model.con_cmp2.jacobian = DenseJacobian() prob.run_model() # Just make sure we are at the right answer assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['d2.y2'], 12.05848819, .00001) wrt = ['x', 'z'] of = ['obj', 'con1', 'con2'] Jbase = {} Jbase['con1', 'x'] = [[-0.98061433]] Jbase['con1', 'z'] = np.array([[-9.61002285, -0.78449158]]) Jbase['con2', 'x'] = [[0.09692762]] Jbase['con2', 'z'] = np.array([[1.94989079, 1.0775421]]) Jbase['obj', 'x'] = [[2.98061392]] Jbase['obj', 'z'] = np.array([[9.61001155, 1.78448534]]) J = prob.compute_totals(of=of, wrt=wrt, return_format='flat_dict') for key, val in iteritems(Jbase): assert_rel_error(self, J[key], val, .00001) prob = Problem() prob.model = SellarStateConnection( linear_solver=self.linear_solver_class(), nl_atol=1e-12) prob.set_solver_print(level=0) prob.setup(check=False, mode='rev') prob.model.sub.d1.jacobian = DenseJacobian() prob.model.sub.d2.jacobian = DenseJacobian() prob.model.sub.state_eq_group.state_eq.jacobian = DenseJacobian() prob.model.obj_cmp.jacobian = DenseJacobian() prob.model.con_cmp1.jacobian = DenseJacobian() prob.model.con_cmp2.jacobian = DenseJacobian() prob.run_model() J = prob.compute_totals(of=of, wrt=wrt, return_format='flat_dict') for key, val in iteritems(Jbase): assert_rel_error(self, J[key], val, .00001)
def test_model_viewer_has_correct_data_from_problem(self): """ Verify that the correct model structure data exists when stored as compared to the expected structure, using the SellarStateConnection model. """ p = Problem(model=SellarStateConnection()) p.setup(check=False) model_viewer_data = _get_viewer_data(p) # check expected model tree self.assertDictEqual(model_viewer_data['tree'], self.expected_tree) # check expected system pathnames pathnames = model_viewer_data['sys_pathnames_list'] self.assertListEqual(sorted(pathnames), self.expected_pathnames) # check expected connections, after mapping cycle_arrows indices back to pathnames connections = model_viewer_data['connections_list'] for conn in connections: if 'cycle_arrows' in conn: cycle_arrows = [] for src, tgt in conn['cycle_arrows']: cycle_arrows.append(' '.join( [pathnames[src], pathnames[tgt]])) conn['cycle_arrows'] = sorted(cycle_arrows) self.assertListEqual(connections, self.expected_conns) # check expected abs2prom map self.assertDictEqual(model_viewer_data['abs2prom'], self.expected_abs2prom)
def test_model_viewer_has_correct_data_from_sqlite(self): """ Verify that the correct data exists when a model structure is recorded and then pulled out of a sqlite db file and compared to the expected structure. Uses the SellarStateConnection model. """ p = om.Problem(model=SellarStateConnection()) r = SqliteRecorder(self.sqlite_db_filename) p.driver.add_recorder(r) p.setup() p.final_setup() r.shutdown() model_viewer_data = _get_viewer_data(self.sqlite_db_filename) with open(os.path.join(self.parent_dir, 'sellar_tree.json')) as json_file: expected_tree = json.load(json_file) # check expected model tree self.check_model_viewer_data( model_viewer_data, expected_tree, self.expected_pathnames, self.expected_conns, self.expected_abs2prom, self.expected_declare_partials, self.expected_driver_name, self.expected_design_vars_names, self.expected_responses_names)
def test_n2_from_sqlite(self): """ Test that an n2 html file is generated from a sqlite file. """ p = om.Problem() p.model = SellarStateConnection() r = SqliteRecorder(self.sqlite_db_filename2) p.driver.add_recorder(r) p.setup() p.final_setup() r.shutdown() n2(p, outfile=self.compare_html_filename, show_browser=DEBUG_BROWSER) n2(self.sqlite_db_filename2, outfile=self.sqlite_html_filename, show_browser=DEBUG_BROWSER) # Check that the html file has been created and has something in it. self.assertTrue(os.path.isfile(self.sqlite_html_filename), (self.sqlite_html_filename + " is not a valid file.")) self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100) # Check that there are no errors when running from the command line with a recording. check_call('openmdao n2 --no_browser %s' % self.sqlite_db_filename2) # Compare models from the files generated from the Problem and the recording sqlite_model_data = self._extract_compressed_model( self.sqlite_html_filename) compare_model_data = self._extract_compressed_model( self.compare_html_filename) self.assertTrue( sqlite_model_data == compare_model_data, 'Model data from sqlite does not match data from Problem.')
def test_n2_from_sqlite(self): """ Test that an n2 html file is generated from a sqlite file. """ p = Problem() p.model = SellarStateConnection() r = SqliteRecorder(self.sqlite_db_filename2) p.driver.add_recorder(r) p.setup() p.final_setup() r.shutdown() n2(p, outfile=self.compare_html_filename, show_browser=DEBUG_BROWSER) n2(self.sqlite_db_filename2, outfile=self.sqlite_html_filename, show_browser=DEBUG_BROWSER) # Check that the html file has been created and has something in it. self.assertTrue(os.path.isfile(self.sqlite_html_filename), (self.sqlite_html_filename + " is not a valid file.")) self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100) # Check that there are no errors when running from the command line with a recording. check_call('openmdao n2 --no_browser %s' % self.sqlite_db_filename2) # Compare the sizes of the files generated from the Problem and the recording size1 = os.path.getsize(self.sqlite_html_filename) size2 = os.path.getsize(self.compare_html_filename) self.assertTrue( size1 == size2, 'File size of ' + self.sqlite_html_filename + ' is ' + str(size1) + ', but size of ' + self.compare_html_filename + ' is ' + str(size2))
def test_model_viewer_has_correct_data_from_problem(self): """ Verify that the correct model structure data exists when stored as compared to the expected structure, using the SellarStateConnection model. """ p = om.Problem(model=SellarStateConnection()) p.setup() p.final_setup() model_viewer_data = _get_viewer_data(p) with open(os.path.join(self.parent_dir, 'sellar_tree.json')) as json_file: expected_tree = json.load(json_file) # check expected model tree self.check_model_viewer_data( model_viewer_data, expected_tree, self.expected_pathnames, self.expected_conns, self.expected_abs2prom, self.expected_declare_partials, self.expected_driver_name, self.expected_design_vars_names, self.expected_responses_names )
def test_viewer_data_from_subgroup(self): """ Test error message when asking for viewer data for a subgroup. """ p = om.Problem(model=SellarStateConnection()) p.setup() msg = "Viewer data is not available for sub-Group 'sub'." with assert_warning(UserWarning, msg): _get_viewer_data(p.model.sub)
def test_view_model_from_problem(self): """ Test that an n2 html file is generated from a Problem. """ p = Problem() p.model = SellarStateConnection() p.setup(check=False) view_model(p, outfile=self.problem_filename, show_browser=False) # Check that the html file has been created and has something in it. self.assertTrue(os.path.isfile(self.problem_html_filename), (self.problem_html_filename + " is not a valid file.")) self.assertGreater(os.path.getsize(self.problem_html_filename), 100)
def test_n2_from_model(self): """ Test that an n2 html file is generated from a model. """ p = om.Problem() p.model = SellarStateConnection() p.setup() n2(p.model, outfile=self.problem_html_filename, show_browser=DEBUG_BROWSER) # Check that the html file has been created and has something in it. self.assertTrue(os.path.isfile(self.problem_html_filename), (self.problem_html_filename + " is not a valid file.")) self.assertGreater(os.path.getsize(self.problem_html_filename), 100)
def test_sellar_state_connection(self): # Sellar model closes loop with state connection instead of a cycle. prob = Problem(model=SellarStateConnection(nonlinear_solver=NewtonSolver())) prob.set_solver_print(level=0) prob.setup(check=False) prob.run_model() assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['state_eq.y2_command'], 12.05848819, .00001) # Make sure we aren't iterating like crazy self.assertLess(prob.model.nonlinear_solver._iter_count, 8)
def test_sellar_state_connection(self): # Sellar model closes loop with state connection instead of a cycle. prob = om.Problem(model=SellarStateConnection(nonlinear_solver=om.NewtonSolver(solve_subsystems=False))) prob.set_solver_print(level=0) prob.setup() prob.run_model() assert_near_equal(prob.get_val('y1'), 25.58830273, .00001) assert_near_equal(prob['state_eq.y2_command'], 12.05848819, .00001) # Make sure we aren't iterating like crazy self.assertLess(prob.model.nonlinear_solver._iter_count, 8)
def test_viewer_data_from_None(self): """ Test error message when asking for viewer data for an invalid source. """ p = om.Problem(model=SellarStateConnection()) p.setup() msg = "Viewer data is not available for 'None'." + \ "The source must be a Problem, model or the filename of a recording." with self.assertRaises(TypeError) as cm: _get_viewer_data(None) self.assertEquals(str(cm.exception), msg)
def test_error_need_direct_solver(self): # Test top level Sellar (i.e., not grouped). prob = Problem() model = prob.model = SellarStateConnection( nonlinear_solver=BroydenSolver(), linear_solver=LinearRunOnce()) prob.setup(check=False) with self.assertRaises(ValueError) as context: prob.run_model() msg = "Linear solver must be DirectSolver when solving the full model." self.assertEqual(str(context.exception), msg)
def test_model_viewer_has_correct_data_from_problem(self): """ Verify that the correct model structure data exists when stored as compared to the expected structure, using the SellarStateConnection model. """ p = Problem() p.model = SellarStateConnection() p.setup(check=False) model_viewer_data = _get_viewer_data(p) tree_json = json.dumps(model_viewer_data['tree']) conns_json = json.dumps(model_viewer_data['connections_list']) self.assertEqual(self.expected_tree_json, tree_json) self.assertEqual(self.expected_conns_json, conns_json)
def test_linsearch_3_deprecation(self): prob = om.Problem() model = prob.model = SellarStateConnection( nonlinear_solver=om.BroydenSolver(), linear_solver=om.LinearRunOnce()) prob.setup() model.nonlinear_solver.options['state_vars'] = ['state_eq.y2_command'] model.nonlinear_solver.options['compute_jacobian'] = False msg = 'Deprecation warning: In V 3.0, the default Broyden solver setup will change ' + \ 'to use the BoundsEnforceLS line search.' with assert_warning(DeprecationWarning, msg): prob.final_setup()
def test_n2_set_title(self): """ Test that an n2 html file is generated from a Problem. """ p = Problem() p.model = SellarStateConnection() p.setup() n2(p, outfile=self.title_html_filename, show_browser=DEBUG_BROWSER, title="Sellar State Connection") # Check that the html file has been created and has something in it. self.assertTrue(os.path.isfile(self.title_html_filename), (self.title_html_filename + " is not a valid file.")) self.assertTrue('OpenMDAO Model Hierarchy and N2 diagram: Sellar State Connection' in open(self.title_html_filename).read())
def test_model_viewer_has_correct_data_from_problem(self): """ Verify that the correct model structure data exists when stored as compared to the expected structure, using the SellarStateConnection model. """ p = Problem() p.model = SellarStateConnection() p.setup(check=False) model_viewer_data = _get_viewer_data(p) self.assertDictEqual(model_viewer_data['tree'], self.expected_tree) self.assertListEqual(model_viewer_data['connections_list'], self.expected_conns) self.assertDictEqual(model_viewer_data['abs2prom'], self.expected_abs2prom)
def test_error_badname(self): # Test top level Sellar (i.e., not grouped). prob = Problem() model = prob.model = SellarStateConnection( nonlinear_solver=BroydenSolver(), linear_solver=LinearRunOnce()) prob.setup(check=False) model.nonlinear_solver.options['state_vars'] = ['junk'] with self.assertRaises(ValueError) as context: prob.run_model() msg = "The following variable names were not found: junk" self.assertEqual(str(context.exception), msg)
def test_simple_sellar(self): # Test top level Sellar (i.e., not grouped). prob = om.Problem() model = prob.model = SellarStateConnection(nonlinear_solver=om.BroydenSolver(), linear_solver=om.LinearRunOnce()) prob.setup() model.nonlinear_solver.options['state_vars'] = ['state_eq.y2_command'] model.nonlinear_solver.options['compute_jacobian'] = False prob.run_model() assert_near_equal(prob['y1'], 25.58830273, .00001) assert_near_equal(prob['state_eq.y2_command'], 12.05848819, .00001)
def test_sellar_state_connection_fd_system(self): # Sellar model closes loop with state connection instead of a cycle. # This test is just fd. prob = om.Problem(model=SellarStateConnection(nonlinear_solver=om.NewtonSolver())) prob.model.approx_totals(method='fd') prob.setup() prob.set_solver_print(level=0) prob.run_model() assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['state_eq.y2_command'], 12.05848819, .00001) # Make sure we aren't iterating like crazy self.assertLess(prob.model.nonlinear_solver._iter_count, 6)
def test_view_model_from_sqlite(self): """ Test that an n2 html file is generated from a sqlite file. """ p = Problem() p.model = SellarStateConnection() r = SqliteRecorder(self.sqlite_db_filename2) p.driver.add_recorder(r) p.setup(check=False) p.final_setup() r.shutdown() view_model(self.sqlite_db_filename2, outfile=self.sqlite_filename, show_browser=False) # Check that the html file has been created and has something in it. self.assertTrue(os.path.isfile(self.sqlite_html_filename), (self.problem_html_filename + " is not a valid file.")) self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100)
def test_model_viewer_has_correct_data_from_problem(self): """ Verify that the correct model structure data exists when stored as compared to the expected structure, using the SellarStateConnection model. """ p = Problem(model=SellarStateConnection()) p.setup() p.final_setup() model_viewer_data = _get_viewer_data(p) # check expected model tree self.check_model_viewer_data( model_viewer_data, self.expected_tree, self.expected_pathnames, self.expected_conns, self.expected_abs2prom, self.expected_declare_partials, self.expected_driver_name, self.expected_design_vars_names, self.expected_responses_names)
def test_model_viewer_has_correct_data_from_sqlite(self): """ Verify that the correct data exists when a model structure is recorded and then pulled out of a sqlite db file and compared to the expected structure. Uses the SellarStateConnection model. """ p = Problem(model=SellarStateConnection()) r = SqliteRecorder(self.sqlite_db_filename) p.driver.add_recorder(r) p.setup() p.final_setup() r.shutdown() model_viewer_data = _get_viewer_data(self.sqlite_db_filename) print(model_viewer_data['tree']) # check expected model tree self.assertDictEqual(model_viewer_data['tree'], self.expected_tree) # check expected system pathnames pathnames = model_viewer_data['sys_pathnames_list'] self.assertListEqual(sorted(pathnames), self.expected_pathnames) # check expected connections, after mapping cycle_arrows indices back to pathnames connections = sorted(model_viewer_data['connections_list'], key=lambda x: (x['tgt'], x['src'])) for conn in connections: if 'cycle_arrows' in conn: cycle_arrows = [] for src, tgt in conn['cycle_arrows']: cycle_arrows.append(' '.join( [pathnames[src], pathnames[tgt]])) conn['cycle_arrows'] = sorted(cycle_arrows) self.assertEqual(len(connections), len(self.expected_conns)) for c, ex in zip(connections, self.expected_conns): self.assertEqual(c['src'], ex['src']) self.assertEqual(c['tgt'], ex['tgt']) self.assertEqual(c.get('cycle_arrows', []), ex.get('cycle_arrows', [])) # check expected abs2prom map self.assertDictEqual(model_viewer_data['abs2prom'], self.expected_abs2prom)
def test_sellar(self): from openmdao.api import Problem, LinearRunOnce, IndepVarComp, BroydenSolver from openmdao.test_suite.components.sellar import SellarStateConnection prob = Problem() model = prob.model = SellarStateConnection(nonlinear_solver=BroydenSolver(), linear_solver=LinearRunOnce()) prob.setup() model.nonlinear_solver.options['state_vars'] = ['state_eq.y2_command'] model.nonlinear_solver.options['compute_jacobian'] = False prob.set_solver_print(level=2) prob.run_model() assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['state_eq.y2_command'], 12.05848819, .00001)
def test_sellar(self): import openmdao.api as om from openmdao.test_suite.components.sellar import SellarStateConnection prob = om.Problem() model = prob.model = SellarStateConnection(nonlinear_solver=om.BroydenSolver(), linear_solver=om.LinearRunOnce()) prob.setup() model.nonlinear_solver.options['state_vars'] = ['state_eq.y2_command'] model.nonlinear_solver.options['compute_jacobian'] = False prob.set_solver_print(level=2) prob.run_model() assert_near_equal(prob['y1'], 25.58830273, .00001) assert_near_equal(prob['state_eq.y2_command'], 12.05848819, .00001)
def test_simple_sellar_full_jacobian(self): # Test top level Sellar (i.e., not grouped). prob = om.Problem() model = prob.model = SellarStateConnection(nonlinear_solver=om.BroydenSolver(), linear_solver=om.LinearRunOnce()) prob.setup() model.nonlinear_solver.linear_solver = om.DirectSolver() prob.run_model() assert_near_equal(prob['y1'], 25.58830273, .00001) assert_near_equal(prob['state_eq.y2_command'], 12.05848819, .00001) # Normally takes about 5 iters, but takes around 4 if you calculate an initial # Jacobian. self.assertTrue(model.nonlinear_solver._iter_count < 5)
def test_simple_sellar_jacobian_assembled(self): # Test top level Sellar (i.e., not grouped). prob = Problem() model = prob.model = SellarStateConnection(nonlinear_solver=BroydenSolver(), linear_solver=LinearRunOnce()) prob.setup(check=False) model.nonlinear_solver.linear_solver = DirectSolver(assemble_jac=True) prob.run_model() assert_rel_error(self, prob['y1'], 25.58830273, .00001) assert_rel_error(self, prob['state_eq.y2_command'], 12.05848819, .00001) # Normally takes about 4 iters, but takes around 3 if you calculate an initial # Jacobian. self.assertTrue(model.nonlinear_solver._iter_count < 4)
def test_model_viewer_has_correct_data_from_sqlite(self): """ Verify that the correct data exists when a model structure is recorded and then pulled out of a sqlite db file and compared to the expected structure. Uses the SellarStateConnection model. """ p = Problem() p.model = SellarStateConnection() r = SqliteRecorder(self.sqlite_db_filename) p.driver.add_recorder(r) p.setup(check=False) p.final_setup() r.close() model_viewer_data = _get_viewer_data(self.sqlite_db_filename) tree_json = json.dumps(model_viewer_data['tree']) conns_json = json.dumps(model_viewer_data['connections_list']) self.assertEqual(self.expected_tree_json, tree_json) self.assertEqual(self.expected_conns_json, conns_json)
def test_sellar_state_connection_fd_system(self): # Sellar model closes loop with state connection instead of a cycle. # This test is just fd. prob = om.Problem() model = prob.model = SellarStateConnection(nonlinear_solver=om.BroydenSolver(), linear_solver=om.LinearRunOnce()) prob.model.approx_totals(method='fd') prob.setup() model.nonlinear_solver.options['state_vars'] = ['state_eq.y2_command'] model.nonlinear_solver.options['compute_jacobian'] = False prob.run_model() assert_near_equal(prob['y1'], 25.58830273, .00001) assert_near_equal(prob['state_eq.y2_command'], 12.05848819, .00001) # Make sure we aren't iterating like crazy self.assertLess(prob.model.nonlinear_solver._iter_count, 6)
def test_view_model_from_sqlite(self): """ Test that an n2 html file is generated from a sqlite file. """ p = Problem() p.model = SellarStateConnection() r = SqliteRecorder(self.sqlite_db_filename2) p.driver.add_recorder(r) p.setup() p.final_setup() r.shutdown() view_model(self.sqlite_db_filename2, outfile=self.sqlite_html_filename, show_browser=DEBUG) # Check that the html file has been created and has something in it. self.assertTrue(os.path.isfile(self.sqlite_html_filename), (self.problem_html_filename + " is not a valid file.")) self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100) # Check that there are no errors when running from the command line with a recording. check_call('openmdao view_model --no_browser %s' % self.sqlite_db_filename2)