# Changeset 052d4c5 in sasmodels

Ignore:
Timestamp:
Jun 12, 2018 4:00:28 AM (12 months ago)
Branches:
master, core_shell_microgels, magnetic_model, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests
Children:
c11d09f
Parents:
0b9c6df (diff), f89ec96 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Paul Butler <butlerpd@…> (06/12/18 04:00:28)
git-committer:
Message:

Merge pull request #64 from SasView?/ticket-896

Ticket 896 - core shell parallelepiped documentation

closes #896

Files:
12 edited

Unmodified
Removed
• ## sasmodels/models/core_shell_parallelepiped.c

 re077231 // outer integral (with gauss points), integration limits = 0, 1 // substitute d_cos_alpha for sin_alpha d_alpha double outer_sum = 0; //initialize integral for( int i=0; i
• ## sasmodels/models/core_shell_parallelepiped.py

 r97be877 Calculates the form factor for a rectangular solid with a core-shell structure. The thickness and the scattering length density of the shell or "rim" can be different on each (pair) of faces. The thickness and the scattering length density of the shell or "rim" can be different on each (pair) of faces. The three dimensions of the core of the parallelepiped (strictly here a cuboid) may be given in *any* size order as long as the particles are randomly oriented (i.e. take on all possible orientations see notes on 2D below). To avoid multiple fit solutions, especially with Monte-Carlo fit methods, it may be advisable to restrict their ranges. There may be a number of closely similar "best fits", so some trial and error, or fixing of some dimensions at expected values, may help. The form factor is normalized by the particle volume $V$ such that .. math:: I(q) = \text{scale}\frac{\langle f^2 \rangle}{V} + \text{background} I(q) = \frac{\text{scale}}{V} \langle P(q,\alpha,\beta) \rangle + \text{background} where $\langle \ldots \rangle$ is an average over all possible orientations of the rectangular solid. The function calculated is the form factor of the rectangular solid below. The core of the solid is defined by the dimensions $A$, $B$, $C$ such that $A < B < C$. .. image:: img/core_shell_parallelepiped_geometry.jpg of the rectangular solid, and the usual $\Delta \rho^2 \ V^2$ term cannot be pulled out of the form factor term due to the multiple slds in the model. The core of the solid is defined by the dimensions $A$, $B$, $C$ here shown such that $A < B < C$. .. figure:: img/parallelepiped_geometry.jpg Core of the core shell parallelepiped with the corresponding definition of sides. There are rectangular "slabs" of thickness $t_A$ that add to the $A$ dimension (on the $BC$ faces). There are similar slabs on the $AC$ $(=t_B)$ and $AB$ $(=t_C)$ faces. The projection in the $AB$ plane is then .. image:: img/core_shell_parallelepiped_projection.jpg The volume of the solid is $(=t_C)$ faces. The projection in the $AB$ plane is .. figure:: img/core_shell_parallelepiped_projection.jpg AB cut through the core-shell parallelipiped showing the cross secion of four of the six shell slabs. As can be seen, this model leaves **"gaps"** at the corners of the solid. The total volume of the solid is thus given as .. math:: V = ABC + 2t_ABC + 2t_BAC + 2t_CAB **meaning that there are "gaps" at the corners of the solid.** The intensity calculated follows the :ref:parallelepiped model, with the core-shell intensity being calculated as the square of the sum of the amplitudes of the core and the slabs on the edges. the scattering amplitude is computed for a particular orientation of the core-shell parallelepiped with respect to the scattering vector and then averaged over all possible orientations, where $\alpha$ is the angle between the $z$ axis and the $C$ axis of the parallelepiped, $\beta$ is the angle between projection of the particle in the $xy$ detector plane and the $y$ axis. .. math:: F(Q) amplitudes of the core and the slabs on the edges. The scattering amplitude is computed for a particular orientation of the core-shell parallelepiped with respect to the scattering vector and then averaged over all possible orientations, where $\alpha$ is the angle between the $z$ axis and the $C$ axis of the parallelepiped, and $\beta$ is the angle between the projection of the particle in the $xy$ detector plane and the $y$ axis. .. math:: P(q)=\frac {\int_{0}^{\pi/2}\int_{0}^{\pi/2}F^2(q,\alpha,\beta) \ sin\alpha \ d\alpha \ d\beta} {\int_{0}^{\pi/2} \ sin\alpha \ d\alpha \ d\beta} and .. math:: F(q,\alpha,\beta) &= (\rho_\text{core}-\rho_\text{solvent}) S(Q_A, A) S(Q_B, B) S(Q_C, C) \\ &+ (\rho_\text{A}-\rho_\text{solvent}) \left[S(Q_A, A+2t_A) - S(Q_A, Q)\right] S(Q_B, B) S(Q_C, C) \\ \left[S(Q_A, A+2t_A) - S(Q_A, A)\right] S(Q_B, B) S(Q_C, C) \\ &+ (\rho_\text{B}-\rho_\text{solvent}) S(Q_A, A) \left[S(Q_B, B+2t_B) - S(Q_B, B)\right] S(Q_C, C) \\ .. math:: S(Q, L) = L \frac{\sin \tfrac{1}{2} Q L}{\tfrac{1}{2} Q L} S(Q_X, L) = L \frac{\sin (\tfrac{1}{2} Q_X L)}{\tfrac{1}{2} Q_X L} and .. math:: Q_A &= \sin\alpha \sin\beta \\ Q_B &= \sin\alpha \cos\beta \\ Q_C &= \cos\alpha Q_A &= q \sin\alpha \sin\beta \\ Q_B &= q \sin\alpha \cos\beta \\ Q_C &= q \cos\alpha where $\rho_\text{core}$, $\rho_\text{A}$, $\rho_\text{B}$ and $\rho_\text{C}$ are the scattering length of the parallelepiped core, and the rectangular are the scattering lengths of the parallelepiped core, and the rectangular slabs of thickness $t_A$, $t_B$ and $t_C$, respectively. $\rho_\text{solvent}$ is the scattering length of the solvent. .. note:: the code actually implements two substitutions: $d(cos\alpha)$ is substituted for -$sin\alpha \ d\alpha$ (note that in the :ref:parallelepiped code this is explicitly implemented with $\sigma = cos\alpha$), and $\beta$ is set to $\beta = u \pi/2$ so that $du = \pi/2 \ d\beta$.  Thus both integrals go from 0 to 1 rather than 0 to $\pi/2$. FITTING NOTES ~~~~~~~~~~~~~ If the scale is set equal to the particle volume fraction, $\phi$, the returned value is the scattered intensity per unit volume, $I(q) = \phi P(q)$. However, **no interparticle interference effects are included in this calculation.** There are many parameters in this model. Hold as many fixed as possible with known values, or you will certainly end up at a solution that is unphysical. The returned value is in units of |cm^-1|, on absolute scale. NB: The 2nd virial coefficient of the core_shell_parallelepiped is calculated based on the the averaged effective radius $(=\sqrt{(A+2t_A)(B+2t_B)/\pi})$ and length $(C+2t_C)$ values, after appropriately sorting the three dimensions to give an oblate or prolate particle, to give an effective radius, for $S(Q)$ when $P(Q) * S(Q)$ is applied. For 2d data the orientation of the particle is required, described using angles $\theta$, $\phi$ and $\Psi$ as in the diagrams below, for further details of the calculation and angular dispersions see :ref:orientation. The angle $\Psi$ is the rotational angle around the *long_c* axis. For example, $\Psi = 0$ when the *short_b* axis is parallel to the *x*-axis of the detector. For 2d, constraints must be applied during fitting to ensure that the inequality $A < B < C$ is not violated, and hence the correct definition of angles is preserved. The calculation will not report an error, but the results may be not correct. #. There are many parameters in this model. Hold as many fixed as possible with known values, or you will certainly end up at a solution that is unphysical. #. The 2nd virial coefficient of the core_shell_parallelepiped is calculated based on the the averaged effective radius $(=\sqrt{(A+2t_A)(B+2t_B)/\pi})$ and length $(C+2t_C)$ values, after appropriately sorting the three dimensions to give an oblate or prolate particle, to give an effective radius for $S(q)$ when $P(q) * S(q)$ is applied. #. For 2d data the orientation of the particle is required, described using angles $\theta$, $\phi$ and $\Psi$ as in the diagrams below, where $\theta$ and $\phi$ define the orientation of the director in the laboratry reference frame of the beam direction ($z$) and detector plane ($x-y$ plane), while the angle $\Psi$ is effectively the rotational angle around the particle $C$ axis. For $\theta = 0$ and $\phi = 0$, $\Psi = 0$ corresponds to the $B$ axis oriented parallel to the y-axis of the detector with $A$ along the x-axis. For other $\theta$, $\phi$ values, the order of rotations matters. In particular, the parallelepiped must first be rotated $\theta$ degrees in the $x-z$ plane before rotating $\phi$ degrees around the $z$ axis (in the $x-y$ plane). Applying orientational distribution to the particle orientation (i.e  jitter to one or more of these angles) can get more confusing as jitter is defined **NOT** with respect to the laboratory frame but the particle reference frame. It is thus highly recmmended to read :ref:orientation for further details of the calculation and angular dispersions. .. note:: For 2d, constraints must be applied during fitting to ensure that the order of sides chosen is not altered, and hence that the correct definition of angles is preserved. For the default choice shown here, that means ensuring that the inequality $A < B < C$ is not violated,  The calculation will not report an error, but the results may be not correct. .. figure:: img/parallelepiped_angle_definition.png Definition of the angles for oriented core-shell parallelepipeds. Note that rotation $\theta$, initially in the $xz$ plane, is carried Note that rotation $\theta$, initially in the $x-z$ plane, is carried out first, then rotation $\phi$ about the $z$ axis, finally rotation $\Psi$ is now around the axis of the cylinder. The neutron or X-ray beam is along the $z$ axis. $\Psi$ is now around the $C$ axis of the particle. The neutron or X-ray beam is along the $z$ axis and the detecotr defines the $x-y$ plane. .. figure:: img/parallelepiped_angle_projection.png Examples of the angles for oriented core-shell parallelepipeds against the detector plane. Validation ---------- Cross-checked against hollow rectangular prism and rectangular prism for equal thickness overlapping sides, and by Monte Carlo sampling of points within the shape for non-uniform, non-overlapping sides. References * **Author:** NIST IGOR/DANSE **Date:** pre 2010 * **Converted to sasmodels by:** Miguel Gonzales **Date:** February 26, 2016 * **Converted to sasmodels by:** Miguel Gonzalez **Date:** February 26, 2016 * **Last Modified by:** Paul Kienzle **Date:** October 17, 2017 * Cross-checked against hollow rectangular prism and rectangular prism for equal thickness overlapping sides, and by Monte Carlo sampling of points within the shape for non-uniform, non-overlapping sides. * **Last Reviewed by:** Paul Butler **Date:** May 24, 2018 - documentation updated """
