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_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 _get_fit(self, model_function=None, cost_function=None, error=None):
'''convenience'''
model_function = model_function or simple_xy_model
# TODO: fix default
cost_function = cost_function or XYCostFunction_Chi2(
axes_to_use='xy', errors_to_use='covariance')
error = error or 1.0
_fit = XYFit(xy_data=self._ref_xy_data,
model_function=model_function,
cost_function=cost_function,
minimizer=self.MINIMIZER)
_fit.add_error(axis='y', err_val=error)
return _fit
def _get_fit(self, errors=None):
'''convenience'''
errors = errors or [dict(axis='y', err_val=1.0)]
_fit = XYFit(xy_data=self._ref_xy_data,
model_function=simple_xy_model,
cost_function=XYCostFunction_Chi2(
axes_to_use='xy', errors_to_use='covariance'),
minimizer=self.MINIMIZER)
for _err in errors:
_fit.add_error(**_err)
return _fit
def test_model_no_pars_raise(self):
def dummy_model():
pass
with self.assertRaises(ModelFunctionException) as _exc:
XYFit(xy_data=self._ref_xy_data,
model_function=dummy_model,
minimizer=self.MINIMIZER)
self.assertIn('needs at least one parameter', _exc.exception.args[0])
def test_reserved_parameter_names_raise(self):
def dummy_model(x, y_data):
pass
with self.assertRaises(XYFitException) as _exc:
XYFit(xy_data=self._ref_xy_data,
model_function=dummy_model,
minimizer=self.MINIMIZER)
self.assertIn('reserved', _exc.exception.args[0])
self.assertIn('y_data', _exc.exception.args[0])
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_model_varargs_varkwargs_raise(self):
# TODO: raise even without 'par'
def dummy_model(x, par, *varargs, **varkwargs):
pass
with self.assertRaises(ModelFunctionException) as _exc:
XYFit(xy_data=self._ref_xy_data,
model_function=dummy_model,
minimizer=self.MINIMIZER)
self.assertIn('variable', _exc.exception.args[0])
self.assertIn('varargs', _exc.exception.args[0])
def _get_fit(self,
model_function=None,
cost_function=None,
errors=None,
dynamic_error_algorithm=None):
'''convenience'''
model_function = model_function or simple_xy_model
# TODO: fix default
cost_function = cost_function or XYCostFunction_Chi2(
axes_to_use='xy', errors_to_use='covariance')
errors = errors or [dict(axis='y', err_val=1.0)]
dynamic_error_algorithm = dynamic_error_algorithm or "nonlinear"
_fit = XYFit(xy_data=self._ref_xy_data,
model_function=model_function,
cost_function=cost_function,
minimizer=self.MINIMIZER,
dynamic_error_algorithm=dynamic_error_algorithm)
for _err in errors:
_fit.add_error(**_err)
return _fit
def _get_fit(self, errors=None):
'''convenience'''
_fit = XYFit(xy_data=self._ref_xy_data,
model_function=simple_xy_model,
cost_function=XYCostFunction_Chi2(
axes_to_use='xy', errors_to_use='covariance'),
minimizer=self.MINIMIZER)
if errors is None:
_fit.add_matrix_error(axis='y',
err_matrix=np.eye(self._n_points),
matrix_type='cov')
else:
for _err in errors:
if 'err_matrix' in _err:
_fit.add_matrix_error(**_err)
else:
_fit.add_error(**_err)
return _fit
def _get_fit(self,
errors=None,
constraints=None,
dynamic_error_algorithm=None):
'''convenience'''
errors = errors or [dict(axis='y', err_val=1.0)]
constraints = constraints or []
dynamic_error_algorithm = dynamic_error_algorithm or "nonlinear"
_fit = XYFit(xy_data=self._ref_xy_data,
model_function=line_xy_model,
cost_function=self._default_cost_function,
minimizer=self.MINIMIZER,
dynamic_error_algorithm=dynamic_error_algorithm)
for _err in errors:
_fit.add_error(**_err)
for _constraint in constraints:
_fit.add_parameter_constraint(**_constraint)
_fit.set_all_parameter_values(self._ref_initial_pars)
return _fit
def _get_fit(self, errors=None):
'''convenience'''
errors = errors or [dict(axis='y', err_val=1.0)]
_fit = XYFit(
xy_data=self._ref_xy_data,
model_function=line_xy_model,
cost_function=self._default_cost_function,
minimizer=self.MINIMIZER,
#x_error_algorithm='nonlinear', # TODO: test other algorithms
)
for _err in errors:
_fit.add_error(**_err)
_fit.set_all_parameter_values(self._ref_initial_pars)
return _fit
###################
# 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')
f.do_fit()
cpf = ContoursProfiler(f)
from kafe2.fit import XYFit
import numpy as np
import matplotlib.pyplot as plt
KAFE_PLOT = False
_x = [-1.0, 1.0]
_y = [-1.0, 1.0]
_x_err = np.sqrt(2.0)
_y_err = np.sqrt(2.0)
def model_function(x, a):
return x * a
_fit_iminuit = XYFit(xy_data=[_x, _y], model_function=model_function, minimizer='iminuit')
_fit_iminuit.add_error('x', _x_err)
_fit_iminuit.add_error('y', _y_err)
_fit_iminuit.do_fit()
#_plot = _fit_iminuit.generate_plot()
#_plot.plot(with_fit_info=True)
_profiler_iminuit = ContoursProfiler(_fit_iminuit)
_a_profile_iminuit = _profiler_iminuit.get_profile('a')
_fit_scipy = XYFit(xy_data=[_x, _y], model_function=model_function, minimizer='scipy')
_fit_scipy.add_error('x', _x_err)
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)
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)
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)
