def setUp(self):
_data = [1, 1, 4, 1, 1, 4, 2, 5, 5, 5, 2, 4, 2, 2, 18, 2, 8, 8, 9]
_nbins = 3
self._container = HistContainer(n_bins=_nbins,
bin_range=(0.0, 10.),
fill_data=_data)
self._container.add_error(err_val=0.1,
name='SC5A_1',
correlation=0.5,
relative=False)
self._container.add_error(
err_val=[i / 10. for i in range(1, _nbins + 1)],
name='SC5A_2',
correlation=0.5,
relative=False)
self._container.add_matrix_error(err_matrix=np.eye(_nbins) * 0.1,
name='MCov',
relative=False,
matrix_type='covariance')
self._container.add_matrix_error(err_matrix=np.eye(_nbins),
name='MCor',
relative=False,
matrix_type='correlation',
err_val=0.03)
self._roundtrip_stringstream = IOStreamHandle(StringIO())
self._testfile_stringstream = IOStreamHandle(
StringIO(TEST_DATASET_HIST))
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_HIST_MSSING_KEYWORD))
self._testfile_stringstream_extra_keyword = IOStreamHandle(
StringIO(TEST_DATASET_HIST_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_n_bins = 2
self._ref_testfile_bin_range = [1.0, 3.0]
self._ref_testfile_bin_edges = [1.0, 2.0, 3.0]
self._ref_testfile_data = [1, 1]
self._ref_testfile_err = [0.89442719, 1]
self._ref_testfile_cov_mat = np.array([[0.8, 0.3], [0.3, 1.0]])
self._ref_testfile_error_names = {
'ErrorOne', 'ErrorTwo', 'ErrorThree', 'ErrorFour'
}
def setUp(self):
_bin_edges = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
_data = [
0.5, 1.5, 1.5, 2.5, 2.5, 2.5, 3.5, 3.5, 3.5, 3.5, 4.5, 4.5, 4.5,
4.5, 4.5
]
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 = HistContainer(n_bins=5,
bin_range=(0.0, 5.0),
fill_data=_data,
dtype=float)
self._data_container.add_error(err_val=1.0)
_a_test = np.linspace(start=1, stop=2, num=9, endpoint=True)
_b_test = np.linspace(start=2, stop=3, 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[::-1] # reverse order
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 = HistFit(
self._data_container,
model_density_function=self._model_function,
bin_evaluation=self._model_function_antiderivative)
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_update_data(self):
_fit = self._get_fit(model_density_antiderivative=hist_model_density_antideriv)
_new_entries = np.array([
19.424357258680693, 19.759361803397155, 18.364336396273362, 18.36464562195573,
21.12001399388072, 18.08232152646234, 20.881797998050466, 19.799071480564336,
20.00149234521563, 18.45879580610016, 20.507568873033875, 20.30648149729429,
20.877350386469818, 19.381958240681676, 19.64442840120083, 19.141355147035597,
19.94101630498644, 20.504982848860507, 17.524033521076785, 20.73543156774036,
21.163113940992737, 19.05979241568689, 20.196952015154917, 20.40130402635463,
21.80417387186999, 20.611530513961164, 19.099481246155072, 21.817653009909904,
19.75055842274471, 20.103815812928232, 18.174017677733538, 21.047249981725685,
21.262823911834488, 21.536864685525888, 18.813610758324447, 21.499655806695163,
19.933264932657465, 21.954933746841995, 17.78470283680212, 19.8917212343489,
19.372012624773838, 18.9520723656944, 19.9905553737993, 18.22737716365809,
22.208437406472243, 19.875706306083835, 19.17672889225326, 20.10750939196147,
20.093938177045032, 19.857292210131092, 20.17843836897936, 20.58803422718744,
19.936410829343984, 19.050688989087522, 18.46936492682146, 21.90955106395087,
19.661176212242154, 22.2764766192496, 19.850200163818528, 18.49289303805954,
19.7563960302135, 20.940311019530235, 19.12732791777932, 22.09224225083453,
20.225667564052465, 20.10787811564912, 18.660130651239726, 18.356069221596094,
20.278651217320608, 18.62176541545302, 18.747451690981315, 19.81307693501857,
19.34065619310232, 19.56998674371285, 19.885577923257177, 18.81752399043877,
20.67686318083984, 20.265021790145465, 19.982547007042093, 19.581967230877964,
18.486722000426457, 19.83143305661045, 21.252124382516378, 20.152988937293436,
18.917354464336892, 18.349803731030892, 21.32702043081207, 22.410955706069743,
20.972404800516973, 19.615870251101295, 19.013627387925588, 19.54487437668081,
20.538542465210206, 18.626198427902466, 20.221745437611307, 19.064952809088076])
_fit.data = HistContainer(
8,
(17, 23),
fill_data=_new_entries
)
_fit.add_error(err_val=1.0)
_ref_data, _ = np.histogram(
_new_entries,
bins=8,
range=(17, 23)
)
self._assert_fit_properties(
_fit,
dict(
data=_ref_data,
)
)
_fit.do_fit()
self._assert_fit_properties(
_fit,
dict(
data=_ref_data,
parameter_values=np.array([19.83815938, 1.1729322]),
poi_values=np.array([19.83815938, 1.1729322]),
),
rtol=1e-2
)
def setUp(self):
self._ref_entries = [-9999., -8279., 3.3, 5.5, 2.2, 8.5, 10., 10.2, 10000., 1e7]
self._ref_n_bins_auto = 25
self._ref_n_bins_manual = 10
self._ref_n_bin_range = (0., 10.)
self._ref_bin_edges_manual_equalspacing = np.linspace(0, 10, self._ref_n_bins_manual + 1)
# [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10]
self._ref_data_manual_equalspacing = np.array([ 0, 0, 1, 1, 0, 1, 0, 0, 1, 0])
self._ref_bin_edges_manual_variablespacing = [0 , 2 , 3 , 3.1 , 3.2 , 3.3 , 3.4 , 7 , 8.5 , 9 , 10]
self._ref_data_manual_variablespacing = np.array([ 0, 1, 0, 0, 0, 1, 1, 0, 1, 0])
self._ref_data_auto = np.array([0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0])
# test rebinning functionality
self._probe_bin_edges_variablespacing_withedges = [0, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 10] # OK
self._probe_bin_edges_variablespacing_noedges = [ 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9] # OK
self._probe_bin_edges_variablespacing_wrongedges1 = [0, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 12.3] # fail
self._probe_bin_edges_variablespacing_wrongedges2 = [-9, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 10] # fail
self._probe_bin_edges_variablespacing_wrongedges3 = [-3, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 22] # fail
self._probe_bin_edges_variablespacing_wrongnumber = [0, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 10] # fail
self._probe_bin_edges_variablespacing_unsorted = [0, 2, 3, 8.5, 3.2, 3.3, 3.4, 7, 3.1, 9, 10] # fail
self.hist_cont_binedges_auto = HistContainer(self._ref_n_bins_auto, self._ref_n_bin_range, bin_edges=None)
self.hist_cont_binedges_manual_equal = HistContainer(self._ref_n_bins_manual, self._ref_n_bin_range, bin_edges=self._ref_bin_edges_manual_equalspacing)
self.hist_cont_binedges_manual_variable = HistContainer(self._ref_n_bins_manual, self._ref_n_bin_range, bin_edges=self._ref_bin_edges_manual_variablespacing)
def setUp(self):
self._ref_n_bins = 11
self._ref_n_bin_range = (-3, 25)
self._ref_bin_edges = np.linspace(self._ref_n_bin_range[0],
self._ref_n_bin_range[1],
self._ref_n_bins + 1)
self._ref_entries = np.array([
11.47195963, 9.96715403, 19.90275216, 13.65225802, 18.52670233,
17.79707059, 11.5441954, 18.42331074, 13.3808496, 18.40632518,
13.21694177, 15.34569261, 9.85164713, 11.56275047, 12.42687109,
9.43924719, 15.03632673, 10.76203991, 15.16788754, 13.78683534,
10.84686619, 17.29655143, 12.58404203, 13.10171453, 20.23773075,
15.00936796, 15.38972301, 12.94254624, 19.01920031, 19.67747312,
14.53196033, 13.78898329, 17.34040707, 17.25328064, 13.64052295,
11.80461841, 14.21872985, 11.59054406, 20.28243216, 15.43544627,
15.85964469, 13.68948162, 14.55574162, 15.70198922, 12.85548112,
14.05419407, 15.85172907, 19.2951937, 12.70652203, 13.47822913,
12.84301792, 13.65407699, 12.81908235, 12.73065184, 23.34917367,
11.38895625, 9.41615435, 7.24554349, 11.4112971, 14.54736404,
15.84186607, 15.33880379, 9.93177073, 15.14220967, 15.19535013,
11.00033758, 11.83671083, 13.02411982, 18.43323913, 12.06272124,
20.57549426, 12.97405382, 13.35969913, 10.76072424, 16.35912216,
14.52842827, 16.97221766, 13.02791932, 14.36097113, 16.93839498,
15.60091018, 11.55044489, 14.06915886, 17.64985576, 11.59865691,
13.41486068, 14.25999508, 10.70887047, 4.08280244, 13.1043861,
14.62321312, 14.85894591, 14.89235398, 10.60967181, 15.22310211,
10.77853626, 14.56823312, 14.46093346, 13.34031129, 14.14203599
])
self._ref_hist_cont = HistContainer(self._ref_n_bins,
self._ref_n_bin_range,
bin_edges=None,
fill_data=self._ref_entries)
# reference initial values
self._ref_initial_pars = np.array([14., 3.])
self._ref_initial_model = (hist_model_density_antideriv(
self._ref_bin_edges[1:], *
self._ref_initial_pars) - hist_model_density_antideriv(
self._ref_bin_edges[:-1], *self._ref_initial_pars)) * len(
self._ref_entries)
# fit data
self._ref_data, _ = np.histogram(self._ref_entries,
bins=self._ref_n_bins,
range=self._ref_n_bin_range)
# pre-fit cost value
self._ref_initial_cost_nll = \
-2*np.sum(stats.poisson.logpmf(self._ref_data, self._ref_initial_model))
self._ref_initial_cost_chi2 = simple_chi2(self._ref_data,
self._ref_initial_model)
# reference fit result values
self._nominal_fit_result_pars_nll = np.array([14.18427759, 3.02257722])
self._nominal_fit_result_pars_chi2 = np.array(
[13.82779489, 2.62746457])
self._nominal_fit_result_model_nll = (hist_model_density_antideriv(
self._ref_bin_edges[1:], *
self._nominal_fit_result_pars_nll) - hist_model_density_antideriv(
self._ref_bin_edges[:-1], *
self._nominal_fit_result_pars_nll)) * len(self._ref_entries)
self._nominal_fit_result_model_chi2 = (hist_model_density_antideriv(
self._ref_bin_edges[1:], *
self._nominal_fit_result_pars_chi2) - hist_model_density_antideriv(
self._ref_bin_edges[:-1], *
self._nominal_fit_result_pars_chi2)) * len(self._ref_entries)
self._nominal_fit_result_cost_nll = \
-2*np.sum(stats.poisson.logpmf(self._ref_data, self._nominal_fit_result_model_nll))
self._nominal_fit_result_cost_chi2 = simple_chi2(
self._ref_data, self._nominal_fit_result_model_chi2)
# helper dict with all reference property values
self._ref_prop_dict = dict(
did_fit=False,
model_count=1,
parameter_values=self._ref_initial_pars,
parameter_names=('mu', 'sigma'),
data=self._ref_data,
model=self._ref_initial_model,
)
class TestParameterConstraintInHistFit(unittest.TestCase):
@staticmethod
def _model_function(x, a, b):
return a * x + b
@staticmethod
def _model_function_antiderivative(x, a, b):
return 0.5 * a * x ** 2 + b * x
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):
_a = self._test_par_values[_i, 0, _j]
_b = self._test_par_values[_i, 1, _j]
_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):
_bin_edges = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
_data = [
0.5,
1.5, 1.5,
2.5, 2.5, 2.5,
3.5, 3.5, 3.5, 3.5,
4.5, 4.5, 4.5, 4.5, 4.5
]
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 = HistContainer(n_bins=5, bin_range=(0.0, 5.0), fill_data=_data, dtype=float)
self._data_container.add_error(err_val=1.0)
_a_test = np.linspace(start=1, stop=2, num=9, endpoint=True)
_b_test = np.linspace(start=2, stop=3, 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[::-1] # reverse order
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 = HistFit(self._data_container, model_density_function=self._model_function,
model_density_antiderivative=self._model_function_antiderivative)
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 = HistFit(self._data_container, model_density_function=self._model_function,
model_density_antiderivative=self._model_function_antiderivative)
with self.assertRaises(HistFitException):
_fit_with_constraint.add_parameter_constraint('c', 1.0, 1.0)
with self.assertRaises(HistFitException):
_fit_with_constraint.add_matrix_parameter_constraint(['a', 'c'], [1.0, 2.0], [[0.2, 0.0], [0.0, 0.1]])
with self.assertRaises(HistFitException):
_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 = HistFit(self._data_container, model_density_function=self._model_function,
model_density_antiderivative=self._model_function_antiderivative)
_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 = HistFit(self._data_container, model_density_function=self._model_function,
model_density_antiderivative=self._model_function_antiderivative)
_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 = HistFit(self._data_container, model_density_function=self._model_function,
model_density_antiderivative=self._model_function_antiderivative)
_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 = HistFit(self._data_container, model_density_function=self._model_function,
model_density_antiderivative=self._model_function_antiderivative)
_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 = HistFit(self._data_container, model_density_function=self._model_function,
model_density_antiderivative=self._model_function_antiderivative)
_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)
def test_raise_construct_bin_edges_variablespacing_unsorted(self):
with self.assertRaises(HistContainerException):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_unsorted)
def test_construct_bin_edges_variablespacing_noedges(self):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_noedges)
class TestDatastoreHistogram(unittest.TestCase):
def setUp(self):
self._ref_entries = [
-9999., -8279., 3.3, 5.5, 2.2, 8.5, 10., 10.2, 10000., 1e7
]
self._ref_n_bins_auto = 25
self._ref_n_bins_manual = 10
self._ref_n_bin_range = (0., 10.)
self._ref_bin_edges_manual_equalspacing = np.linspace(
0, 10, self._ref_n_bins_manual + 1)
# [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10]
self._ref_data_manual_equalspacing = np.array(
[0, 0, 1, 1, 0, 1, 0, 0, 1, 0])
self._ref_bin_heights_manual = np.array(
[5, 4, 10, 3, 0, 15, 7, 4, 20, 1])
self._ref_bin_edges_manual_variablespacing = [
0, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 10
]
self._ref_data_manual_variablespacing = np.array(
[0, 1, 0, 0, 0, 1, 1, 0, 1, 0])
self._ref_data_auto = np.array([
0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1,
0, 0, 0
])
# test rebinning functionality
self._probe_bin_edges_variablespacing_withedges = [
0, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 10
] # OK
self._probe_bin_edges_variablespacing_noedges = [
2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9
] # OK
self._probe_bin_edges_variablespacing_wrongedges1 = [
0, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 12.3
] # fail
self._probe_bin_edges_variablespacing_wrongedges2 = [
-9, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 10
] # fail
self._probe_bin_edges_variablespacing_wrongedges3 = [
-3, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 9, 22
] # fail
self._probe_bin_edges_variablespacing_wrongnumber = [
0, 2, 3, 3.1, 3.2, 3.3, 3.4, 7, 8.5, 10
] # fail
self._probe_bin_edges_variablespacing_unsorted = [
0, 2, 3, 8.5, 3.2, 3.3, 3.4, 7, 3.1, 9, 10
] # fail
self.hist_cont_binedges_auto = HistContainer(self._ref_n_bins_auto,
self._ref_n_bin_range,
bin_edges=None)
self.hist_cont_binedges_manual_equal = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._ref_bin_edges_manual_equalspacing)
self.hist_cont_binedges_manual_variable = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._ref_bin_edges_manual_variablespacing)
def test_property_size(self):
self.assertEqual(self.hist_cont_binedges_auto.size,
self._ref_n_bins_auto)
self.assertEqual(self.hist_cont_binedges_manual_equal.size,
self._ref_n_bins_manual)
self.assertEqual(self.hist_cont_binedges_manual_variable.size,
self._ref_n_bins_manual)
def test_property_low(self):
self.assertEqual(self.hist_cont_binedges_auto.low,
self._ref_n_bin_range[0])
self.assertEqual(self.hist_cont_binedges_manual_equal.low,
self._ref_n_bin_range[0])
self.assertEqual(self.hist_cont_binedges_manual_variable.low,
self._ref_n_bin_range[0])
def test_property_high(self):
self.assertEqual(self.hist_cont_binedges_auto.high,
self._ref_n_bin_range[1])
self.assertEqual(self.hist_cont_binedges_manual_equal.high,
self._ref_n_bin_range[1])
self.assertEqual(self.hist_cont_binedges_manual_variable.high,
self._ref_n_bin_range[1])
def test_fill_empty_binedges_auto_compare_data(self):
self.hist_cont_binedges_auto.fill(self._ref_entries)
self.assertTrue(
np.allclose(self.hist_cont_binedges_auto.data,
self._ref_data_auto))
def test_fill_empty_binedges_manual_equal_compare_data(self):
self.hist_cont_binedges_manual_equal.fill(self._ref_entries)
self.assertTrue(
np.allclose(self.hist_cont_binedges_manual_equal.data,
self._ref_data_manual_equalspacing))
def test_fill_empty_binedges_manual_variable_compare_data(self):
self.hist_cont_binedges_manual_variable.fill(self._ref_entries)
self.assertTrue(
np.allclose(self.hist_cont_binedges_manual_variable.data,
self._ref_data_manual_variablespacing))
def test_fill_empty_binedges_auto_rebin_manual_equal_compare_data(self):
self.hist_cont_binedges_auto.fill(self._ref_entries)
self.hist_cont_binedges_auto.rebin(
self._ref_bin_edges_manual_equalspacing)
self.assertTrue(
np.allclose(self.hist_cont_binedges_auto.data,
self._ref_data_manual_equalspacing))
def test_fill_empty_binedges_auto_rebin_manual_variable_compare_data(self):
self.hist_cont_binedges_auto.fill(self._ref_entries)
self.hist_cont_binedges_auto.rebin(
self._ref_bin_edges_manual_variablespacing)
self.assertTrue(
np.allclose(self.hist_cont_binedges_auto.data,
self._ref_data_manual_variablespacing))
def test_manual_bin_height(self):
self.hist_cont_binedges_manual_equal.set_bins(
self._ref_bin_heights_manual)
self.assertTrue(
np.alltrue(self.hist_cont_binedges_manual_equal.data ==
self._ref_bin_heights_manual))
self.assertTrue(self.hist_cont_binedges_manual_equal._manual_heights)
def test_construct_bin_edges_variablespacing_withedges(self):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_withedges)
def test_construct_bin_edges_variablespacing_noedges(self):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_noedges)
def test_raise_construct_bin_edges_variablespacing_wrongedges1(self):
with self.assertRaises(HistContainerException):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_wrongedges1)
def test_raise_construct_bin_edges_variablespacing_wrongedges2(self):
with self.assertRaises(HistContainerException):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_wrongedges2)
def test_raise_construct_bin_edges_variablespacing_wrongedges3(self):
with self.assertRaises(HistContainerException):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_wrongedges3)
def test_raise_construct_bin_edges_variablespacing_wrongnumber(self):
with self.assertRaises(HistContainerException):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_wrongnumber)
def test_raise_construct_bin_edges_variablespacing_unsorted(self):
with self.assertRaises(HistContainerException):
_hc = HistContainer(
self._ref_n_bins_manual,
self._ref_n_bin_range,
bin_edges=self._probe_bin_edges_variablespacing_unsorted)
def test_raise_add_same_error_name_twice(self):
self.hist_cont_binedges_auto.add_error(0.1,
name="MyNewError",
correlation=0,
relative=False)
with self.assertRaises(DataContainerException):
self.hist_cont_binedges_auto.add_error(0.1,
name="MyNewError",
correlation=0,
relative=False)
def test_raise_get_inexistent_error(self):
with self.assertRaises(DataContainerException):
self.hist_cont_binedges_auto.get_error("MyInexistentError")
def test_raise_manual_bin_heights_rebin(self):
self.hist_cont_binedges_manual_equal.set_bins(
self._ref_bin_heights_manual)
with self.assertRaises(DataContainerException):
self.hist_cont_binedges_manual_equal.rebin(
self._ref_bin_edges_manual_variablespacing)
class TestHistContainerYamlRepresentation(unittest.TestCase):
def setUp(self):
_data = [1, 1, 4, 1, 1, 4, 2, 5, 5, 5, 2, 4, 2, 2, 18, 2, 8, 8, 9]
_nbins = 3
self._container = HistContainer(n_bins=_nbins,
bin_range=(0.0, 10.),
fill_data=_data)
self._container.add_error(err_val=0.1,
name='SC5A_1',
correlation=0.5,
relative=False)
self._container.add_error(
err_val=[i / 10. for i in range(1, _nbins + 1)],
name='SC5A_2',
correlation=0.5,
relative=False)
self._container.add_matrix_error(err_matrix=np.eye(_nbins) * 0.1,
name='MCov',
relative=False,
matrix_type='covariance')
self._container.add_matrix_error(err_matrix=np.eye(_nbins),
name='MCor',
relative=False,
matrix_type='correlation',
err_val=0.03)
self._roundtrip_stringstream = IOStreamHandle(StringIO())
self._testfile_stringstream = IOStreamHandle(
StringIO(TEST_DATASET_HIST))
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_HIST_MSSING_KEYWORD))
self._testfile_stringstream_extra_keyword = IOStreamHandle(
StringIO(TEST_DATASET_HIST_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_n_bins = 2
self._ref_testfile_bin_range = [1.0, 3.0]
self._ref_testfile_bin_edges = [1.0, 2.0, 3.0]
self._ref_testfile_data = [1, 1]
self._ref_testfile_err = [0.89442719, 1]
self._ref_testfile_cov_mat = np.array([[0.8, 0.3], [0.3, 1.0]])
self._ref_testfile_error_names = {
'ErrorOne', 'ErrorTwo', 'ErrorThree', 'ErrorFour'
}
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, HistContainer))
self.assertTrue(_read_container.n_bins == self._ref_testfile_n_bins)
self.assertTrue(
np.allclose(_read_container.bin_range,
self._ref_testfile_bin_range))
self.assertTrue(
np.allclose(_read_container.bin_edges,
self._ref_testfile_bin_edges))
self.assertTrue(
np.allclose(_read_container.data, self._ref_testfile_data))
self.assertTrue(
np.allclose(_read_container.err, self._ref_testfile_err))
self.assertTrue(
np.allclose(
_read_container.cov_mat,
self._ref_testfile_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, HistContainer))
self.assertTrue(self._container.n_bins == _read_container.n_bins)
self.assertTrue(
np.allclose(self._container.bin_range, _read_container.bin_range))
self.assertTrue(
np.allclose(self._container.bin_edges, _read_container.bin_edges))
# compare data members
self.assertTrue(np.allclose(self._container.data,
_read_container.data))
# compare (total) errors and cov mats
# TODO: compare individual error components -> nontrivial because error ids change...
self.assertTrue(np.allclose(self._container.err, _read_container.err))
self.assertTrue(
np.allclose(self._container.cov_mat, _read_container.cov_mat))
# check that the error names are the same
self.assertEqual(set(self._container._error_dicts.keys()),
set(_read_container._error_dicts.keys()))
