Changes in / [7eb2a4d:eeb772e] in sasmodels


Ignore:
Files:
6 added
14 edited

Legend:

Unmodified
Added
Removed

  • doc/guide/index.rst

    rda5536f rbc69321  
    1212   pd/polydispersity.rst 
    1313   resolution.rst 
     14   plugin.rst 
     15   fitting_sq.rst 
    1416   magnetism/magnetism.rst 
    1517   orientation/orientation.rst 
    1618   sesans/sans_to_sesans.rst 
    1719   sesans/sesans_fitting.rst 
    18    plugin.rst 
    1920   scripting.rst 
    2021   refs.rst 

  • doc/guide/pd/polydispersity.rst

    rd089a00 ra5cb9bc  
    1111-------------------------------------------- 
    1212 
    13 For some models we can calculate the average intensity for a population of  
    14 particles that possess size and/or orientational (ie, angular) distributions.  
    15 In SasView we call the former *polydispersity* but use the parameter *PD* to  
    16 parameterise both. In other words, the meaning of *PD* in a model depends on  
     13For some models we can calculate the average intensity for a population of 
     14particles that possess size and/or orientational (ie, angular) distributions. 
     15In SasView we call the former *polydispersity* but use the parameter *PD* to 
     16parameterise both. In other words, the meaning of *PD* in a model depends on 
    1717the actual parameter it is being applied too. 
    1818 
    19 The resultant intensity is then normalized by the average particle volume such  
     19The resultant intensity is then normalized by the average particle volume such 
    2020that 
    2121 
    … …  
    2424  P(q) = \text{scale} \langle F^* F \rangle / V + \text{background} 
    2525 
    26 where $F$ is the scattering amplitude and $\langle\cdot\rangle$ denotes an  
     26where $F$ is the scattering amplitude and $\langle\cdot\rangle$ denotes an 
    2727average over the distribution $f(x; \bar x, \sigma)$, giving 
    2828 
    2929.. math:: 
    3030 
    31   P(q) = \frac{\text{scale}}{V} \int_\mathbb{R}  
     31  P(q) = \frac{\text{scale}}{V} \int_\mathbb{R} 
    3232  f(x; \bar x, \sigma) F^2(q, x)\, dx + \text{background} 
    3333 
    3434Each distribution is characterized by a center value $\bar x$ or 
    3535$x_\text{med}$, a width parameter $\sigma$ (note this is *not necessarily* 
    36 the standard deviation, so read the description of the distribution carefully),  
    37 the number of sigmas $N_\sigma$ to include from the tails of the distribution,  
    38 and the number of points used to compute the average. The center of the  
    39 distribution is set by the value of the model parameter. 
    40  
    41 The distribution width applied to *volume* (ie, shape-describing) parameters  
    42 is relative to the center value such that $\sigma = \mathrm{PD} \cdot \bar x$.  
    43 However, the distribution width applied to *orientation* parameters is just  
    44 $\sigma = \mathrm{PD}$. 
     36the standard deviation, so read the description carefully), the number of 
     37sigmas $N_\sigma$ to include from the tails of the distribution, and the 
     38number of points used to compute the average. The center of the distribution 
     39is set by the value of the model parameter. The meaning of a polydispersity 
     40parameter *PD* (not to be confused with a molecular weight distributions 
     41in polymer science) in a model depends on the type of parameter it is being 
     42applied too. 
     43 
     44The distribution width applied to *volume* (ie, shape-describing) parameters 
     45is relative to the center value such that $\sigma = \mathrm{PD} \cdot \bar x$. 
     46However, the distribution width applied to *orientation* (ie, angle-describing) 
     47parameters is just $\sigma = \mathrm{PD}$. 
    4548 
    4649$N_\sigma$ determines how far into the tails to evaluate the distribution, 
    … …  
    5255 
    5356Users should note that the averaging computation is very intensive. Applying 
    54 polydispersion and/or orientational distributions to multiple parameters at  
    55 the same time, or increasing the number of points in the distribution, will  
    56 require patience! However, the calculations are generally more robust with  
     57polydispersion and/or orientational distributions to multiple parameters at 
     58the same time, or increasing the number of points in the distribution, will 
     59require patience! However, the calculations are generally more robust with 
    5760more data points or more angles. 
    5861 
    … …  
    6669*  *Schulz Distribution* 
    6770*  *Array Distribution* 
     71*  *User-defined Distributions* 
    6872 
    6973These are all implemented as *number-average* distributions. 
    7074 
    71 Additional distributions are under consideration. 
    7275 
    7376**Beware: when the Polydispersity & Orientational Distribution panel in SasView is** 
    … …  
    7578**This may not be suitable. See Suggested Applications below.** 
    7679 
    77 .. note:: In 2009 IUPAC decided to introduce the new term 'dispersity' to replace  
    78            the term 'polydispersity' (see `Pure Appl. Chem., (2009), 81(2),  
    79            351-353 <http://media.iupac.org/publications/pac/2009/pdf/8102x0351.pdf>`_  
    80            in order to make the terminology describing distributions of chemical  
    81            properties unambiguous. However, these terms are unrelated to the  
    82            proportional size distributions and orientational distributions used in  
     80.. note:: In 2009 IUPAC decided to introduce the new term 'dispersity' to replace 
     81           the term 'polydispersity' (see `Pure Appl. Chem., (2009), 81(2), 
     82           351-353 <http://media.iupac.org/publications/pac/2009/pdf/8102x0351.pdf>`_ 
     83           in order to make the terminology describing distributions of chemical 
     84           properties unambiguous. However, these terms are unrelated to the 
     85           proportional size distributions and orientational distributions used in 
    8386           SasView models. 
    8487 
    … …  
    9295or angular orientations, consider using the Gaussian or Boltzmann distributions. 
    9396 
    94 If applying polydispersion to parameters describing angles, use the Uniform  
    95 distribution. Beware of using distributions that are always positive (eg, the  
     97If applying polydispersion to parameters describing angles, use the Uniform 
     98distribution. Beware of using distributions that are always positive (eg, the 
    9699Lognormal) because angles can be negative! 
    97100 
    98 The array distribution allows a user-defined distribution to be applied. 
     101The array distribution provides a very simple means of implementing a user- 
     102defined distribution, but without any fittable parameters. Greater flexibility 
     103is conferred by the user-defined distribution. 
    99104 
    100105.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 
    … …  
    334339.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 
    335340 
     341User-defined Distributions 
     342^^^^^^^^^^^^^^^^^^^^^^^^^^ 
     343 
     344You can also define your own distribution by creating a python file defining a 
     345*Distribution* object with a *_weights* method.  The *_weights* method takes 
     346*center*, *sigma*, *lb* and *ub* as arguments, and can access *self.npts* 
     347and *self.nsigmas* from the distribution.  They are interpreted as follows: 
     348 
     349* *center* the value of the shape parameter (for size dispersity) or zero 
     350  if it is an angular dispersity.  This parameter may be fitted. 
     351 
     352* *sigma* the width of the distribution, which is the polydispersity parameter 
     353  times the center for size dispersity, or the polydispersity parameter alone 
     354  for angular dispersity.  This parameter may be fitted. 
     355 
     356* *lb*, *ub* are the parameter limits (lower & upper bounds) given in the model 
     357  definition file.  For example, a radius parameter has *lb* equal to zero.  A 
     358  volume fraction parameter would have *lb* equal to zero and *ub* equal to one. 
     359 
     360* *self.nsigmas* the distance to go into the tails when evaluating the 
     361  distribution.  For a two parameter distribution, this value could be 
     362  co-opted to use for the second parameter, though it will not be available 
     363  for fitting. 
     364 
     365* *self.npts* the number of points to use when evaluating the distribution. 
     366  The user will adjust this to trade calculation time for accuracy, but the 
     367  distribution code is free to return more or fewer, or use it for the third 
     368  parameter in a three parameter distribution. 
     369 
     370As an example, the code following wraps the Laplace distribution from scipy stats:: 
     371 
     372    import numpy as np 
     373    from scipy.stats import laplace 
     374 
     375    from sasmodels import weights 
     376 
     377    class Dispersion(weights.Dispersion): 
     378        r""" 
     379        Laplace distribution 
     380 
     381        .. math:: 
     382 
     383            w(x) = e^{-\sigma |x - \mu|} 
     384        """ 
     385        type = "laplace" 
     386        default = dict(npts=35, width=0, nsigmas=3)  # default values 
     387        def _weights(self, center, sigma, lb, ub): 
     388            x = self._linspace(center, sigma, lb, ub) 
     389            wx = laplace.pdf(x, center, sigma) 
     390            return x, wx 
     391 
     392You can plot the weights for a given value and width using the following:: 
     393 
     394    from numpy import inf 
     395    from matplotlib import pyplot as plt 
     396    from sasmodels import weights 
     397 
     398    # reload the user-defined weights 
     399    weights.load_weights() 
     400    x, wx = weights.get_weights('laplace', n=35, width=0.1, nsigmas=3, value=50, 
     401                                limits=[0, inf], relative=True) 
     402 
     403    # plot the weights 
     404    plt.interactive(True) 
     405    plt.plot(x, wx, 'x') 
     406 
     407The *self.nsigmas* and *self.npts* parameters are normally used to control 
     408the accuracy of the distribution integral. The *self._linspace* function 
     409uses them to define the *x* values (along with the *center*, *sigma*, 
     410*lb*, and *ub* which are passed as parameters).  If you repurpose npts or 
     411nsigmas you will need to generate your own *x*.  Be sure to honour the 
     412limits *lb* and *ub*, for example to disallow a negative radius or constrain 
     413the volume fraction to lie between zero and one. 
     414 
     415To activate a user-defined distribution, put it in a file such as *distname.py* 
     416in the *SAS_WEIGHTS_PATH* folder.  This is defined with an environment 
     417variable, defaulting to:: 
     418 
     419    SAS_WEIGHTS_PATH=~/.sasview/weights 
     420 
     421The weights path is loaded on startup.  To update the distribution definition 
     422in a running application you will need to enter the following python commands:: 
     423 
     424    import sasmodels.weights 
     425    sasmodels.weights.load_weights('path/to/distname.py') 
     426 
     427.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 
     428 
    336429Note about DLS polydispersity 
    337430^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
    338431 
    339 Several measures of polydispersity abound in Dynamic Light Scattering (DLS) and  
    340 it should not be assumed that any of the following can be simply equated with  
     432Several measures of polydispersity abound in Dynamic Light Scattering (DLS) and 
     433it should not be assumed that any of the following can be simply equated with 
    341434the polydispersity *PD* parameter used in SasView. 
    342435 
    343 The dimensionless **Polydispersity Index (PI)** is a measure of the width of the  
    344 distribution of autocorrelation function decay rates (*not* the distribution of  
    345 particle sizes itself, though the two are inversely related) and is defined by  
     436The dimensionless **Polydispersity Index (PI)** is a measure of the width of the 
     437distribution of autocorrelation function decay rates (*not* the distribution of 
     438particle sizes itself, though the two are inversely related) and is defined by 
    346439ISO 22412:2017 as 
    347440 
    … …  
    350443    PI = \mu_{2} / \bar \Gamma^2 
    351444 
    352 where $\mu_\text{2}$ is the second cumulant, and $\bar \Gamma^2$ is the  
     445where $\mu_\text{2}$ is the second cumulant, and $\bar \Gamma^2$ is the 
    353446intensity-weighted average value, of the distribution of decay rates. 
    354447 
    … …  
    359452    PI = \sigma^2 / 2\bar \Gamma^2 
    360453 
    361 where $\sigma$ is the standard deviation, allowing a **Relative Polydispersity (RP)**  
     454where $\sigma$ is the standard deviation, allowing a **Relative Polydispersity (RP)** 
    362455to be defined as 
    363456 
    … …  
    366459    RP = \sigma / \bar \Gamma = \sqrt{2 \cdot PI} 
    367460 
    368 PI values smaller than 0.05 indicate a highly monodisperse system. Values  
     461PI values smaller than 0.05 indicate a highly monodisperse system. Values 
    369462greater than 0.7 indicate significant polydispersity. 
    370463 
    371 The **size polydispersity P-parameter** is defined as the relative standard  
    372 deviation coefficient of variation   
     464The **size polydispersity P-parameter** is defined as the relative standard 
     465deviation coefficient of variation 
    373466 
    374467.. math:: 
    … …  
    377470 
    378471where $\nu$ is the variance of the distribution and $\bar R$ is the mean 
    379 value of $R$. Here, the product $P \bar R$ is *equal* to the standard  
     472value of $R$. Here, the product $P \bar R$ is *equal* to the standard 
    380473deviation of the Lognormal distribution. 
    381474 

  • doc/guide/plugin.rst

    rdb1d9d5 re15a822  
    456456............. 
    457457 
     458.. note:: 
     459 
     460   Pure python models do not yet support direct computation of $<F(Q)^2>$ or 
     461   $<F(Q)>^2$. Neither do they support orientational distributions or magnetism 
     462   (use C models if these are required). 
     463 
    458464For pure python models, define the *Iq* function:: 
    459465 
    … …  
    516522is automatically scaled by *form_volume/shell_volume* prior to calling the 
    517523structure factor. 
    518  
    519 **Note: Pure python models do not yet support direct computation of the** 
    520 **average of $F(q)$ and $F^2(q)$. Neither do they support orientational** 
    521 **distributions or magnetism (use C models if these are required).** 
    522524 
    523525Embedded C Models 

  • sasmodels/compare.py

    rb297ba9 rb297ba9  
    3939 
    4040from . import core 
     41from . import weights 
    4142from . import kerneldll 
    4243from . import kernelcl 
    … …  
    4546from .direct_model import DirectModel, get_mesh 
    4647from .generate import FLOAT_RE, set_integration_size 
    47 from .weights import plot_weights 
    4848 
    4949# pylint: disable=unused-import 
    … …  
    115115 
    116116    === environment variables === 
    117     -DSAS_MODELPATH=path sets directory containing custom models 
     117    -DSAS_MODELPATH=~/.sasmodels/custom_models sets path to custom models 
     118    -DSAS_WEIGHTS_PATH=~/.sasview/weights sets path to custom distributions 
    118119    -DSAS_OPENCL=vendor:device|cuda:device|none sets the target GPU device 
    119120    -DXDG_CACHE_HOME=~/.cache sets the pyopencl cache root (linux only) 
    120121    -DSAS_COMPILER=tinycc|msvc|mingw|unix sets the DLL compiler 
    121     -DSAS_OPENMP=1 turns on OpenMP for the DLLs 
    122     -DSAS_DLL_PATH=path sets the path to the compiled modules 
     122    -DSAS_OPENMP=0 set to 1 to turn on OpenMP for the DLLs 
     123    -DSAS_DLL_PATH=~/.sasmodels/compiled_models sets the DLL cache 
    123124 
    124125The interpretation of quad precision depends on architecture, and may 
    … …  
    784785            model_info = base._kernel.info 
    785786            dim = base._kernel.dim 
    786             plot_weights(model_info, get_mesh(model_info, base_pars, dim=dim)) 
     787            weights.plot_weights(model_info, get_mesh(model_info, base_pars, dim=dim)) 
    787788        if opts['show_profile']: 
    788789            import pylab 
    … …  
    14411442    #import pprint; pprint.pprint(model_info) 
    14421443 
     1444    # Hack to load user-defined distributions; run through all parameters 
     1445    # and make sure any pd_type parameter is a defined distribution. 
     1446    if (any(p.endswith('pd_type') and v not in weights.MODELS 
     1447            for p, v in pars.items()) or 
     1448        any(p.endswith('pd_type') and v not in weights.MODELS 
     1449            for p, v in pars2.items())): 
     1450       weights.load_weights() 
     1451 
    14431452    if opts['show_pars']: 
    14441453        if model_info.name != model_info2.name or pars != pars2: 

  • sasmodels/kernelcl.py

    ra34b811 r9fac5f5  
    158158ENV = None 
    159159def reset_environment(): 
    160     # type: () -> None 
    161     """ 
    162     Call to create a new OpenCL context, such as after a change to SAS_OPENCL. 
     160    # type: () -> "GpuEnvironment" 
     161    """ 
     162    Return a new OpenCL context, such as after a change to SAS_OPENCL. 
    163163    """ 
    164164    global ENV 
    165165    ENV = GpuEnvironment() if use_opencl() else None 
    166  
     166    return ENV 
    167167 
    168168def environment(): 

  • sasmodels/models/__init__.py

    r2d81cfe rd827c5e  
    11""" 
    2 1D Modeling for SAS 
     2Model definition files 
     3---------------------- 
     4 
     5The models below are grouped by type.  The list is a snapshot at a particular 
     6time and may be out of date. 
     7 
     8Models with pure form factor (all of which define *F(Q)*): 
     9 
     10    :mod:`barbell` 
     11    :mod:`capped_cylinder` 
     12    :mod:`core_multi_shell` 
     13    :mod:`core_shell_bicelle` 
     14    :mod:`core_shell_bicelle_elliptical` 
     15    :mod:`core_shell_bicelle_elliptical_belt_rough` 
     16    :mod:`core_shell_cylinder` 
     17    :mod:`core_shell_ellipsoid` 
     18    :mod:`core_shell_parallelepipied` 
     19    :mod:`core_shell_sphere` 
     20    :mod:`cylinder` [limiting conditions (long rods, thin disks) not implemented] 
     21    :mod:`ellipsoid` 
     22    :mod:`elliptical_cylinder` 
     23    :mod:`fuzzy_sphere` 
     24    :mod:`hollow_cylinder` 
     25    :mod:`hollow_rectangular_prism` 
     26    :mod:`hollow_rectangular_prism_thin_walls` 
     27    :mod:`multilayer_vesicle` 
     28    :mod:`onion` 
     29    :mod:`parallelepiped` 
     30    :mod:`rectangular_prism` 
     31    :mod:`sphere` 
     32    :mod:`spherical_sld` 
     33    :mod:`triaxial_ellipsoid` 
     34    :mod:`vesicle` 
     35 
     36Models with local structure factor: 
     37 
     38    :mod:`flexible_cylinder` 
     39    :mod:`flexible_cylinder_elliptical` 
     40    :mod:`linear_pearls` 
     41    :mod:`mono_gauss_coil` 
     42    :mod:`pearl_necklace` 
     43    :mod:`poly_gauss_coil` 
     44    :mod:`polymer_micelle` 
     45    :mod:`pringle` 
     46    :mod:`raspberry` 
     47    :mod:`stacked_disks` 
     48    :mod:`star_polymer` 
     49 
     50Models with long range structure factor: 
     51 
     52    :mod:`binary_hard_sphere` 
     53    :mod:`bcc_paracrystal` 
     54    :mod:`fcc_paracrystal` 
     55    :mod:`fractal` 
     56    :mod:`fractal_core_shell` 
     57    :mod:`lamellar` 
     58    :mod:`lamellar_hg` 
     59    :mod:`lamellar_hg_stack_caille` 
     60    :mod:`lamellar_stack_caille` 
     61    :mod:`lamellar_stack_paracrystal` 
     62    :mod:`mass_fractal` 
     63    :mod:`mass_surface_fractal` 
     64    :mod:`rpa` 
     65    :mod:`sc_paracrystal` 
     66    :mod:`surface_fractal` 
     67 
     68Models which are pure structure factors:: 
     69 
     70    :mod:`hardsphere` 
     71    :mod:`hayter_msa` 
     72    :mod:`squarewell` 
     73    :mod:`stickyhardsphere` 
     74 
     75Other models: 
     76 
     77    :mod:`adsorbed_layer` 
     78    :mod:`be_polyelectrolyte` 
     79    :mod:`broad_peak` 
     80    :mod:`correlation_length` 
     81    :mod:`dab` 
     82    :mod:`gauss_lorentz_gel` 
     83    :mod:`gaussian_peak` 
     84    :mod:`gel_fit` 
     85    :mod:`guinier_porod` 
     86    :mod:`guinier` 
     87    :mod:`line` 
     88    :mod:`lorentz` 
     89    :mod:`peak_lorentz` 
     90    :mod:`polymer_excl_volume` 
     91    :mod:`porod` 
     92    :mod:`power_law` 
     93    :mod:`spinodal` 
     94    :mod:`teubner_strey` 
     95    :mod:`two_lorentzian` 
     96    :mod:`unified_power_Rg` 
     97 
    398""" 

  • sasmodels/models/hardsphere.py

    rdb1d9d5 r4d00de6  
    1616   Earlier versions of SasView did not incorporate the so-called 
    1717   $\beta(q)$ ("beta") correction [1] for polydispersity and non-sphericity. 
    18    This is only available in SasView versions 4.2.2 and higher. 
     18   This is only available in SasView versions 5.0 and higher. 
    1919 
    2020radius_effective is the effective hard sphere radius. 

  • sasmodels/models/hayter_msa.py

    rdb1d9d5 r4d00de6  
    1818   Earlier versions of SasView did not incorporate the so-called 
    1919   $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity. 
    20    This is only available in SasView versions 4.2.2 and higher. 
     20   This is only available in SasView versions 5.0 and higher. 
    2121 
    2222The salt concentration is used to compute the ionic strength of the solution 

  • sasmodels/models/sphere.py

    ra34b811 r934a001  
    3636References 
    3737---------- 
    38  
    39 .. [#] A Guinier and G. Fournet, *Small-Angle Scattering of X-Rays*, John Wiley and Sons, New York, (1955) 
     38  
     39.. [#] A Guinier and G. Fournet, *Small-Angle Scattering of X-Rays*, 
     40   John Wiley and Sons, New York, (1955) 
    4041 
    4142Source 
    … …  
    9091    ) 
    9192    return pars 
    92  
     93#2345678901234567890123456789012345678901234567890123456789012345678901234567890 
    9394tests = [ 
    94      [{}, 0.2, 0.726362], # each test starts with default parameter values inside { }, unless modified. Then Q and expected value of I(Q) 
     95     [{}, 0.2, 0.726362], # each test starts with default parameter values  
     96     #            inside { }, unless modified. Then Q and expected value of I(Q) 
     97     # putting None for an expected result will pass the test if there are no  
     98     # errors from the routine, but without any check on the value of the result 
     99    [{"scale": 1., "background": 0., "sld": 6., "sld_solvent": 1., 
     100       "radius": 120.}, [0.01,0.1,0.2],  
     101     [1.34836265e+04, 6.20114062e+00, 1.04733914e-01]], 
    95102     [{"scale": 1., "background": 0., "sld": 6., "sld_solvent": 1., 
     103     #  careful tests here R=120 Pd=.2, then with S(Q) at default Reff=50  
     104     #  (but this gets changed to 120) phi=0,2 
    96105       "radius": 120., "radius_pd": 0.2, "radius_pd_n":45}, 
    97       0.2, 0.2288431], 
    98     [{"radius": 120., "radius_pd": 0.02, "radius_pd_n":45}, 
    99       0.2, 792.0646662454202, 1166737.0473152, 120.0, 7246723.820358589, 1.0], # the longer list here checks  F1, F2, R_eff, volume, volume_ratio = call_Fq(kernel, pars) 
     106      [0.01,0.1,0.2], [1.74395295e+04, 3.68016987e+00, 2.28843099e-01]],   
     107     # a list of Q values and list of expected results is also possible 
     108    [{"scale": 1., "background": 0., "sld": 6., "sld_solvent": 1., 
     109     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45}, 
     110      0.01, 335839.88055473, 1.41045057e+11, 120.0, 8087664.122641933, 1.0],  
     111     # the longer list here checks  F1, F2, R_eff, volume, volume_ratio  
     112    [{"radius": 120., "radius_pd": 0.2, "radius_pd_n":45}, 
     113      0.1, 482.93824329, 29763977.79867414, 120.0, 8087664.122641933, 1.0],  
     114    [{"radius": 120., "radius_pd": 0.2, "radius_pd_n":45}, 
     115      0.2, 1.23330406, 1850806.1197361, 120.0, 8087664.122641933, 1.0], 
    100116   #  But note P(Q) = F2/volume 
    101    #  F and F^2 are "unscaled", with for  n <F F*>S(q) or for beta approx I(q) = n [<F F*> + <F><F*> (S(q) - 1)] 
    102    #  for n the number density and <.> the orientation average, and F = integral rho(r) exp(i q . r) dr. 
     117   #  F and F^2 are "unscaled", with for  n <F F*>S(q) or for beta approx  
     118   #          I(q) = n [<F F*> + <F><F*> (S(q) - 1)] 
     119   #  for n the number density and <.> the orientation average, and  
     120   #  F = integral rho(r) exp(i q . r) dr. 
    103121   #  The number density is volume fraction divided by particle volume. 
    104    #  Effectively, this leaves F = V drho form, where form is the usual 3 j1(qr)/(qr) or whatever depending on the shape. 
    105    # [{"@S": "hardsphere"}, 
    106    #    0.01, 55.881884232102124], # this is current value, not verified elsewhere yet 
    107    # [{"radius": 120., "radius_pd": 0.2, "radius_pd_n":45}, 
    108    #   0.2, 1.233304061, [1850806.119736], 120.0, 8087664.1226, 1.0], # the longer list here checks  F1, F2, R_eff, volume, volume_ratio = call_Fq(kernel, pars) 
    109    # [{"@S": "hardsphere"}, 
    110    #     0.2, 0.14730859242492958], #  this is current value, not verified elsewhere yet 
    111     # [{"@S": "hardsphere"}, 
    112     #    0.1, 0.7940350343811906], #  this is current value, not verified elsewhere yet 
     122   #  Effectively, this leaves F = V drho form, where form is the usual  
     123   #  3 j1(qr)/(qr) or whatever depending on the shape. 
     124   # @S RESULTS using F1 and F2 from the longer test strng above: 
     125   # 
     126   # I(Q) = (F2 + F1^2*(S(Q) -1))*volfraction*scale/Volume  + background 
     127   # 
     128   # with by default scale=1.0, background=0.001 
     129   # NOTE currently S(Q) volfraction is also included in scaling 
     130   #  structure_factor_mode 0 = normal decoupling approx,  
     131   #                        1 = beta(Q) approx 
     132   # radius_effective_mode  0 is for free choice,  
     133   #                        1 is use radius from F2(Q) 
     134   #    (sphere only has two choices, other models may have more) 
     135    [{"@S": "hardsphere", 
     136     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45,"volfraction":0.2, 
     137     #"radius_effective":50.0,    # hard sphere structure factor 
     138     "structure_factor_mode": 1,  # mode 0 = normal decoupling approx,  
     139     #                                   1 = beta(Q) approx 
     140     "radius_effective_mode": 0   # this used default hardsphere Reff=50     
     141     }, [0.01,0.1,0.2], [1.32473756e+03, 7.36633631e-01, 4.67686201e-02]  ], 
    113142    [{"@S": "hardsphere", 
    114143     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45, 
    115144     "volfraction":0.2, 
    116      "radius_effective":45.0,     # uses this (check) 
    117      "structure_factor_mode": 1,  # 0 = normal decoupling approximation, 1 = beta(Q) approx 
    118      "radius_effective_mode": 0   # equivalent sphere, there is only one valid mode for sphere. says -this used r_eff =0 or default 50? 
     145     "radius_effective":45.0,     # explicit Reff over rides either 50 or 120 
     146     "structure_factor_mode": 1,  # beta approx 
     147     "radius_effective_mode": 0   #  
    119148     }, 0.01, 1316.2990966463444 ], 
    120149    [{"@S": "hardsphere", 
    121150     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45, 
    122151     "volfraction":0.2, 
    123      "radius_effective":50.0,        # hard sphere structure factor 
    124      "structure_factor_mode": 1,  # 0 = normal decoupling approximation, 1 = beta(Q) approx 
    125      "radius_effective_mode": 0   # this used r_eff =0 or default 50? 
    126      }, 0.01, 1324.7375636587356 ], 
     152     "radius_effective":120.0,    # over ride Reff 
     153     "structure_factor_mode": 1,  # beta approx 
     154     "radius_effective_mode": 0   # (mode=1 here also uses 120)  
     155     }, [0.01,0.1,0.2], [1.57928589e+03, 7.37067923e-01, 4.67686197e-02  ]], 
    127156    [{"@S": "hardsphere", 
    128157     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45, 
    129158     "volfraction":0.2, 
    130      "radius_effective":50.0,        # hard sphere structure factor 
    131      "structure_factor_mode": 1,  # 0 = normal decoupling approximation, 1 = beta(Q) approx 
    132      "radius_effective_mode": 1   # this used 120 ??? 
    133      }, 0.01, 1579.2858949296565 ] 
     159     #"radius_effective":120.0,   # hard sphere structure factor 
     160     "structure_factor_mode": 0,  # normal decoupling approximation 
     161     "radius_effective_mode": 1   # this uses 120 from the form factor 
     162     }, [0.01,0.1,0.2], [1.10112335e+03, 7.41366536e-01, 4.66630207e-02]], 
     163    [{"@S": "hardsphere", 
     164     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45, 
     165     "volfraction":0.2, 
     166     #"radius_effective":50.0,    # hard sphere structure factor 
     167     "structure_factor_mode": 0,  # normal decoupling approximation 
     168     "radius_effective_mode": 0   # this used 50 the default for hardsphere 
     169     }, [0.01,0.1,0.2], [7.82803598e+02, 6.85943611e-01, 4.71586457e-02 ]] 
    134170] 
    135 # putting None for expected result will pass the test if there are no errors from the routine, but without any check on the value of the result 
     171# 

  • sasmodels/models/squarewell.py

    rdb1d9d5 r4d00de6  
    2020   Earlier versions of SasView did not incorporate the so-called 
    2121   $\beta(q)$ ("beta") correction [2] for polydispersity and non-sphericity. 
    22    This is only available in SasView versions 4.2.2 and higher. 
     22   This is only available in SasView versions 5.0 and higher. 
    2323 
    2424The well width $(\lambda)$ is defined as multiples of the particle diameter 

  • sasmodels/models/stickyhardsphere.py

    rdb1d9d5 r4d00de6  
    5656   Earlier versions of SasView did not incorporate the so-called 
    5757   $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity. 
    58    This is only available in SasView versions 4.2.2 and higher. 
     58   This is only available in SasView versions 5.0 and higher. 
    5959 
    6060In SasView the effective radius may be calculated from the parameters 

  • sasmodels/sasview_model.py

    ra34b811 ra34b811  
    3131from . import modelinfo 
    3232from .details import make_kernel_args, dispersion_mesh 
     33 
     34# Hack: load in any custom distributions 
     35# Uses ~/.sasview/weights/*.py unless SASMODELS_WEIGHTS is set in the environ. 
     36# Override with weights.load_weights(pattern="<weights_path>/*.py") 
     37weights.load_weights() 
    3338 
    3439# pylint: disable=unused-import 

  • sasmodels/sesans.py

    rb297ba9 rda33725  
    1515from numpy import pi  # type: ignore 
    1616from scipy.special import j0 
     17 
    1718 
    1819class SesansTransform(object): 
    … …  
    3839 
    3940    # transform arrays 
    40     _H = None  # type: np.ndarray 
    41     _H0 = None # type: np.ndarray 
     41    _H = None   # type: np.ndarray 
     42    _H0 = None  # type: np.ndarray 
    4243 
    43     def __init__(self, z, SElength, lam, zaccept, Rmax): 
     44    def __init__(self, z, SElength, lam, zaccept, Rmax, log_spacing=1.0003): 
    4445        # type: (np.ndarray, float, float) -> None 
    45         #import logging; logging.info("creating SESANS transform") 
    4646        self.q = z 
     47        self.log_spacing = log_spacing 
    4748        self._set_hankel(SElength, lam, zaccept, Rmax) 
    4849 
    … …  
    5960    def _set_hankel(self, SElength, lam, zaccept, Rmax): 
    6061        # type: (np.ndarray, float, float) -> None 
    61         # Force float32 arrays, otherwise run into memory problems on some machines 
    62         SElength = np.asarray(SElength, dtype='float32') 
    63  
    64         #Rmax = #value in text box somewhere in FitPage? 
     62        SElength = np.asarray(SElength) 
    6563        q_max = 2*pi / (SElength[1] - SElength[0]) 
    6664        q_min = 0.1 * 2*pi / (np.size(SElength) * SElength[-1]) 
    67         q = np.arange(q_min, q_max, q_min, dtype='float32') 
    68         dq = q_min 
     65        q = np.exp(np.arange(np.log(q_min), np.log(q_max), 
     66                             np.log(self.log_spacing))) 
    6967 
    70         H0 = np.float32(dq/(2*pi)) * q 
     68        dq = np.diff(q) 
     69        dq = np.insert(dq, 0, dq[0]) 
    7170 
    72         repq = np.tile(q, (SElength.size, 1)).T 
    73         repSE = np.tile(SElength, (q.size, 1)) 
    74         H = np.float32(dq/(2*pi)) * j0(repSE*repq) * repq 
     71        H0 = dq/(2*pi) * q 
    7572 
    76         replam = np.tile(lam, (q.size, 1)) 
    77         reptheta = np.arcsin(repq*replam/2*np.pi) 
     73        H = np.outer(q, SElength) 
     74        j0(H, out=H) 
     75        H *= (dq * q / (2*pi)).reshape((-1, 1)) 
     76 
     77        reptheta = np.outer(q, lam/(2*pi)) 
     78        np.arcsin(reptheta, out=reptheta) 
    7879        mask = reptheta > zaccept 
    7980        H[mask] = 0 

  • sasmodels/weights.py

    rb297ba9 rb297ba9  
    230230)) 
    231231 
     232SAS_WEIGHTS_PATH = "~/.sasview/weights" 
     233def load_weights(pattern=None): 
     234    # type: (str) -> None 
     235    """ 
     236    Load dispersion distributions matching the given glob pattern 
     237    """ 
     238    import logging 
     239    import os 
     240    import os.path 
     241    import glob 
     242    import traceback 
     243    from .custom import load_custom_kernel_module 
     244    if pattern is None: 
     245        path = os.environ.get("SAS_WEIGHTS_PATH", SAS_WEIGHTS_PATH) 
     246        pattern = os.path.join(path, "*.py") 
     247    for filename in sorted(glob.glob(os.path.expanduser(pattern))): 
     248        try: 
     249            #print("loading weights from", filename) 
     250            module = load_custom_kernel_module(filename) 
     251            MODELS[module.Dispersion.type] = module.Dispersion 
     252        except Exception as exc: 
     253            logging.error(traceback.format_exc(exc)) 
    232254 
    233255def get_weights(disperser, n, width, nsigmas, value, limits, relative): 
Note: See TracChangeset for help on using the changeset viewer.