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()))