def test_model_viewer_has_correct_data_from_sqlite(self):
"""
Verify that the correct data exists when a model structure is recorded
and then pulled out of a sqlite db file and compared to the expected
structure. Uses the SellarStateConnection model.
"""
p = om.Problem(model=SellarStateConnection())
r = SqliteRecorder(self.sqlite_db_filename)
p.driver.add_recorder(r)
p.setup()
p.final_setup()
r.shutdown()
model_viewer_data = _get_viewer_data(self.sqlite_db_filename)
with open(os.path.join(self.parent_dir,
'sellar_tree.json')) as json_file:
expected_tree = json.load(json_file)
# check expected model tree
self.check_model_viewer_data(
model_viewer_data, expected_tree, self.expected_pathnames,
self.expected_conns, self.expected_abs2prom,
self.expected_declare_partials, self.expected_driver_name,
self.expected_design_vars_names, self.expected_responses_names)
def 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 test_n2_from_sqlite(self):
"""
Test that an n2 html file is generated from a sqlite file.
"""
p = om.Problem()
p.model = SellarStateConnection()
r = SqliteRecorder(self.sqlite_db_filename2)
p.driver.add_recorder(r)
p.setup()
p.final_setup()
r.shutdown()
n2(p, outfile=self.compare_html_filename, show_browser=DEBUG_BROWSER)
n2(self.sqlite_db_filename2,
outfile=self.sqlite_html_filename,
show_browser=DEBUG_BROWSER)
# Check that the html file has been created and has something in it.
self.assertTrue(os.path.isfile(self.sqlite_html_filename),
(self.sqlite_html_filename + " is not a valid file."))
self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100)
# Check that there are no errors when running from the command line with a recording.
check_call('openmdao n2 --no_browser %s' % self.sqlite_db_filename2)
# Compare models from the files generated from the Problem and the recording
sqlite_model_data = self._extract_compressed_model(
self.sqlite_html_filename)
compare_model_data = self._extract_compressed_model(
self.compare_html_filename)
self.assertTrue(
sqlite_model_data == compare_model_data,
'Model data from sqlite does not match data from Problem.')
def test_n2_from_sqlite(self):
"""
Test that an n2 html file is generated from a sqlite file.
"""
p = Problem()
p.model = SellarStateConnection()
r = SqliteRecorder(self.sqlite_db_filename2)
p.driver.add_recorder(r)
p.setup()
p.final_setup()
r.shutdown()
n2(p, outfile=self.compare_html_filename, show_browser=DEBUG_BROWSER)
n2(self.sqlite_db_filename2,
outfile=self.sqlite_html_filename,
show_browser=DEBUG_BROWSER)
# Check that the html file has been created and has something in it.
self.assertTrue(os.path.isfile(self.sqlite_html_filename),
(self.sqlite_html_filename + " is not a valid file."))
self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100)
# Check that there are no errors when running from the command line with a recording.
check_call('openmdao n2 --no_browser %s' % self.sqlite_db_filename2)
# Compare the sizes of the files generated from the Problem and the recording
size1 = os.path.getsize(self.sqlite_html_filename)
size2 = os.path.getsize(self.compare_html_filename)
self.assertTrue(
size1 == size2, 'File size of ' + self.sqlite_html_filename +
' is ' + str(size1) + ', but size of ' +
self.compare_html_filename + ' is ' + str(size2))
def test_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.shutdown()
view_model(self.sqlite_db_filename2, outfile=self.sqlite_filename, show_browser=False)
# Check that the html file has been created and has something in it.
self.assertTrue(os.path.isfile(self.sqlite_html_filename), (self.problem_html_filename + " is not a valid file."))
self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100)
def test_pyxdsm_case_reading(self):
"""
Writes a recorder file, and the XDSM writer makes the diagram based on the SQL file
and not the Problem instance.
"""
from openmdao.recorders.sqlite_recorder import SqliteRecorder
filename = 'xdsm_from_sql'
case_recording_filename = filename + '.sql'
prob = Problem()
prob.model = model = SellarNoDerivatives()
model.add_design_var('z', lower=np.array([-10.0, 0.0]),
upper=np.array([10.0, 10.0]), indices=np.arange(2, dtype=int))
model.add_design_var('x', lower=0.0, upper=10.0)
model.add_objective('obj')
model.add_constraint('con1', equals=np.zeros(1))
model.add_constraint('con2', upper=0.0)
recorder = SqliteRecorder(case_recording_filename)
prob.driver.add_recorder(recorder)
prob.setup(check=False)
prob.final_setup()
# Write output
write_xdsm(case_recording_filename, filename=filename, out_format='tex',
show_browser=False, quiet=QUIET)
# Check if file was created
self.assertTrue(os.path.isfile(case_recording_filename))
self.assertTrue(os.path.isfile('.'.join([filename, 'tex'])))
# Check that there are no errors when running from the command line with a recording.
check_call('openmdao xdsm --no_browser %s' % case_recording_filename)
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 test_model_viewer_has_correct_data_from_sqlite(self):
"""
Verify that the correct data exists when a model structure is recorded
and then pulled out of a sqlite db file and compared to the expected
structure. Uses the SellarStateConnection model.
"""
p = Problem(model=SellarStateConnection())
r = SqliteRecorder(self.sqlite_db_filename)
p.driver.add_recorder(r)
p.setup()
p.final_setup()
r.shutdown()
model_viewer_data = _get_viewer_data(self.sqlite_db_filename)
print(model_viewer_data['tree'])
# check expected model tree
self.assertDictEqual(model_viewer_data['tree'], self.expected_tree)
# check expected system pathnames
pathnames = model_viewer_data['sys_pathnames_list']
self.assertListEqual(sorted(pathnames), self.expected_pathnames)
# check expected connections, after mapping cycle_arrows indices back to pathnames
connections = sorted(model_viewer_data['connections_list'],
key=lambda x: (x['tgt'], x['src']))
for conn in connections:
if 'cycle_arrows' in conn:
cycle_arrows = []
for src, tgt in conn['cycle_arrows']:
cycle_arrows.append(' '.join(
[pathnames[src], pathnames[tgt]]))
conn['cycle_arrows'] = sorted(cycle_arrows)
self.assertEqual(len(connections), len(self.expected_conns))
for c, ex in zip(connections, self.expected_conns):
self.assertEqual(c['src'], ex['src'])
self.assertEqual(c['tgt'], ex['tgt'])
self.assertEqual(c.get('cycle_arrows', []),
ex.get('cycle_arrows', []))
# check expected abs2prom map
self.assertDictEqual(model_viewer_data['abs2prom'],
self.expected_abs2prom)
def test_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)
def test_view_model_from_sqlite(self):
"""
Test that an n2 html file is generated from a sqlite file.
"""
p = Problem()
p.model = SellarStateConnection()
r = SqliteRecorder(self.sqlite_db_filename2)
p.driver.add_recorder(r)
p.setup(check=False)
p.final_setup()
r.shutdown()
view_model(self.sqlite_db_filename2, outfile=self.sqlite_html_filename, show_browser=DEBUG)
# Check that the html file has been created and has something in it.
self.assertTrue(os.path.isfile(self.sqlite_html_filename),
(self.problem_html_filename + " is not a valid file."))
self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100)
# Check that there are no errors when running from the command line with a recording.
check_call('openmdao view_model --no_browser %s' % self.sqlite_db_filename2)
def test_view_model_from_sqlite(self):
"""
Test that an n2 html file is generated from a sqlite file.
"""
p = Problem()
p.model = SellarStateConnection()
r = SqliteRecorder(self.sqlite_db_filename2)
p.driver.add_recorder(r)
p.setup()
p.final_setup()
r.shutdown()
view_model(self.sqlite_db_filename2,
outfile=self.sqlite_html_filename,
show_browser=DEBUG)
# Check that the html file has been created and has something in it.
self.assertTrue(os.path.isfile(self.sqlite_html_filename),
(self.problem_html_filename + " is not a valid file."))
self.assertGreater(os.path.getsize(self.sqlite_html_filename), 100)
# Check that there are no errors when running from the command line with a recording.
check_call('openmdao view_model --no_browser %s' %
self.sqlite_db_filename2)
def test_model_viewer_has_correct_data_from_sqlite(self):
"""
Verify that the correct data exists when a model structure is recorded
and then pulled out of a sqlite db file and compared to the expected
structure. Uses the SellarStateConnection model.
"""
p = Problem(model=SellarStateConnection())
r = SqliteRecorder(self.sqlite_db_filename)
p.driver.add_recorder(r)
p.setup(check=False)
p.final_setup()
r.shutdown()
model_viewer_data = _get_viewer_data(self.sqlite_db_filename)
# check expected model tree
self.assertDictEqual(model_viewer_data['tree'], self.expected_tree)
# check expected system pathnames
pathnames = model_viewer_data['sys_pathnames_list']
self.assertListEqual(sorted(pathnames), self.expected_pathnames)
# check expected connections, after mapping cycle_arrows indices back to pathnames
connections = model_viewer_data['connections_list']
for conn in connections:
if 'cycle_arrows' in conn:
cycle_arrows = []
for src, tgt in conn['cycle_arrows']:
cycle_arrows.append(' '.join([pathnames[src], pathnames[tgt]]))
conn['cycle_arrows'] = sorted(cycle_arrows)
self.assertListEqual(connections, self.expected_conns)
# check expected abs2prom map
self.assertDictEqual(model_viewer_data['abs2prom'], self.expected_abs2prom)
def test_pyxdsm_case_reading(self):
"""
Writes a recorder file, and the XDSM writer makes the diagram based on the SQL file
and not the Problem instance.
"""
from openmdao.recorders.sqlite_recorder import SqliteRecorder
filename = 'xdsm_from_sql'
case_recording_filename = filename + '.sql'
prob = Problem()
prob.model = model = SellarNoDerivatives()
model.add_design_var('z',
lower=np.array([-10.0, 0.0]),
upper=np.array([10.0, 10.0]),
indices=np.arange(2, dtype=int))
model.add_design_var('x', lower=0.0, upper=10.0)
model.add_objective('obj')
model.add_constraint('con1', equals=np.zeros(1))
model.add_constraint('con2', upper=0.0)
recorder = SqliteRecorder(case_recording_filename)
prob.driver.add_recorder(recorder)
prob.setup(check=False)
prob.final_setup()
# Write output
msg = (
'For SQL input the XDSM writer shows only the model hierarchy, '
'and the driver, design variables and responses are not part of the '
'diagram.')
with assert_warning(Warning, msg):
write_xdsm(case_recording_filename,
filename=filename,
out_format='tex',
show_browser=False,
quiet=QUIET)
# Check if file was created
self.assertTrue(os.path.isfile(case_recording_filename))
self.assertTrue(os.path.isfile('.'.join([filename, 'tex'])))
def setUp(self):
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.tablename = 'openmdao'
self.recorder = SqliteRecorder(self.filename)
# recording_includes_options = ['obj.val']
# for j in range(npts):
# recording_includes_options.append('pt%s.ConCh' % str(j))
# recording_includes_options.append('pt%s.ConDs' % str(j))
# recording_includes_options.append('pt%s.ConS0' % str(j))
# recording_includes_options.append('pt%s.ConS1' % str(j))
# recording_includes_options.append('pt%s_con5.val' % str(j))
#
# #from openmdao.recorders import DumpRecorder
# #rec = DumpRecorder(out='data.dmp')
# #model.driver.add_recorder(rec)
# #rec.options['includes'] = recording_includes_options
from openmdao.recorders.sqlite_recorder import SqliteRecorder
rec = SqliteRecorder(out='data.sql')
model.driver.add_recorder(rec)
# rec.options['includes'] = recording_includes_options
model.setup()
model.run()
import resource
print("Memory Usage:",
resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000.0,
"MB (on unix)")
#----------------------------------------------------------------
# Below this line, code I was using for verifying and profiling.
#----------------------------------------------------------------
def compute(self, inputs, outputs):
# type: (Vector, Vector) -> None
"""Computation performed by the component.
Parameters
----------
inputs : all inputs coming from outside the component in the group
outputs : all outputs provided outside the component in the group"""
# Define problem of subdriver
p = self.prob
m = p.model
# Push global inputs down
for input_name in m.model_constants:
p[input_name] = inputs[input_name]
failed_experiments = {}
# sort to have outputs first
sorted_model_super_inputs = sorted(m.model_super_inputs.keys(), reverse=True)
for input_name in sorted_model_super_inputs:
if input_name in m.sm_of_training_params.keys(): # Add these inputs as training data
sm_uid = m.sm_of_training_params[input_name]
pred_param = m.find_mapped_parameter(input_name,
m.sm_prediction_inputs[sm_uid] |
m.sm_prediction_outputs[sm_uid])
sm_comp = getattr(m, str_to_valid_sys_name(sm_uid))
if sm_uid not in failed_experiments.keys():
failed_experiments[sm_uid] = (None, None)
sm_comp.options['train:'+pred_param], failed_experiments[sm_uid]\
= p.postprocess_experiments(inputs[input_name], input_name,
failed_experiments[sm_uid])
else:
p[input_name] = inputs[input_name]
# Provide message on failed experiments
warn_about_failed_experiments(failed_experiments)
# Set initial values of design variables back to original ones (to avoid using values of
# last run)
for des_var, attrbs in m.design_vars.items():
p[des_var] = attrbs['initial']
# Run the driver
print('Running subdriver {}'.format(self.options['driver_uid']))
if 'Sub-Optimizer' not in p.case_reader_path:
p.driver.cleanup()
basename, extension = os.path.splitext(p.case_reader_path)
case_reader_filename = basename + '_loop' + str(self._run_count) + extension
p.driver.add_recorder(SqliteRecorder(case_reader_filename))
p.driver.recording_options['includes'] = ['*']
p.driver.recording_options['record_model_metadata'] = True
p.driver._setup_recording()
p.run_driver()
self._add_run_count()
# Pull the value back up to the output array
doe_out_vecs = {}
for output_name in m.model_super_outputs:
# Add these outputs as vectors based on DOE driver
if output_name in m.doe_parameters.keys():
doe_out_vecs[output_name] = []
else:
if not p.driver.fail:
outputs[output_name] = p[output_name]
else:
outputs[output_name] = float('nan')
# If the driver failed (hence, optimization failed), then send message and clean
if p.driver.fail:
print('Driver run failed!')
p.clean_driver_after_failure()
# Provide DOE output vectors as output of the component, if this is expected
if doe_out_vecs:
# First read out the case reader
cr = CaseReader(case_reader_filename)
cases = cr.list_cases('driver')
for n in range(len(cases)):
cr_outputs = cr.get_case(n).outputs
doe_param_matches = {}
for output_name in doe_out_vecs.keys():
doe_param_matches[output_name] = doe_param_match \
= m.find_mapped_parameter(output_name, cr_outputs.keys())
doe_out_vecs[output_name].append(cr_outputs[doe_param_match][0])
# Then write the final vectors to the global output array
for output_name in doe_out_vecs.keys():
if output_name in p.doe_samples[p.driver_uid]['inputs']:
des_var_match = m.find_mapped_parameter(output_name, m._design_vars.keys())
doe_out_vecs[output_name] = unscale_value(doe_out_vecs[output_name],
m._design_vars[des_var_match]['ref0'],
m._design_vars[des_var_match]['ref'])
outputs[output_name] = np.array(doe_out_vecs[output_name])
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)
recording_includes_options = ["obj.val"]
for j in range(npts):
recording_includes_options.append("pt%s.ConCh" % str(j))
recording_includes_options.append("pt%s.ConDs" % str(j))
recording_includes_options.append("pt%s.ConS0" % str(j))
recording_includes_options.append("pt%s.ConS1" % str(j))
recording_includes_options.append("pt%s_con5.val" % str(j))
# from openmdao.recorders import DumpRecorder
# rec = DumpRecorder(out='data.dmp')
# model.driver.add_recorder(rec)
# rec.options['includes'] = recording_includes_options
from openmdao.recorders.sqlite_recorder import SqliteRecorder
rec = SqliteRecorder(out="data.sql")
model.driver.add_recorder(rec)
rec.options["includes"] = recording_includes_options
model.setup()
model.run()
import resource
print("Memory Usage:", resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000.0, "MB (on unix)")
# ----------------------------------------------------------------
# Below this line, code I was using for verifying and profiling.
# ----------------------------------------------------------------
# profile = False
# params = model.driver.get_desvars().keys()
# Parallel Derivative calculation
for con_name in ['.ConCh','.ConDs','.ConS0','.ConS1','_con5.val']:
model.driver.parallel_derivs(['%s%s'%(n,con_name) for n in names])
# Recording
# Some constraints only exit on one process so cannot record everything
recording_includes_options = ['obj.val']
for j in range(npts):
recording_includes_options.append('pt%s.ConCh' % str(j))
recording_includes_options.append('pt%s.ConDs' % str(j))
recording_includes_options.append('pt%s.ConS0' % str(j))
recording_includes_options.append('pt%s.ConS1' % str(j))
recording_includes_options.append('pt%s_con5.val' % str(j))
from openmdao.recorders.sqlite_recorder import SqliteRecorder
rec = SqliteRecorder(out='data.sql')
model.driver.add_recorder(rec)
rec.options['includes'] = recording_includes_options
model.setup()
model.run()
import resource
print("Memory Usage:", resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1000.0, "MB (on unix)")
#----------------------------------------------------------------
# Below this line, code I was using for verifying and profiling.
#----------------------------------------------------------------
#profile = False
#params = model.driver.get_desvars().keys()
#unks = model.driver.get_objectives().keys() + model.driver.get_constraints().keys()
# Parallel Derivative calculation
for con_name in ['.ConCh','.ConDs','.ConS0','.ConS1','_con5.val']:
model.driver.parallel_derivs(['%s%s'%(n,con_name) for n in names])
# Recording
# Some constraints only exit on one process so cannot record everything
recording_includes_options = ['obj.val']
for j in range(npts):
recording_includes_options.append('pt%s.ConCh' % str(j))
recording_includes_options.append('pt%s.ConDs' % str(j))
recording_includes_options.append('pt%s.ConS0' % str(j))
recording_includes_options.append('pt%s.ConS1' % str(j))
recording_includes_options.append('pt%s_con5.val' % str(j))
from openmdao.recorders.sqlite_recorder import SqliteRecorder
rec = SqliteRecorder(out='data.sql')
model.driver.add_recorder(rec)
rec.options['includes'] = recording_includes_options
rec.options['record_derivs'] = False
model.setup()
model.run()
import resource
print("Memory Usage:", resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1000.0, "MB (on unix)")
#----------------------------------------------------------------
# Below this line, code I was using for verifying and profiling.
#----------------------------------------------------------------
#profile = False
#params = list(model.driver.get_desvars().keys())
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)
# Some constraints only exit on one process so cannot record everything
recording_includes_options = ['obj.val']
for j in range(npts):
recording_includes_options.append('pt%s.ConCh' % str(j))
recording_includes_options.append('pt%s.ConDs' % str(j))
recording_includes_options.append('pt%s.ConS0' % str(j))
recording_includes_options.append('pt%s.ConS1' % str(j))
recording_includes_options.append('pt%s_con5.val' % str(j))
#from openmdao.recorders import DumpRecorder
#rec = DumpRecorder(out='data.dmp')
#model.driver.add_recorder(rec)
#rec.options['includes'] = recording_includes_options
from openmdao.recorders.sqlite_recorder import SqliteRecorder
rec = SqliteRecorder(out='data.sql')
model.driver.add_recorder(rec)
rec.options['includes'] = recording_includes_options
model.setup()
model.run()
import resource
print("Memory Usage:", resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1000.0, "MB (on unix)")
#----------------------------------------------------------------
# Below this line, code I was using for verifying and profiling.
#----------------------------------------------------------------
#profile = False
#params = model.driver.get_desvars().keys()
#unks = model.driver.get_objectives().keys() + model.driver.get_constraints().keys()
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)
