def _extract_case_from_row(self, row):
"""
Pull data out of a queried SQLite row.
Parameters
----------
row : (id, counter, iter_coordinate, timestamp, success, msg, inputs, outputs)
Queried SQLite driver table row.
Returns
-------
DriverCase
Case for associated row.
"""
idx, counter, iteration_coordinate, timestamp, success, msg, inputs_text, \
outputs_text, = row
if self.format_version >= 3:
inputs_array = json_to_np_array(inputs_text, self._abs2meta)
outputs_array = json_to_np_array(outputs_text, self._abs2meta)
elif self.format_version in (1, 2):
inputs_array = blob_to_array(inputs_text)
outputs_array = blob_to_array(outputs_text)
case = DriverCase(self.filename, counter, iteration_coordinate,
timestamp, success, msg, inputs_array, outputs_array,
self._prom2abs, self._abs2prom, self._abs2meta,
self._var_settings)
return case
def _extract_case_from_row(self, row):
"""
Pull data out of a queried SQLite row.
Parameters
----------
row : (id, counter, iter_coordinate, timestamp, success, msg, abs_err, rel_err,
inputs, outputs, residuals)
Queried SQLite solvers table row.
Returns
-------
SolverCase
Case for associated row.
"""
idx, counter, iteration_coordinate, timestamp, success, msg, abs_err, rel_err, \
input_text, output_text, residuals_text = row
if self.format_version >= 3:
input_array = json_to_np_array(input_text, self._abs2meta)
output_array = json_to_np_array(output_text, self._abs2meta)
residuals_array = json_to_np_array(residuals_text, self._abs2meta)
elif self.format_version in (1, 2):
input_array = blob_to_array(input_text)
output_array = blob_to_array(output_text)
residuals_array = blob_to_array(residuals_text)
case = SolverCase(self.filename, counter, iteration_coordinate,
timestamp, success, msg, abs_err, rel_err,
input_array, output_array, residuals_array,
self._prom2abs, self._abs2prom, self._abs2meta)
return case
def assertSystemIterDataRecorded(test, expected, tolerance, prefix=None):
"""
Expected can be from multiple cases.
"""
with database_cursor(test.filename) as db_cur:
db_cur.execute("SELECT format_version FROM metadata")
f_version = db_cur.fetchone()[0]
# iterate through the cases
for coord, (t0, t1), inputs_expected, outputs_expected, residuals_expected in expected:
iter_coord = format_iteration_coordinate(coord, prefix=prefix)
# from the database, get the actual data recorded
db_cur.execute("SELECT * FROM system_iterations WHERE "
"iteration_coordinate=:iteration_coordinate",
{"iteration_coordinate": iter_coord})
row_actual = db_cur.fetchone()
test.assertTrue(row_actual, 'System iterations table does not contain the requested '
'iteration coordinate: "{}"'.format(iter_coord))
counter, global_counter, iteration_coordinate, timestamp, success, msg, inputs_text, \
outputs_text, residuals_text = row_actual
if f_version >= 3:
inputs_actual = json_to_np_array(inputs_text)
outputs_actual = json_to_np_array(outputs_text)
residuals_actual = json_to_np_array(residuals_text)
elif f_version in (1, 2):
inputs_actual = blob_to_array(inputs_text)
outputs_actual = blob_to_array(outputs_text)
residuals_actual = blob_to_array(residuals_text)
# Does the timestamp make sense?
test.assertTrue(t0 <= timestamp and timestamp <= t1)
test.assertEqual(success, 1)
test.assertEqual(msg, '')
for vartype, actual, expected in (
('inputs', inputs_actual, inputs_expected),
('outputs', outputs_actual, outputs_expected),
('residuals', residuals_actual, residuals_expected),
):
if expected is None:
if f_version == 3:
test.assertIsNone(actual)
if f_version in (1, 2):
test.assertEqual(actual, np.array(None, dtype=object))
else:
# Check to see if the number of values in actual and expected match
test.assertEqual(len(actual[0]), len(expected))
for key, value in iteritems(expected):
# Check to see if the keys in the actual and expected match
test.assertTrue(key in actual[0].dtype.names,
'{} variable not found in actual data '
'from recorder'.format(key))
# Check to see if the values in actual and expected match
assert_rel_error(test, actual[0][key], expected[key], tolerance)
def assertSystemIterDataRecorded(test, expected, tolerance, prefix=None):
"""
Expected can be from multiple cases.
"""
with database_cursor(test.filename) as db_cur:
f_version, abs2meta = get_format_version_abs2meta(db_cur)
# iterate through the cases
for coord, (t0, t1), inputs_expected, outputs_expected, residuals_expected in expected:
iter_coord = format_iteration_coordinate(coord, prefix=prefix)
# from the database, get the actual data recorded
db_cur.execute("SELECT * FROM system_iterations WHERE "
"iteration_coordinate=:iteration_coordinate",
{"iteration_coordinate": iter_coord})
row_actual = db_cur.fetchone()
test.assertTrue(row_actual, 'System iterations table does not contain the requested '
'iteration coordinate: "{}"'.format(iter_coord))
counter, global_counter, iteration_coordinate, timestamp, success, msg, inputs_text, \
outputs_text, residuals_text = row_actual
if f_version >= 3:
inputs_actual = json_to_np_array(inputs_text, abs2meta)
outputs_actual = json_to_np_array(outputs_text, abs2meta)
residuals_actual = json_to_np_array(residuals_text, abs2meta)
elif f_version in (1, 2):
inputs_actual = blob_to_array(inputs_text)
outputs_actual = blob_to_array(outputs_text)
residuals_actual = blob_to_array(residuals_text)
# Does the timestamp make sense?
test.assertTrue(t0 <= timestamp and timestamp <= t1)
test.assertEqual(success, 1)
test.assertEqual(msg, '')
for vartype, actual, expected in (
('inputs', inputs_actual, inputs_expected),
('outputs', outputs_actual, outputs_expected),
('residuals', residuals_actual, residuals_expected),
):
if expected is None:
if f_version >= 3:
test.assertIsNone(actual)
if f_version in (1, 2):
test.assertEqual(actual, np.array(None, dtype=object))
else:
# Check to see if the number of values in actual and expected match
test.assertEqual(len(actual[0]), len(expected))
for key, value in iteritems(expected):
# Check to see if the keys in the actual and expected match
test.assertTrue(key in actual[0].dtype.names,
'{} variable not found in actual data '
'from recorder'.format(key))
# Check to see if the values in actual and expected match
assert_rel_error(test, actual[0][key], expected[key], tolerance)
def _extract_case_from_row(self, row):
"""
Pull data out of a queried SQLite row.
Parameters
----------
row : (id, counter, iter_coordinate, timestamp, success, msg, outputs)
Queried SQLite problems table row.
Returns
-------
ProblemCase
Case for associated row.
"""
idx, counter, case_name, timestamp, success, msg, \
outputs_text, = row
if self.format_version >= 3:
outputs_array = json_to_np_array(outputs_text, self._abs2meta)
elif self.format_version in (1, 2):
outputs_array = blob_to_array(outputs_text)
case = ProblemCase(self.filename, counter, case_name, timestamp,
success, msg, outputs_array, self._prom2abs,
self._abs2prom, self._abs2meta)
return case
def assertProblemDataRecorded(test, expected, tolerance):
"""
Expected can be from multiple cases.
"""
with database_cursor(test.filename) as db_cur:
f_version, abs2meta = get_format_version_abs2meta(db_cur)
# iterate through the cases
for case, (t0, t1), outputs_expected in expected:
# from the database, get the actual data recorded
db_cur.execute(
"SELECT * FROM problem_cases WHERE case_name=:case_name",
{"case_name": case})
row_actual = db_cur.fetchone()
test.assertTrue(
row_actual, 'Problem table does not contain the requested '
'case name: "{}"'.format(case))
counter, global_counter, case_name, timestamp, success, msg, outputs_text = row_actual
if f_version >= 3:
outputs_actual = json_to_np_array(outputs_text, abs2meta)
elif f_version in (1, 2):
outputs_actual = blob_to_array(outputs_text)
test.assertEqual(success, 1)
test.assertEqual(msg, '')
for vartype, actual, expected in (('outputs', outputs_actual,
outputs_expected), ):
if expected is None:
if f_version >= 3:
test.assertIsNone(actual)
if f_version in (1, 2):
test.assertEqual(actual, np.array(None, dtype=object))
else:
actual = actual[0]
# Check to see if the number of values in actual and expected match
test.assertEqual(len(actual), len(expected))
for key, value in iteritems(expected):
# Check to see if the keys in the actual and expected match
test.assertTrue(
key in actual.dtype.names,
'{} variable not found in actual data'
' from recorder'.format(key))
# Check to see if the values in actual and expected match
assert_rel_error(test, actual[key], expected[key],
tolerance)
def assertProblemDataRecorded(test, expected, tolerance):
"""
Expected can be from multiple cases.
"""
with database_cursor(test.filename) as db_cur:
f_version, abs2meta = get_format_version_abs2meta(db_cur)
# iterate through the cases
for case, (t0, t1), outputs_expected in expected:
# from the database, get the actual data recorded
db_cur.execute("SELECT * FROM problem_cases WHERE case_name=:case_name",
{"case_name": case})
row_actual = db_cur.fetchone()
test.assertTrue(row_actual, 'Problem table does not contain the requested '
'case name: "{}"'.format(case))
counter, global_counter, case_name, timestamp, success, msg, outputs_text = row_actual
if f_version >= 3:
outputs_actual = json_to_np_array(outputs_text, abs2meta)
elif f_version in (1, 2):
outputs_actual = blob_to_array(outputs_text)
test.assertEqual(success, 1)
test.assertEqual(msg, '')
for vartype, actual, expected in (
('outputs', outputs_actual, outputs_expected),
):
if expected is None:
if f_version >= 3:
test.assertIsNone(actual)
if f_version in (1, 2):
test.assertEqual(actual, np.array(None, dtype=object))
else:
actual = actual[0]
# Check to see if the number of values in actual and expected match
test.assertEqual(len(actual), len(expected))
for key, value in iteritems(expected):
# Check to see if the keys in the actual and expected match
test.assertTrue(key in actual.dtype.names,
'{} variable not found in actual data'
' from recorder'.format(key))
# Check to see if the values in actual and expected match
assert_rel_error(test, actual[key], expected[key], tolerance)
def assertSolverIterDataRecorded(test, expected, tolerance, prefix=None):
"""
Expected can be from multiple cases.
"""
with database_cursor(test.filename) as db_cur:
f_version, abs2meta = get_format_version_abs2meta(db_cur)
# iterate through the cases
for coord, (t0, t1), expected_abs_error, expected_rel_error, expected_output, \
expected_solver_residuals in expected:
iter_coord = format_iteration_coordinate(coord, prefix=prefix)
# from the database, get the actual data recorded
db_cur.execute(
"SELECT * FROM solver_iterations "
"WHERE iteration_coordinate=:iteration_coordinate",
{"iteration_coordinate": iter_coord})
row_actual = db_cur.fetchone()
test.assertTrue(
row_actual,
'Solver iterations table does not contain the requested '
'iteration coordinate: "{}"'.format(iter_coord))
counter, global_counter, iteration_coordinate, timestamp, success, msg, \
abs_err, rel_err, input_blob, output_text, residuals_text = row_actual
if f_version >= 3:
output_actual = json_to_np_array(output_text, abs2meta)
residuals_actual = json_to_np_array(residuals_text, abs2meta)
elif f_version in (1, 2):
output_actual = blob_to_array(output_text)
residuals_actual = blob_to_array(residuals_text)
# Does the timestamp make sense?
test.assertTrue(
t0 <= timestamp and timestamp <= t1,
'timestamp should be between when the model started and stopped'
)
test.assertEqual(success, 1)
test.assertEqual(msg, '')
if expected_abs_error:
test.assertTrue(abs_err,
'Expected absolute error but none recorded')
assert_rel_error(test, abs_err, expected_abs_error, tolerance)
if expected_rel_error:
test.assertTrue(rel_err,
'Expected relative error but none recorded')
assert_rel_error(test, rel_err, expected_rel_error, tolerance)
for vartype, actual, expected in (
('outputs', output_actual, expected_output),
('residuals', residuals_actual, expected_solver_residuals),
):
if expected is None:
if f_version >= 3:
test.assertIsNone(actual)
if f_version in (1, 2):
test.assertEqual(actual, np.array(None, dtype=object))
else:
# Check to see if the number of values in actual and expected match
test.assertEqual(len(actual[0]), len(expected))
for key, value in iteritems(expected):
# Check to see if the keys in the actual and expected match
test.assertTrue(
key in actual[0].dtype.names,
'{} variable not found in actual data '
'from recorder'.format(key))
# Check to see if the values in actual and expected match
assert_rel_error(test, actual[0][key], expected[key],
tolerance)
def __init__(self, source, data, prom2abs, abs2prom, abs2meta, voi_meta, data_format=None):
"""
Initialize.
Parameters
----------
source : str
The unique id of the system/solver/driver/problem that did the recording.
data : dict-like
Dictionary of data for a case
prom2abs : {'input': dict, 'output': dict}
Dictionary mapping promoted names of all variables to absolute names.
abs2prom : {'input': dict, 'output': dict}
Dictionary mapping absolute names of all variables to promoted names.
abs2meta : dict
Dictionary mapping absolute names of all variables to variable metadata.
voi_meta : dict
Dictionary mapping absolute names of variables of interest to variable metadata.
data_format : int
A version number specifying the format of array data, if not numpy arrays.
"""
self.source = source
self._format_version = data_format
if 'iteration_coordinate' in data.keys():
self.iteration_coordinate = data['iteration_coordinate']
parts = self.iteration_coordinate.split('|')
if len(parts) > 2:
self.parent = '|'.join(parts[:-2])
else:
self.parent = None
elif 'case_name' in data.keys():
self.iteration_coordinate = data['case_name'] # problem cases
self.parent = None
else:
self.iteration_coordinate = None
self.parent = None
self.counter = data['counter']
self.timestamp = data['timestamp']
self.success = data['success']
self.msg = data['msg']
# for a solver case
self.abs_err = data['abs_err'] if 'abs_err' in data.keys() else None
self.rel_err = data['abs_err'] if 'rel_err' in data.keys() else None
# rename solver keys
if 'solver_inputs' in data.keys():
if not isinstance(data, dict):
data = dict(zip(data.keys(), data))
data['inputs'] = data.pop('solver_inputs')
data['outputs'] = data.pop('solver_output')
data['residuals'] = data.pop('solver_residuals')
# default properties to None
self.inputs = None
self.outputs = None
self.residuals = None
self.jacobian = None
if 'inputs' in data.keys():
if data_format >= 3:
inputs = json_to_np_array(data['inputs'], abs2meta)
elif data_format in (1, 2):
inputs = blob_to_array(data['inputs'])
if type(inputs) is np.ndarray and not inputs.shape:
inputs = None
else:
inputs = data['inputs']
if inputs is not None:
self.inputs = PromotedToAbsoluteMap(inputs[0], prom2abs, abs2prom, output=False)
if 'outputs' in data.keys():
if data_format >= 3:
outputs = json_to_np_array(data['outputs'], abs2meta)
elif self._format_version in (1, 2):
outputs = blob_to_array(data['outputs'])
if type(outputs) is np.ndarray and not outputs.shape:
outputs = None
else:
outputs = data['outputs']
if outputs is not None:
self.outputs = PromotedToAbsoluteMap(outputs[0], prom2abs, abs2prom)
if 'residuals' in data.keys():
if data_format >= 3:
residuals = json_to_np_array(data['residuals'], abs2meta)
elif data_format in (1, 2):
residuals = blob_to_array(data['residuals'])
if type(residuals) is np.ndarray and not residuals.shape:
residuals = None
else:
residuals = data['residuals']
if residuals is not None:
self.residuals = PromotedToAbsoluteMap(residuals[0], prom2abs, abs2prom)
if 'jacobian' in data.keys():
if data_format >= 2:
jacobian = blob_to_array(data['jacobian'])
if type(jacobian) is np.ndarray and not jacobian.shape:
jacobian = None
else:
jacobian = data['jacobian']
if jacobian is not None:
self.jacobian = PromotedToAbsoluteMap(jacobian[0], prom2abs, abs2prom, output=True)
# save var name & meta dict references for use by self._get_variables_of_type()
self._prom2abs = prom2abs
self._abs2prom = abs2prom
self._abs2meta = abs2meta
# save VOI dict reference for use by self._scale()
self._voi_meta = voi_meta
def __init__(self, source, data, prom2abs, abs2prom, abs2meta, voi_meta, data_format=None):
"""
Initialize.
Parameters
----------
source : str
The unique id of the system/solver/driver/problem that did the recording.
data : dict-like
Dictionary of data for a case
prom2abs : {'input': dict, 'output': dict}
Dictionary mapping promoted names of all variables to absolute names.
abs2prom : {'input': dict, 'output': dict}
Dictionary mapping absolute names of all variables to promoted names.
abs2meta : dict
Dictionary mapping absolute names of all variables to variable metadata.
voi_meta : dict
Dictionary mapping absolute names of variables of interest to variable metadata.
data_format : int
A version number specifying the format of array data, if not numpy arrays.
"""
self.source = source
self._format_version = data_format
if 'iteration_coordinate' in data.keys():
self.iteration_coordinate = data['iteration_coordinate']
parts = self.iteration_coordinate.split('|')
if len(parts) > 2:
self.parent = '|'.join(parts[:-2])
else:
self.parent = None
elif 'case_name' in data.keys():
self.iteration_coordinate = data['case_name'] # problem cases
self.parent = None
else:
self.iteration_coordinate = None
self.parent = None
self.counter = data['counter']
self.timestamp = data['timestamp']
self.success = data['success']
self.msg = data['msg']
# for a solver case
self.abs_err = data['abs_err'] if 'abs_err' in data.keys() else None
self.rel_err = data['abs_err'] if 'rel_err' in data.keys() else None
# rename solver keys
if 'solver_inputs' in data.keys():
if not isinstance(data, dict):
data = dict(zip(data.keys(), data))
data['inputs'] = data.pop('solver_inputs')
data['outputs'] = data.pop('solver_output')
data['residuals'] = data.pop('solver_residuals')
# default properties to None
self.inputs = None
self.outputs = None
self.residuals = None
self.jacobian = None
if 'inputs' in data.keys():
if data_format >= 3:
inputs = json_to_np_array(data['inputs'], abs2meta)
elif data_format in (1, 2):
inputs = blob_to_array(data['inputs'])
if type(inputs) is np.ndarray and not inputs.shape:
inputs = None
else:
inputs = data['inputs']
if inputs is not None:
self.inputs = PromotedToAbsoluteMap(inputs[0], prom2abs, abs2prom, output=False)
if 'outputs' in data.keys():
if data_format >= 3:
outputs = json_to_np_array(data['outputs'], abs2meta)
elif self._format_version in (1, 2):
outputs = blob_to_array(data['outputs'])
if type(outputs) is np.ndarray and not outputs.shape:
outputs = None
else:
outputs = data['outputs']
if outputs is not None:
self.outputs = PromotedToAbsoluteMap(outputs[0], prom2abs, abs2prom)
if 'residuals' in data.keys():
if data_format >= 3:
residuals = json_to_np_array(data['residuals'], abs2meta)
elif data_format in (1, 2):
residuals = blob_to_array(data['residuals'])
if type(residuals) is np.ndarray and not residuals.shape:
residuals = None
else:
residuals = data['residuals']
if residuals is not None:
self.residuals = PromotedToAbsoluteMap(residuals[0], prom2abs, abs2prom)
if 'jacobian' in data.keys():
if data_format >= 2:
jacobian = blob_to_array(data['jacobian'])
if type(jacobian) is np.ndarray and not jacobian.shape:
jacobian = None
else:
jacobian = data['jacobian']
if jacobian is not None:
self.jacobian = PromotedToAbsoluteMap(jacobian[0], prom2abs, abs2prom, output=True)
# save var name & meta dict references for use by self._get_variables_of_type()
self._prom2abs = prom2abs
self._abs2prom = abs2prom
self._abs2meta = abs2meta
# save VOI dict reference for use by self._scale()
self._voi_meta = voi_meta
