def build_model(model_name, q, **pars):
from sasmodels.core import load_model_info, build_model as build_sasmodel
from sasmodels.data import empty_data1D
from sasmodels.direct_model import DirectModel
model_info = load_model_info(model_name)
model = build_sasmodel(model_info, dtype='double!')
data = empty_data1D(q)
calculator = DirectModel(data, model, cutoff=0)
calculator.pars = pars.copy()
calculator.pars.setdefault('background', 0)
return calculator
def _sasmodels_Iq(kernel, q, pars):
from sasmodels.data import empty_data1D
from sasmodels.direct_model import DirectModel
data = empty_data1D(q)
calculator = DirectModel(data, kernel)
Iq = calculator(**pars)
return Iq
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 plot_1d(model, opts, ax):
q_min, q_max, nq = opts['q_min'], opts['q_max'], opts['nq']
q_min = math.log10(q_min)
q_max = math.log10(q_max)
q = np.logspace(q_min, q_max, nq)
data = empty_data1D(q)
calculator = DirectModel(data, model)
Iq1D = calculator()
ax.plot(q, Iq1D, color='blue', lw=2, label=model_info['name'])
ax.set_xlabel(r'$Q \/(\AA^{-1})$')
ax.set_ylabel(r'$I(Q) \/(\mathrm{cm}^{-1})$')
ax.set_xscale(opts['xscale'])
ax.set_yscale(opts['yscale'])
def _sasmodels_Iqxy(kernel, qx, qy, pars, view):
from sasmodels.data import Data2D
from sasmodels.direct_model import DirectModel
Iq = 100 * np.ones_like(qx)
data = Data2D(x=qx, y=qy, z=Iq, dx=None, dy=None, dz=np.sqrt(Iq))
data.x_bins = qx[0,:]
data.y_bins = qy[:,0]
data.filename = "fake data"
calculator = DirectModel(data, kernel)
pars_plus_view = pars.copy()
pars_plus_view.update(theta=view[0], phi=view[1], psi=view[2])
Iqxy = calculator(**pars_plus_view)
return Iqxy.reshape(qx.shape)
def build_model(model_name, n=150, qmax=0.5, **pars):
"""
Build a calculator for the given shape.
*model_name* is any sasmodels model. *n* and *qmax* define an n x n mesh
on which to evaluate the model. The remaining parameters are stored in
the returned calculator as *calculator.pars*. They are used by
:func:`draw_scattering` to set the non-orientation parameters in the
calculation.
Returns a *calculator* function which takes a dictionary or parameters and
produces Iqxy. The Iqxy value needs to be reshaped to an n x n matrix
for plotting. See the :class:`sasmodels.direct_model.DirectModel` class
for details.
"""
from sasmodels.core import load_model_info, build_model
from sasmodels.data import empty_data2D
from sasmodels.direct_model import DirectModel
model_info = load_model_info(model_name)
model = build_model(model_info) #, dtype='double!')
q = np.linspace(-qmax, qmax, n)
data = empty_data2D(q, q)
calculator = DirectModel(data, model)
# stuff the values for non-orientation parameters into the calculator
calculator.pars = pars.copy()
calculator.pars.setdefault('backgound', 1e-3)
# fix the data limits so that we can see if the pattern fades
# under rotation or angular dispersion
Iqxy = calculator(theta=0, phi=0, psi=0, **calculator.pars)
Iqxy = np.log(Iqxy)
vmin, vmax = clipped_range(Iqxy, 0.95, mode='top')
calculator.limits = vmin, vmax + 1
return calculator
def plot_2d(model, opts, ax):
qx_max, nq2d = opts['qx_max'], opts['nq2d']
q = np.linspace(-qx_max, qx_max, nq2d)
data2d = empty_data2D(q, resolution=0.0)
calculator = DirectModel(data2d, model)
Iq2D = calculator() #background=0)
Iq2D = Iq2D.reshape(nq2d, nq2d)
if opts['zscale'] == 'log':
Iq2D = np.log(np.clip(Iq2D, opts['vmin'], np.inf))
ax.imshow(Iq2D,
interpolation='nearest',
aspect=1,
origin='lower',
extent=[-qx_max, qx_max, -qx_max, qx_max],
cmap=opts['colormap'])
ax.set_xlabel(r'$Q_x \/(\AA^{-1})$')
ax.set_ylabel(r'$Q_y \/(\AA^{-1})$')
def plot_1d(model, opts, ax):
# type: (KernelModel, Dict[str, Any], Axes) -> None
"""
Create a 1-D image.
"""
q_min, q_max, nq = opts['q_min'], opts['q_max'], opts['nq']
q_min = math.log10(q_min)
q_max = math.log10(q_max)
q = np.logspace(q_min, q_max, nq)
data = empty_data1D(q)
calculator = DirectModel(data, model)
Iq1D = calculator()
ax.plot(q, Iq1D, color='blue', lw=2, label=model.info.name)
ax.set_xlabel(r'$Q \/(\AA^{-1})$')
ax.set_ylabel(r'$I(Q) \/(\mathrm{cm}^{-1})$')
ax.set_xscale(opts['xscale'])
ax.set_yscale(opts['yscale'])