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 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)