def test_includes_and_excludes(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['includes'] = ['comp1.*'] self.recorder.options['excludes'] = ["*.y2"] self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = True prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders coordinate = [0, 'Driver', (1,)] expected_params = [ ("comp1.x1", 2.0) ] expected_unknowns = [ ("comp1.y1", 8.0) ] expected_resids = [ ("comp1.y1", 0.0) ] self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps)
def test_only_params_recorded(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = False self.recorder.options['record_unknowns'] = False prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders coordinate = [0, 'Driver', (1,)] expected_params = [ ("comp1.x1", 2.0), ("comp2.x1", 8.0), ("comp3.x1", 6.0), ("comp4.x1", 4.0), ("comp4.x2", 21.0), ("comp5.x1", 46.0), ("comp6.x1", -93.0), ("comp7.x1", 36.8), ("comp7.x2", -46.5) ] self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, None, None),), self.eps)
def test_root_derivs_array(self): prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1.0e-8 prob.driver.options['disp'] = False prob.driver.add_desvar('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar('x', lower=0.0, upper=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False self.recorder.options['record_derivs'] = True prob.setup(check=False) prob.run() prob.cleanup() sout = open(self.filename) lines = sout.readlines() self.assertEqual(lines[12].rstrip(), 'Derivatives:') self.assertTrue('9.61' in lines[13]) self.assertTrue('0.784' in lines[14]) self.assertTrue('1.077' in lines[15])
def test_root_derivs_array(self): prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = ScipyOptimizer() prob.driver.options["optimizer"] = "SLSQP" prob.driver.options["tol"] = 1.0e-8 prob.driver.options["disp"] = False prob.driver.add_desvar("z", lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar("x", lower=0.0, upper=10.0) prob.driver.add_objective("obj") prob.driver.add_constraint("con1", upper=0.0) prob.driver.add_constraint("con2", upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options["record_metadata"] = False self.recorder.options["record_derivs"] = True prob.setup(check=False) prob.run() prob.cleanup() sout = open(self.filename) lines = sout.readlines() self.assertEqual(lines[12].rstrip(), "Derivatives:") self.assertTrue("9.61" in lines[13]) self.assertTrue("0.784" in lines[14]) self.assertTrue("1.077" in lines[15])
def test_sublevel_record(self): prob = Problem() prob.root = ExampleGroup() prob.root.G2.G1.nl_solver.add_recorder(self.recorder) self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = False prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() coordinate = [0, 'Driver', (1,), "root", (1,), "G2", (1,), "G1", (1,)] expected_params = [ ("C2.x", 5.0) ] expected_unknowns = [ ("C2.y", 10.0) ] expected_resids = [ ("C2.y", 0.0) ] self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps)
def test_driver_records_unknown_types_metadata(self): prob = Problem() root = prob.root = Group() # Need an optimization problem to test to make sure # the is_desvar, is_con, is_obj metadata is being # recorded for the Unknowns root.add("p1", IndepVarComp("x", 50.0)) root.add("p2", IndepVarComp("y", 50.0)) root.add("comp", Paraboloid()) root.connect("p1.x", "comp.x") root.connect("p2.y", "comp.y") prob.driver = ScipyOptimizer() prob.driver.options["optimizer"] = "SLSQP" prob.driver.add_desvar("p1.x", lower=-50.0, upper=50.0) prob.driver.add_desvar("p2.y", lower=-50.0, upper=50.0) prob.driver.add_objective("comp.f_xy") prob.driver.options["disp"] = False prob.driver.add_recorder(self.recorder) self.recorder.options["record_metadata"] = True prob.setup(check=False) prob.cleanup() # close recorders expected_params = list(iteritems(prob.root.params)) expected_unknowns = list(iteritems(prob.root.unknowns)) expected_resids = list(iteritems(prob.root.resids)) self.assertMetadataRecorded((expected_params, expected_unknowns, expected_resids))
def test_driver_records_unknown_types_metadata(self): prob = Problem() root = prob.root = Group() # Need an optimization problem to test to make sure # the is_desvar, is_con, is_obj metadata is being # recorded for the Unknowns root.add('p1', IndepVarComp('x', 50.0)) root.add('p2', IndepVarComp('y', 50.0)) root.add('comp', Paraboloid()) root.connect('p1.x', 'comp.x') root.connect('p2.y', 'comp.y') prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.add_desvar('p1.x', lower=-50.0, upper=50.0) prob.driver.add_desvar('p2.y', lower=-50.0, upper=50.0) prob.driver.add_objective('comp.f_xy') prob.driver.options['disp'] = False prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = True prob.setup(check=False) prob.cleanup() # close recorders expected_params = list(iteritems(prob.root.params)) expected_unknowns = list(iteritems(prob.root.unknowns)) expected_resids = list(iteritems(prob.root.resids)) self.assertMetadataRecorded((expected_params, expected_unknowns, expected_resids))
def test_root_derivs_dict(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") prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = pyOptSparseDriver() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.opt_settings['ACC'] = 1e-9 prob.driver.options['print_results'] = False prob.driver.add_desvar('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar('x', lower=0.0, upper=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False self.recorder.options['record_derivs'] = True prob.setup(check=False) prob.run() prob.cleanup() self.io.seek(0) csv_reader = csv.DictReader(self.io) rows = [row for row in csv_reader] # execution row = rows[0] self.assertEqual(row['Derivatives'], '') # derivatives row = rows[1] self.assertEqual(row['obj'], '') J1 = eval(row['Derivatives'])[0] Jbase = {} Jbase['con1'] = {} Jbase['con1']['x'] = -0.98061433 Jbase['con1']['z'] = np.array([-9.61002285, -0.78449158]) Jbase['con2'] = {} Jbase['con2']['x'] = 0.09692762 Jbase['con2']['z'] = np.array([1.94989079, 1.0775421 ]) Jbase['obj'] = {} Jbase['obj']['x'] = 2.98061392 Jbase['obj']['z'] = np.array([9.61001155, 1.78448534]) for key1, val1 in Jbase.items(): for key2, val2 in val1.items(): assert_rel_error(self, J1[key1][key2], val2, .00001)
def test_multilevel_record(self): prob = Problem() prob.root = ExampleGroup() prob.root.G2.G1.nl_solver.add_recorder(self.recorder) prob.driver.add_recorder(self.recorder) self.recorder.options["record_params"] = True self.recorder.options["record_resids"] = True prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders solver_coordinate = [0, "Driver", (1,), "root", (1,), "G2", (1,), "G1", (1,)] g1_expected_params = [("C2.x", 5.0)] g1_expected_unknowns = [("C2.y", 10.0)] g1_expected_resids = [("C2.y", 0.0)] driver_coordinate = [0, "Driver", (1,)] driver_expected_params = [("G3.C3.x", 10.0)] driver_expected_unknowns = [("G2.C1.x", 5.0), ("G2.G1.C2.y", 10.0), ("G3.C3.y", 20.0), ("G3.C4.y", 40.0)] driver_expected_resids = [("G2.C1.x", 0.0), ("G2.G1.C2.y", 0.0), ("G3.C3.y", 0.0), ("G3.C4.y", 0.0)] expected = [] expected.append((solver_coordinate, (t0, t1), g1_expected_params, g1_expected_unknowns, g1_expected_resids)) expected.append( (driver_coordinate, (t0, t1), driver_expected_params, driver_expected_unknowns, driver_expected_resids) ) self.assertIterationDataRecorded(expected, self.eps)
def test_only_resids_recorded(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['record_params'] = False self.recorder.options['record_unknowns'] = False self.recorder.options['record_resids'] = True prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders coordinate = [0, 'Driver', (1, )] expected_resids = [ ("comp1.y1", 0.0), ("comp1.y2", 0.0), ("comp2.y1", 0.0), ("comp3.y1", 0.0), ("comp4.y1", 0.0), ("comp4.y2", 0.0), ("comp5.y1", 0.0), ("comp6.y1", 0.0), ("comp7.y1", 0.0), ("p.x", 0.0) ] self.assertIterationDataRecorded(((coordinate, (t0, t1), None, None, expected_resids),), self.eps)
def test_only_unknowns_recorded(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders coordinate = [0, 'Driver', (1, )] expected_unknowns = [ ("comp1.y1", 8.0), ("comp1.y2", 6.0), ("comp2.y1", 4.0), ("comp3.y1", 21.0), ("comp4.y1", 46.0), ("comp4.y2", -93.0), ("comp5.y1", 36.8), ("comp6.y1", -46.5), ("comp7.y1", -102.7), ("p.x", 2.0) ] self.assertIterationDataRecorded(((coordinate, (t0, t1), None, expected_unknowns, None),), self.eps)
def test_driver_doesnt_record_metadata(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False prob.setup(check=False) prob.cleanup() # closes recorders self.assertMetadataRecorded(None)
def test_root_solver_doesnt_record_metadata(self): prob = Problem() prob.root = ConvergeDiverge() prob.root.nl_solver.add_recorder(self.recorder) self.recorder.options["record_metadata"] = False prob.setup(check=False) prob.cleanup() self.assertMetadataRecorded(None)
def test_subsolver_doesnt_record_metadata(self): prob = Problem() prob.root = ExampleGroup() prob.root.G2.G1.nl_solver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False prob.setup(check=False) prob.cleanup() # closes recorders self.assertMetadataRecorded(None)
def test_basic(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options["record_params"] = True self.recorder.options["record_resids"] = True self.recorder.options["record_resids"] = False prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() coordinate = [0, "Driver", (1,)] expected_params = [ ("comp1.x1", 2.0), ("comp2.x1", 8.0), ("comp3.x1", 6.0), ("comp4.x1", 4.0), ("comp4.x2", 21.0), ("comp5.x1", 46.0), ("comp6.x1", -93.0), ("comp7.x1", 36.8), ("comp7.x2", -46.5), ] expected_unknowns = [ ("comp1.y1", 8.0), ("comp1.y2", 6.0), ("comp2.y1", 4.0), ("comp3.y1", 21.0), ("comp4.y1", 46.0), ("comp4.y2", -93.0), ("comp5.y1", 36.8), ("comp6.y1", -46.5), ("comp7.y1", -102.7), ("p.x", 2.0), ] expected_resids = [ ("comp1.y1", 0.0), ("comp1.y2", 0.0), ("comp2.y1", 0.0), ("comp3.y1", 0.0), ("comp4.y1", 0.0), ("comp4.y2", 0.0), ("comp5.y1", 0.0), ("comp6.y1", 0.0), ("comp7.y1", 0.0), ("p.x", 0.0), ] self.assertIterationDataRecorded( ((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps )
def test_multilevel_record(self): # FIXME: this test fails with the csv recorder self.recorder.close() raise unittest.SkipTest('This is not supported by the csv recorder yet.') prob = Problem() prob.root = ExampleGroup() prob.root.G2.G1.nl_solver.add_recorder(self.recorder) prob.driver.add_recorder(self.recorder) self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = True prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() solver_coordinate = ['Driver', (1,), "root", (1,), "G2", (1,), "G1", (1,)] g1_expected_params = [ ("C2.x", 5.0) ] g1_expected_unknowns = [ ("C2.y", 10.0) ] g1_expected_resids = [ ("C2.y", 0.0) ] # g1_expected = (g1_expected_params, g1_expected_unknowns, g1_expected_resids) driver_coordinate = ['Driver', (1,)] driver_expected_params = [ ("G3.C3.x", 10.0) ] driver_expected_unknowns = [ ("G2.C1.x", 5.0), ("G2.G1.C2.y", 10.0), ("G3.C3.y", 20.0), ("G3.C4.y", 40.0), ] driver_expected_resids = [ ("G2.C1.x", 0.0), ("G2.G1.C2.y", 0.0), ("G3.C3.y", 0.0), ("G3.C4.y", 0.0), ] expected = [] expected.append((solver_coordinate, (t0, t1), g1_expected_params, g1_expected_unknowns, g1_expected_resids)) expected.append((driver_coordinate, (t0, t1), driver_expected_params, driver_expected_unknowns, driver_expected_resids)) self.assertIterationDataRecorded(expected, self.eps)
def test_subsolver_records_metadata(self): prob = Problem() prob.root = ExampleGroup() prob.root.G2.G1.nl_solver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = True prob.setup(check=False) prob.cleanup() # closes recorders expected_params = list(iteritems(prob.root.params)) expected_unknowns = list(iteritems(prob.root.unknowns)) expected_resids = list(iteritems(prob.root.resids)) self.assertMetadataRecorded((expected_params, expected_unknowns, expected_resids))
def test_driver_records_metadata(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = True prob.setup(check=False) prob.cleanup() # close recorders expected_params = list(iteritems(prob.root.params)) expected_unknowns = list(iteritems(prob.root.unknowns)) expected_resids = list(iteritems(prob.root.resids)) self.assertMetadataRecorded((expected_params, expected_unknowns, expected_resids))
def test_root_derivs_dict(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") prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = pyOptSparseDriver() prob.driver.options["optimizer"] = "SLSQP" prob.driver.opt_settings["ACC"] = 1e-9 prob.driver.options["print_results"] = False prob.driver.add_desvar("z", lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar("x", lower=0.0, upper=10.0) prob.driver.add_objective("obj") prob.driver.add_constraint("con1", upper=0.0) prob.driver.add_constraint("con2", upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options["record_metadata"] = False self.recorder.options["record_derivs"] = True prob.setup(check=False) prob.run() prob.cleanup() db = SqliteDict(self.filename, self.tablename_derivs, flag="r") J1 = db["rank0:SLSQP|1"]["Derivatives"] Jbase = {} Jbase["con1"] = {} Jbase["con1"]["x"] = -0.98061433 Jbase["con1"]["z"] = np.array([-9.61002285, -0.78449158]) Jbase["con2"] = {} Jbase["con2"]["x"] = 0.09692762 Jbase["con2"]["z"] = np.array([1.94989079, 1.0775421]) Jbase["obj"] = {} Jbase["obj"]["x"] = 2.98061392 Jbase["obj"]["z"] = np.array([9.61001155, 1.78448534]) for key1, val1 in Jbase.items(): for key2, val2 in val1.items(): assert_rel_error(self, J1[key1][key2], val2, 0.00001)
def test_root_derivs_array(self): prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1.0e-8 prob.driver.options['disp'] = False prob.driver.add_desvar('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar('x', lower=0.0, upper=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False self.recorder.options['record_derivs'] = True prob.setup(check=False) prob.run() prob.cleanup() self.io.seek(0) csv_reader = csv.DictReader(self.io) rows = [row for row in csv_reader] # execution row = rows[0] self.assertEqual(row['Derivatives'], '') # derivatives row = rows[1] self.assertEqual(row['obj'], '') J1 = eval('array(' + row['Derivatives'] + ')')[0] assert_rel_error(self, J1[0][0], 9.61001155, .00001) assert_rel_error(self, J1[0][1], 1.78448534, .00001) assert_rel_error(self, J1[0][2], 2.98061392, .00001) assert_rel_error(self, J1[1][0], -9.61002285, .00001) assert_rel_error(self, J1[1][1], -0.78449158, .00001) assert_rel_error(self, J1[1][2], -0.98061433, .00001) assert_rel_error(self, J1[2][0], 1.94989079, .00001) assert_rel_error(self, J1[2][1], 1.0775421, .00001) assert_rel_error(self, J1[2][2], 0.09692762, .00001)
def test_root_derivs_array(self): prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = ScipyOptimizer() prob.driver.options["optimizer"] = "SLSQP" prob.driver.options["tol"] = 1.0e-8 prob.driver.options["disp"] = False prob.driver.add_desvar("z", lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar("x", lower=0.0, upper=10.0) prob.driver.add_objective("obj") prob.driver.add_constraint("con1", upper=0.0) prob.driver.add_constraint("con2", upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options["record_metadata"] = False self.recorder.options["record_derivs"] = True prob.setup(check=False) prob.run() prob.cleanup() self.io.seek(0) csv_reader = csv.DictReader(self.io) rows = [row for row in csv_reader] # execution row = rows[0] self.assertEqual(row["Derivatives"], "") # derivatives row = rows[1] self.assertEqual(row["obj"], "") J1 = eval("array(" + row["Derivatives"] + ")")[0] assert_rel_error(self, J1[0][0], 9.61001155, 0.00001) assert_rel_error(self, J1[0][1], 1.78448534, 0.00001) assert_rel_error(self, J1[0][2], 2.98061392, 0.00001) assert_rel_error(self, J1[1][0], -9.61002285, 0.00001) assert_rel_error(self, J1[1][1], -0.78449158, 0.00001) assert_rel_error(self, J1[1][2], -0.98061433, 0.00001) assert_rel_error(self, J1[2][0], 1.94989079, 0.00001) assert_rel_error(self, J1[2][1], 1.0775421, 0.00001) assert_rel_error(self, J1[2][2], 0.09692762, 0.00001)
def test_recording_system_metadata(self): prob = Problem() prob.root = ConvergeDiverge() prob.root.add_metadata("string", "just a test") prob.root.add_metadata("ints", [1, 2, 3]) prob.driver.add_recorder(self.recorder) self.recorder.options["record_metadata"] = True prob.setup(check=False) prob.cleanup() # closes recorders # check the system metadata recording sqlite_metadata = SqliteDict(filename=self.filename, flag="r", tablename="metadata") system_metadata = sqlite_metadata["system_metadata"] self.assertEqual(len(system_metadata), 2) self.assertEqual(system_metadata["string"], "just a test") self.assertEqual(system_metadata["ints"], [1, 2, 3]) sqlite_metadata.close()
def test_recording_model_viewer_data(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options["record_metadata"] = True prob.setup(check=False) prob.cleanup() # closes recorders # do some basic tests to make sure the model_viewer_data was recorded db = SqliteDict(filename=self.filename, flag="r", tablename="metadata") model_viewer_data = db["model_viewer_data"] tr = model_viewer_data["tree"] self.assertEqual(set(["name", "type", "subsystem_type", "children"]), set(tr.keys())) cl = model_viewer_data["connections_list"] for c in cl: self.assertEqual(set(["src", "tgt"]), set(c.keys())) db.close()
def test_root_derivs_dict(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") prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = pyOptSparseDriver() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.opt_settings['ACC'] = 1e-9 prob.driver.options['print_results'] = False self.recorder.options['record_unknowns'] = True prob.driver.add_desvar('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar('x', lower=0.0, upper=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False self.recorder.options['record_derivs'] = True prob.setup(check=False) prob.run() prob.cleanup() sout = open(self.filename) lines = sout.readlines() self.assertEqual(lines[12].rstrip(), 'Derivatives:') self.assertTrue(' con1 wrt x:' in lines[13]) self.assertTrue(' con1 wrt z:' in lines[14]) self.assertTrue(' con2 wrt x:' in lines[15]) self.assertTrue(' con2 wrt z:' in lines[16]) self.assertTrue(' obj wrt x:' in lines[17]) self.assertTrue(' obj wrt z:' in lines[18]) self.assertTrue('1.784' in lines[18])
def test_load_driver_cases(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 50.0), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 50.0), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_subsystem('con', ExecComp('c = x - y'), promotes=['*']) prob.set_solver_print(level=0) prob.driver = ScipyOptimizeDriver() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1e-9 prob.driver.options['disp'] = False model.add_design_var('x', lower=-50.0, upper=50.0) model.add_design_var('y', lower=-50.0, upper=50.0) model.add_objective('f_xy') model.add_constraint('c', lower=15.0) prob.driver.add_recorder(self.recorder) prob.set_solver_print(0) prob.setup() prob.run_driver() prob.cleanup() cr = CaseReader(self.filename) case = cr.driver_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: prob.model._inputs[name] += 1.0 for name in prob.model._outputs: prob.model._outputs[name] += 1.0 # Now load in the case we recorded prob.load_case(case) _assert_model_matches_case(case, model)
def test_multilevel_record(self): prob = Problem() prob.root = ExampleGroup() prob.root.G2.G1.nl_solver.add_recorder(self.recorder) prob.driver.add_recorder(self.recorder) self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = True prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders solver_coordinate = [ 0, 'Driver', (1, ), "root", (1, ), "G2", (1, ), "G1", (1, ) ] g1_expected_params = [("C2.x", 5.0)] g1_expected_unknowns = [("C2.y", 10.0)] g1_expected_resids = [("C2.y", 0.0)] driver_coordinate = [0, 'Driver', (1, )] driver_expected_params = [("G3.C3.x", 10.0)] driver_expected_unknowns = [ ("G2.C1.x", 5.0), ("G2.G1.C2.y", 10.0), ("G3.C3.y", 20.0), ("G3.C4.y", 40.0), ] driver_expected_resids = [ ("G2.C1.x", 0.0), ("G2.G1.C2.y", 0.0), ("G3.C3.y", 0.0), ("G3.C4.y", 0.0), ] expected = [] expected.append((solver_coordinate, (t0, t1), g1_expected_params, g1_expected_unknowns, g1_expected_resids)) expected.append((driver_coordinate, (t0, t1), driver_expected_params, driver_expected_unknowns, driver_expected_resids)) self.assertIterationDataRecorded(expected, self.eps)
def test_root_derivs_dict(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") prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = pyOptSparseDriver() prob.driver.options["optimizer"] = "SLSQP" prob.driver.opt_settings["ACC"] = 1e-9 prob.driver.options["print_results"] = False self.recorder.options["record_unknowns"] = True prob.driver.add_desvar("z", lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar("x", lower=0.0, upper=10.0) prob.driver.add_objective("obj") prob.driver.add_constraint("con1", upper=0.0) prob.driver.add_constraint("con2", upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options["record_metadata"] = False self.recorder.options["record_derivs"] = True prob.setup(check=False) prob.run() prob.cleanup() sout = open(self.filename) lines = sout.readlines() self.assertEqual(lines[12].rstrip(), "Derivatives:") self.assertTrue(" con1 wrt x:" in lines[13]) self.assertTrue(" con1 wrt z:" in lines[14]) self.assertTrue(" con2 wrt x:" in lines[15]) self.assertTrue(" con2 wrt z:" in lines[16]) self.assertTrue(" obj wrt x:" in lines[17]) self.assertTrue(" obj wrt z:" in lines[18]) self.assertTrue("1.784" in lines[18])
def test_distrib_record_driver(self): size = 100 # how many items in the array prob = Problem() prob.model.add_subsystem('des_vars', IndepVarComp('x', np.ones(size)), promotes=['x']) prob.model.add_subsystem('plus', DistributedAdder(size), promotes=['x', 'y']) prob.model.add_subsystem('summer', Summer(size), promotes=['y', 'sum']) prob.driver.recording_options['record_desvars'] = True prob.driver.recording_options['record_responses'] = True prob.driver.recording_options['record_objectives'] = True prob.driver.recording_options['record_constraints'] = True prob.driver.recording_options['includes'] = [] prob.driver.add_recorder(self.recorder) prob.model.add_design_var('x') prob.model.add_objective('sum') prob.setup() prob['x'] = np.ones(size) t0, t1 = run_driver(prob) prob.cleanup() if prob.comm.rank == 0: coordinate = [0, 'Driver', (0, )] expected_desvars = { "des_vars.x": prob['des_vars.x'], } expected_objectives = { "summer.sum": prob['summer.sum'], } expected_outputs = expected_desvars expected_outputs.update(expected_objectives) expected_data = ((coordinate, (t0, t1), expected_outputs, None), ) assertDriverIterDataRecorded(self, expected_data, self.eps)
def test_full_factorial(self): from openmdao.api import Problem, IndepVarComp, PETScVector from openmdao.test_suite.components.paraboloid import Paraboloid from openmdao.api import DOEDriver, FullFactorialGenerator from openmdao.api import SqliteRecorder, CaseReader from mpi4py import MPI prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x']) model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y']) model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy']) model.add_design_var('x', lower=0.0, upper=1.0) model.add_design_var('y', lower=0.0, upper=1.0) model.add_objective('f_xy') prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.options['parallel'] = True prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup() prob.run_driver() prob.cleanup() self.assertEqual(MPI.COMM_WORLD.size, 2) # check recorded cases from each case file rank = MPI.COMM_WORLD.rank filename = "CASES.db_%d" % rank self.assertEqual(filename, "CASES.db_%d" % rank) cases = CaseReader(filename).driver_cases self.assertEqual(cases.num_cases, 5 if rank == 0 else 4) values = [] for n in range(cases.num_cases): case = cases.get_case(n) values.append((case.outputs['x'], case.outputs['y'], case.outputs['f_xy']))
def test_recording_system_metadata(self): prob = Problem() prob.root = ConvergeDiverge() prob.root.add_metadata('string', 'just a test') prob.root.add_metadata('ints', [1, 2, 3]) prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = True prob.setup(check=False) prob.cleanup() # closes recorders # check the system metadata recording sqlite_metadata = SqliteDict(filename=self.filename, flag='r', tablename='metadata') system_metadata = sqlite_metadata['system_metadata'] self.assertEqual(len(system_metadata), 2) self.assertEqual(system_metadata['string'], 'just a test') self.assertEqual(system_metadata['ints'], [1, 2, 3]) sqlite_metadata.close()
def test_distrib_record_driver(self): size = 100 # how many items in the array prob = Problem() prob.model = Group() prob.model.add_subsystem('des_vars', IndepVarComp('x', np.ones(size)), promotes=['x']) prob.model.add_subsystem('plus', DistributedAdder(size), promotes=['x', 'y']) prob.model.add_subsystem('summer', Summer(size), promotes=['y', 'sum']) self.recorder.options['record_desvars'] = True self.recorder.options['record_responses'] = True self.recorder.options['record_objectives'] = True self.recorder.options['record_constraints'] = True prob.driver.add_recorder(self.recorder) prob.model.add_design_var('x') prob.model.add_objective('sum') prob.setup(vector_class=PETScVector, check=False) prob['x'] = np.ones(size) t0, t1 = run_driver(prob) prob.cleanup() if prob.comm.rank == 0: coordinate = [0, 'Driver', (0, )] expected_desvars = { "des_vars.x": prob['des_vars.x'], } expected_objectives = { "summer.sum": prob['summer.sum'], } self.assertDriverIterationDataRecorded( ((coordinate, (t0, t1), expected_desvars, None, expected_objectives, None, None), ), self.eps)
def generate(method, params, **kwargs): # map method to openmdao driver assert method in _METHOD_TO_DRIVER.keys() _driver = _METHOD_TO_DRIVER[method]['cls'] # cast and check params matix if not isinstance(params, np.ndarray): params = np.asarray(params, dtype=float) assert len(params.shape) == 2 assert params.shape[1] == 2 # check for required keyword arguments parsed_keys = kwargs.keys() for req_arg in _METHOD_TO_DRIVER[method]['req_args']: assert req_arg in parsed_keys # construct openmdao problem num_params = len(params) top = Problem() top.root = Group() top.driver = _driver(**kwargs) i = 0 for vmin, vmax in params: pname = 'p%d' % i vname = 'v%d' % i top.root.add(pname, IndepVarComp(vname, 0.0), promotes=['*']) top.driver.add_desvar(vname, lower=float(vmin), upper=float(vmax)) i += 1 doe = [] top.root.add('pout', _CaptureParams(num_params, doe), promotes=['*']) top.driver.add_objective('vout') # setup, run and terminate the openmdao problem top.setup(check=False) top.run() top.cleanup() del top.driver del top.root del top # return as a numpy array return np.array(doe)
def test_includes(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['includes'] = ['comp1.*'] self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = True prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders coordinate = [0, 'Driver', (1, )] expected_params = [("comp1.x1", 2.0)] expected_unknowns = [("comp1.y1", 8.0), ("comp1.y2", 6.0)] expected_resids = [("comp1.y1", 0.0), ("comp1.y2", 0.0)] self.assertIterationDataRecorded( ((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids), ), self.eps)
def test_sublevel_record(self): prob = Problem() prob.root = ExampleGroup() prob.root.G2.G1.nl_solver.add_recorder(self.recorder) self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = True prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # close recorders coordinate = ['Driver', (1, ), "root", (1, ), "G2", (1, ), "G1", (1, )] expected_params = [("C2.x", 5.0)] expected_unknowns = [("C2.y", 10.0)] expected_resids = [("C2.y", 0.0)] self.assertIterationDataRecorded( ((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids), ), self.eps)
def test_includes(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options["includes"] = ["comp1.*"] self.recorder.options["record_params"] = True self.recorder.options["record_resids"] = False prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() coordinate = [0, "Driver", (1,)] expected_params = [("comp1.x1", 2.0)] expected_unknowns = [("comp1.y1", 8.0), ("comp1.y2", 6.0)] expected_resids = [("comp1.y1", 0.0), ("comp1.y2", 0.0)] self.assertIterationDataRecorded( ((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps )
def test_only_unknowns_recorded(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders coordinate = [0, 'Driver', (1, )] expected_unknowns = [("comp1.y1", 8.0), ("comp1.y2", 6.0), ("comp2.y1", 4.0), ("comp3.y1", 21.0), ("comp4.y1", 46.0), ("comp4.y2", -93.0), ("comp5.y1", 36.8), ("comp6.y1", -46.5), ("comp7.y1", -102.7), ("p.x", 2.0)] self.assertIterationDataRecorded( ((coordinate, (t0, t1), None, expected_unknowns, None), ), self.eps)
def test_fan_in_grouped(self): from openmdao.api import Problem, PETScVector from openmdao.test_suite.groups.parallel_groups import FanInGrouped from openmdao.api import DOEDriver, FullFactorialGenerator from openmdao.api import SqliteRecorder, CaseReader from mpi4py import MPI prob = Problem(FanInGrouped()) model = prob.model model.add_design_var('iv.x1', lower=0.0, upper=1.0) model.add_design_var('iv.x2', lower=0.0, upper=1.0) model.add_objective('c3.y') prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.add_recorder(SqliteRecorder("CASES.db")) doe_parallel = prob.driver.options['parallel'] = 2 prob.setup() prob.run_driver() prob.cleanup() rank = MPI.COMM_WORLD.rank # check recorded cases from each case file if rank < doe_parallel: filename = "CASES.db_%d" % rank cases = CaseReader(filename).driver_cases values = [] for n in range(cases.num_cases): case = cases.get_case(n) values.append((case.outputs['iv.x1'], case.outputs['iv.x2'], case.outputs['c3.y'])) self.assertEqual("\n"+"\n".join(["iv.x1: %5.2f, iv.x2: %5.2f, c3.y: %6.2f" % (x1, x2, y) for x1, x2, y in values]), self.expect_text)
def test_diff_conn_input_units_w_src(self): raise unittest.SkipTest( "no compatability checking of connected inputs yet") p = Problem() root = p.model num_comps = 50 root.add_subsystem("desvars", IndepVarComp('dvar1', 1.0)) # add a bunch of comps for i in range(num_comps): if i % 2 == 0: units = "ft" else: units = "m" root.add_subsystem("C%d" % i, ExecComp('y=x*2.0', units={'x': units})) # connect all of their inputs (which have different units) for i in range(1, num_comps): root.connect("C%d.x" % (i - 1), "C%d.x" % i) try: p.setup() except Exception as err: self.assertTrue( "The following connected inputs have no source and different units" in str(err)) else: self.fail("Exception expected") # now, connect a source and the error should go away p.cleanup() root.connect('desvars.dvar1', 'C10.x') p.setup()
def test_full_factorial(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x']) model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y']) model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy']) model.add_design_var('x', lower=0.0, upper=1.0) model.add_design_var('y', lower=0.0, upper=1.0) model.add_objective('f_xy') prob.driver = DOEDriver(generator=FullFactorialGenerator(levels=3)) prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup(check=False) prob.run_driver() prob.cleanup() expected = { 0: {'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])}, 1: {'x': np.array([.5]), 'y': np.array([0.]), 'f_xy': np.array([19.25])}, 2: {'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])}, 3: {'x': np.array([0.]), 'y': np.array([.5]), 'f_xy': np.array([26.25])}, 4: {'x': np.array([.5]), 'y': np.array([.5]), 'f_xy': np.array([23.75])}, 5: {'x': np.array([1.]), 'y': np.array([.5]), 'f_xy': np.array([21.75])}, 6: {'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])}, 7: {'x': np.array([.5]), 'y': np.array([1.]), 'f_xy': np.array([28.75])}, 8: {'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])}, } cases = CaseReader("CASES.db").driver_cases self.assertEqual(cases.num_cases, 9) for n in range(cases.num_cases): self.assertEqual(cases.get_case(n).outputs['x'], expected[n]['x']) self.assertEqual(cases.get_case(n).outputs['y'], expected[n]['y']) self.assertEqual(cases.get_case(n).outputs['f_xy'], expected[n]['f_xy'])
def test_distrib_record_driver(self): size = 100 # how many items in the array prob = Problem() prob.model = Group() prob.model.add_subsystem('des_vars', IndepVarComp('x', np.ones(size)), promotes=['x']) prob.model.add_subsystem('plus', DistributedAdder(size), promotes=['x', 'y']) prob.model.add_subsystem('summer', Summer(size), promotes=['y', 'sum']) prob.driver.recording_options['record_desvars'] = True prob.driver.recording_options['record_responses'] = True prob.driver.recording_options['record_objectives'] = True prob.driver.recording_options['record_constraints'] = True prob.driver.recording_options['includes'] = [] prob.driver.add_recorder(self.recorder) prob.model.add_design_var('x') prob.model.add_objective('sum') prob.setup(check=False) prob['x'] = np.ones(size) t0, t1 = run_driver(prob) prob.cleanup() if prob.comm.rank == 0: coordinate = [0, 'Driver', (0,)] expected_desvars = { "des_vars.x": prob['des_vars.x'], } expected_objectives = { "summer.sum": prob['summer.sum'], } expected_outputs = expected_desvars expected_outputs.update(expected_objectives) expected_data = ((coordinate, (t0, t1), expected_outputs, None),) assertDriverIterDataRecorded(self, expected_data, self.eps)
def test_only_params_recorded(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = False self.recorder.options['record_unknowns'] = False prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders coordinate = [0, 'Driver', (1, )] expected_params = [("comp1.x1", 2.0), ("comp2.x1", 8.0), ("comp3.x1", 6.0), ("comp4.x1", 4.0), ("comp4.x2", 21.0), ("comp5.x1", 46.0), ("comp6.x1", -93.0), ("comp7.x1", 36.8), ("comp7.x2", -46.5)] self.assertIterationDataRecorded( ((coordinate, (t0, t1), expected_params, None, None), ), self.eps)
def test_opt_cylinder_nested(self, which_err=None, check=False): prob = Problem(root=Group()) driver = prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['disp'] = False prob.driver.add_desvar("indep.r", lower=0.0, upper=1.e99) prob.driver.add_desvar("indep.h", lower=0.0, upper=1.e99) prob.driver.add_objective("subprob.cylinder.area") prob.driver.add_constraint("subprob.cylinder.volume", equals=1.5) # we need IndepVarComp for model params at top level because the top level # driver has them as design vars. prob.root.add("indep", IndepVarComp([('r', 1.0, {'units':'cm'}), ('h', 1.0, {'units':'cm'})])) subprob = ErrProb(which_err=which_err, root=CylinderGroup()) prob.root.add('subprob', SubProblem(subprob, params=['indep.r', 'indep.h'], unknowns=['cylinder.area', 'cylinder.volume'])) prob.root.connect('indep.r', 'subprob.indep.r') prob.root.connect('indep.h', 'subprob.indep.h') # we have to set check=True to test some error handling, but never # want to see the output, so just send it to a cStringIO prob.setup(check=check, out_stream=cStringIO()) prob.run() self.assertAlmostEqual(prob['subprob.cylinder.volume'], 1.5, places=4, msg="volume should be 1.5, but got %s" % prob['subprob.cylinder.volume']) for name, opt in cylinder_opts: self.assertAlmostEqual(prob[name], opt, places=4, msg="%s should be %s, but got %s" % (name, opt, prob[name])) prob.cleanup()
def omdaoSingle(record): print 'Executing a single instance of an OpenMDAO-defined FAST component' print '' # Imports from runFAST_v8 import runFAST_v8 from openmdao.api import Group, Problem, Component, IndepVarComp, ParallelGroup from FASTv8_aeroelasticsolver import FASTv8_Workflow # Initial OpenMDAO problem setup top = Problem() root = top.root = Group() # Setup input config dictionary. For OpenMDAO cases, fst_exe, fst_dir, etc. are specified # in config dictionary alongside FST/AeroDyn/ElastoDyn parameters. Running directory is # automatically setup inside of FASTv8_Workflow and assumes directory run_omdao exists. caseid = "omdaoSingleCase" cfg = { 'fst_exe': "/home/sebasanper/Downloads/FAST_v8.15.00a-bjj/bin/FAST_glin64", 'fst_dir': "TemplateTest/", 'fst_file': "Test18_.fst", 'DT': 0.02, 'TMax': 10, 'fstInst.run_dir': "run", 'InflowFile': "Wind/turbsim.dat" } root.add('fast_component', FASTv8_Workflow(cfg, caseid)) # Set up recorder if desired (requires sqlite) if record: from openmdao.api import SqliteRecorder recorder = SqliteRecorder('omdaosingle.sqlite') top.driver.add_recorder(recorder) # Perform setup and run OpenMDAO problem top.setup() top.run() print root.fast_component.unknowns['GenPwr'] top.cleanup() # Good practice, especially when using recorder
def test_no_generator(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_design_var('x', lower=-10, upper=10) model.add_design_var('y', lower=-10, upper=10) model.add_objective('f_xy') prob.driver = DOEDriver() prob.driver.add_recorder(SqliteRecorder("cases.sql")) prob.setup(check=False) prob.run_driver() prob.cleanup() cases = CaseReader("cases.sql").driver_cases self.assertEqual(cases.num_cases, 0)
def test_root_derivs_array(self): prob = Problem() prob.root = SellarDerivativesGrouped() prob.driver = ScipyOptimizer() prob.driver.options['optimizer'] = 'SLSQP' prob.driver.options['tol'] = 1.0e-8 prob.driver.options['disp'] = False prob.driver.add_desvar('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) prob.driver.add_desvar('x', lower=0.0, upper=10.0) prob.driver.add_objective('obj') prob.driver.add_constraint('con1', upper=0.0) prob.driver.add_constraint('con2', upper=0.0) prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False self.recorder.options['record_derivs'] = True prob.setup(check=False) prob.run() prob.cleanup() db = SqliteDict(self.filename, self.tablename, flag='r') J1 = db['rank0:SLSQP/1/derivs']['Derivatives'] assert_rel_error(self, J1[0][0], 9.61001155, .00001) assert_rel_error(self, J1[0][1], 1.78448534, .00001) assert_rel_error(self, J1[0][2], 2.98061392, .00001) assert_rel_error(self, J1[1][0], -9.61002285, .00001) assert_rel_error(self, J1[1][1], -0.78449158, .00001) assert_rel_error(self, J1[1][2], -0.98061433, .00001) assert_rel_error(self, J1[2][0], 1.94989079, .00001) assert_rel_error(self, J1[2][1], 1.0775421, .00001) assert_rel_error(self, J1[2][2], 0.09692762, .00001)
def test_only_resids_recorded(self): prob = Problem() prob.root = ConvergeDiverge() prob.driver.add_recorder(self.recorder) self.recorder.options['record_params'] = False self.recorder.options['record_unknowns'] = False self.recorder.options['record_resids'] = True prob.setup(check=False) t0, t1 = run_problem(prob) prob.cleanup() # closes recorders coordinate = [0, 'Driver', (1, )] expected_resids = [("comp1.y1", 0.0), ("comp1.y2", 0.0), ("comp2.y1", 0.0), ("comp3.y1", 0.0), ("comp4.y1", 0.0), ("comp4.y2", 0.0), ("comp5.y1", 0.0), ("comp6.y1", 0.0), ("comp7.y1", 0.0), ("p.x", 0.0)] self.assertIterationDataRecorded( ((coordinate, (t0, t1), None, None, expected_resids), ), self.eps)
def _setup_test_case(case, record_params=True, record_resids=True, record_unknowns=True, record_derivs=True, record_metadata=True, optimizer='scipy'): case.dir = mkdtemp() case.filename = os.path.join(case.dir, "sqlite_test") case.recorder = SqliteRecorder(case.filename) prob = Problem() root = prob.root = Group() root.add('p1', IndepVarComp('xy', np.zeros((2,)))) root.add('p', Paraboloid()) root.connect('p1.xy', 'p.x', src_indices=[0]) root.connect('p1.xy', 'p.y', src_indices=[1]) prob.driver = optimizers[optimizer]() prob.driver.add_desvar('p1.xy', lower=-1, upper=10, scaler=1.0, adder=0.0) prob.driver.add_objective('p.f_xy', scaler=1.0, adder=0.0) prob.driver.add_recorder(case.recorder) case.recorder.options['record_params'] = record_params case.recorder.options['record_resids'] = record_resids case.recorder.options['record_unknowns'] = record_unknowns case.recorder.options['record_metadata'] = record_metadata case.recorder.options['record_derivs'] = record_derivs prob.setup(check=False) prob['p1.xy'][0] = 10.0 prob['p1.xy'][1] = 10.0 case.original_path = os.getcwd() os.chdir(case.dir) prob.run() prob.cleanup() # closes recorders
def test_uniform(self): from openmdao.api import Problem, IndepVarComp from openmdao.test_suite.components.paraboloid import Paraboloid from openmdao.api import DOEDriver, UniformGenerator, SqliteRecorder, CaseReader prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_design_var('x', lower=-10, upper=10) model.add_design_var('y', lower=-10, upper=10) model.add_objective('f_xy') prob.driver = DOEDriver(UniformGenerator(num_samples=5)) prob.driver.add_recorder(SqliteRecorder("cases.sql")) prob.setup() prob.run_driver() prob.cleanup() cases = CaseReader("cases.sql").driver_cases self.assertEqual(cases.num_cases, 5) values = [] for n in range(cases.num_cases): outputs = cases.get_case(n).outputs values.append((outputs['x'], outputs['y'], outputs['f_xy'])) print("\n".join([ "x: %5.2f, y: %5.2f, f_xy: %6.2f" % (x, y, f_xy) for x, y, f_xy in values ]))
def test_load_solver_cases(self): prob = Problem() model = prob.model model.add_subsystem('px', IndepVarComp('x', 1.0), 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=0.0), 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.linear_solver = LinearBlockGS() model.nonlinear_solver = NewtonSolver() model.linear_solver.add_recorder(self.recorder) prob.setup() 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: prob.model._inputs[name] += 1.0 for name in prob.model._outputs: prob.model._outputs[name] += 1.0 # Now load in the case we recorded prob.load_case(case) _assert_model_matches_case(case, model)
def test_ListRecorder(): from openmdao.api import Problem, IndepVarComp from openmdao.test_suite.components.paraboloid import Paraboloid prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*']) model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*']) model.add_subsystem('comp', Paraboloid(), promotes=['*']) model.add_design_var('x', lower=-10, upper=10) model.add_design_var('y', lower=-10, upper=10) model.add_objective('f_xy') xyf = [[0.98, 4.30, 74.1844], [2.06, 0.90, 23.7476], [-1.53, 2.92, 60.9397], [-1.25, 7.84, 145.4481]] prob.driver = DOEDriver( ListGenerator([[('x', xy[0]), ('y', xy[1])] for xy in xyf])) recorder = ListRecorder() prob.driver.add_recorder(recorder) prob.setup() prob.run_driver() prob.cleanup() cases = recorder.driver_cases assert cases.num_cases == 4 npt.assert_array_equal(recorder.get('counter'), range(1, 5)) npt.assert_array_equal(recorder['counter'], range(1, 5)) npt.assert_array_almost_equal(recorder.get(['x', 'y', 'f_xy']), xyf, 4) for xyf, k in zip(xyf[0], ['x', 'y', 'f_xy']): npt.assert_allclose(cases.get_case(0).outputs[k][0], xyf) with pytest.raises(KeyError, match="missing"): recorder.get('missing')
def test_full_factorial_array(self): prob = Problem() model = prob.model model.add_subsystem('p1', IndepVarComp('xy', np.array([0., 0.])), promotes=['*']) model.add_subsystem('comp', ParaboloidArray(), promotes=['*']) model.add_design_var('xy', lower=np.array([-50., -50.]), upper=np.array([50., 50.])) model.add_objective('f_xy') prob.driver = DOEDriver(FullFactorialGenerator(levels=3)) prob.driver.add_recorder(SqliteRecorder("CASES.db")) prob.setup(check=False) prob.run_driver() prob.cleanup() expected = { 0: {'xy': np.array([-50., -50.])}, 1: {'xy': np.array([ 0., -50.])}, 2: {'xy': np.array([ 50., -50.])}, 3: {'xy': np.array([-50., 0.])}, 4: {'xy': np.array([ 0., 0.])}, 5: {'xy': np.array([ 50., 0.])}, 6: {'xy': np.array([-50., 50.])}, 7: {'xy': np.array([ 0., 50.])}, 8: {'xy': np.array([ 50., 50.])}, } cases = CaseReader("CASES.db").driver_cases self.assertEqual(cases.num_cases, 9) for n in range(cases.num_cases): self.assertEqual(cases.get_case(n).outputs['xy'][0], expected[n]['xy'][0]) self.assertEqual(cases.get_case(n).outputs['xy'][1], expected[n]['xy'][1])
def test_recording_remote_voi(self): # Create a parallel model model = Group() model.add_subsystem('par', ParallelGroup()) model.par.add_subsystem('G1', Mygroup()) model.par.add_subsystem('G2', Mygroup()) model.connect('par.G1.y', 'Obj.y1') model.connect('par.G2.y', 'Obj.y2') model.add_subsystem('Obj', ExecComp('obj=y1+y2')) model.add_objective('Obj.obj') # Configure driver to record VOIs on both procs driver = ScipyOptimizeDriver(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 driver.recording_options['includes'] = ['par.G1.y', 'par.G2.y'] driver.add_recorder(self.recorder) # Create problem and run driver prob = Problem(model, driver) prob.setup() t0, t1 = run_driver(prob) prob.cleanup() # Since the test will compare the last case recorded, just check the # current values in the problem. This next section is about getting those values # These involve collective gathers so all ranks need to run this expected_outputs = prob.driver.get_design_var_values() expected_outputs.update(prob.driver.get_objective_values()) expected_outputs.update(prob.driver.get_constraint_values()) # includes for outputs are specified as promoted names but we need absolute names prom2abs = model._var_allprocs_prom2abs_list['output'] abs_includes = [ prom2abs[n][0] for n in prob.driver.recording_options['includes'] ] # Absolute path names of includes on this rank rrank = model.comm.rank rowned = model._owning_rank local_includes = [n for n in abs_includes if rrank == rowned[n]] # Get values for all vars on this rank inputs, outputs, residuals = model.get_nonlinear_vectors() # Get values for includes on this rank local_vars = {n: outputs[n] for n in local_includes} # Gather values for includes on all ranks all_vars = model.comm.gather(local_vars, root=0) if prob.comm.rank == 0: # Only on rank 0 do we have all the values. The all_vars variable is a list of # dicts from all ranks 0,1,... In this case, just ranks 0 and 1 dct = all_vars[-1] for d in all_vars[:-1]: dct.update(d) expected_includes = { 'par.G1.Cy.y': dct['par.G1.Cy.y'], 'par.G2.Cy.y': dct['par.G2.Cy.y'], } expected_outputs.update(expected_includes) coordinate = [0, 'ScipyOptimize_SLSQP', (driver.iter_count - 1, )] expected_data = ((coordinate, (t0, t1), expected_outputs, None), ) assertDriverIterDataRecorded(self, expected_data, self.eps)
top.driver.add_recorder(recorder) #Define solver type root.ln_solver = ScipyGMRES() start1 = time.time() #timer for set-up and re-order top.setup() order = root.list_auto_order() #This is to ensure that the mda_l group is executed always before the mda_h group a, b = order[0].index('mda_group_h'), order[0].index('mda_group_l') order[0].insert(a, order[0].pop(b)) root.set_order(order[0]) end1 = time.time() view_model(top, show_browser=False) #generates an N2 diagram to visualize connections #Setting initial values for design variables top['t'] = t_0 top['chords'] = chords_0 top['sweep'] = sweep_0 top['b'] = b_0 top['alpha'] = alpha_0 top['theta'] = theta_0 top['tc'] = tc_0 start2 = time.time() top.run() end2 = time.time() top.cleanup() # this closes all recorders print("Set up time = " + str(end1 - start1)) print("Run time = " + str(end2 - start2))
# set some airplane-specific values prob[ 'analysis.cruise.acmodel.OEW.const.structural_fudge'] = 2.0 prob['ac|propulsion|propeller|diameter'] = 2.2 prob['ac|propulsion|engine|rating'] = 1117.2 run_flag = prob.run_driver() if run_flag: raise ValueError('Opt failed') except BaseException as e: if write_logs: logging.error('Optimization ' + filename_to_save + ' failed because ' + repr(e)) prob.cleanup() try: os.rename( filename_to_save, filename_to_save.split('.sql')[0] + '_failed.sql') except WindowsError as we: if write_logs: logging.error('Error renaming file: ' + repr(we)) os.remove(filename_to_save) # print some outputs vars_list = [ 'ac|weights|MTOW', 'climb.OEW', 'descent.fuel_used_final', 'rotate.range_final', 'descent.propmodel.batt1.SOC_final', 'cruise.hybridization', 'ac|weights|W_battery', 'margins.MTOW_margin', 'ac|propulsion|motor|rating', 'ac|propulsion|generator|rating',
class TestSqliteCaseReader(unittest.TestCase): def setup_sellar_model_with_optimization(self): self.prob = Problem() self.prob.model = SellarDerivatives() optimizer = 'pyoptsparse' self.prob.driver = optimizers[optimizer]() self.prob.model.add_design_var('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) self.prob.model.add_design_var('x', lower=0.0, upper=10.0) self.prob.model.add_objective('obj') self.prob.model.add_constraint('con1', upper=0.0) self.prob.model.add_constraint('con2', upper=0.0) self.prob.model.suppress_solver_output = True self.prob.driver.options['print_results'] = False def setup_sellar_model(self): self.prob = Problem() model = self.prob.model = Group() model.add_subsystem('px', IndepVarComp('x', 1.0), 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=0.0), 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']) self.prob.model.nonlinear_solver = NonlinearBlockGS() self.prob.model.linear_solver = LinearBlockGS() self.prob.model.add_design_var('z', lower=np.array([-10.0, 0.0]), upper=np.array([10.0, 10.0])) self.prob.model.add_design_var('x', lower=0.0, upper=10.0) self.prob.model.add_objective('obj') self.prob.model.add_constraint('con1', upper=0.0) self.prob.model.add_constraint('con2', upper=0.0) def setup_sellar_grouped_model(self): self.prob = Problem() model = self.prob.model = Group() model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x']) model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z']) mda = model.add_subsystem('mda', Group(), promotes=['x', 'z', 'y1', 'y2']) mda.linear_solver = ScipyIterativeSolver() mda.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2']) mda.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=0.0, y1=0.0, y2=0.0), 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']) mda.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) def setup_sellar_grouped_scaled_model(self): self.prob = Problem() model = self.prob.model = Group() model.add_subsystem('px', IndepVarComp('x', 1.0), promotes=['x']) model.add_subsystem('pz', IndepVarComp('z', np.array([5.0, 2.0]), ref=2.0), promotes=['z']) mda = model.add_subsystem('mda', Group(), promotes=['x', 'z', 'y1', 'y2']) mda.linear_solver = ScipyIterativeSolver() mda.add_subsystem('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1', 'y2']) mda.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=0.0, y1=0.0, y2=0.0), 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']) mda.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) def setUp(self): recording_iteration.stack = [ ] # reset to avoid problems from earlier tests self.dir = mkdtemp() self.filename = os.path.join(self.dir, "sqlite_test") self.recorder = SqliteRecorder(self.filename) self.original_path = os.getcwd() os.chdir(self.dir) def tearDown(self): os.chdir(self.original_path) try: rmtree(self.dir) except OSError as e: # If directory already deleted, keep going if e.errno not in (errno.ENOENT, errno.EACCES, errno.EPERM): raise e 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_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.') @unittest.skipIf(OPT is None, "pyoptsparse is not installed") @unittest.skipIf(OPTIMIZER is None, "pyoptsparse is not providing SNOPT or SLSQP") 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_system_cases(self): self.setup_sellar_model() self.recorder.options['record_inputs'] = True self.recorder.options['record_outputs'] = True self.recorder.options['record_residuals'] = True self.recorder.options['record_metadata'] = False self.prob.model.add_recorder(self.recorder) d1 = self.prob.model.get_subsystem( 'd1') # instance of SellarDis1withDerivatives, a Group d1.add_recorder(self.recorder) obj_cmp = self.prob.model.get_subsystem('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['obj_cmp.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_cmp.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_cmp.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_solver_cases(self): self.setup_sellar_model() self.recorder.options['record_abs_error'] = True self.recorder.options['record_rel_error'] = True self.recorder.options['record_solver_output'] = True self.recorder.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['px.x'], [ 1.0, ], err_msg='Case reader gives ' 'incorrect output value for {0}'.format('px.x')) np.testing.assert_almost_equal( last_case.residuals['con_cmp2.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)) @unittest.skipIf(OPT is None, "pyoptsparse is not installed") @unittest.skipIf(OPTIMIZER is None, "pyoptsparse is not providing SNOPT or SLSQP") 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) 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 if OPTIMIZER == 'SLSQP': self.prob.driver.opt_settings['ACC'] = 1e-9 self.recorder.options['record_inputs'] = True self.recorder.options['record_outputs'] = True self.recorder.options['record_residuals'] = True self.recorder.options['record_metadata'] = True self.prob.model.add_recorder(self.recorder) pz = self.prob.model.get_subsystem( 'pz') # IndepVarComp which is an ExplicitComponent pz.add_recorder(self.recorder) mda = self.prob.model.get_subsystem('mda') # Group d1 = mda.get_subsystem('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'])) assert_rel_error( self, cr.system_metadata['pz']['output']['nonlinear']['phys'][0][1], [2.0, 2.0], 1.0e-3) def test_reading_solver_metadata(self): self.setup_sellar_model() self.recorder.options['record_abs_error'] = True self.recorder.options['record_rel_error'] = True self.recorder.options['record_solver_output'] = True self.recorder.options['record_solver_residuals'] = True self.prob.model.nonlinear_solver.add_recorder(self.recorder) self.prob.model.linear_solver.add_recorder(self.recorder) d1 = self.prob.model.get_subsystem( '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') @unittest.skipIf(OPT is None, "pyoptsparse is not installed") @unittest.skipIf(OPTIMIZER is None, "pyoptsparse is not providing SNOPT or SLSQP") def test_reading_driver_recording_with_system_vars(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.driver.add_recorder(self.recorder) 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.recorder.options['system_includes'] = [ 'mda.d2.y2', ] 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) # 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['pz.z'], err_msg='Case reader gives ' 'incorrect Parameter value' ' for {0}'.format('pz.z')) np.testing.assert_almost_equal(last_case.desvars['px.x'], self.prob['px.x'], err_msg='Case reader gives ' 'incorrect Parameter value' ' for {0}'.format('px.x')) np.testing.assert_almost_equal(last_case.sysincludes['mda.d2.y2'], self.prob['mda.d2.y2'], err_msg='Case reader gives ' 'incorrect Parameter value' ' for {0}'.format('mda.d2.y2'))
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)
prob.driver.add_recorder(case.recorder) case.recorder.options['record_params'] = record_params case.recorder.options['record_resids'] = record_resids case.recorder.options['record_unknowns'] = record_unknowns case.recorder.options['record_metadata'] = record_metadata case.recorder.options['record_derivs'] = record_derivs prob.setup(check=False) prob['p1.xy'][0] = 10.0 prob['p1.xy'][1] = 10.0 case.original_path = os.getcwd() os.chdir(case.dir) prob.run() prob.cleanup() # closes recorders @unittest.skipIf(NO_HDF5, 'HDF5Reader tests skipped. HDF5 not available.') class TestHDF5CaseReader(unittest.TestCase): def setUp(self): _setup_test_case(self, record_params=True, record_metadata=True, record_derivs=True, record_resids=True, record_unknowns=True, optimizer='scipy') def tearDown(self): os.chdir(self.original_path)
class NLP: """NLP class transcribes a continuous-time optimal control problem in trajectory optimization into a Non Linear Programming Problem (NLP) using the OpenMDAO and dymos libraries. Parameters ---------- body : Primary Instance of `Primary` class representing the central attracting body sc : Spacecraft Instance of `Spacecraft` class representing the spacecraft method : str Transcription method used to discretize the continuous time trajectory into a finite set of nodes, allowed ``gauss-lobatto``, ``radau-ps`` and ``runge-kutta`` nb_seg : int or tuple Number of segments in which each phase is discretized order : int or tuple Transcription order within each phase, must be odd solver : str NLP solver, must be supported by OpenMDAO snopt_opts : dict or None, optional SNOPT optional settings expressed as key-value pairs. Refer to the SNOPT User Guide [1]_ for more details. Default is None rec_file : str or None, optional Name of the file in which the computed solution is recorded or None. Default is None Attributes ---------- body : Primary Instance of `Primary` class representing the central attracting body sc : Spacecraft Instance of `Spacecraft` class representing the spacecraft method : str Transcription method used to discretize the continuous time trajectory into a finite set of nodes, allowed ``gauss-lobatto``, ``radau-ps`` and ``runge-kutta`` nb_seg : int or tuple Number of segments in which each phase is discretized order : int or tuple Transcription order within each phase, must be odd solver : str NLP solver, must be supported by OpenMDAO snopt_opts : dict or None SNOPT optional settings expressed as key-value pairs. Refer to the SNOPT User Guide [1]_ for more details. rec_file : str or None Name of the file in which the computed solution is recorded or None p : Problem OpenMDAO `Problem` class instance representing the NLP trajectory : Trajectory Dymos `Trajectory` class instance representing the spacecraft trajectory p_exp : Problem OpenMDAO `Problem` class instance representing the explicitly simulated trajectory References ---------- .. [1] Gill, Philip E., et al. User’s Guide for SNOPT Version 7.7: Software for Large-Scale Nonlinear Programming, Feb. 2019, p. 126. """ def __init__(self, body, sc, method, nb_seg, order, solver, snopt_opts=None, rec_file=None): """Initializes NLP class. """ # input parameters self.body = body self.sc = sc self.method = method self.nb_seg = nb_seg self.order = order self.solver = solver if self.solver == 'SNOPT': self.snopt_opts = snopt_opts else: self.snopt_opts = None self.rec_file = rec_file # Problem object self.p = Problem(model=Group()) # Problem Driver self.p.driver = pyOptSparseDriver() self.p.driver.options['optimizer'] = self.solver self.p.driver.options['print_results'] = False self.p.driver.options['dynamic_derivs_sparsity'] = True if self.snopt_opts is not None: for k in self.snopt_opts.keys(): self.p.driver.opt_settings[k] = self.snopt_opts[k] self.p.driver.declare_coloring(show_summary=True, show_sparsity=False) # Problem Recorder if rec_file is not None: recorder = SqliteRecorder(rec_file) opts = ['record_objectives', 'record_constraints', 'record_desvars'] self.p.add_recorder(recorder) for opt in opts: self.p.recording_options[opt] = False self.p.recording_options['excludes'] = rec_excludes self.rec_file = rec_file # Trajectory object self.trajectory = self.p.model.add_subsystem('traj', Trajectory()) # Problem object for explicit simulation self.p_exp = None def setup(self): """Set up the Jacobian type, linear solver and derivatives type. """ self.p.model.options['assembled_jac_type'] = 'csc' self.p.model.linear_solver = DirectSolver() self.p.setup(check=True, force_alloc_complex=True, derivatives=True) def exp_sim(self, rec_file=None): """Explicitly simulate the implicitly obtained optimal solution using Scipy `solve_ivp` method. """ if rec_file is not None: self.p_exp = self.trajectory.simulate(atol=1e-12, rtol=1e-12, record_file=rec_file) else: self.p_exp = self.trajectory.simulate(atol=1e-12, rtol=1e-12) self.cleanup() def cleanup(self): """Clean up resources. """ self.trajectory.cleanup() self.p.driver.cleanup() self.p.cleanup() def __str__(self): """Prints info on the NLP. Returns ------- s : str Info on the NLP """ lines = ['\n{:^40s}'.format('NLP characteristics:'), '\n{:<25s}{:<15s}'.format('Solver:', self.solver), '{:<25s}{:<15s}'.format('Transcription method:', str(self.method)), '{:<25s}{:<15s}'.format('Number of segments:', str(self.nb_seg)), '{:<25s}{:<15s}'.format('Transcription order:', str(self.order))] s = '\n'.join(lines) return s
# Add parallel group to omdao problem, pass in master config file # strangely Turbsim needs to come second to be run first if dlc_cfg['RunFAST'] == True: root.add('ParallelFASTCases', FST8AeroElasticSolver(cfg_master, caseids)) if dlc_cfg['RunTurbsim'] == True: root.add('ParallelTurbsimCases', TurbSim_Solver(cfg_master_wind, caseids_wind)) top.setup() top.check_setup() #view_model(top) top.run() top.cleanup() #Good practice, especially when using recorder # ===================== Write Output files into txt ===================== postdir = os.path.join(postdir, 'DLC%s') % dlcstring if not os.path.exists(postdir): os.makedirs(postdir) print postdir outfiles_file = os.path.join(postdir, 'Outputfiles.txt') f = open(outfiles_file, 'w') f.write( '----- Input Files ------------------------------------------------------------\n' ) f.write( '{:3} NumFiles The number of input files to read.\n' .format(counter))