def _eval_sphere(self, pars, resolution):
from sasmodels import direct_model
kernel = self.model.make_kernel([resolution.q_calc])
theory = direct_model.call_kernel(kernel, pars)
result = resolution.apply(theory)
kernel.release()
return result
def eval_form(q, form, pars):
"""
Return the SAS model evaluated at *q*.
*form* is the SAS model returned from :fun:`core.load_model`.
*pars* are the parameter values to use when evaluating.
"""
from sasmodels import direct_model
kernel = form.make_kernel([q])
theory = direct_model.call_kernel(kernel, pars)
kernel.release()
return theory
def _eval_demo_1d(resolution, title):
import sys
from sasmodels import core
from sasmodels import direct_model
name = sys.argv[1] if len(sys.argv) > 1 else 'cylinder'
if name == 'cylinder':
pars = {'length': 210, 'radius': 500, 'background': 0}
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,
'background': 0,
'r_polar': 500,
'r_equatorial': 15000,
'sld': 6,
'sld_solvent': 1,
}
else:
pars = {}
model_info = core.load_model_info(name)
model = core.build_model(model_info)
kernel = model.make_kernel([resolution.q_calc])
theory = direct_model.call_kernel(kernel, pars)
Iq = resolution.apply(theory)
if isinstance(resolution, Slit1D):
width, height = resolution.qx_width, resolution.qy_width
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 # type: ignore
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)
"""
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()
def saxs_curve(q, *args):
kernel = m.make_kernel([q])
p_fit = dict(zip(inputs, args))
return call_kernel(kernel, p_fit)
"""
Minimal example of calling a kernel for a specific set of q values.
"""
from numpy import logspace
from matplotlib import pyplot as plt
from sasmodels.core import load_model
from sasmodels.direct_model import call_kernel
model = load_model('cylinder')
q = logspace(-3, -1, 200)
kernel = model.make_kernel([q])
Iq = call_kernel(kernel, dict(radius=200.))
plt.loglog(q, Iq)
plt.xlabel('q (1/A)')
plt.ylabel('I(q)')
plt.title('Cylinder with radius 200.')
plt.show()
