def fitFunction(x, *tmp_params):
model = load_model(equation)
data = empty_data1D(x)
param_dict = dict(zip(param_names, tmp_params))
model_wrapper = Model(model, **param_dict)
if value_ranges is not None:
for name, values in value_ranges.items():
model_wrapper.__dict__[name].range(values[0], values[1])
func_wrapper = Experiment(data=data, model=model_wrapper)
return func_wrapper.theory()
)
# SET THE FITTING PARAMETERS
model.radius_equat_minor.range(15, 1000)
model.radius_equat_major.range(15, 1000)
#model.radius_polar.range(15, 1000)
#model.background.range(0,1000)
#model.theta_pd.range(0, 360)
#model.phi_pd.range(0, 360)
#model.psi_pd.range(0, 360)
else:
print("No parameters for %s" % name)
sys.exit(1)
model.cutoff = cutoff
M = Experiment(data=data, model=model)
if section == "both":
tan_model = Model(model.sasmodel, **model.parameters())
tan_model.phi = model.phi - 90
tan_model.cutoff = cutoff
tan_M = Experiment(data=tan_data, model=tan_model)
problem = FitProblem([M, tan_M])
else:
problem = FitProblem(M)
if __name__ == "__main__":
problem.plot()
import pylab
pylab.show()
# Background is different for sans and usans so set it as a free variable
# in the model.
free = FreeVariables(
names=[data.run[0] for data in datasets],
background=model.background,
)
free.background.range(-inf, inf)
# Note: can access the parameters for the individual models using
# free.background[0] and free.background[1], setting constraints or
# ranges as appropriate.
# For more complex systems where different datasets require independent models,
# separate models can be defined, with parameters tied together using
# constraint expressions. For example, the following could be used to fit
# data set 1 to spheres and data set 2 to cylinders of the same volume:
# model1 = Model(load_model('sphere'))
# model2 = Model(load_model('cylinder'))
# model1.sld = model2.sld
# model1.sld_solvent = model2.sld_solvent
# model1.scale = model2.scale
# # set cylinders and spheres to the same volume
# model1.radius = (3/4*model2.radius**2*model2.length)**(1/3)
# model1.background.range(0, 2)
# model2.background.range(0, 2)
# Setup the experiments, sharing the same model across all datasets.
M = [Experiment(data=data, model=model, name=data.run[0]) for data in datasets]
problem = FitProblem(M, freevars=free)
""" IMPORT THE DATA USED """
radial_data = load_data('DEC07267.DAT')
set_beam_stop(radial_data, 0.00669, outer=0.025)
set_top(radial_data, -.0185)
kernel = load_model("ellipsoid")
model = Model(kernel,
scale=0.08,
radius_polar=15, radius_equatorial=800,
sld=.291, sld_solvent=7.105,
background=0,
theta=90, phi=0,
theta_pd=15, theta_pd_n=40, theta_pd_nsigma=3,
radius_polar_pd=0.222296, radius_polar_pd_n=1, radius_polar_pd_nsigma=0,
radius_equatorial_pd=.000128, radius_equatorial_pd_n=1, radius_equatorial_pd_nsigma=0,
phi_pd=0, phi_pd_n=20, phi_pd_nsigma=3,
)
# SET THE FITTING PARAMETERS
model.radius_polar.range(15, 1000)
model.radius_equatorial.range(15, 1000)
model.theta_pd.range(0, 360)
model.background.range(0,1000)
model.scale.range(0, 10)
#cutoff = 0 # no cutoff on polydisperisity loops
#cutoff = 1e-5 # default cutoff
cutoff = 1e-3 # low precision cutoff
M = Experiment(data=radial_data, model=model, cutoff=cutoff)
problem = FitProblem(M)
radius_polar=2200,
radius_equatorial=2200,
sld=.291,
sld_solvent=7.105,
#theta=90, theta_pd=0, theta_pd_n=0, theta_pd_nsigma=3,
#phi=90, phi_pd=0, phi_pd_n=20, phi_pd_nsigma=3,
radius_polar_pd=0.222296,
radius_polar_pd_n=1,
radius_polar_pd_nsigma=0,
radius_equatorial_pd=.000128,
radius_equatorial_pd_n=1,
radius_equatorial_pd_nsigma=0,
)
# Tie the model to the data
M = Experiment(data=data, model=model)
# Stack mulitple scattering on top of the existing resolution function.
M.resolution = MultipleScattering(resolution=M.resolution, probability=0.)
# SET THE FITTING PARAMETERS
model.radius_polar.range(15, 3000)
model.radius_equatorial.range(15, 3000)
#model.theta.range(0, 90)
#model.theta_pd.range(0,10)
#model.phi_pd.range(0,20)
#model.phi.range(0, 180)
model.background.range(0, 1000)
model.scale.range(0, 0.1)
# The multiple scattering probability parameter is in the resolution function
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)
background=0,
sld=.291,
sld_solvent=7.105,
r_polar=1800,
r_polar_pd=0.222296,
r_polar_pd_n=0,
r_equatorial=2600,
r_equatorial_pd=0.28,
r_equatorial_pd_n=0,
theta=60,
theta_pd=0,
theta_pd_n=0,
phi=60,
phi_pd=0,
phi_pd_n=0,
)
# SET THE FITTING PARAMETERS
model.r_polar.range(1000, 10000)
model.r_equatorial.range(1000, 10000)
model.theta.range(0, 360)
model.phi.range(0, 360)
model.background.range(0, 1000)
model.scale.range(0, 10)
#cutoff = 0 # no cutoff on polydisperisity loops
#cutoff = 1e-5 # default cutoff
cutoff = 1e-3 # low precision cutoff
M = Experiment(data=usans, model=model, cutoff=cutoff)
problem = FitProblem(M)
theta_pd_n=0,
theta_pd_nsigma=3,
phi_pd=0,
phi_pd_n=20,
phi_pd_nsigma=3,
radius_polar_pd=0.222296,
radius_polar_pd_n=1,
radius_polar_pd_nsigma=0,
radius_equatorial_pd=.000128,
radius_equatorial_pd_n=1,
radius_equatorial_pd_nsigma=0)
model = Model(kernel, **pars)
# PARAMETER RANGES (ONLY THOSE PARAMETERS ARE FITTED)
model.scale.range(0, inf)
model.background.range(-inf, inf)
#model.sld.range(-inf, inf)
model.sld_solvent.range(-inf, inf)
#model.radius_polar.range(0, inf)
#model.radius_equatorial.range(0, inf)
#model.volfraction.range(0,0.74)
#model.charge.range(0, inf)
#model.temperature.range(0,1000)
#model.concentration_salt.range(0, 1)
#model.dielectconst.range(0,inf)
M = Experiment(data=data, model=model)
problem = FitProblem(M)
# SET THE FITTING PARAMETERS
model.radius_polar.range(15, 3000)
model.radius_equatorial.range(15, 3000)
#model.theta.range(0, 90)
#model.theta_pd.range(0,10)
#model.phi_pd.range(0,20)
#model.phi.range(0, 180)
model.background.range(0,1000)
model.scale.range(0, 0.1)
# Mulitple scattering probability parameter
# HACK: the probability is stuffed in as an extra parameter to the experiment.
probability = Parameter(name="probability", value=0.0)
probability.range(0.0, 0.9)
M = Experiment(data=data, model=model, extra_pars={'probability': probability})
# Stack mulitple scattering on top of the existing resolution function.
# Because resolution functions in sasview don't have fitting parameters,
# we instead allow the multiple scattering calculator to take a function
# instead of a probability. This function returns the current value of
# the parameter. ** THIS IS TEMPORARY ** when multiple scattering is
# properly integrated into sasmodels and sasview, its fittable parameter
# will be treated like the model parameters.
M.resolution = MultipleScattering(resolution=M.resolution,
probability=lambda: probability.value,
)
M._kernel_inputs = M.resolution.q_calc
problem = FitProblem(M)
if __name__ == "__main__":
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')
datafiles = ['latex_smeared_out_0.txt', 'latex_smeared_out_1.txt']
datasets = [load_data(el) for el in datafiles]
for data in datasets:
data.qmin = 0.0
data.qmax = 10.0
#sphere model
kernel = load_model('sphere', dtype="single")
pars = dict(scale=0.01, background=0.0, sld=1.0, sld_solvent=6.0, radius=1500.)
model = Model(kernel, **pars)
model.radius.range(0, inf)
#model.background.range(-inf, inf)
#model.scale.range(0, inf)
model.sld.range(-inf, inf)
model.sld_solvent.range(-inf, inf)
free = FreeVariables(
names=[data.filename for data in datasets],
background=model.background,
scale=model.scale,
)
free.background.range(-inf, inf)
free.scale.range(0, inf)
M = [Experiment(data=data, model=model) for data in datasets]
problem = FitProblem(M, freevars=free)
print(problem._parameters)
