def setUp(self):
self.xdata = np.linspace(-4, 4, 100)
self.p0 = np.array([0., 1., 0.0, 1.])
self.bounds = [(-1, 1), (0, 2), (-1, 1.), (0.001, 2)]
self.params = curvefitter.to_parameters(self.p0 + 0.2, bounds=self.bounds)
self.final_params = curvefitter.to_parameters(self.p0, bounds=self.bounds)
self.ydata = gauss(self.xdata, self.final_params)
self.f = CurveFitter(gauss, (self.xdata, self.ydata), self.params)
def setUp(self):
theoretical = np.loadtxt(os.path.join(path, 'gauss_data.txt'))
xvals, yvals, evals = np.hsplit(theoretical, 3)
self.xvals = xvals.flatten()
self.yvals = yvals.flatten()
self.evals = evals.flatten()
self.best_weighted = [-0.00246095, 19.5299, -8.28446e-2, 1.24692]
self.best_weighted_errors = [0.0220313708486, 1.12879436221,
0.0447659158681, 0.0412022938883]
self.best_weighted_chisqr = 77.6040960351
self.best_unweighted = [-0.10584111872702096, 19.240347049328989,
0.0092623066070940396, 1.501362314145845]
self.best_unweighted_errors = [0.34246565477, 0.689820935208,
0.0411243173041, 0.0693429375282]
self.best_unweighted_chisqr = 497.102084956
self.p0 = np.array([0.1, 20., 0.1, 0.1])
self.bounds = [(-1, 1), (0, 30), (-5., 5.), (0.001, 2)]
self.params = curvefitter.to_parameters(self.p0, bounds=self.bounds)
def setUp(self):
coefs = np.zeros((16))
coefs[0] = 2
coefs[1] = 1.
coefs[2] = 2.07
coefs[4] = 6.36
coefs[6] = 2.e-07
coefs[7] = 3
coefs[8] = 40
coefs[9] = 3.47
coefs[11] = 3
coefs[12] = 200.
coefs[13] = 2
coefs[15] = 3
self.coefs = coefs
self.best_fit = np.array([2, 8.9692e-01, 2.07, 0., 6.36, 0.,
3.3588842e-07, 2.8938204, 38.129,
3.47, 0., 3.0, 2.5910e+02, 2.5406,
0., 3.])
lowlim = np.zeros(16)
hilim = 2 * coefs
self.params = curvefitter.to_parameters(coefs, bounds=zip(lowlim, hilim),
varies=[False] * 16)
fname = os.path.join(CURDIR, 'c_PLP0011859_q.txt')
theoretical = np.loadtxt(fname)
qvals, rvals, evals, dummy = np.hsplit(theoretical, 4)
rvals = np.log10(rvals)
self.f = curvefitter.CurveFitter(reflect_fitfunc, qvals.flatten(),
rvals.flatten(), self.params)
def test_reflectivity_model(self):
# test reflectivity calculation with values generated from Motofit
params = curvefitter.to_parameters(self.coefs)
fitfunc = reflect.ReflectivityFitFunction(dq=0.)
model = fitfunc.model(self.qvals, params)
assert_almost_equal(model, self.rvals)
def setUp(self):
self.coefs = np.zeros(12)
self.coefs[0] = 1.
self.coefs[1] = 1.
self.coefs[4] = 2.07
self.coefs[7] = 3
self.coefs[8] = 100
self.coefs[9] = 3.47
self.coefs[11] = 2
self.layer_format = reflect.coefs_to_layer(self.coefs)
theoretical = np.loadtxt(os.path.join(path, 'theoretical.txt'))
qvals, rvals = np.hsplit(theoretical, 2)
self.qvals = qvals.flatten()
self.rvals = rvals.flatten()
# e361 is an older dataset, but well characterised
self.coefs361 = np.zeros(16)
self.coefs361[0] = 2
self.coefs361[1] = 1.
self.coefs361[2] = 2.07
self.coefs361[4] = 6.36
self.coefs361[6] = 2e-5
self.coefs361[7] = 3
self.coefs361[8] = 10
self.coefs361[9] = 3.47
self.coefs361[11] = 4
self.coefs361[12] = 200
self.coefs361[13] = 1
self.coefs361[15] = 3
lowlim = np.zeros(16)
lowlim[1] = 0.1
lowlim[4] = 6.2
hilim = 2 * self.coefs361
bounds = list(zip(lowlim, hilim))
e361 = np.loadtxt(os.path.join(path, 'e361r.txt'))
self.qvals361, self.rvals361, self.evals361 = np.hsplit(e361, 3)
np.seterr(invalid='raise')
self.params361 = curvefitter.to_parameters(self.coefs361,
bounds=bounds,
varies=[False] * 16)
fit = [1, 4, 6, 8, 12, 13]
for p in fit:
self.params361['p%d' % p].vary = True
def test_globfit_modelvals_degenerate_layers(self):
# try fitting dataset with a deposited layer split into two degenerate
# layers
coefs = np.zeros((20))
coefs[0] = 3
coefs[1] = 1.
coefs[2] = 2.07
coefs[4] = 6.36
coefs[6] = 2e-6
coefs[7] = 3
coefs[8] = 30
coefs[9] = 3.47
coefs[11] = 4
coefs[12] = 125
coefs[13] = 2
coefs[15] = 4
coefs[16] = 125
coefs[17] = 2
coefs[19] = 4
lowlim = np.zeros(20)
hilim = 2 * coefs
bounds = zip(lowlim, hilim)
params = curvefitter.to_parameters(coefs,
bounds=bounds,
varies=[False] * 20)
fit = np.array([6, 7, 8, 11, 12, 13, 15, 16, 17, 19])
for p in fit:
params['p%d' % p].vary = True
self.f.params = params
a = GlobalFitter([self.f], constraints=['d0:p16=d0:p12',
'd0:p17=d0:p13',
'd0:p19=d0:p15'])
res = a.fit(method='differential_evolution')
values = list(res.params.valuesdict().values())
assert_equal(values[12], values[16])
assert_equal(values[13], values[17])
assert_equal(values[15], values[19])
def test_smeared_reflectivity_fitter(self):
# test smeared reflectivity calculation with values generated from
# Motofit (quadrature precsion order = 13)
theoretical = np.loadtxt(os.path.join(path, 'smeared_theoretical.txt'))
qvals, rvals, dqvals = np.hsplit(theoretical, 3)
'''
the order of the quadrature precision used to create these smeared
values in Motofit was 13.
Do the same here
'''
params = curvefitter.to_parameters(self.coefs)
fitfunc = RFF(quad_order=13)
fitter = CurveFitter(fitfunc,
(qvals, rvals),
params,
fcn_kws={'dqvals': dqvals})
model = fitter.model(params)
assert_almost_equal(model, rvals)
def test_reflectivity_fit(self):
# a smoke test to make sure the reflectivity fit proceeds
params = curvefitter.to_parameters(self.coefs)
params['p1'].value = 1.1
fitfunc = reflect.ReflectivityFitFunction()
fitter = CurveFitter(fitfunc, self.qvals, self.rvals, params)
fitter.fit()
transform = reflect.Transform('logY')
yt, et = transform.transform(self.qvals361,
self.rvals361,
self.evals361)
kws = {'transform':transform.transform}
fitter2 = CurveFitter(fitfunc,
self.qvals361,
yt,
self.params361,
edata=et,
fcn_kws=kws)
fitter2.fit('differential_evolution')
# coefs[6] is the background
# these will both be 1 and 0 respectively to start off with
coefs = reflect.layer_to_coefs(layers)
lowlim = reflect.layer_to_coefs(lowlim)
hilim = reflect.layer_to_coefs(hilim)
coefs[1] = 1.0
coefs[6] = 3.e-6
lowlim[1] = 0.6
hilim[1] = 1.2
lowlim[6] = 0.
hilim[6] = 9e-6
bounds = zip(lowlim, hilim)
# create a parameter instance
parameters = curvefitter.to_parameters(coefs, bounds=bounds, varies=[False] * 16)
# which parameters do you want to allow to vary
fitted_parameters = np.array([1, 6, 7, 8, 11, 12, 13, 15])
for fit in fitted_parameters:
parameters['p%d' % fit].vary = True
# use resolution smearing and fit on a logR scale (transform the data as well)
fitter = reflect.ReflectivityFitFunction(xdata, ydata, parameters, edata=dydata,
fcn_kws = {'dqvals': dxdata})
fitter.model(parameters)
def test_abeles(self):
# test reflectivity calculation with values generated from Motofit
p = curvefitter.to_parameters(self.coefs)
calc = reflect_fitfunc(self.qvals, p)
calc = np.power(10, calc)
assert_almost_equal(calc, self.rvals)
def test_multipledataset_corefinement(self):
# test corefinement of three datasets
e361 = np.loadtxt(os.path.join(CURDIR, 'e361r.txt'))
e365 = np.loadtxt(os.path.join(CURDIR, 'e365r.txt'))
e366 = np.loadtxt(os.path.join(CURDIR, 'e366r.txt'))
coefs361 = np.zeros(16)
coefs361[0] = 2
coefs361[1] = 1.
coefs361[2] = 2.07
coefs361[4] = 6.36
coefs361[6] = 2e-5
coefs361[7] = 3
coefs361[8] = 10
coefs361[9] = 3.47
coefs361[11] = 4
coefs361[12] = 200
coefs361[13] = 1
coefs361[15] = 3
coefs365 = np.copy(coefs361)
coefs366 = np.copy(coefs361)
coefs365[4] = 3.47
coefs366[4] = -0.56
qvals361, rvals361, evals361 = np.hsplit(e361, 3)
qvals365, rvals365, evals365 = np.hsplit(e365, 3)
qvals366, rvals366, evals366 = np.hsplit(e366, 3)
lowlim = np.zeros(16)
lowlim[4] = -0.8
hilim = 2 * coefs361
bounds = list(zip(lowlim, hilim))
params361 = curvefitter.to_parameters(coefs361, bounds=bounds,
varies=[False] * 16)
params365 = curvefitter.to_parameters(coefs365, bounds=bounds,
varies=[False] * 16)
params366 = curvefitter.to_parameters(coefs366, bounds=bounds,
varies=[False] * 16)
assert_(len(params361), 16)
assert_(len(params365), 16)
assert_(len(params366), 16)
fit = [1, 6, 8, 12, 13]
for p in fit:
params361['p%d' % p].vary = True
params365['p%d' % p].vary = True
params366['p%d' % p].vary = True
a = CurveFitter(reflect_fitfunc, qvals361.flatten(),
np.log10(rvals361.flatten()),
params361)
b = CurveFitter(reflect_fitfunc, qvals365.flatten(),
np.log10(rvals365.flatten()),
params365)
c = CurveFitter(reflect_fitfunc, qvals366.flatten(),
np.log10(rvals366.flatten()),
params366)
g = GlobalFitter([a, b, c], constraints=['d1:p8=d0:p8',
'd2:p8=d0:p8',
'd1:p12=d0:p12',
'd2:p12 = d0:p12'],
kws={'seed':1})
indiv_chisqr = (a.residuals(a.params) ** 2
+ b.residuals(b.params) ** 2
+ c.residuals(c.params) ** 2)
global_chisqr = g.residuals(g.params) ** 2
assert_almost_equal(indiv_chisqr.sum(), global_chisqr.sum())
# import time
res = g.fit('differential_evolution')
# start = time.time()
# g.emcee(params=res.params, nwalkers=300, steps=500, workers=1)
# finish = time.time()
# print(finish - start)
assert_almost_equal(res.chisqr, 0.774590447535, 4)
def run():
DATASET_NAME = 'c_PLP0011859_q.txt'
USE_DIFFERENTIAL_EVOLUTION = True
#load the data
dataset = ReflectDataset()
with open(DATASET_NAME) as f:
dataset.load(f)
xdata, ydata, dydata, dxdata = dataset.data
# create an array to hold the parameters, also create limits
layers = np.array([[0, 2.07, 0, 0], # fronting medium
[30, 3.47, 0, 3], # 1st layer
[250, 2.00, 0, 3], # 2nd layer
[0, 6.36, 0, 3]]) # backing medium
lowlim = np.array([[0, 2.07, 0, 0], # fronting medium
[15, 3.47, 0, 1], # 1st layer
[200, 0.10, 0, 1], # 2nd layer
[0, 6.36, 0, 1]]) # backing medium
hilim = np.array([[0, 2.07, 0, 0], # fronting medium
[50, 3.47, 0, 9], # 1st layer
[300, 3.00, 0, 9], # 2nd layer
[0, 6.36, 0, 9]]) # backing medium
# create a linear array of the parameters
# coefs[1] is the scale factor
# coefs[6] is the background
# these will both be 1 and 0 respectively to start off with
coefs = reflect.layer_to_coefs(layers)
lowlim = reflect.layer_to_coefs(lowlim)
hilim = reflect.layer_to_coefs(hilim)
coefs[1] = 1.0
coefs[6] = 3.e-6
lowlim[1] = 0.6
hilim[1] = 1.2
lowlim[6] = 0.
hilim[6] = 9e-6
bounds = zip(lowlim, hilim)
# create a parameter instance
parameters = curvefitter.to_parameters(coefs, bounds=bounds, varies=[False] * 16)
# which parameters do you want to allow to vary
fitted_parameters = np.array([1, 6, 7, 8, 11, 12, 13, 15])
for fit in fitted_parameters:
parameters['p%d' % fit].vary = True
# use resolution smearing and fit on a logR scale (transform the data as well)
t = reflect.Transform('logY').transform
ydata, dydata = t(xdata, ydata, dydata)
fcn_kws = {'dqvals': dxdata, 'transform': t}
# create the fit instance
fitter = reflect.ReflectivityFitFunction(xdata, ydata, parameters, edata=dydata,
fcn_kws=fcn_kws)
#do the fit
np.random.seed(1)
if USE_DIFFERENTIAL_EVOLUTION:
fitter.fit(method='differential_evolution')
def test_multipledataset_corefinement(self):
# test corefinement of three datasets
e361 = np.loadtxt(os.path.join(CURDIR, 'e361r.txt'))
e365 = np.loadtxt(os.path.join(CURDIR, 'e365r.txt'))
e366 = np.loadtxt(os.path.join(CURDIR, 'e366r.txt'))
coefs361 = np.zeros(16)
coefs361[0] = 2
coefs361[1] = 1.
coefs361[2] = 2.07
coefs361[4] = 6.36
coefs361[6] = 2e-5
coefs361[7] = 3
coefs361[8] = 10
coefs361[9] = 3.47
coefs361[11] = 4
coefs361[12] = 200
coefs361[13] = 1
coefs361[15] = 3
coefs365 = np.copy(coefs361)
coefs366 = np.copy(coefs361)
coefs365[4] = 3.47
coefs366[4] = -0.56
qvals361, rvals361, evals361 = np.hsplit(e361, 3)
qvals365, rvals365, evals365 = np.hsplit(e365, 3)
qvals366, rvals366, evals366 = np.hsplit(e366, 3)
lowlim = np.zeros(16)
lowlim[4] = -0.8
hilim = 2 * coefs361
bounds = list(zip(lowlim, hilim))
params361 = curvefitter.to_parameters(coefs361,
bounds=bounds,
varies=[False] * 16)
params365 = curvefitter.to_parameters(coefs365,
bounds=bounds,
varies=[False] * 16)
params366 = curvefitter.to_parameters(coefs366,
bounds=bounds,
varies=[False] * 16)
assert_(len(params361), 16)
assert_(len(params365), 16)
assert_(len(params366), 16)
fit = [1, 6, 8, 12, 13]
for p in fit:
params361['p%d' % p].vary = True
params365['p%d' % p].vary = True
params366['p%d' % p].vary = True
a = CurveFitter(reflect_fitfunc,
(qvals361.flatten(), np.log10(rvals361.flatten())),
params361)
b = CurveFitter(reflect_fitfunc,
(qvals365.flatten(), np.log10(rvals365.flatten())),
params365)
c = CurveFitter(reflect_fitfunc,
(qvals366.flatten(), np.log10(rvals366.flatten())),
params366)
g = GlobalFitter([a, b, c], constraints=['d1:p8=d0:p8',
'd2:p8=d0:p8',
'd1:p12=d0:p12',
'd2:p12 = d0:p12'],
kws={'seed': 1})
indiv_chisqr = (a.residuals(a.params) ** 2 +
b.residuals(b.params) ** 2 +
c.residuals(c.params) ** 2)
global_chisqr = g.residuals(g.params) ** 2
assert_almost_equal(indiv_chisqr.sum(), global_chisqr.sum())
# import time
res = g.fit('differential_evolution')
# start = time.time()
# g.emcee(params=res.params, nwalkers=300, steps=500, workers=1)
# finish = time.time()
# print(finish - start)
assert_almost_equal(res.chisqr, 0.774590447535, 4)
# updating of constraints should happen during the fit
assert_almost_equal(a.params['p12'].value, res.params['p12_d0'].value)
assert_almost_equal(b.params['p12'].value, a.params['p12'].value)
assert_almost_equal(c.params['p12'].value, a.params['p12'].value)
g.params['p8_d0'].value = 10.123456
# shouldn't need to call update constraints within the gfitter, that
# happens when you retrieve a specific value
assert_almost_equal(g.params['p8_d1'].value, g.params['p8_d0'].value)
# However, you have to call model or residuals to redistribute the
# parameters to the original fitters
g.model()
assert_almost_equal(a.params['p8'].value, 10.123456)
assert_almost_equal(b.params['p8'].value, 10.123456)
