def XicamSASModel(name, params):
"""
XicamModel wraps sasmdoels from sasview (https://github.com/SasView/sasmodles),
in a fittable 1-D plugin for Xi-cam. This object can be passed to astropy for
data fitting.
Parameters:
name (str) : name of the sasmoels (http://www.sasview.org/sasmodels/index.html)
params (dict): key : value pairs of fittable parameters
Returns:
func (XicamFittable) : function that takes q-values and returns intensity values
"""
inputs = [p.name() for p in params]
model_name = name.lower().replace(' ', '_')
m = load_model(model_name)
# evaluate callback
def saxs_curve(q, *args):
kernel = m.make_kernel([q])
p_fit = dict(zip(inputs, args))
return call_kernel(kernel, p_fit)
# create an astropy fittable model
names = {
'name': 'SASFittable_' + name + 'Model',
'inputs': inputs,
'outputs': ['I'],
'evaluate': staticmethod(saxs_curve)
}
p = dict((p.name(), create_param(p)) for p in params)
names.update(p)
return type('SASModelFittable', (Fittable1DModel, ), names)()
def sasmodels_fn(x, dtype, platform='ocl'):
"""
Calculation using pade approximant.
"""
from sasmodels import core, data, direct_model
model = core.load_model('bessel', dtype=dtype)
calculator = direct_model.DirectModel(data.empty_data1D(x), model)
return calculator(background=0)
def sasmodels_rpa(q, pars):
from sasmodels.models import rpa
from sasmodels.core import load_model
from sasmodels.direct_model import DirectModel
from sasmodels.data import empty_data1D
data = empty_data1D(q, resolution=0.0)
model = load_model(rpa, dtype="double", platform="dll")
#model = load_model(rpa, dtype="single", platform="ocl")
M = DirectModel(data, model)
return M(**pars)
def sasmodels_rpa(q, pars):
from sasmodels.models import rpa
from sasmodels.core import load_model
from sasmodels.direct_model import DirectModel
from sasmodels.data import empty_data1D
data = empty_data1D(q, resolution=0.0)
model = load_model(rpa, dtype="double", platform="dll")
#model = load_model(rpa, dtype="single", platform="ocl")
M = DirectModel(data, model)
return M(**pars)
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()
def _eval_demo_1d(resolution, title):
import sys
from sasmodels import core
name = sys.argv[1] if len(sys.argv) > 1 else 'cylinder'
if name == 'cylinder':
pars = {'length': 210, 'radius': 500}
elif name == 'teubner_strey':
pars = {'a2': 0.003, 'c1': -1e4, 'c2': 1e10, 'background': 0.312643}
elif name == 'sphere' or name == 'spherepy':
pars = TEST_PARS_SLIT_SPHERE
elif name == 'ellipsoid':
pars = {
'scale': 0.05,
'rpolar': 500,
'requatorial': 15000,
'sld': 6,
'solvent_sld': 1,
}
else:
pars = {}
defn = core.load_model_definition(name)
model = core.load_model(defn)
kernel = core.make_kernel(model, [resolution.q_calc])
theory = core.call_kernel(kernel, pars)
Iq = resolution.apply(theory)
if isinstance(resolution, Slit1D):
width, height = resolution.width, resolution.height
Iq_romb = romberg_slit_1d(resolution.q, width, height, model, pars)
else:
dq = resolution.q_width
Iq_romb = romberg_pinhole_1d(resolution.q, dq, model, pars)
import matplotlib.pyplot as plt
plt.loglog(resolution.q_calc, theory, label='unsmeared')
plt.loglog(resolution.q, Iq, label='smeared', hold=True)
plt.loglog(resolution.q, Iq_romb, label='romberg smeared', hold=True)
plt.legend()
plt.title(title)
plt.xlabel("Q (1/Ang)")
plt.ylabel("I(Q) (1/cm)")
def _eval_demo_1d(resolution, title):
import sys
from sasmodels import core
name = sys.argv[1] if len(sys.argv) > 1 else 'cylinder'
if name == 'cylinder':
pars = {'length':210, 'radius':500}
elif name == 'teubner_strey':
pars = {'a2':0.003, 'c1':-1e4, 'c2':1e10, 'background':0.312643}
elif name == 'sphere' or name == 'spherepy':
pars = TEST_PARS_SLIT_SPHERE
elif name == 'ellipsoid':
pars = {
'scale':0.05,
'rpolar':500, 'requatorial':15000,
'sld':6, 'solvent_sld': 1,
}
else:
pars = {}
defn = core.load_model_definition(name)
model = core.load_model(defn)
kernel = core.make_kernel(model, [resolution.q_calc])
theory = core.call_kernel(kernel, pars)
Iq = resolution.apply(theory)
if isinstance(resolution, Slit1D):
width, height = resolution.width, resolution.height
Iq_romb = romberg_slit_1d(resolution.q, width, height, model, pars)
else:
dq = resolution.q_width
Iq_romb = romberg_pinhole_1d(resolution.q, dq, model, pars)
import matplotlib.pyplot as plt
plt.loglog(resolution.q_calc, theory, label='unsmeared')
plt.loglog(resolution.q, Iq, label='smeared', hold=True)
plt.loglog(resolution.q, Iq_romb, label='romberg smeared', hold=True)
plt.legend()
plt.title(title)
plt.xlabel("Q (1/Ang)")
plt.ylabel("I(Q) (1/cm)")
def main():
"""Command line interface to multiple scattering calculator."""
parser = argparse.ArgumentParser(
description="Compute multiple scattering",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument('-p', '--probability', type=float, default=0.1,
help="scattering probability")
parser.add_argument('-n', '--nq', type=int, default=1024,
help='number of mesh points')
parser.add_argument('-q', '--qmax', type=float, default=0.5,
help='max q')
parser.add_argument('-w', '--window', type=float, default=2.0,
help='q calc = q max * window')
parser.add_argument('-2', '--2d', dest='is2d', action='store_true',
help='oriented sample')
parser.add_argument('-s', '--seed', default=-1,
help='random pars with given seed')
parser.add_argument('-r', '--random', action='store_true',
help='random pars with random seed')
parser.add_argument('-o', '--outfile', type=str, default="",
help='save to outfile.txt and outfile_powers.txt')
parser.add_argument('model', type=str,
help='sas model name such as cylinder')
parser.add_argument('pars', type=str, nargs='*',
help='model parameters such as radius=30')
opts = parser.parse_args()
assert opts.nq%2 == 0, "require even # points"
model = core.load_model(opts.model)
pars = parse_pars(model, opts)
res = MultipleScattering(qmax=opts.qmax, nq=opts.nq, window=opts.window,
probability=opts.probability, is2d=opts.is2d)
kernel = model.make_kernel(res.q_calc)
#print(pars)
bg = pars.get('background', 0.0)
pars['background'] = 0.0
theory = call_kernel(kernel, pars)
Iq = res.apply(theory) + bg
_plot_and_save_powers(res, theory, Iq, outfile=opts.outfile, background=bg)
set_top(radial_data, -.0185)
tan_data = load_data('DEC07266.DAT')
set_beam_stop(tan_data, 0.00669, outer=0.025)
set_top(tan_data, -.0185)
#sas.set_half(tan_data, 'right')
name = "ellipsoid" if len(sys.argv) < 2 else sys.argv[1]
section = "radial" if len(sys.argv) < 3 else sys.argv[2]
if section not in ("radial", "tangential", "both"):
raise ValueError("section %r should be 'radial', 'tangential' or 'both'" %
section)
data = radial_data if section != "tangential" else tan_data
theta = 89.9 if section != "tangential" else 0
phi = 90
kernel = load_model(name, dtype="single")
cutoff = 1e-3
if name == "ellipsoid":
model = Model(
kernel,
scale=0.08,
background=35,
radius_polar=15,
radius_equatorial=800,
sld=.291,
sld_solvent=7.105,
theta=theta,
phi=phi,
theta_pd=0,
theta_pd_n=0,
def get_bumps_model(model_name):
kernel = core.load_model(model_name)
model = bumps_model.Model(kernel)
return model
from bumps.names import *
from sasmodels.core import load_model
from sasmodels.bumps_model import Model, Experiment
from sasmodels.data import load_data, plot_data
# latex data, same sample usans and sans
# particles radius ~2300, uniform dispersity
datasets = load_data('latex_smeared.xml', index='all')
#[print(data) for data in datasets]
# A single sphere model to share between the datasets. We will use
# FreeVariables below to set the parameters that are independent between
# the datasets.
kernel = load_model('sphere')
pars = dict(
scale=0.01,
background=0.0,
sld=5.0,
sld_solvent=0.0,
radius=1500.,
#radius_pd=0.1, radius_pd_n=35,
)
model = Model(kernel, **pars)
# radius and polydispersity (if any) are shared
model.radius.range(0, inf)
#model.radius_pd.range(0, 1)
# Contrast and dilution are the same for both measurements, but are not
# separable with a single measurement (i.e., I(q) ~ F(q) contrast^2 Vf),
# so fit one of scale, sld or solvent sld. With absolute scaling from
class SESANSData1D:
#q_zmax = 0.23 # [A^-1]
lam = 0.2 # [nm]
x = SElength
y = data
dy = err_data
sample = Sample()
data = SESANSData1D()
radius = 1000
data.Rmax = 3*radius # [A]
## Sphere parameters
kernel = core.load_model("sphere", dtype='single')
phi = Parameter(0.1, name="phi")
model = bumps_model.Model(kernel,
scale=phi*(1-phi), sld=7.0, solvent_sld=1.0, radius=radius,
)
phi.range(0.001,0.5)
#model.radius.pmp(40)
model.radius.range(1,10000)
#model.sld.pm(5)
#model.background
#model.radius_pd=0
#model.radius_pd_n=0
### Tri-Axial Ellipsoid
#
#kernel = core.load_model("triaxial_ellipsoid", dtype='single')
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
from bumps.names import *
from sasmodels.core import load_model
from sasmodels.bumps_model import Model, Experiment
from sasmodels.data import load_data, set_beam_stop, set_top
""" 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)
def wrap_sasmodel(name, **pars):
from sasmodels.core import load_model
kernel = load_model(name)
fn = lambda q: _sasmodels_Iq(kernel, q, pars)
fn_xy = lambda qx, qy, view: _sasmodels_Iqxy(kernel, qx, qy, pars, view)
return fn, fn_xy
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)
# To Sasview/documents/scripts
from bumps.names import *
from sasmodels.core import load_model
from sasmodels.bumps_model import Model, Experiment
from sasmodels.data import load_data, plot_data
""" IMPORT THE DATA USED """
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)
def setUp(self):
self.pars = TEST_PARS_PINHOLE_SPHERE
from sasmodels import core
self.model = core.load_model("sphere", dtype='double')
from bumps.names import *
from sasmodels.data import load_data
from sasmodels.core import load_model
from sasmodels.bumps_model import Model, Experiment
# Spherical particle data, not ellipsoids
sans, usans = load_data('../../sasview/sasview/test/1d_data/latex_smeared.xml')
usans.qmin, usans.qmax = np.min(usans.x), np.max(usans.x)
usans.mask = (usans.x < 0.0)
usans.oriented = True
#print sans.dxl, usans.dxl
#import pprint; pprint.pprint(sans.__dict__)
kernel = load_model("ellipsoid")
model = Model(
kernel,
scale=0.08, 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)
set_beam_stop(radial_data, 0.00669, outer=0.025)
set_top(radial_data, -.0185)
tan_data = load_data('DEC07266.DAT')
set_beam_stop(tan_data, 0.00669, outer=0.025)
set_top(tan_data, -.0185)
#sas.set_half(tan_data, 'right')
name = "ellipsoid" if len(sys.argv) < 2 else sys.argv[1]
section = "radial" if len(sys.argv) < 3 else sys.argv[2]
if section not in ("radial","tangential","both"):
raise ValueError("section %r should be 'radial', 'tangential' or 'both'"
% section)
data = radial_data if section != "tangential" else tan_data
phi = 0 if section != "tangential" else 90
kernel = load_model(name, dtype="single")
cutoff = 1e-3
if name == "ellipsoid":
model = Model(kernel,
scale=0.08,
r_polar=15, r_equatorial=800,
sld=.291, sld_solvent=7.105,
background=0,
theta=90, phi=phi,
theta_pd=15, theta_pd_n=40, theta_pd_nsigma=3,
r_polar_pd=0.222296, r_polar_pd_n=1, r_polar_pd_nsigma=0,
r_equatorial_pd=.000128, r_equatorial_pd_n=1, r_equatorial_pd_nsigma=0,
phi_pd=0, phi_pd_n=20, phi_pd_nsigma=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')
def setUp(self):
self.pars = TEST_PARS_PINHOLE_SPHERE
from sasmodels import core
from sasmodels.models import sphere
self.model = core.load_model(sphere, dtype='double')
def load_sasmodel(self, model):
self.kernel = load_model(model)
import numpy as np
from bumps.names import *
from sasmodels.core import load_model
from sasmodels.bumps_model import Model, Experiment
from sasmodels.data import load_data, plot_data
# IMPORT THE DATA USED
data = load_data(sys.argv[1])
#setattr(data, 'qmin', 0.0)
#setattr(data, 'qmax', 10.0)
# DEFINE THE MODEL
kernel = load_model('ellipsoid')
pars = dict(scale=0.08,
background=35,
radius_polar=15,
radius_equatorial=800,
sld=.291,
sld_solvent=7.105,
theta=89.9,
phi=90,
theta_pd=0,
theta_pd_n=0,
theta_pd_nsigma=3,
phi_pd=0,
phi_pd_n=20,
phi_pd_nsigma=3,
"""
Minimal example of calling a kernel for a specific set of q values.
"""
from numpy import logspace, sqrt
from matplotlib import pyplot as plt
from sasmodels.core import load_model
from sasmodels.direct_model import call_kernel, call_Fq
model = load_model('cylinder')
q = logspace(-3, -1, 200)
kernel = model.make_kernel([q])
pars = {'radius': 200, 'radius_pd': 0.1, 'scale': 2}
Iq = call_kernel(kernel, pars)
F, Fsq, Reff, V, Vratio = call_Fq(kernel, pars)
plt.loglog(q, Iq, label='2 I(q)')
plt.loglog(q, F**2/V, label='<F(q)>^2/V')
plt.loglog(q, Fsq/V, label='<F^2(q)>/V')
plt.xlabel('q (1/A)')
plt.ylabel('I(q) (1/cm)')
plt.title('Cylinder with radius 200.')
plt.legend()
plt.show()
import numpy as np
from bumps.names import *
from sasmodels.core import load_model
from sasmodels.bumps_model import Model, Experiment
from sasmodels.data import load_data, plot_data
# IMPORT THE DATA USED
data = load_data(sys.argv[1])
#setattr(data, 'qmin', 0.0)
#setattr(data, 'qmax', 10.0)
# DEFINE THE MODEL
kernel = load_model('ellipsoid*hayter_msa')
pars = dict(scale=6.4,
background=0.06,
sld=0.33,
sld_solvent=2.15,
radius_polar=14.0,
radius_equatorial=24.0,
volfraction=0.075,
charge=66.373,
temperature=298.0,
concentration_salt=0.001,
dielectconst=71.0)
model = Model(kernel, **pars)
