Пример #1
0
    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)
Пример #2
0
    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)
Пример #3
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()

        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])
Пример #4
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()

        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])
Пример #5
0
    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)
Пример #6
0
    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))
Пример #7
0
    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))
Пример #8
0
    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)
Пример #9
0
    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)
Пример #10
0
    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)
Пример #11
0
    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)
Пример #12
0
    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)
Пример #13
0
    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)
Пример #14
0
    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)
Пример #15
0
    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
        )
Пример #16
0
    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)
Пример #17
0
    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))
Пример #18
0
    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))
Пример #19
0
    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)
Пример #20
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()

        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)
Пример #21
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()

        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)
Пример #22
0
    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()
Пример #23
0
    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()
Пример #24
0
    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])
Пример #25
0
    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)
Пример #26
0
    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)
Пример #27
0
    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)
Пример #29
0
    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']))
Пример #30
0
    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()
Пример #31
0
    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)
Пример #32
0
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)
Пример #33
0
    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)
Пример #34
0
    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)
Пример #35
0
    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
        )
Пример #36
0
    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)
Пример #37
0
    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)
Пример #38
0
    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()
Пример #39
0
    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)
Пример #41
0
    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)
Пример #42
0
    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()
Пример #43
0
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
Пример #44
0
    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)
Пример #45
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)
Пример #46
0
    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)
Пример #47
0
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
Пример #48
0
    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
        ]))
Пример #49
0
    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)
Пример #50
0
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')
Пример #51
0
    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))
Пример #54
0
                # 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',
Пример #55
0
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'))
Пример #56
0
    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)
Пример #57
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


@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)
Пример #58
0
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
Пример #59
0
# 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))