def setUp(self):
self._ref_x_data = [0, 1, 2, 3, 4]
self._ref_y_data = [3.3, 5.5, 2.2, 8.5, 10.2]
self.data_xy = XYContainer(x_data=self._ref_x_data,
y_data=self._ref_y_data)
self._ref_x_err_abs_singlevalue = 0.1
self._ref_y_err_abs_singlevalue = 1.2
self._ref_x_err_abs_valuearray = np.array([0.1, 0.1, 0.2, 0.4, 0.5])
self._ref_y_err_abs_valuearray = [1.2, 1.1, 1.2, 1.2, 1.1]
self._ref_x_err_corr_coeff = 0.1
self._ref_y_err_corr_coeff = 0.23
self.data_xy.add_error('x',
self._ref_x_err_abs_valuearray,
name='MyXError',
correlation=self._ref_x_err_corr_coeff,
relative=False)
self.data_xy.add_error('y',
self._ref_y_err_abs_valuearray,
name='MyYError',
correlation=self._ref_y_err_corr_coeff,
relative=False)
self._ref_x_cov_mat = cov_mat_from_float_list(
self._ref_x_err_abs_valuearray,
correlation=self._ref_x_err_corr_coeff).mat
self._ref_y_cov_mat = cov_mat_from_float_list(
self._ref_y_err_abs_valuearray,
correlation=self._ref_y_err_corr_coeff).mat
def _generate_dataset(output_filename='double_slit.yml'):
"""
Create an XYContainer holding the measurement data
and the errors and write it to a file.
"""
xy_data = [
[ # x data: position
-0.044, -0.040, -0.036, -0.030, -0.024, -0.018, -0.012, -0.008,
-0.004, -0.001, 0.004, 0.008, 0.012, 0.018, 0.024, 0.030, 0.036,
0.040, 0.044
],
[ # y data: light intensity
0.06, 0.07, 0.03, 0.04, 0.32, 0.03, 0.64, 0.08, 0.20, 1.11, 0.52,
0.07, 0.89, 0.01, 0.17, 0.05, 0.09, 0.02, 0.01
]
]
d = XYContainer(x_data=xy_data[0], y_data=xy_data[1])
d.add_error('x', 0.002, relative=False)
d.add_error('y', [
0.02, 0.02, 0.02, 0.02, 0.04, 0.02, 0.05, 0.03, 0.05, 0.08, 0.05, 0.03,
0.05, 0.01, 0.04, 0.03, 0.03, 0.02, 0.01
],
relative=False)
d.to_file(output_filename)
def setUp(self):
_x = [0.0, 1.0, 2.0, 3.0, 4.0]
_y = [-2.1, 0.2, 1.9, 3.8, 6.1]
self._means = np.array([3.654, 7.789])
self._vars = np.array([2.467, 1.543])
self._cov_mat_uncor = np.array([[self._vars[0], 0.0],
[0.0, self._vars[1]]])
self._cov_mat_uncor_inv = np.linalg.inv(self._cov_mat_uncor)
self._cov_mat_cor = np.array([[self._vars[0], 0.1],
[0.1, self._vars[1]]])
self._cov_mat_cor_inv = np.linalg.inv(self._cov_mat_cor)
self._cov_mat_simple_a_inv = np.array([[1.0 / self._vars[0], 0.0],
[0.0, 0.0]])
self._cov_mat_simple_b_inv = np.array([[0.0, 0.0],
[0.0, 1.0 / self._vars[1]]])
self._data_container = XYContainer(x_data=_x, y_data=_y)
self._data_container.add_error(axis='y', err_val=1.0)
_a_test = np.linspace(start=0, stop=4, num=9, endpoint=True)
_b_test = np.linspace(start=-4, stop=0, num=9, endpoint=True)
self._test_par_values = np.zeros((4, 2, 9))
self._test_par_values[0, 0] = _a_test
self._test_par_values[1, 1] = _b_test
self._test_par_values[2, 0] = _a_test
self._test_par_values[2, 1] = _b_test
self._test_par_values[3, 0] = _a_test
self._test_par_values[3, 1] = -_b_test
self._test_par_res = self._test_par_values - self._means.reshape(
(1, 2, 1))
self._test_par_res = np.transpose(self._test_par_res, axes=(0, 2, 1))
self._fit_no_constraints = XYFit(self._data_container)
self._fit_no_constraints.do_fit()
_cost_function = self._fit_no_constraints._fitter._fcn_wrapper
self._profile_no_constraints = np.zeros((4, 9))
for _i in range(4):
for _j in range(9):
self._profile_no_constraints[_i, _j] = _cost_function(
self._test_par_values[_i, 0, _j],
self._test_par_values[_i, 1, _j])
#_generate_dataset()
###################
# Model functions #
###################
def interference(x, I0=1., b=1e-5, g=2e-5, k=1e7):
# our first model is a simple linear function
k_half_sine_alpha = k / 2 * np.sin(x) # helper variable
k_b = k_half_sine_alpha * b
k_g = k_half_sine_alpha * g
return I0 * (np.sin(k_b) / (k_b) * np.cos(k_g))**2
# read in the measurement data from a file
d = XYContainer.from_file("double_slit.yml")
# create XYFits, specifying the measurement data and model function
f = XYFit(xy_data=d, model_function=interference, minimizer='iminuit')
# assign LaTeX strings to various quantities (for nice display)
f.assign_parameter_latex_names(I0='I_0', b='b', g='g', k='k')
f.assign_model_function_latex_name('I')
f.assign_model_function_latex_expression(
r"{I0}\,\left(\frac{{\sin(\frac{{{k}}}{{2}}\,b\,\sin{{{x}}})}}"
r"{{\frac{{{k}}}{{2}}\,b\,\sin{{{x}}}}}"
r"\cos(\frac{{{k}}}{{2}}\,g\,\sin{{{x}}})\right)^2")
# perform the fits
f.set_parameter_values(I0=1., b=20e-6, g=50e-6, k=9.67e6)
f.fix_parameter('k')
class TestParameterConstraintInXYFit(unittest.TestCase):
def _expected_profile_diff(self, res, cov_mat_inv):
return res.dot(cov_mat_inv).dot(res)
def _test_consistency(self, constrained_fit, par_cov_mat_inv):
constrained_fit.do_fit()
_cost_function = constrained_fit._fitter._fcn_wrapper
for _i in range(4):
for _j in range(9):
_profile_constrained = _cost_function(self._test_par_values[_i, 0, _j], self._test_par_values[_i, 1, _j])
_diff = _profile_constrained - self._profile_no_constraints[_i, _j]
_expected_profile_diff = self._expected_profile_diff(self._test_par_res[_i, _j], par_cov_mat_inv)
self.assertTrue(np.abs(_diff - _expected_profile_diff) < 1e-12)
def setUp(self):
_x = [ 0.0, 1.0, 2.0, 3.0, 4.0]
_y = [-2.1, 0.2, 1.9, 3.8, 6.1]
self._means = np.array([3.654, 7.789])
self._vars = np.array([2.467, 1.543])
self._cov_mat_uncor = np.array([[self._vars[0], 0.0], [0.0, self._vars[1]]])
self._cov_mat_uncor_inv = np.linalg.inv(self._cov_mat_uncor)
self._cov_mat_cor = np.array([[self._vars[0], 0.1], [0.1, self._vars[1]]])
self._cov_mat_cor_inv = np.linalg.inv(self._cov_mat_cor)
self._cov_mat_simple_a_inv = np.array([[1.0 / self._vars[0], 0.0], [0.0, 0.0]])
self._cov_mat_simple_b_inv = np.array([[0.0, 0.0], [0.0, 1.0 / self._vars[1]]])
self._data_container = XYContainer(x_data=_x, y_data=_y)
self._data_container.add_error(axis='y', err_val=1.0)
_a_test = np.linspace(start=0, stop=4, num=9, endpoint=True)
_b_test = np.linspace(start=-4, stop=0, num=9, endpoint=True)
self._test_par_values = np.zeros((4, 2, 9))
self._test_par_values[0, 0] = _a_test
self._test_par_values[1, 1] = _b_test
self._test_par_values[2, 0] = _a_test
self._test_par_values[2, 1] = _b_test
self._test_par_values[3, 0] = _a_test
self._test_par_values[3, 1] = -_b_test
self._test_par_res = self._test_par_values - self._means.reshape((1, 2, 1))
self._test_par_res = np.transpose(self._test_par_res, axes=(0, 2, 1))
self._fit_no_constraints = XYFit(self._data_container)
self._fit_no_constraints.do_fit()
_cost_function = self._fit_no_constraints._fitter._fcn_wrapper
self._profile_no_constraints = np.zeros((4, 9))
for _i in range(4):
for _j in range(9):
self._profile_no_constraints[_i, _j] = _cost_function(
self._test_par_values[_i, 0, _j],
self._test_par_values[_i, 1, _j])
def test_bad_input_exception(self):
_fit_with_constraint = XYFit(self._data_container)
with self.assertRaises(XYFitException):
_fit_with_constraint.add_parameter_constraint('c', 1.0, 1.0)
with self.assertRaises(XYFitException):
_fit_with_constraint.add_matrix_parameter_constraint(['a', 'c'], [1.0, 2.0], [[0.2, 0.0], [0.0, 0.1]])
with self.assertRaises(XYFitException):
_fit_with_constraint.add_matrix_parameter_constraint(['a'], [1.0, 2.0], [[0.2, 0.0], [0.0, 0.1]])
def test_fit_profile_cov_mat_uncorrelated(self):
_fit_with_constraint = XYFit(self._data_container)
_fit_with_constraint.add_matrix_parameter_constraint(['a', 'b'], self._means, self._cov_mat_uncor)
self._test_consistency(_fit_with_constraint, self._cov_mat_uncor_inv)
_fit_with_constraint_alt = XYFit(self._data_container)
_fit_with_constraint_alt.add_parameter_constraint('a', self._means[0], np.sqrt(self._vars[0]))
_fit_with_constraint_alt.add_parameter_constraint('b', self._means[1], np.sqrt(self._vars[1]))
self._test_consistency(_fit_with_constraint_alt, self._cov_mat_uncor_inv)
def test_fit_profile_cov_mat_correlated(self):
_fit_with_constraint = XYFit(self._data_container)
_fit_with_constraint.add_matrix_parameter_constraint(['a', 'b'], self._means, self._cov_mat_cor)
self._test_consistency(_fit_with_constraint, self._cov_mat_cor_inv)
def test_fit_profile_simple_a(self):
_fit_with_constraint = XYFit(self._data_container)
_fit_with_constraint.add_parameter_constraint('a', self._means[0], np.sqrt(self._vars[0]))
self._test_consistency(_fit_with_constraint, self._cov_mat_simple_a_inv)
def test_fit_profile_simple_b(self):
_fit_with_constraint = XYFit(self._data_container)
_fit_with_constraint.add_parameter_constraint('b', self._means[1], np.sqrt(self._vars[1]))
self._test_consistency(_fit_with_constraint, self._cov_mat_simple_b_inv)
class TestDatastoreXY(unittest.TestCase):
def setUp(self):
self._ref_x_data = [0, 1, 2, 3, 4]
self._ref_y_data = [3.3, 5.5, 2.2, 8.5, 10.2]
self.data_xy = XYContainer(x_data=self._ref_x_data,
y_data=self._ref_y_data)
self._ref_x_err_abs_singlevalue = 0.1
self._ref_y_err_abs_singlevalue = 1.2
self._ref_x_err_abs_valuearray = np.array([0.1, 0.1, 0.2, 0.4, 0.5])
self._ref_y_err_abs_valuearray = [1.2, 1.1, 1.2, 1.2, 1.1]
self._ref_x_err_corr_coeff = 0.1
self._ref_y_err_corr_coeff = 0.23
self.data_xy.add_error('x',
self._ref_x_err_abs_valuearray,
name='MyXError',
correlation=self._ref_x_err_corr_coeff,
relative=False)
self.data_xy.add_error('y',
self._ref_y_err_abs_valuearray,
name='MyYError',
correlation=self._ref_y_err_corr_coeff,
relative=False)
self._ref_x_cov_mat = cov_mat_from_float_list(
self._ref_x_err_abs_valuearray,
correlation=self._ref_x_err_corr_coeff).mat
self._ref_y_cov_mat = cov_mat_from_float_list(
self._ref_y_err_abs_valuearray,
correlation=self._ref_y_err_corr_coeff).mat
def test_get_matching_error_all_empty_dict(self):
_errs = self.data_xy.get_matching_errors(matching_criteria=dict())
self.assertEqual(len(_errs), 2)
self.assertIs(self.data_xy._error_dicts['MyXError']['err'],
_errs['MyXError'])
self.assertIs(self.data_xy._error_dicts['MyYError']['err'],
_errs['MyYError'])
def test_get_matching_error_all_None(self):
_errs = self.data_xy.get_matching_errors(matching_criteria=None)
self.assertEqual(len(_errs), 2)
self.assertIs(self.data_xy._error_dicts['MyXError']['err'],
_errs['MyXError'])
self.assertIs(self.data_xy._error_dicts['MyYError']['err'],
_errs['MyYError'])
def test_get_matching_error_name(self):
_errs = self.data_xy.get_matching_errors(matching_criteria=dict(
name='MyXError'))
self.assertEqual(len(_errs), 1)
self.assertIs(self.data_xy._error_dicts['MyXError']['err'],
_errs['MyXError'])
def test_get_matching_error_type_simple(self):
_errs = self.data_xy.get_matching_errors(matching_criteria=dict(
type='simple'))
self.assertEqual(len(_errs), 2)
self.assertIs(self.data_xy._error_dicts['MyXError']['err'],
_errs['MyXError'])
self.assertIs(self.data_xy._error_dicts['MyYError']['err'],
_errs['MyYError'])
def test_get_matching_error_type_matrix(self):
_errs = self.data_xy.get_matching_errors(matching_criteria=dict(
type='matrix'))
self.assertEqual(len(_errs), 0)
def test_get_matching_error_uncorrelated(self):
_errs = self.data_xy.get_matching_errors(matching_criteria=dict(
correlated=False))
self.assertEqual(len(_errs), 0)
def test_get_matching_error_correlated(self):
_errs = self.data_xy.get_matching_errors(matching_criteria=dict(
correlated=True))
self.assertEqual(len(_errs), 2)
self.assertIs(self.data_xy._error_dicts['MyXError']['err'],
_errs['MyXError'])
self.assertIs(self.data_xy._error_dicts['MyYError']['err'],
_errs['MyYError'])
def test_get_matching_error_axis(self):
_errs = self.data_xy.get_matching_errors(matching_criteria=dict(
axis=1))
self.assertEqual(len(_errs), 1)
self.assertIs(self.data_xy._error_dicts['MyYError']['err'],
_errs['MyYError'])
def test_compare_error_reference(self):
for _err_dict in self.data_xy._error_dicts.values():
_err_ref_vals = _err_dict['err'].reference
_axis = _err_dict['axis']
assert _axis in (0, 1)
if _axis == 0:
self.assertTrue(np.all(_err_ref_vals == self._ref_x_data))
elif _axis == 1:
self.assertTrue(np.all(_err_ref_vals == self._ref_y_data))
def test_compare_ref_x_data(self):
self.assertTrue(np.all(self.data_xy.x == self._ref_x_data))
def test_compare_ref_y_data(self):
self.assertTrue(np.all(self.data_xy.y == self._ref_y_data))
def test_compare_ref_x_err(self):
self.assertTrue(
np.allclose(self.data_xy.x_err,
self._ref_x_err_abs_valuearray,
atol=1e-10))
def test_compare_ref_y_err(self):
self.assertTrue(
np.allclose(self.data_xy.y_err,
self._ref_y_err_abs_valuearray,
atol=1e-10))
# def test_compare_ref_x_cov_mat(self):
# self.assertTrue(np.allclose(self.data_xy.???, self._ref_x_cov_mat, atol=1e-5))
#
# def test_compare_ref_y_cov_mat(self):
# self.assertTrue(np.allclose(self.data_xy.???, self._ref_y_cov_mat, atol=1e-5))
def test_compare_ref_total_x_cov_mat(self):
_err = self.data_xy.get_total_error(0)
_mat = _err.cov_mat
self.assertTrue(np.allclose(_mat, self._ref_x_cov_mat, atol=1e-5))
def test_compare_ref_total_y_cov_mat(self):
_err = self.data_xy.get_total_error(1)
_mat = _err.cov_mat
self.assertTrue(np.allclose(_mat, self._ref_y_cov_mat, atol=1e-5))
def test_compare_ref_total_y_for_x_plus_y_as_y_err(self):
self.data_xy.add_error('y',
self._ref_x_err_abs_valuearray,
correlation=self._ref_x_err_corr_coeff,
relative=False)
_err = self.data_xy.get_total_error(1)
_mat = _err.cov_mat
self.assertTrue(
np.allclose(_mat,
self._ref_y_cov_mat + self._ref_x_cov_mat,
atol=1e-5))
def test_compare_ref_total_y_for_x_plus_y_as_y_err_disabled(self):
self.data_xy.add_error('y',
self._ref_x_err_abs_valuearray,
name="MyNewYError",
correlation=self._ref_x_err_corr_coeff,
relative=False)
self.data_xy.disable_error("MyNewYError")
_err = self.data_xy.get_total_error(1)
_mat = _err.cov_mat
self.assertTrue(np.allclose(_mat, self._ref_y_cov_mat, atol=1e-5))
def test_compare_ref_total_y_for_x_plus_y_as_y_err_disabled_reenabled(
self):
self.data_xy.add_error('y',
self._ref_x_err_abs_valuearray,
name="MyNewYError",
correlation=self._ref_x_err_corr_coeff,
relative=False)
self.data_xy.disable_error("MyNewYError")
_err = self.data_xy.get_total_error(1)
self.data_xy.enable_error("MyNewYError")
_err = self.data_xy.get_total_error(1)
_mat = _err.cov_mat
self.assertTrue(
np.allclose(_mat,
self._ref_y_cov_mat + self._ref_x_cov_mat,
atol=1e-5))
def test_raise_add_same_error_name_twice(self):
self.data_xy.add_error('y',
0.1,
name="MyNewYError",
correlation=0,
relative=False)
with self.assertRaises(DataContainerException):
self.data_xy.add_error('y',
0.1,
name="MyNewYError",
correlation=0,
relative=False)
def test_raise_get_inexistent_error(self):
with self.assertRaises(DataContainerException):
self.data_xy.get_error("MyInexistentYError")
def setUp(self):
_data = [[0.0, .1, .3], [10, 24, 44]]
_ndat = len(_data[0])
self._container = XYContainer(x_data=_data[0], y_data=_data[1])
self._container.add_error(axis='y',
name="ySUA",
err_val=0.1,
correlation=0.0,
relative=False)
self._container.add_error(axis='y',
name="ySUR",
err_val=0.1,
correlation=0.0,
relative=True)
self._container.add_error(axis='y',
name="ySCA",
err_val=0.1,
correlation=1.0,
relative=False)
self._container.add_matrix_error(axis='y',
name="yMCov",
err_matrix=np.eye(_ndat) * 0.1,
relative=False,
matrix_type='covariance')
self._container.add_matrix_error(axis='y',
name="yMCor",
err_matrix=np.eye(_ndat),
relative=False,
matrix_type='correlation',
err_val=0.1)
self._container.add_error(axis='x',
name="xSUA",
err_val=0.1,
correlation=0.0,
relative=False)
self._container.add_error(axis='x',
name="xSUR",
err_val=0.1,
correlation=0.0,
relative=True)
self._container.add_matrix_error(axis='x',
name="xMCov",
err_matrix=np.eye(_ndat) * 0.1,
relative=False,
matrix_type='covariance')
# self._container.add_simple_error(axis='x', err_val=0.1, correlation=0.0, relative=False)
# self._container.add_simple_error(axis='y', err_val=0.2, correlation=0.0, relative=False)
# self._container.add_matrix_error(axis='y', err_matrix=np.eye(8) * 0.1, relative=False, matrix_type='covariance')
self._roundtrip_stringstream = IOStreamHandle(StringIO())
self._testfile_stringstream = IOStreamHandle(StringIO(TEST_DATASET_XY))
self._roundtrip_streamreader = DataContainerYamlReader(
self._roundtrip_stringstream)
self._roundtrip_streamwriter = DataContainerYamlWriter(
self._container, self._roundtrip_stringstream)
self._testfile_streamreader = DataContainerYamlReader(
self._testfile_stringstream)
self._testfile_stringstream_missing_keyword = IOStreamHandle(
StringIO(TEST_DATASET_XY_MISSING_KEYWORD))
self._testfile_stringstream_extra_keyword = IOStreamHandle(
StringIO(TEST_DATASET_XY_EXTRA_KEYWORD))
self._testfile_streamreader_missing_keyword = DataContainerYamlReader(
self._testfile_stringstream_missing_keyword)
self._testfile_streamreader_extra_keyword = DataContainerYamlReader(
self._testfile_stringstream_extra_keyword)
self._ref_testfile_x_data = [5, 17]
self._ref_testfile_y_data = [80.429, 80.339]
self._ref_testfile_x_err = [0.70710678, 0.70710678]
self._ref_testfile_y_err = [0.54772256, 0.54772256]
self._ref_testfile_y_cov_mat = np.array([[0.3, 0.1], [0.1, 0.3]])
self._ref_testfile_x_cov_mat = np.array([[0.5, 0.2], [0.2, 0.5]])
self._ref_testfile_error_names = {
'XErrorOne', 'XErrorTwo', 'YErrorOne', 'YErrorTwo'
}
class TestXYContainerYamlRepresentation(unittest.TestCase):
def setUp(self):
_data = [[0.0, .1, .3], [10, 24, 44]]
_ndat = len(_data[0])
self._container = XYContainer(x_data=_data[0], y_data=_data[1])
self._container.add_error(axis='y',
name="ySUA",
err_val=0.1,
correlation=0.0,
relative=False)
self._container.add_error(axis='y',
name="ySUR",
err_val=0.1,
correlation=0.0,
relative=True)
self._container.add_error(axis='y',
name="ySCA",
err_val=0.1,
correlation=1.0,
relative=False)
self._container.add_matrix_error(axis='y',
name="yMCov",
err_matrix=np.eye(_ndat) * 0.1,
relative=False,
matrix_type='covariance')
self._container.add_matrix_error(axis='y',
name="yMCor",
err_matrix=np.eye(_ndat),
relative=False,
matrix_type='correlation',
err_val=0.1)
self._container.add_error(axis='x',
name="xSUA",
err_val=0.1,
correlation=0.0,
relative=False)
self._container.add_error(axis='x',
name="xSUR",
err_val=0.1,
correlation=0.0,
relative=True)
self._container.add_matrix_error(axis='x',
name="xMCov",
err_matrix=np.eye(_ndat) * 0.1,
relative=False,
matrix_type='covariance')
# self._container.add_simple_error(axis='x', err_val=0.1, correlation=0.0, relative=False)
# self._container.add_simple_error(axis='y', err_val=0.2, correlation=0.0, relative=False)
# self._container.add_matrix_error(axis='y', err_matrix=np.eye(8) * 0.1, relative=False, matrix_type='covariance')
self._roundtrip_stringstream = IOStreamHandle(StringIO())
self._testfile_stringstream = IOStreamHandle(StringIO(TEST_DATASET_XY))
self._roundtrip_streamreader = DataContainerYamlReader(
self._roundtrip_stringstream)
self._roundtrip_streamwriter = DataContainerYamlWriter(
self._container, self._roundtrip_stringstream)
self._testfile_streamreader = DataContainerYamlReader(
self._testfile_stringstream)
self._testfile_stringstream_missing_keyword = IOStreamHandle(
StringIO(TEST_DATASET_XY_MISSING_KEYWORD))
self._testfile_stringstream_extra_keyword = IOStreamHandle(
StringIO(TEST_DATASET_XY_EXTRA_KEYWORD))
self._testfile_streamreader_missing_keyword = DataContainerYamlReader(
self._testfile_stringstream_missing_keyword)
self._testfile_streamreader_extra_keyword = DataContainerYamlReader(
self._testfile_stringstream_extra_keyword)
self._ref_testfile_x_data = [5, 17]
self._ref_testfile_y_data = [80.429, 80.339]
self._ref_testfile_x_err = [0.70710678, 0.70710678]
self._ref_testfile_y_err = [0.54772256, 0.54772256]
self._ref_testfile_y_cov_mat = np.array([[0.3, 0.1], [0.1, 0.3]])
self._ref_testfile_x_cov_mat = np.array([[0.5, 0.2], [0.2, 0.5]])
self._ref_testfile_error_names = {
'XErrorOne', 'XErrorTwo', 'YErrorOne', 'YErrorTwo'
}
def test_write_to_roundtrip_stringstream(self):
self._roundtrip_streamwriter.write()
def test_read_from_testfile_stream(self):
_read_container = self._testfile_streamreader.read()
self.assertTrue(isinstance(_read_container, XYContainer))
self.assertTrue(
np.allclose(_read_container.x, self._ref_testfile_x_data))
self.assertTrue(
np.allclose(_read_container.y, self._ref_testfile_y_data))
self.assertTrue(
np.allclose(_read_container.x_err, self._ref_testfile_x_err))
self.assertTrue(
np.allclose(_read_container.y_err, self._ref_testfile_y_err))
self.assertTrue(
np.allclose(
_read_container.x_cov_mat,
self._ref_testfile_x_cov_mat,
))
self.assertTrue(
np.allclose(
_read_container.y_cov_mat,
self._ref_testfile_y_cov_mat,
))
# check that the error names are the same
self.assertEqual(set(_read_container._error_dicts.keys()),
self._ref_testfile_error_names)
def test_read_from_testfile_stream_missing_keyword(self):
with self.assertRaises(YamlReaderException):
self._testfile_streamreader_missing_keyword.read()
def test_read_from_testfile_stream_extra_keyword(self):
with self.assertRaises(YamlReaderException):
self._testfile_streamreader_extra_keyword.read()
def test_round_trip_with_stringstream(self):
self._roundtrip_streamwriter.write()
self._roundtrip_stringstream.seek(0) # return to beginning
_read_container = self._roundtrip_streamreader.read()
self.assertTrue(isinstance(_read_container, XYContainer))
# compare data members
self.assertTrue(np.allclose(self._container.x, _read_container.x))
self.assertTrue(np.allclose(self._container.y, _read_container.y))
# compare (total) errors and cov mats
# TODO: compare individual error components -> nontrivial because error ids change...
self.assertTrue(
np.allclose(self._container.x_err, _read_container.x_err))
self.assertTrue(
np.allclose(self._container.y_err, _read_container.y_err))
self.assertTrue(
np.allclose(self._container.x_cov_mat, _read_container.x_cov_mat))
self.assertTrue(
np.allclose(self._container.y_cov_mat, _read_container.y_cov_mat))
# check that the error names are the same
self.assertEqual(set(self._container._error_dicts.keys()),
set(_read_container._error_dicts.keys()))