• ## sasmodels/models/parallelepiped.c

 r108e70e inner_total += GAUSS_W[j] * square(si1 * si2); } // now complete change of inner integration variable (1-0)/(1-(-1))= 0.5 inner_total *= 0.5; outer_total += GAUSS_W[i] * inner_total * si * si; } // now complete change of outer integration variable (1-0)/(1-(-1))= 0.5 outer_total *= 0.5;

 ref07e95 # Note: model title and parameter table are inserted automatically r""" The form factor is normalized by the particle volume. For information about polarised and magnetic scattering, see the :ref:magnetism documentation. Definition ---------- This model calculates the scattering from a rectangular parallelepiped (\:numref:parallelepiped-image\). If you need to apply polydispersity, see also :ref:rectangular-prism. This model calculates the scattering from a rectangular solid (:numref:parallelepiped-image). If you need to apply polydispersity, see also :ref:rectangular-prism. For information about polarised and magnetic scattering, see the :ref:magnetism documentation. .. _parallelepiped-image: The three dimensions of the parallelepiped (strictly here a cuboid) may be given in *any* size order. To avoid multiple fit solutions, especially with Monte-Carlo fit methods, it may be advisable to restrict their ranges. There may be a number of closely similar "best fits", so some trial and error, or fixing of some dimensions at expected values, may help. The 1D scattering intensity $I(q)$ is calculated as: given in *any* size order as long as the particles are randomly oriented (i.e. take on all possible orientations see notes on 2D below). To avoid multiple fit solutions, especially with Monte-Carlo fit methods, it may be advisable to restrict their ranges. There may be a number of closely similar "best fits", so some trial and error, or fixing of some dimensions at expected values, may help. The form factor is normalized by the particle volume and the 1D scattering intensity $I(q)$ is then calculated as: .. Comment by Miguel Gonzalez: I(q) = \frac{\text{scale}}{V} (\Delta\rho \cdot V)^2 \left< P(q, \alpha) \right> + \text{background} \left< P(q, \alpha, \beta) \right> + \text{background} where the volume $V = A B C$, the contrast is defined as $\Delta\rho = \rho_\text{p} - \rho_\text{solvent}$, $P(q, \alpha)$ is the form factor corresponding to a parallelepiped oriented at an angle $\alpha$ (angle between the long axis C and $\vec q$), and the averaging $\left<\ldots\right>$ is applied over all orientations. $\Delta\rho = \rho_\text{p} - \rho_\text{solvent}$, $P(q, \alpha, \beta)$ is the form factor corresponding to a parallelepiped oriented at an angle $\alpha$ (angle between the long axis C and $\vec q$), and $\beta$ (the angle between the projection of the particle in the $xy$ detector plane and the $y$ axis) and the averaging $\left<\ldots\right>$ is applied over all orientations. Assuming $a = A/B < 1$, $b = B /B = 1$, and $c = C/B > 1$, the form factor is given by (Mittelbach and Porod, 1961) form factor is given by (Mittelbach and Porod, 1961 [#Mittelbach]_) .. math:: \mu &= qB The scattering intensity per unit volume is returned in units of |cm^-1|. NB: The 2nd virial coefficient of the parallelepiped is calculated based on the averaged effective radius, after appropriately sorting the three dimensions, to give an oblate or prolate particle, $(=\sqrt{AB/\pi})$ and length $(= C)$ values, and used as the effective radius for $S(q)$ when $P(q) \cdot S(q)$ is applied. For 2d data the orientation of the particle is required, described using angles $\theta$, $\phi$ and $\Psi$ as in the diagrams below, for further details of the calculation and angular dispersions see :ref:orientation . .. Comment by Miguel Gonzalez: The following text has been commented because I think there are two mistakes. Psi is the rotational angle around C (but I cannot understand what it means against the q plane) and psi=0 corresponds to a||x and b||y. The angle $\Psi$ is the rotational angle around the $C$ axis against the $q$ plane. For example, $\Psi = 0$ when the $B$ axis is parallel to the $x$-axis of the detector. The angle $\Psi$ is the rotational angle around the $C$ axis. For $\theta = 0$ and $\phi = 0$, $\Psi = 0$ corresponds to the $B$ axis oriented parallel to the y-axis of the detector with $A$ along the x-axis. For other $\theta$, $\phi$ values, the parallelepiped has to be first rotated $\theta$ degrees in the $z-x$ plane and then $\phi$ degrees around the $z$ axis, before doing a final rotation of $\Psi$ degrees around the resulting $C$ axis of the particle to obtain the final orientation of the parallelepiped. .. _parallelepiped-orientation: .. figure:: img/parallelepiped_angle_definition.png Definition of the angles for oriented parallelepiped, shown with $A • ## doc/guide/magnetism/magnetism.rst  r4f5afc9 .. math:: -- &= ((1-u_i)(1-u_f))^{1/4} \\ -+ &= ((1-u_i)(u_f))^{1/4} \\ +- &= ((u_i)(1-u_f))^{1/4} \\ ++ &= ((u_i)(u_f))^{1/4} -- &= (1-u_i)(1-u_f) \\ -+ &= (1-u_i)(u_f) \\ +- &= (u_i)(1-u_f) \\ ++ &= (u_i)(u_f) Ideally the experiment would measure the pure spin states independently and | 2015-05-02 Steve King | 2017-11-15 Paul Kienzle | 2018-06-02 Adam Washington • ## doc/guide/plugin.rst  r7e6bc45e :code:source = ["lib/Si.c", ...] (Si.c _) (Si.c _) sas_3j1x_x(x): • ## sasmodels/compare.py  r1fbadb2 def make_data(opts): # type: (Dict[str, Any]) -> Tuple[Data, np.ndarray] # type: (Dict[str, Any], float) -> Tuple[Data, np.ndarray] """ Generate an empty dataset, used with the model to set Q points if opts['zero']: q = np.hstack((0, q)) data = empty_data1D(q, resolution=res) # TODO: provide command line control of lambda and Delta lambda/lambda #L, dLoL = 5, 0.14/np.sqrt(6) # wavelength and 14% triangular FWHM L, dLoL = 0, 0 data = empty_data1D(q, resolution=res, L=L, dL=L*dLoL) index = slice(None, None) return data, index base_n, comp_n = opts['count'] base_pars, comp_pars = opts['pars'] data = opts['data'] base_data, comp_data = opts['data'] comparison = comp is not None print("%s t=%.2f ms, intensity=%.0f" % (base.engine, base_time, base_value.sum())) _show_invalid(data, base_value) _show_invalid(base_data, base_value) except ImportError: traceback.print_exc() print("%s t=%.2f ms, intensity=%.0f" % (comp.engine, comp_time, comp_value.sum())) _show_invalid(data, comp_value) _show_invalid(base_data, comp_value) except ImportError: traceback.print_exc() have_base, have_comp = (base_value is not None), (comp_value is not None) base, comp = opts['engines'] data = opts['data'] base_data, comp_data = opts['data'] use_data = (opts['datafile'] is not None) and (have_base ^ have_comp) # Plot if requested view = opts['view'] #view = 'log' if limits is None: vmin, vmax = np.inf, -np.inf if have_comp: plt.subplot(131) plot_theory(data, base_value, view=view, use_data=use_data, limits=limits) plot_theory(base_data, base_value, view=view, use_data=use_data, limits=limits) plt.title("%s t=%.2f ms"%(base.engine, base_time)) #cbar_title = "log I" plt.subplot(132) if not opts['is2d'] and have_base: plot_theory(data, base_value, view=view, use_data=use_data, limits=limits) plot_theory(data, comp_value, view=view, use_data=use_data, limits=limits) plot_theory(comp_data, base_value, view=view, use_data=use_data, limits=limits) plot_theory(comp_data, comp_value, view=view, use_data=use_data, limits=limits) plt.title("%s t=%.2f ms"%(comp.engine, comp_time)) #cbar_title = "log I" err[err > cutoff] = cutoff #err,errstr = base/comp,"ratio" plot_theory(data, None, resid=err, view=errview, use_data=use_data) # Note: base_data only since base and comp have same q values (though # perhaps different resolution), and we are plotting the difference # at each q plot_theory(base_data, None, resid=err, view=errview, use_data=use_data) plt.xscale('log' if view == 'log' and not opts['is2d'] else 'linear') plt.legend(['P%d'%(k+1) for k in range(setnum+1)], loc='best') 'qmax' : 0.05, 'nq' : 128, 'res' : 0.0, 'res' : '0.0', 'noise' : 0.0, 'accuracy' : 'Low', elif arg.startswith('-q='): opts['qmin'], opts['qmax'] = [float(v) for v in arg[3:].split(':')] elif arg.startswith('-res='): opts['res'] = float(arg[5:]) elif arg.startswith('-res='): opts['res'] = arg[5:] elif arg.startswith('-noise='): opts['noise'] = float(arg[7:]) elif arg.startswith('-sets='): opts['sets'] = int(arg[6:]) if opts['qmin'] is None: opts['qmin'] = 0.001*opts['qmax'] if opts['datafile'] is not None: data = load_data(os.path.expanduser(opts['datafile'])) else: data, _ = make_data(opts) comparison = any(PAR_SPLIT in v for v in values) opts['cutoff'] = [float(opts['cutoff'])]*2 base = make_engine(model_info[0], data, opts['engine'][0], if PAR_SPLIT in opts['res']: opts['res'] = [float(k) for k in opts['res'].split(PAR_SPLIT, 2)] comparison = True else: opts['res'] = [float(opts['res'])]*2 if opts['datafile'] is not None: data = load_data(os.path.expanduser(opts['datafile'])) else: # Hack around the fact that make_data doesn't take a pair of resolutions res = opts['res'] opts['res'] = res[0] data0, _ = make_data(opts) if res[0] != res[1]: opts['res'] = res[1] data1, _ = make_data(opts) else: data1 = data0 opts['res'] = res data = data0, data1 base = make_engine(model_info[0], data[0], opts['engine'][0], opts['cutoff'][0], opts['ngauss'][0]) if comparison: comp = make_engine(model_info[1], data, opts['engine'][1], comp = make_engine(model_info[1], data[1], opts['engine'][1], opts['cutoff'][1], opts['ngauss'][1]) else: • ## sasmodels/data.py  rd86f0fc import numpy as np # type: ignore from numpy import sqrt, sin, cos, pi # pylint: disable=unused-import def empty_data1D(q, resolution=0.0): def empty_data1D(q, resolution=0.0, L=0., dL=0.): # type: (np.ndarray, float) -> Data1D """ r""" Create empty 1D data using the given *q* as the x value. *resolution* dq/q defaults to 5%. rms *resolution*$\Delta q/q$defaults to 0%. If wavelength *L* and rms wavelength divergence *dL* are defined, then *resolution* defines rms$\Delta \theta/\theta$for the lowest *q*, with$\theta$derived from$q = 4\pi/\lambda \sin(\theta)$. """ Iq, dIq = None, None q = np.asarray(q) data = Data1D(q, Iq, dx=resolution * q, dy=dIq) if L != 0 and resolution != 0: theta = np.arcsin(q*L/(4*pi)) dtheta = theta[0]*resolution ## Solving Gaussian error propagation from ## Dq^2 = (dq/dL)^2 DL^2 + (dq/dtheta)^2 Dtheta^2 ## gives ## (Dq/q)^2 = (DL/L)**2 + (Dtheta/tan(theta))**2 ## Take the square root and multiply by q, giving ## Dq = (4*pi/L) * sqrt((sin(theta)*dL/L)**2 + (cos(theta)*dtheta)**2) dq = (4*pi/L) * sqrt((sin(theta)*dL/L)**2 + (cos(theta)*dtheta)**2) else: dq = resolution * q data = Data1D(q, Iq, dx=dq, dy=dIq) data.filename = "fake data" return data • ## sasmodels/jitter.py  rb3703f5 # set small jitter as 0 if multiple pd dims dims = sum(v > 0 for v in jitter) limit = [0, 0, 0.5, 5][dims] limit = [0, 0.5, 5][dims] jitter = [0 if v < limit else v for v in jitter] axes.cla() • ## sasmodels/kernel_iq.c  rdc6f601 in_spin = clip(in_spin, 0.0, 1.0); out_spin = clip(out_spin, 0.0, 1.0); // Note: sasview 3.1 scaled all slds by sqrt(weight) and assumed that // Previous version of this function took the square root of the weights, // under the assumption that // // w*I(q, rho1, rho2, ...) = I(q, sqrt(w)*rho1, sqrt(w)*rho2, ...) // which is likely to be the case for simple models. weight[0] = sqrt((1.0-in_spin) * (1.0-out_spin)); // dd weight[1] = sqrt((1.0-in_spin) * out_spin); // du.real weight[2] = sqrt(in_spin * (1.0-out_spin)); // ud.real weight[3] = sqrt(in_spin * out_spin); // uu // // However, since the weights are applied to the final intensity and // are not interned inside the I(q) function, we want the full // weight and not the square root. Any function using // set_spin_weights as part of calculating an amplitude will need to // manually take that square root, but there is currently no such // function. weight[0] = (1.0-in_spin) * (1.0-out_spin); // dd weight[1] = (1.0-in_spin) * out_spin; // du weight[2] = in_spin * (1.0-out_spin); // ud weight[3] = in_spin * out_spin; // uu weight[4] = weight[1]; // du.imag weight[5] = weight[2]; // ud.imag • ## sasmodels/models/mass_surface_fractal.py  r2d81cfe The surface ($D_s$) and mass ($D_m$) fractal dimensions are only valid if$0 < surface\_dim < 6$,$0 < mass\_dim < 6$, and$(surface\_dim + mass\_dim ) < 6$.$(surface\_dim + mass\_dim ) < 6$. Older versions of sasview may have the default primary particle radius larger than the cluster radius, this was an error, also present in the Schmidt review paper below. The primary particle should be the smaller as described in the original Hurd et.al. who also point out that polydispersity in the primary particle sizes may affect their apparent surface fractal dimension. References ---------- P Schmidt, *J Appl. Cryst.*, 24 (1991) 414-435 Equation(19) .. [#] P Schmidt, *J Appl. Cryst.*, 24 (1991) 414-435 Equation(19) .. [#] A J Hurd, D W Schaefer, J E Martin, *Phys. Rev. A*, 35 (1987) 2361-2364 Equation(2) A J Hurd, D W Schaefer, J E Martin, *Phys. Rev. A*, 35 (1987) 2361-2364 Equation(2) Authorship and Verification ---------------------------- * **Converted to sasmodels by:** Piotr Rozyczko **Date:** Jan 20, 2016 * **Last Reviewed by:** Richard Heenan **Date:** May 30, 2018 """ rg_primary = rg background = background Ref: Schmidt, J Appl Cryst, eq(19), (1991), 24, 414-435 Hurd, Schaefer, Martin, Phys Rev A, eq(2),(1987),35, 2361-2364 Note that 0 < Ds< 6 and 0 < Dm < 6. ["fractal_dim_mass", "", 1.8, [0.0, 6.0], "", "Mass fractal dimension"], ["fractal_dim_surf", "", 2.3, [0.0, 6.0], "", "Surface fractal dimension"], ["rg_cluster", "Ang", 86.7, [0.0, inf], "", "Cluster radius of gyration"], ["rg_primary", "Ang", 4000., [0.0, inf], "", "Primary particle radius of gyration"], ["rg_cluster", "Ang", 4000., [0.0, inf], "", "Cluster radius of gyration"], ["rg_primary", "Ang", 86.7, [0.0, inf], "", "Primary particle radius of gyration"], ] # pylint: enable=bad-whitespace, line-too-long fractal_dim_mass=1.8, fractal_dim_surf=2.3, rg_cluster=86.7, rg_primary=4000.0) rg_cluster=4000.0, rg_primary=86.7) tests = [ # Accuracy tests based on content in test/utest_other_models.py [{'fractal_dim_mass': 1.8, # Accuracy tests based on content in test/utest_other_models.py All except first, changed so rg_cluster is the larger, RKH 30 May 2018 [{'fractal_dim_mass': 1.8, 'fractal_dim_surf': 2.3, 'rg_cluster': 86.7, [{'fractal_dim_mass': 3.3, 'fractal_dim_surf': 1.0, 'rg_cluster': 90.0, 'rg_primary': 4000.0, }, 0.001, 0.18562699016], 'rg_cluster': 4000.0, 'rg_primary': 90.0, }, 0.001, 0.0932516614456], [{'fractal_dim_mass': 1.3, 'fractal_dim_surf': 1.0, 'rg_cluster': 90.0, 'rg_primary': 2000.0, 'fractal_dim_surf': 2.0, 'rg_cluster': 2000.0, 'rg_primary': 90.0, 'background': 0.8, }, 0.001, 1.16539753641], }, 0.001, 1.28296431786], [{'fractal_dim_mass': 2.3, 'fractal_dim_surf': 1.0, 'rg_cluster': 90.0, 'rg_primary': 1000.0, 'fractal_dim_surf': 3.1, 'rg_cluster': 1000.0, 'rg_primary': 30.0, 'scale': 10.0, 'background': 0.0, }, 0.051, 0.000169548800377], }, 0.051, 0.00333804044899], ] • ## sasmodels/resolution.py  r2d81cfe MINIMUM_RESOLUTION = 1e-8 MINIMUM_ABSOLUTE_Q = 0.02 # relative to the minimum q in the data PINHOLE_N_SIGMA = 2.5 # From: Barker & Pedersen 1995 JAC class Resolution(object): *q_calc* is the list of points to calculate, or None if this should be estimated from the *q* and *q_width*. """ def __init__(self, q, q_width, q_calc=None, nsigma=3): *nsigma* is the width of the resolution function. Should be 2.5. See :func:pinhole_resolution for details. """ def __init__(self, q, q_width, q_calc=None, nsigma=PINHOLE_N_SIGMA): #*min_step* is the minimum point spacing to use when computing the #underlying model. It should be on the order of # Protect against models which are not defined for very low q. Limit # the smallest q value evaluated (in absolute) to 0.02*min # the smallest q value evaluated to 0.02*min. Note that negative q # values are trimmed even for broad resolution. Although not possible # from the geometry, they may appear since we are using a truncated # gaussian to represent resolution rather than a skew distribution. cutoff = MINIMUM_ABSOLUTE_Q*np.min(self.q) self.q_calc = self.q_calc[abs(self.q_calc) >= cutoff] self.q_calc = self.q_calc[self.q_calc >= cutoff] # Build weight matrix from calculated q values self.weight_matrix = pinhole_resolution( self.q_calc, self.q, np.maximum(q_width, MINIMUM_RESOLUTION)) self.q_calc = abs(self.q_calc) self.q_calc, self.q, np.maximum(q_width, MINIMUM_RESOLUTION), nsigma=nsigma) def apply(self, theory): *q* points at which the data is measured. *dqx* slit width in qx *dqy* slit height in qy *qx_width* slit width in qx *qy_width* slit height in qy *q_calc* is the list of points to calculate, or None if this should def pinhole_resolution(q_calc, q, q_width): """ def pinhole_resolution(q_calc, q, q_width, nsigma=PINHOLE_N_SIGMA): r""" Compute the convolution matrix *W* for pinhole resolution 1-D data. *W*, the resolution smearing can be computed using *dot(W,q)*. Note that resolution is limited to$\pm 2.5 \sigma$.[1] The true resolution function is a broadened triangle, and does not extend over the entire range$(-\infty, +\infty)\$.  It is important to impose this limitation since some models fall so steeply that the weighted value in gaussian tails would otherwise dominate the integral. *q_calc* must be increasing.  *q_width* must be greater than zero. [1] Barker, J. G., and J. S. Pedersen. 1995. Instrumental Smearing Effects in Radially Symmetric Small-Angle Neutron Scattering by Numerical and Analytical Methods. Journal of Applied Crystallography 28 (2): 105--14. https://doi.org/10.1107/S0021889894010095. """ # The current algorithm is a midpoint rectangle rule.  In the test case, cdf = erf((edges[:, None] - q[None, :]) / (sqrt(2.0)*q_width)[None, :]) weights = cdf[1:] - cdf[:-1] # Limit q range to +/- 2.5 sigma qhigh = q + nsigma*q_width #qlow = q - nsigma*q_width  # linear limits qlow = q*q/qhigh  # log limits weights[q_calc[:, None] < qlow[None, :]] = 0. weights[q_calc[:, None] > qhigh[None, :]] = 0. weights /= np.sum(weights, axis=0)[None, :] return weights def gaussian(q, q0, dq): """ Return the Gaussian resolution function. def gaussian(q, q0, dq, nsigma=2.5): """ Return the truncated Gaussian resolution function. *q0* is the center, *dq* is the width and *q* are the points to evaluate. """ return exp(-0.5*((q-q0)/dq)**2)/(sqrt(2*pi)*dq) # Calculate the density of the tails; the resulting gaussian needs to be # scaled by this amount in ordere to integrate to 1.0 two_tail_density = 2 * (1 + erf(-nsigma/sqrt(2)))/2 return exp(-0.5*((q-q0)/dq)**2)/(sqrt(2*pi)*dq)/(1-two_tail_density) def romberg_pinhole_1d(q, q_width, form, pars, nsigma=5): def romberg_pinhole_1d(q, q_width, form, pars, nsigma=2.5): """ Romberg integration for pinhole resolution. np.testing.assert_equal(output, self.y) # TODO: turn pinhole/slit demos into tests @unittest.skip("suppress comparison with old version; pinhole calc changed") def test_pinhole(self): """ theory = 12.0-1000.0*resolution.q_calc output = resolution.apply(theory) # Note: answer came from output of previous run.  Non-integer # values at ends come from the fact that q_calc does not # extend beyond q, and so the weights don't balance. answer = [ 10.44785079, 9.84991299, 8.98101708, 7.99906585, 6.99998311, 6.00001689, 5.00093415, 4.01898292, 3.15008701, 2.55214921, 10.47037734, 9.86925860, 9., 8., 7., 6., 5., 4., 3.13074140, 2.52962266, ] np.testing.assert_allclose(output, answer, atol=1e-8) self._compare(q, output, answer, 1e-6) @unittest.skip("suppress comparison with old version; pinhole calc changed") def test_pinhole(self): """ self._compare(q, output, answer, 3e-4) @unittest.skip("suppress comparison with old version; pinhole calc changed") def test_pinhole_romberg(self): """ #                     2*np.pi/pars['radius']/200) #tol = 0.001 ## The default 3 sigma and no extra points gets 1% ## The default 2.5 sigma and no extra points gets 1% q_calc = None  # type: np.ndarray tol = 0.01 if isinstance(resolution, Slit1D): width, height = resolution.dqx, resolution.dqy width, height = resolution.qx_width, resolution.qy_width Iq_romb = romberg_slit_1d(resolution.q, width, height, model, pars) else:
Note: See TracChangeset for help on using the changeset viewer.