def test_view_model_from_sqlite(self):
"""
Test that an n2 html file is generated from a sqlite file.
"""
p = Problem()
p.model = SellarStateConnection()
r = SqliteRecorder(self.sqlite_db_filename2)
p.driver.add_recorder(r)
p.setup(check=False)
p.final_setup()
r.close()
view_model(self.sqlite_db_filename2, outfile=self.sqlite_filename, show_browser=False)
# Check that the html file has been created and has something in it.
self.assertTrue(os.path.isfile(self.sqlite_html_filename), (self.problem_html_filename + " is not a valid file."))
self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100)
def test_view_model_from_sqlite(self):
"""
Test that an n2 html file is generated from a sqlite file.
"""
p = Problem()
p.model = SellarStateConnection()
r = SqliteRecorder(self.sqlite_db_filename2)
p.driver.add_recorder(r)
p.setup(check=False)
p.final_setup()
r.close()
view_model(self.sqlite_db_filename2,
outfile=self.sqlite_filename,
show_browser=False)
# Check that the html file has been created and has something in it.
self.assertTrue(os.path.isfile(self.sqlite_html_filename),
(self.problem_html_filename + " is not a valid file."))
self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100)
def test_model_viewer_has_correct_data_from_sqlite(self):
"""
Verify that the correct data exists when a model structure is recorded
and then pulled out of a sqlite db file and compared to the expected
structure. Uses the SellarStateConnection model.
"""
p = Problem()
p.model = SellarStateConnection()
r = SqliteRecorder(self.sqlite_db_filename)
p.driver.add_recorder(r)
p.setup(check=False)
p.final_setup()
r.close()
model_viewer_data = _get_viewer_data(self.sqlite_db_filename)
tree_json = json.dumps(model_viewer_data['tree'])
conns_json = json.dumps(model_viewer_data['connections_list'])
self.assertEqual(self.expected_tree_json, tree_json)
self.assertEqual(self.expected_conns_json, conns_json)
def test_model_viewer_has_correct_data_from_sqlite(self):
"""
Verify that the correct data exists when a model structure is recorded
and then pulled out of a sqlite db file and compared to the expected
structure. Uses the SellarStateConnection model.
"""
p = Problem()
p.model = SellarStateConnection()
r = SqliteRecorder(self.sqlite_db_filename)
p.driver.add_recorder(r)
p.setup(check=False)
p.final_setup()
r.close()
model_viewer_data = _get_viewer_data(self.sqlite_db_filename)
tree_json = json.dumps(model_viewer_data['tree'])
conns_json = json.dumps(model_viewer_data['connections_list'])
self.assertEqual(self.expected_tree_json, tree_json)
self.assertEqual(self.expected_conns_json, conns_json)
class TestSqliteRecorder(RecorderTests.Tests):
filename = ""
dir = ""
def setUp(self):
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.tablename = 'openmdao'
self.recorder = SqliteRecorder(self.filename)
def tearDown(self):
super(TestSqliteRecorder, self).tearDown()
try:
rmtree(self.dir)
except OSError as e:
# If directory already deleted, keep going
if e.errno != errno.ENOENT:
raise e
def assertDatasetEquals(self, expected, tolerance):
# Close the file to ensure it is written to disk.
self.recorder.close()
# self.recorder.out = None
sentinel = object()
db = SqliteDict( self.filename, self.tablename )
###### Need a way to get a list of the group_names in the order in which they were written and put it in a variable named order
order = db['order']
del db['order']
for coord, expect in expected:
iter_coord = format_iteration_coordinate(coord)
self.assertEqual(order.pop(0), iter_coord)
groupings = (
("Parameters", expect[0]),
("Unknowns", expect[1]),
("Residuals", expect[2])
)
#### Need to get the record with the key of 'iter_coord'
actual_group = db[iter_coord]
for label, values in groupings:
actual = actual_group[label]
# If len(actual) == len(expected) and actual <= expected, then
# actual == expected.
self.assertEqual(len(actual), len(values))
for key, val in values:
found_val = actual.get(key, sentinel)
if found_val is sentinel:
self.fail("Did not find key '{0}'".format(key))
assert_rel_error(self, found_val, val, tolerance)
del db[iter_coord]
######## delete the record with the key 'iter_coord'
# Having deleted all found values, the file should now be empty.
###### Need a way to get the number of records in the main table
self.assertEqual(len(db), 0)
# As should the ordering.
self.assertEqual(len(order), 0)
db.close()
class TestSqliteRecorder(unittest.TestCase):
def setUp(self):
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.tablename = 'openmdao'
self.recorder = SqliteRecorder(self.filename)
self.recorder.options['record_metadata'] = False
self.eps = 1e-5
def tearDown(self):
try:
rmtree(self.dir)
except OSError as e:
# If directory already deleted, keep going
if e.errno != errno.ENOENT:
raise e
def assertMetadataRecorded(self, expected):
with SqliteDict( self.filename, self.tablename, flag='r' ) as db:
_assertMetadataRecorded( self, db, expected )
def assertIterationDataRecorded(self, expected, tolerance):
db = SqliteDict( self.filename, self.tablename )
_assertIterationDataRecorded(self, db, expected, tolerance)
db.close()
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)
self.recorder.close()
coordinate = ['Driver', (1, )]
expected_resids = [
("comp1.y1", 0.0),
("comp1.y2", 0.0),
("comp2.y1", 0.0),
("comp3.y1", 0.0),
("comp4.y1", 0.0),
("comp4.y2", 0.0),
("comp5.y1", 0.0),
("comp6.y1", 0.0),
("comp7.y1", 0.0),
("p.x", 0.0)
]
self.assertIterationDataRecorded(((coordinate, (t0, t1), None, None, expected_resids),), self.eps)
def test_only_unknowns_recorded(self):
prob = Problem()
prob.root = ConvergeDiverge()
prob.driver.add_recorder(self.recorder)
prob.setup(check=False)
t0, t1 = run_problem(prob)
self.recorder.close()
coordinate = ['Driver', (1, )]
expected_unknowns = [
("comp1.y1", 8.0),
("comp1.y2", 6.0),
("comp2.y1", 4.0),
("comp3.y1", 21.0),
("comp4.y1", 46.0),
("comp4.y2", -93.0),
("comp5.y1", 36.8),
("comp6.y1", -46.5),
("comp7.y1", -102.7),
("p.x", 2.0)
]
self.assertIterationDataRecorded(((coordinate, (t0, t1), None, expected_unknowns, None),), self.eps)
def test_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)
self.recorder.close()
coordinate = ['Driver', (1,)]
expected_params = [
("comp1.x1", 2.0),
("comp2.x1", 8.0),
("comp3.x1", 6.0),
("comp4.x1", 4.0),
("comp4.x2", 21.0),
("comp5.x1", 46.0),
("comp6.x1", -93.0),
("comp7.x1", 36.8),
("comp7.x2", -46.5)
]
self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, None, None),), self.eps)
def test_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
prob.setup(check=False)
t0, t1 = run_problem(prob)
self.recorder.close()
coordinate = ['Driver', (1, )]
expected_params = [
("comp1.x1", 2.0),
("comp2.x1", 8.0),
("comp3.x1", 6.0),
("comp4.x1", 4.0),
("comp4.x2", 21.0),
("comp5.x1", 46.0),
("comp6.x1", -93.0),
("comp7.x1", 36.8),
("comp7.x2", -46.5)
]
expected_unknowns = [
("comp1.y1", 8.0),
("comp1.y2", 6.0),
("comp2.y1", 4.0),
("comp3.y1", 21.0),
("comp4.y1", 46.0),
("comp4.y2", -93.0),
("comp5.y1", 36.8),
("comp6.y1", -46.5),
("comp7.y1", -102.7),
("p.x", 2.0)
]
expected_resids = [
("comp1.y1", 0.0),
("comp1.y2", 0.0),
("comp2.y1", 0.0),
("comp3.y1", 0.0),
("comp4.y1", 0.0),
("comp4.y2", 0.0),
("comp5.y1", 0.0),
("comp6.y1", 0.0),
("comp7.y1", 0.0),
("p.x", 0.0)
]
self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps)
def test_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)
self.recorder.close()
coordinate = ['Driver', (1,)]
expected_params = [
("comp1.x1", 2.0)
]
expected_unknowns = [
("comp1.y1", 8.0),
("comp1.y2", 6.0)
]
expected_resids = [
("comp1.y1", 0.0),
("comp1.y2", 0.0)
]
self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps)
def test_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)
self.recorder.close()
coordinate = ['Driver', (1,)]
expected_params = [
("comp1.x1", 2.0)
]
expected_unknowns = [
("comp1.y1", 8.0)
]
expected_resids = [
("comp1.y1", 0.0)
]
self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps)
def test_solver_record(self):
prob = Problem()
prob.root = ConvergeDiverge()
prob.root.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)
self.recorder.close()
coordinate = ['Driver', (1,), "root", (1,)]
expected_params = [
("comp1.x1", 2.0),
("comp2.x1", 8.0),
("comp3.x1", 6.0),
("comp4.x1", 4.0),
("comp4.x2", 21.0),
("comp5.x1", 46.0),
("comp6.x1", -93.0),
("comp7.x1", 36.8),
("comp7.x2", -46.5)
]
expected_unknowns = [
("comp1.y1", 8.0),
("comp1.y2", 6.0),
("comp2.y1", 4.0),
("comp3.y1", 21.0),
("comp4.y1", 46.0),
("comp4.y2", -93.0),
("comp5.y1", 36.8),
("comp6.y1", -46.5),
("comp7.y1", -102.7),
("p.x", 2.0)
]
expected_resids = [
("comp1.y1", 0.0),
("comp1.y2", 0.0),
("comp2.y1", 0.0),
("comp3.y1", 0.0),
("comp4.y1", 0.0),
("comp4.y2", 0.0),
("comp5.y1", 0.0),
("comp6.y1", 0.0),
("comp7.y1", 0.0),
("p.x", 0.0)
]
self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps)
def test_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)
self.recorder.close()
coordinate = ['Driver', (1,), "root", (1,), "G2", (1,), "G1", (1,)]
expected_params = [
("C2.x", 5.0)
]
expected_unknowns = [
("C2.y", 10.0)
]
expected_resids = [
("C2.y", 0.0)
]
self.assertIterationDataRecorded(((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps)
def test_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)
self.recorder.close()
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)
]
driver_coordinate = ['Driver', (1,)]
driver_expected_params = [
("G3.C3.x", 10.0)
]
driver_expected_unknowns = [
("G2.C1.x", 5.0),
("G2.G1.C2.y", 10.0),
("G3.C3.y", 20.0),
("G3.C4.y", 40.0),
]
driver_expected_resids = [
("G2.C1.x", 0.0),
("G2.G1.C2.y", 0.0),
("G3.C3.y", 0.0),
("G3.C4.y", 0.0),
]
expected = []
expected.append((solver_coordinate, (t0, t1), g1_expected_params, g1_expected_unknowns, g1_expected_resids))
expected.append((driver_coordinate, (t0, t1), driver_expected_params, driver_expected_unknowns, driver_expected_resids))
self.assertIterationDataRecorded(expected, self.eps)
def test_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)
self.recorder.close()
expected_params = list(iteritems(prob.root.params))
expected_unknowns = list(iteritems(prob.root.unknowns))
expected_resids = list(iteritems(prob.root.resids))
self.assertMetadataRecorded((expected_params, expected_unknowns, expected_resids))
def test_driver_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)
self.recorder.close()
self.assertMetadataRecorded(None)
def test_root_solver_records_metadata(self):
prob = Problem()
prob.root = ConvergeDiverge()
prob.root.nl_solver.add_recorder(self.recorder)
self.recorder.options['record_metadata'] = True
prob.setup(check=False)
self.recorder.close()
expected_params = list(iteritems(prob.root.params))
expected_unknowns = list(iteritems(prob.root.unknowns))
expected_resids = list(iteritems(prob.root.resids))
self.assertMetadataRecorded((expected_params, expected_unknowns, expected_resids))
def test_root_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)
self.recorder.close()
self.assertMetadataRecorded(None)
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)
self.recorder.close()
expected_params = list(iteritems(prob.root.params))
expected_unknowns = list(iteritems(prob.root.unknowns))
expected_resids = list(iteritems(prob.root.resids))
self.assertMetadataRecorded((expected_params, expected_unknowns, expected_resids))
def test_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)
self.recorder.close()
self.assertMetadataRecorded(None)
class TestSqliteRecorder(MPITestCase):
filename = ""
dir = ""
N_PROCS = 2
def setUp(self):
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.tablename = "openmdao"
self.recorder = SqliteRecorder(self.filename)
self.recorder.options["record_metadata"] = False
self.eps = 1e-5
def tearDown(self):
try:
rmtree(self.dir)
except OSError as e:
# If directory already deleted, keep going
if e.errno != errno.ENOENT:
raise e
def assertMetadataRecorded(self, expected):
if self.comm.rank != 0:
return
db = SqliteDict(self.filename, self.tablename)
_assertMetadataRecorded(self, db, expected)
db.close()
def assertIterationDataRecorded(self, expected, tolerance, root):
if self.comm.rank != 0:
return
db = SqliteDict(self.filename, self.tablename)
_assertIterationDataRecorded(self, db, expected, tolerance)
db.close()
def test_basic(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add("G1", ParallelGroup())
G1.add("P1", IndepVarComp("x", np.ones(size, float) * 1.0))
G1.add("P2", IndepVarComp("x", np.ones(size, float) * 2.0))
prob.root.add("C1", ABCDArrayComp(size))
prob.root.connect("G1.P1.x", "C1.a")
prob.root.connect("G1.P2.x", "C1.b")
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(prob)
self.recorder.close()
coordinate = ["Driver", (1,)]
expected_params = [("C1.a", [1.0, 1.0, 1.0]), ("C1.b", [2.0, 2.0, 2.0])]
expected_unknowns = [
("G1.P1.x", np.array([1.0, 1.0, 1.0])),
("G1.P2.x", np.array([2.0, 2.0, 2.0])),
("C1.c", np.array([3.0, 3.0, 3.0])),
("C1.d", np.array([-1.0, -1.0, -1.0])),
("C1.out_string", "_C1"),
("C1.out_list", [1.5]),
]
expected_resids = [
("G1.P1.x", np.array([0.0, 0.0, 0.0])),
("G1.P2.x", np.array([0.0, 0.0, 0.0])),
("C1.c", np.array([0.0, 0.0, 0.0])),
("C1.d", np.array([0.0, 0.0, 0.0])),
("C1.out_string", ""),
("C1.out_list", []),
]
self.assertIterationDataRecorded(
((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps, prob.root
)
def test_includes(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add("G1", ParallelGroup())
G1.add("P1", IndepVarComp("x", np.ones(size, float) * 1.0))
G1.add("P2", IndepVarComp("x", np.ones(size, float) * 2.0))
prob.root.add("C1", ABCDArrayComp(size))
prob.root.connect("G1.P1.x", "C1.a")
prob.root.connect("G1.P2.x", "C1.b")
prob.driver.add_recorder(self.recorder)
self.recorder.options["record_params"] = True
self.recorder.options["record_resids"] = True
self.recorder.options["includes"] = ["C1.*"]
prob.setup(check=False)
t0, t1 = run(prob)
self.recorder.close()
coordinate = ["Driver", (1,)]
expected_params = [("C1.a", [1.0, 1.0, 1.0]), ("C1.b", [2.0, 2.0, 2.0])]
expected_unknowns = [
("C1.c", np.array([3.0, 3.0, 3.0])),
("C1.d", np.array([-1.0, -1.0, -1.0])),
("C1.out_string", "_C1"),
("C1.out_list", [1.5]),
]
expected_resids = [
("C1.c", np.array([0.0, 0.0, 0.0])),
("C1.d", np.array([0.0, 0.0, 0.0])),
("C1.out_string", ""),
("C1.out_list", []),
]
self.assertIterationDataRecorded(
((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps, prob.root
)
def test_includes_and_excludes(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add("G1", ParallelGroup())
G1.add("P1", IndepVarComp("x", np.ones(size, float) * 1.0))
G1.add("P2", IndepVarComp("x", np.ones(size, float) * 2.0))
prob.root.add("C1", ABCDArrayComp(size))
prob.root.connect("G1.P1.x", "C1.a")
prob.root.connect("G1.P2.x", "C1.b")
prob.driver.add_recorder(self.recorder)
self.recorder.options["includes"] = ["C1.*"]
self.recorder.options["excludes"] = ["*.out*"]
self.recorder.options["record_params"] = True
self.recorder.options["record_resids"] = True
prob.setup(check=False)
t0, t1 = run(prob)
self.recorder.close()
coordinate = ["Driver", (1,)]
expected_params = [("C1.a", [1.0, 1.0, 1.0]), ("C1.b", [2.0, 2.0, 2.0])]
expected_unknowns = [("C1.c", np.array([3.0, 3.0, 3.0])), ("C1.d", np.array([-1.0, -1.0, -1.0]))]
expected_resids = [("C1.c", np.array([0.0, 0.0, 0.0])), ("C1.d", np.array([0.0, 0.0, 0.0]))]
self.assertIterationDataRecorded(
((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps, prob.root
)
def test_solver_record(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add("G1", ParallelGroup())
G1.add("P1", IndepVarComp("x", np.ones(size, float) * 1.0))
G1.add("P2", IndepVarComp("x", np.ones(size, float) * 2.0))
prob.root.add("C1", ABCDArrayComp(size))
prob.root.connect("G1.P1.x", "C1.a")
prob.root.connect("G1.P2.x", "C1.b")
prob.root.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(prob)
self.recorder.close()
coordinate = ["Driver", (1,), "root", (1,)]
expected_params = [("C1.a", [1.0, 1.0, 1.0]), ("C1.b", [2.0, 2.0, 2.0])]
expected_unknowns = [
("G1.P1.x", np.array([1.0, 1.0, 1.0])),
("G1.P2.x", np.array([2.0, 2.0, 2.0])),
("C1.c", np.array([3.0, 3.0, 3.0])),
("C1.d", np.array([-1.0, -1.0, -1.0])),
("C1.out_string", "_C1"),
("C1.out_list", [1.5]),
]
expected_resids = [
("G1.P1.x", np.array([0.0, 0.0, 0.0])),
("G1.P2.x", np.array([0.0, 0.0, 0.0])),
("C1.c", np.array([0.0, 0.0, 0.0])),
("C1.d", np.array([0.0, 0.0, 0.0])),
("C1.out_string", ""),
("C1.out_list", []),
]
self.assertIterationDataRecorded(
((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids),), self.eps, prob.root
)
def test_driver_records_metadata(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add("G1", ParallelGroup())
G1.add("P1", IndepVarComp("x", np.ones(size, float) * 1.0))
G1.add("P2", IndepVarComp("x", np.ones(size, float) * 2.0))
prob.root.add("C1", ABCDArrayComp(size))
prob.root.connect("G1.P1.x", "C1.a")
prob.root.connect("G1.P2.x", "C1.b")
prob.driver.add_recorder(self.recorder)
self.recorder.options["record_metadata"] = True
prob.setup(check=False)
self.recorder.close()
expected = (
list(prob.root.params.iteritems()),
list(prob.root.unknowns.iteritems()),
list(prob.root.resids.iteritems()),
)
self.assertMetadataRecorded(expected)
def test_driver_doesnt_records_metadata(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add("G1", ParallelGroup())
G1.add("P1", IndepVarComp("x", np.ones(size, float) * 1.0))
G1.add("P2", IndepVarComp("x", np.ones(size, float) * 2.0))
prob.root.add("C1", ABCDArrayComp(size))
prob.root.connect("G1.P1.x", "C1.a")
prob.root.connect("G1.P2.x", "C1.b")
prob.driver.add_recorder(self.recorder)
self.recorder.options["record_metadata"] = False
prob.setup(check=False)
self.recorder.close()
self.assertMetadataRecorded(None)
class TestSqliteRecorder(MPITestCase):
filename = ""
dir = ""
N_PROCS = 2
def setUp(self):
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.tablename = 'openmdao'
self.recorder = SqliteRecorder(self.filename)
self.recorder.options['record_metadata'] = False
self.eps = 1e-5
def tearDown(self):
try:
rmtree(self.dir)
except OSError as e:
# If directory already deleted, keep going
if e.errno != errno.ENOENT:
raise e
def assertMetadataRecorded(self, expected):
if self.comm.rank != 0:
return
db = SqliteDict(self.filename, self.tablename)
_assertMetadataRecorded(self, db, expected)
db.close()
def assertIterationDataRecorded(self, expected, tolerance, root):
if self.comm.rank != 0:
return
db = SqliteDict(self.filename, self.tablename)
_assertIterationDataRecorded(self, db, expected, tolerance)
db.close()
def test_basic(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add('G1', ParallelGroup())
G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0))
G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0))
prob.root.add('C1', ABCDArrayComp(size))
prob.root.connect('G1.P1.x', 'C1.a')
prob.root.connect('G1.P2.x', 'C1.b')
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(prob)
self.recorder.close()
coordinate = ['Driver', (1, )]
expected_params = [
("C1.a", [1.0, 1.0, 1.0]),
("C1.b", [2.0, 2.0, 2.0]),
]
expected_unknowns = [
("G1.P1.x", np.array([1.0, 1.0, 1.0])),
("G1.P2.x", np.array([2.0, 2.0, 2.0])),
("C1.c", np.array([3.0, 3.0, 3.0])),
("C1.d", np.array([-1.0, -1.0, -1.0])),
("C1.out_string", "_C1"),
("C1.out_list", [1.5]),
]
expected_resids = [
("G1.P1.x", np.array([0.0, 0.0, 0.0])),
("G1.P2.x", np.array([0.0, 0.0, 0.0])),
("C1.c", np.array([0.0, 0.0, 0.0])),
("C1.d", np.array([0.0, 0.0, 0.0])),
("C1.out_string", ""),
("C1.out_list", []),
]
self.assertIterationDataRecorded(
((coordinate, (t0, t1), expected_params, expected_unknowns,
expected_resids), ), self.eps, prob.root)
def test_includes(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add('G1', ParallelGroup())
G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0))
G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0))
prob.root.add('C1', ABCDArrayComp(size))
prob.root.connect('G1.P1.x', 'C1.a')
prob.root.connect('G1.P2.x', 'C1.b')
prob.driver.add_recorder(self.recorder)
self.recorder.options['record_params'] = True
self.recorder.options['record_resids'] = True
self.recorder.options['includes'] = ['C1.*']
prob.setup(check=False)
t0, t1 = run(prob)
self.recorder.close()
coordinate = ['Driver', (1, )]
expected_params = [
("C1.a", [1.0, 1.0, 1.0]),
("C1.b", [2.0, 2.0, 2.0]),
]
expected_unknowns = [
("C1.c", np.array([3.0, 3.0, 3.0])),
("C1.d", np.array([-1.0, -1.0, -1.0])),
("C1.out_string", "_C1"),
("C1.out_list", [1.5]),
]
expected_resids = [
("C1.c", np.array([0.0, 0.0, 0.0])),
("C1.d", np.array([0.0, 0.0, 0.0])),
("C1.out_string", ""),
("C1.out_list", []),
]
self.assertIterationDataRecorded(
((coordinate, (t0, t1), expected_params, expected_unknowns,
expected_resids), ), self.eps, prob.root)
def test_includes_and_excludes(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add('G1', ParallelGroup())
G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0))
G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0))
prob.root.add('C1', ABCDArrayComp(size))
prob.root.connect('G1.P1.x', 'C1.a')
prob.root.connect('G1.P2.x', 'C1.b')
prob.driver.add_recorder(self.recorder)
self.recorder.options['includes'] = ['C1.*']
self.recorder.options['excludes'] = ['*.out*']
self.recorder.options['record_params'] = True
self.recorder.options['record_resids'] = True
prob.setup(check=False)
t0, t1 = run(prob)
self.recorder.close()
coordinate = ['Driver', (1, )]
expected_params = [
("C1.a", [1.0, 1.0, 1.0]),
("C1.b", [2.0, 2.0, 2.0]),
]
expected_unknowns = [
("C1.c", np.array([3.0, 3.0, 3.0])),
("C1.d", np.array([-1.0, -1.0, -1.0])),
]
expected_resids = [
("C1.c", np.array([0.0, 0.0, 0.0])),
("C1.d", np.array([0.0, 0.0, 0.0])),
]
self.assertIterationDataRecorded(
((coordinate, (t0, t1), expected_params, expected_unknowns,
expected_resids), ), self.eps, prob.root)
def test_solver_record(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add('G1', ParallelGroup())
G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0))
G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0))
prob.root.add('C1', ABCDArrayComp(size))
prob.root.connect('G1.P1.x', 'C1.a')
prob.root.connect('G1.P2.x', 'C1.b')
prob.root.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(prob)
self.recorder.close()
coordinate = ['Driver', (1, ), "root", (1, )]
expected_params = [
("C1.a", [1.0, 1.0, 1.0]),
("C1.b", [2.0, 2.0, 2.0]),
]
expected_unknowns = [
("G1.P1.x", np.array([1.0, 1.0, 1.0])),
("G1.P2.x", np.array([2.0, 2.0, 2.0])),
("C1.c", np.array([3.0, 3.0, 3.0])),
("C1.d", np.array([-1.0, -1.0, -1.0])),
("C1.out_string", "_C1"),
("C1.out_list", [1.5]),
]
expected_resids = [
("G1.P1.x", np.array([0.0, 0.0, 0.0])),
("G1.P2.x", np.array([0.0, 0.0, 0.0])),
("C1.c", np.array([0.0, 0.0, 0.0])),
("C1.d", np.array([0.0, 0.0, 0.0])),
("C1.out_string", ""),
("C1.out_list", []),
]
self.assertIterationDataRecorded(
((coordinate, (t0, t1), expected_params, expected_unknowns,
expected_resids), ), self.eps, prob.root)
def test_driver_records_metadata(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add('G1', ParallelGroup())
G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0))
G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0))
prob.root.add('C1', ABCDArrayComp(size))
prob.root.connect('G1.P1.x', 'C1.a')
prob.root.connect('G1.P2.x', 'C1.b')
prob.driver.add_recorder(self.recorder)
self.recorder.options['record_metadata'] = True
prob.setup(check=False)
self.recorder.close()
expected = (
list(prob.root.params.iteritems()),
list(prob.root.unknowns.iteritems()),
list(prob.root.resids.iteritems()),
)
self.assertMetadataRecorded(expected)
def test_driver_doesnt_records_metadata(self):
size = 3
prob = Problem(Group(), impl=impl)
G1 = prob.root.add('G1', ParallelGroup())
G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0))
G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0))
prob.root.add('C1', ABCDArrayComp(size))
prob.root.connect('G1.P1.x', 'C1.a')
prob.root.connect('G1.P2.x', 'C1.b')
prob.driver.add_recorder(self.recorder)
self.recorder.options['record_metadata'] = False
prob.setup(check=False)
self.recorder.close()
self.assertMetadataRecorded(None)
