source: sasmodels/sasmodels/models/sphere.py @ eb69cce

r"""
For information about polarised and magnetic scattering, click here_.

.. _here: polar_mag_help.html

Definition
----------

The 1D scattering intensity is calculated in the following way (Guinier, 1955)

.. math::

    I(q) = \frac{\text{scale}}{V} \cdot \left[
        3V(\Delta\rho) \cdot \frac{\sin(qr) - qr\cos(qr))}{(qr)^3}
        \right]^2 + \text{background}

where *scale* is a volume fraction, $V$ is the volume of the scatterer,
$r$ is the radius of the sphere, *background* is the background level and
*sld* and *solvent_sld* are the scattering length densities (SLDs) of the
scatterer and the solvent respectively.

Note that if your data is in absolute scale, the *scale* should represent
the volume fraction (which is unitless) if you have a good fit. If not,
it should represent the volume fraction times a factor (by which your data
might need to be rescaled).

The 2D scattering intensity is the same as above, regardless of the
orientation of $\vec q$.

Validation
----------

Validation of our code was done by comparing the output of the 1D model
to the output of the software provided by the NIST (Kline, 2006).
Figure :num:`figure #sphere-comparison` shows a comparison of the output
of our model and the output of the NIST software.

.. _sphere-comparison:

.. figure:: img/sphere_comparison.jpg

    Comparison of the DANSE scattering intensity for a sphere with the
    output of the NIST SANS analysis software. The parameters were set to:
    *scale* = 1.0, *radius* = 60 |Ang|, *contrast* = 1e-6 |Ang^-2|, and
    *background* = 0.01 |cm^-1|.


References
----------

A Guinier and G. Fournet, *Small-Angle Scattering of X-Rays*,
John Wiley and Sons, New York, (1955)

*2013/09/09 and 2014/01/06 - Description reviewed by S King and P Parker.*
"""

from numpy import inf

name = "sphere"
title = "Spheres with uniform scattering length density"
description = """\
P(q)=(scale/V)*[3V(sld-solvent_sld)*(sin(qr)-qr cos(qr))
                /(qr)^3]^2 + background
    r: radius of sphere
    V: The volume of the scatter
    sld: the SLD of the sphere
    solvent_sld: the SLD of the solvent
"""
category = "shape:sphere"

#             ["name", "units", default, [lower, upper], "type","description"],
parameters = [["sld", "1e-6/Ang^2", 1, [-inf, inf], "",
               "Layer scattering length density"],
              ["solvent_sld", "1e-6/Ang^2", 6, [-inf, inf], "",
               "Solvent scattering length density"],
              ["radius", "Ang", 50, [0, inf], "volume",
               "Sphere radius"],
             ]


# No volume normalization despite having a volume parameter
# This should perhaps be volume normalized?
form_volume = """
    return 1.333333333333333*M_PI*radius*radius*radius;
    """

Iq = """
    const double qr = q*radius;
    const double qrsq = qr*qr;
    double sn, cn;
    SINCOS(qr, sn, cn);
    // Use taylor series for low q to avoid cancellation error.  Tested against
    // the following expression in quad precision:
    //     3.0*(sn-qr*cn)/(qr*qr*qr);
    // Note that the values differ from sasview ~ 5e-12 rather than 5e-14, but
    // in this case it is likely cancellation errors in the original expression
    // using double precision that are the source.  Single precision only
    // requires the first 3 terms.  Double precision requires the 4th term.
    // The fifth term is not needed, and is commented out below.
    const double bes = (qr < 1e-1)
        ? 1.0 + qrsq*(-3./30. + qrsq*(3./840. + qrsq*(-3./45360.)))// + qrsq*(3./3991680.))))
        : 3.0*(sn/qr - cn)/qrsq;
    const double fq = bes * (sld - solvent_sld) * form_volume(radius);
    return 1.0e-4*fq*fq;
    """

Iqxy = """
    // never called since no orientation or magnetic parameters.
    //return -1.0;
    return Iq(sqrt(qx*qx + qy*qy), sld, solvent_sld, radius);
    """

def ER(radius):
    return radius

# VR defaults to 1.0

demo = dict(scale=1, background=0,
            sld=6, solvent_sld=1,
            radius=120,
            radius_pd=.2, radius_pd_n=45)
oldname = "SphereModel"
oldpars = dict(sld='sldSph', solvent_sld='sldSolv', radius='radius')