def fit(model):
# nllfs = []
# zin = []
# for tns in np.arange(50,200, 5):
# #print("zs", zs)
# model.Tn.value = tns
# model.update()
# schi=model.nllf()
# nllfs.append(schi)
# zin.append(tns)
# plt.scatter(zin, nllfs)
# plt.xlabel("tn in")
# plt.ylabel("chi")
# plt.show()
# plt.close()
# model.Tn.value = 200
model.update()
problem = FitProblem(model)
result = fitters.fit(problem,
method='dream',
name='order',
store='/work/kmm11/orderout/dreamOut')
for p, v in zip(problem._parameters, result.dx):
p.dx = v
return result.x, result.dx, problem.chisq(), problem._parameters
def better_bumps(model):
zin=[]
zout=[]
chis=[]
dzs=[]
nllfs=[]
# for zs in np.arange(.05,.45,.005):
# #print("zs", zs)
# model.atomListModel.atomModels[0].z.value = zs
# model.update()
# schi=model.nllf()
# nllfs.append(schi)
# zin.append(zs)
xpeaks = findmin(zin,nllfs,10)
print('xpeak', xpeaks)
# these are experimental values, shortcut
model.atomListModel.atomModels[0].z.value = .35973
model.atomListModel.atomModels[5].x.value = .07347
model.atomListModel.atomModels[5].y.value = .07347
model.update()
problem = bumps.FitProblem(model)
result = fitters.fit(problem, method='lm')
for p, v in zip(problem._parameters, result.dx):
p.dx = v
return result.x, result.dx, problem.chisq(), problem._parameters
def fit(model):
model.update()
problem = FitProblem(model)
result = fitters.fit(problem,
method='dream',
name='order',
store='/work/kmm11/orderout/dreamOut')
for p, v in zip(problem._parameters, result.dx):
p.dx = v
return result.x, result.dx, problem.chisq(), problem._parameters
Mq.A0.range(0, 0.05)
Mq.A1.range(0, 1)
Mq.hwhm1.range(0, 0.5)
Mq.hwhm2.range(0, 3)
# Q-independent parameters
if i == 0:
QA0 = Mq.A0
else:
Mq.A0 = QA0
M.append(Mq)
problem = bmp.FitProblem(M)
# Preview of the settings
print('Initial chisq', problem.chisq_str())
problem.plot()
result = fit(problem, method='lm', steps=100, verbose=True)
problem.plot()
# Print chi**2 and parameters' values after fit
print("final chisq", problem.chisq_str())
for k, v, dv in zip(problem.labels(), result.x, result.dx):
print(k, ":", format_uncertainty(v, dv))
plt.show()
def scat_model(data, label):
if label == "ellipsoid":
pars = dict(
scale=1.0,
background=0.001,
)
kernel = load_model(label)
model = Model(kernel, **pars)
# SET THE FITTING PARAMETERS
model.radius_polar.range(0.0, 1000.0)
model.radius_equatorial.range(0.0, 1000.0)
model.sld.range(-0.56, 8.00)
model.sld_solvent.range(-0.56, 6.38)
model.radius_polar_pd.range(0, 0.11)
experiment = Experiment(data=data, model=model)
problem = FitProblem(experiment)
result = fit(problem, method='dream')
chisq = problem.chisq()
if label == "shell":
label = "core_shell_sphere"
pars = dict(
scale=1.0,
background=0.001,
)
kernel = load_model(label)
model = Model(kernel, **pars)
# SET THE FITTING PARAMETERS
model.radius.range(0.0, 1000.0)
model.thickness.range(0.0, 100.0)
model.sld_core.range(-0.56, 8.00)
model.sld_shell.range(-0.56, 8.00)
model.sld_solvent.range(-0.56, 6.38)
model.radius_pd.range(0.1, 0.11)
experiment = Experiment(data=data, model=model)
problem = FitProblem(experiment)
result = fit(problem, method='dream')
chisq = problem.chisq()
if label == "cylinder":
pars = dict(
scale=1.0,
background=0.001,
)
kernel = load_model(label)
model = Model(kernel, **pars)
# SET THE FITTING PARAMETERS
model.radius.range(0, 1000.0)
model.length.range(0, 1000.0)
model.sld.range(-0.56, 8.00)
model.sld_solvent.range(-0.56, 6.38)
model.radius_pd.range(0, 0.11)
experiment = Experiment(data=data, model=model)
problem = FitProblem(experiment)
result = fit(problem, method='dream')
chisq = problem.chisq()
if label == "sphere":
pars = dict(
scale=1.0,
background=0.001,
)
kernel = load_model(label)
model = Model(kernel, **pars)
# SET THE FITTING PARAMETERS
model.radius.range(0.0, 3200.0)
model.sld.range(-0.56, 8.00)
model.sld_solvent.range(-0.56, 6.38)
model.radius_pd.range(0.1, 0.11)
experiment = Experiment(data=data, model=model)
problem = FitProblem(experiment)
result = fit(problem, method='dream')
chisq = problem.chisq()
return np.round(chisq, 3)
def fit_function(key, sans_data, usans_data, actual_vol, actual_stdev_vol,
backgrounds, avg_scale, avg_rg, ps_s, ps_porod_exp, slds, cps,
matrix):
#np.savetxt('Sample_'+str(key)+'.txt', np.array(['Fitting']), fmt='%s')
kernel = load_model("guinier_porod+ellipsoid")
# loading the data
sans = sans_data[key]
sans.dx = sans.dx - sans.dx # removing smearing from sans segment
usans = usans_data[key]
vol = actual_vol[key] / 100 # cp volume fraction from uv-vis
vol_stdev = actual_stdev_vol[key] / 100
# initial parameter values
scale = Parameter(1, name=str(key) + 'scale')
background = Parameter(backgrounds[key][0], name=str(key) + 'background')
A_scale = Parameter(avg_scale * (1 - vol), name=str(key) + ' PS scale')
A_rg = Parameter(avg_rg, name=str(key) + ' PS rg')
A_s = Parameter(ps_s, name=str(key) + ' PS s')
A_porod_exp = Parameter(ps_porod_exp, name=str(key) + ' PS porod_exp')
B_scale_normal = bumps.bounds.Normal(mean=vol, std=vol_stdev)
B_scale = Parameter(vol,
name=str(key) + ' sphere scale',
bounds=B_scale_normal)
B_sld = Parameter(slds[cps[key]], name=str(key) + ' PS sld')
B_sld_solvent = Parameter(slds[matrix[key]], name=str(key) + ' PS solvent')
B_radius_polar = Parameter(1000,
limits=[0, inf],
name=str(key) + ' ellipsoid polar radius')
B_radius_polar_pd = Parameter(0.5,
name=str(key) + ' ellipsoid polar radius pd')
B_radius_polar_pd_n = Parameter(200,
name=str(key) +
' ellipsoid polar radius pd n')
B_radius_polar_pd_nsigma = Parameter(8,
name=str(key) +
' ellipsoid polar radius pd nsigma')
B_radius_equatorial = Parameter(1000,
limits=[0, inf],
name=str(key) +
' ellipsoid equatorial radius')
B_radius_equatorial_pd = Parameter(0.5,
name=str(key) +
' ellipsoid equatorial radius pd')
B_radius_equatorial_pd_n = Parameter(200,
name=str(key) +
' ellipsoid equatorial radius pd n')
B_radius_equatorial_pd_nsigma = Parameter(
8, name=str(key) + ' ellipsoid equatorial radius pd nsigma')
# setting up the combined model for fitting
sans_model = Model(
model=kernel,
scale=scale,
background=background,
A_scale=A_scale,
A_rg=A_rg,
A_s=A_s,
A_porod_exp=A_porod_exp,
B_scale=B_scale,
B_sld=B_sld,
B_sld_solvent=B_sld_solvent,
B_radius_polar=B_radius_polar,
B_radius_polar_pd_type='lognormal',
B_radius_polar_pd=B_radius_polar_pd,
B_radius_polar_pd_n=B_radius_polar_pd_n,
B_radius_polar_pd_nsigma=B_radius_polar_pd_nsigma,
B_radius_equatorial=B_radius_equatorial,
B_radius_equatorial_pd_type='lognormal',
B_radius_equatorial_pd=B_radius_equatorial_pd,
B_radius_equatorial_pd_n=B_radius_equatorial_pd_n,
B_radius_equatorial_pd_nsigma=B_radius_equatorial_pd_nsigma,
)
# setting parameter ranges as needed
sans_model.B_radius_polar.range(0, 200000)
sans_model.B_radius_equatorial.range(0, 200000)
sans_experiment = Experiment(data=sans, model=sans_model)
usans_experiment = Experiment(data=usans, model=sans_model)
usans_smearing = sasmodels.resolution.Slit1D(usans.x, 0.117)
usans_experiment.resolution = usans_smearing
experiment = [sans_experiment, usans_experiment]
problem = FitProblem(experiment)
result = fit(problem,
method='dream',
samples=1e6,
steps=1000,
verbose=True)
result.state.save(
'../data/sans/Sample_Fitting/fitting_results/ps_ellipsoid_match/CMW' +
str(key) + '_ps_ellipsoid_state')
y = [2.1, 4.0, 6.3, 8.03, 9.6, 11.9]
dy = [0.05, 0.05, 0.2, 0.05, 0.2, 0.2]
def line(x, m, b=0):
return m*x + b
M = Curve(line, x, y, dy, m=2, b=2)
M.m.range(0, 4)
M.b.range(-5, 5)
problem = FitProblem(M)
# With the problem defined, we can now call the fitter. The following
# uses the minimalist fit interface defined in bumps, which takes a problem
# definition and returns a results object with x, dx attributes for the
# best value and the estimated uncertainty. The 'dream' fitter will
# additionally return the dream state, which allows for more detailed
# uncertainty analysis.
from bumps.fitters import fit
from bumps.formatnum import format_uncertainty
# Allow choice of fitter from the command line
method = 'amoeba' if len(sys.argv) < 2 else sys.argv[1]
print("initial chisq", problem.chisq_str())
result = fit(problem, method=method, xtol=1e-6, ftol=1e-8)
print("final chisq", problem.chisq_str())
for k, v, dv in zip(problem.labels(), result.x, result.dx):
print(k, ":", format_uncertainty(v, dv))
