def test_lnpost(self):
data = (self.xvals, self.yvals, self.evals)
f = _parallel_likelihood_calculator(gauss,
data_tuple=data)
lnprob = f(self.params)
def lnpost(pars, generative, y, e):
resid = y - generative
resid /= e
resid *= resid
resid += np.log(2 * np.pi * e**2)
return -0.5 * np.sum(resid)
g = _parallel_likelihood_calculator(gauss,
data_tuple=data,
lnpost=lnpost)
lnprob2 = g(self.params)
assert_equal(lnprob2, lnprob)
pars_copy = deepcopy(self.params)
f = CurveFitter(gauss,
data,
self.params)
res = f.emcee(steps=10, burn=0, thin=1, seed=1)
g = CurveFitter(gauss,
data,
pars_copy,
lnpost=lnpost)
res2 = g.emcee(steps=10, burn=0, thin=1, seed=1)
assert_almost_equal(values(res.params), values(res2.params))
def test_args_kwds_are_used(self):
# check that user defined args and kwds make their way into the user
# function
a = [1., 2.]
x = np.linspace(0, 10, 11)
y = a[0] + 1 + 2 * a[1] * x
par = Parameters()
par.add('p0', 1.5)
par.add('p1', 2.5)
def fun(x, p, *args, **kwds):
assert_equal(args, a)
return args[0] + p['p0'] + p['p1'] * a[1] * x
g = CurveFitter(fun, (x, y), par, fcn_args=a)
res = g.fit()
assert_almost_equal(values(res.params), [1., 2.])
d = {'a': 1, 'b': 2}
def fun(x, p, *args, **kwds):
return kwds['a'] + p['p0'] + p['p1'] * kwds['b'] * x
g = CurveFitter(fun, (x, y), par, fcn_kws=d)
res = g.fit()
assert_almost_equal(values(res.params), [1., 2.])
def test_costfun(self):
# test user defined costfun
res = self.f.fit('nelder')
def costfun(params, generative, y, e):
return np.sum((y - generative / e) ** 2)
g = CurveFitter(gauss,
(self.xdata, self.ydata),
self.params,
costfun=costfun)
res2 = g.fit('nelder')
assert_almost_equal(values(res.params), values(res2.params))
def data(self, index, role=QtCore.Qt.DisplayRole):
if not index.isValid():
return False
row = index.row()
col = index.column()
if not reflect.is_proper_abeles_input(curvefitter.values(self.params)):
return None
nlayers = int(self.params['nlayers'].value)
if row == 0 and (col == 0 or col == 3):
return None
if row == nlayers + 1 and col == 0:
return None
name = self.rowcol_to_name(row, col, nlayers)
if role == QtCore.Qt.DisplayRole:
return str(self.params[name].value)
if role == QtCore.Qt.CheckStateRole:
if self.params[name].vary:
return QtCore.Qt.Unchecked
else:
return QtCore.Qt.Checked
def test_reflectivity_emcee(self):
transform = reflect.Transform('logY')
yt, et = transform.transform(self.qvals361,
self.rvals361,
self.evals361)
kws = {'transform': transform.transform}
fitfunc = RFF(transform=transform.transform, dq=5.)
fitter = CurveFitter(fitfunc,
(self.qvals361, yt, et),
self.params361,
fcn_kws=kws)
res = fitter.fit()
res_em = fitter.emcee(steps=10, seed=1)
assert_allclose(values(res.params), values(res_em.params), rtol=1e-2)
def add_layer(self, insertpoint):
params = self.params
values = curvefitter.values(params)
if not reflect.is_proper_abeles_input(values):
raise ValueError('The size of the parameter array passed'
' to reflectivity should be 4 * coefs[0] + 8')
oldlayers = int(values[0])
self.params['nlayers'].value = oldlayers + 1
self.beginInsertRows(QtCore.QModelIndex(), insertpoint + 1,
insertpoint + 1)
values = curvefitter.values(self.params)
varys = curvefitter.varys(self.params)
bounds = curvefitter.bounds(self.params)
#do the insertion
startP = 4 * insertpoint + 8
values = np.insert(values, startP, [0] * 4)
dummy = [varys.insert(startP, i) for i
in [True] * 4]
dummy = [bounds.insert(startP, i) for i
in [(None, None)] * 4]
bounds = np.array(bounds)
names = ReflectivityFitFunction.parameter_names(nparams=values.size)
#clear the parameters
map(self.params.pop, self.params.keys())
# reinsert parameters
parlist = zip(names,
values,
varys,
bounds.T[0],
bounds.T[1],
[None] * values.size)
for para in parlist:
self.params.add(*para)
self.endInsertRows()
def test_best_weighted(self):
f = CurveFitter(gauss, (self.xvals, self.yvals, self.evals), self.params)
res = f.fit()
output = values(res.params)
assert_almost_equal(output, self.best_weighted, 4)
assert_almost_equal(res.chisqr, self.best_weighted_chisqr)
uncertainties = [res.params['p%d' % i].stderr for i in range(4)]
assert_almost_equal(uncertainties, self.best_weighted_errors, 3)
def remove_layer(self, which_layer):
params = self.params
values = curvefitter.values(params)
if int(values[0]) == 0:
return False
if not reflect.is_proper_abeles_input(values):
raise ValueError('The size of the parameter array passed'
' to reflectivity should be 4 * coefs[0] + 8')
oldlayers = int(values[0])
self.beginRemoveRows(QtCore.QModelIndex(), which_layer, which_layer)
self.params['nlayers'].value = oldlayers - 1
startP = 4 * (which_layer - 1) + 8
#get rid of parameters we don't need anymore
names_lost = curvefitter.names(self.params)[startP: startP + 4]
map(self.params.pop, names_lost)
# but now we need to rejig parameters names
# the only way to do this is to pop them all and readd
values = curvefitter.values(self.params)
varys = curvefitter.varys(self.params)
bounds = np.array(curvefitter.bounds(self.params))
names = ReflectivityFitFunction.parameter_names(values.size)
map(self.params.pop, self.params.keys())
parlist = zip(names,
values,
varys,
bounds.T[0],
bounds.T[1],
[None] * values.size)
for para in parlist:
self.params.add(*para)
self.endRemoveRows()
def flags(self, index, filterNormalRef=True):
names = self.params_store.names
params = self.params_store[names[index.row()]]
if self.params_store.displayOtherThanReflect:
return (QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
else:
values = curvefitter.values(params)
if reflect.is_proper_abeles_input(values):
return (QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
else:
return (QtCore.Qt.NoItemFlags)
def flags(self, index, filterNormalRef=True):
names = self.params_store.names
params = self.params_store[names[index.row()]]
if self.params_store.displayOtherThanReflect:
return (QtCore.Qt.ItemIsEnabled |
QtCore.Qt.ItemIsSelectable)
else:
values = curvefitter.values(params)
if reflect.is_proper_abeles_input(values):
return (QtCore.Qt.ItemIsEnabled |
QtCore.Qt.ItemIsSelectable)
else:
return (QtCore.Qt.NoItemFlags)
def data(self, index, role=QtCore.Qt.DisplayRole):
if not index.isValid():
return None
values = curvefitter.values(self.params)
if not reflect.is_proper_abeles_input(values):
return None
if index.row() != 0 or index.column() < 0 or index.column() > 1:
return None
coltopar = ['scale', 'bkg']
if role == QtCore.Qt.DisplayRole:
return str(self.params[coltopar[index.column()]].value)
if role == QtCore.Qt.CheckStateRole:
if self.params[coltopar[index.column()]].vary:
return QtCore.Qt.Unchecked
else:
return QtCore.Qt.Checked
def test_scalar_minimize(self):
assert_equal(values(self.params), self.p0 + 0.2)
res = self.f.fit(method='differential_evolution')
assert_almost_equal(values(res.params), self.p0, 3)
def test_leastsq(self):
# test that a custom method can be used with scipy.optimize.minimize
res = self.f.fit()
assert_almost_equal(values(res.params), self.p0)
def test_fitting(self):
# the simplest test - a really simple gauss curve with perfect data
res = self.f.fit()
assert_almost_equal(values(res.params), self.p0)
assert_almost_equal(res.chisqr, 0)
def within_sigma(desired, actual_params):
# are the fitted params within sigma of where we know them to be?
p0 = curvefitter.values(actual_params)
sigmas = [actual_params[par].stderr for par in actual_params]
for p, sigma, des in zip(p0, sigmas, desired):
assert_allclose(p, des, atol=sigma)
def gauss(x, p0, *args):
p = values(p0)
return p[0] + p[1] * np.exp(-((x - p[2]) / p[3])**2)
