Changeset 830cf6b in sasmodels


Ignore:
Timestamp:
Mar 28, 2019 5:48:37 PM (8 weeks ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
master, ticket-1257-vesicle-product, ticket_1156, ticket_822_more_unit_tests
Children:
b2f0e5d, abe4255
Parents:
e220acc (diff), 62dc889 (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.
Message:

Merge branch 'master' into ticket_822_v5_unit_tests

Files:
84 edited
1 moved

Legend:

Unmodified
Added
Removed
  • sasmodels/models/core_shell_ellipsoid.py

    rdb1d9d5 r830cf6b  
    4747 
    4848.. In following equation SK changed radius\_equat\_core to R_e 
    49  
    5049.. math:: 
    5150    :nowrap: 
  • sasmodels/models/flexible_cylinder.py

    rdb1d9d5 r830cf6b  
    4141    pseudocontinuous limit. 
    4242    See equations (13,26-27) in the original reference for the details. 
     43 
     44.. note:: 
     45 
     46    There are several typos in the original reference that have been corrected 
     47    by WRC [2]. Details of the corrections are in the reference below. Most notably 
     48 
     49    - Equation (13): the term $(1 - w(QR))$ should swap position with $w(QR)$ 
     50 
     51    - Equations (23) and (24) are incorrect; WRC has entered these into 
     52      Mathematica and solved analytically. The results were then converted to 
     53      code. 
     54 
     55    - Equation (27) should be $q0 = max(a3/(Rg^2)^{1/2},3)$ instead of 
     56      $max(a3*b(Rg^2)^{1/2},3)$ 
     57 
     58    - The scattering function is negative for a range of parameter values and 
     59      q-values that are experimentally accessible. A correction function has been 
     60      added to give the proper behavior. 
     61 
     62 
     63**This is a model with complex behaviour depending on the ratio of** $L/b$ **and the 
     64reader is strongly encouraged to read reference [1] before use.** 
    4365 
    4466.. note:: 
  • doc/guide/plugin.rst

    rc94ab04 rdb1d9d5  
    303303**Note: The order of the parameters in the definition will be the order of the 
    304304parameters in the user interface and the order of the parameters in Fq(), Iq(), 
    305 Iqac(), Iqabc(), form_volume() and shell_volume(). 
     305Iqac(), Iqabc(), radius_effective(), form_volume() and shell_volume(). 
    306306And** *scale* **and** *background* **parameters are implicit to all models, 
    307307so they do not need to be included in the parameter table.** 
     
    387387can take arbitrary values, even for integer parameters, so your model should 
    388388round the incoming parameter value to the nearest integer inside your model 
    389 you should round to the nearest integer.  In C code, you can do this using:: 
     389you should round to the nearest integer.  In C code, you can do this using: 
     390 
     391.. code-block:: c 
    390392 
    391393    static double 
     
    499501Models should define *form_volume(par1, par2, ...)* where the parameter 
    500502list includes the *volume* parameters in order.  This is used for a weighted 
    501 volume normalization so that scattering is on an absolute scale.  If 
    502 *form_volume* is not defined, then the default *form_volume = 1.0* will be 
    503 used. 
     503volume normalization so that scattering is on an absolute scale.  For 
     504solid shapes, the *I(q)* function should use *form_volume* squared 
     505as its scale factor.  If *form_volume* is not defined, then the default 
     506*form_volume = 1.0* will be used. 
    504507 
    505508Hollow shapes, where the volume fraction of particle corresponds to the 
    506509material in the shell rather than the volume enclosed by the shape, must 
    507510also define a *shell_volume(par1, par2, ...)* function.  The parameters 
    508 are the same as for *form_volume*.  The *I(q)* calculation should use 
    509 *shell_volume* squared as its scale factor for the volume normalization. 
    510 The structure factor calculation needs *form_volume* in order to properly 
    511 scale the volume fraction parameter, so both functions are required for 
    512 hollow shapes. 
     511are the same as for *form_volume*.  Here the *I(q)* function should use 
     512*shell_volume* squared instead of *form_volume* squared so that the scale 
     513parameter corresponds to the volume fraction of material in the sample. 
     514The structure factor calculation needs the volume fraction of the filled 
     515shapes for its calculation, so the volume fraction parameter in the model 
     516is automatically scaled by *form_volume/shell_volume* prior to calling the 
     517structure factor. 
    513518 
    514519**Note: Pure python models do not yet support direct computation of the** 
     
    525530    """ 
    526531 
    527 This expands into the equivalent C code:: 
     532This expands into the equivalent C code: 
     533 
     534.. code-block:: c 
    528535 
    529536    double Iq(double q, double par1, double par2, ...); 
     
    536543includes only the volume parameters. 
    537544 
    538 *form_volume* defines the volume of the shell for hollow shapes. As in 
     545*shell_volume* defines the volume of the shell for hollow shapes. As in 
    539546python models, it includes only the volume parameters. 
    540547 
     
    568575Rather than returning NAN from Iq, you must define the *INVALID(v)*.  The 
    569576*v* parameter lets you access all the parameters in the model using 
    570 *v.par1*, *v.par2*, etc. For example:: 
     577*v.par1*, *v.par2*, etc. For example: 
     578 
     579.. code-block:: c 
    571580 
    572581    #define INVALID(v) (v.bell_radius < v.radius) 
     
    583592 
    584593Instead of defining the *Iq* function, models can define *Fq* as 
    585 something like:: 
     594something like: 
     595 
     596.. code-block:: c 
    586597 
    587598    double Fq(double q, double *F1, double *F2, double par1, double par2, ...); 
     
    615626laboratory frame and beam travelling along $-z$. 
    616627 
    617 The oriented C model (oriented pure Python models are not supported)  
     628The oriented C model (oriented pure Python models are not supported) 
    618629is called using *Iqabc(qa, qb, qc, par1, par2, ...)* where 
    619630*par1*, etc. are the parameters to the model.  If the shape is rotationally 
     
    644655 
    645656Using the $z, w$ values for Gauss-Legendre integration in "lib/gauss76.c", the 
    646 numerical integration is then:: 
     657numerical integration is then: 
     658 
     659.. code-block:: c 
    647660 
    648661    double outer_sum = 0.0; 
     
    9871000  memory, and wrong answers computed. The conclusion from a very long and 
    9881001  strange debugging session was that any arrays that you declare in your 
    989   model should be a multiple of four. For example:: 
     1002  model should be a multiple of four. For example: 
     1003 
     1004  .. code-block:: c 
    9901005 
    9911006      double Iq(q, p1, p2, ...) 
     
    10191034structure factor is the *hardsphere* interaction, which 
    10201035uses the effective radius of the form factor as an input to the structure 
    1021 factor model.  The effective radius is the average radius of the 
    1022 form averaged over all the polydispersity values. 
    1023  
    1024 :: 
    1025  
    1026     def ER(radius, thickness): 
    1027         """Effective radius of a core-shell sphere.""" 
    1028         return radius + thickness 
    1029  
    1030 Now consider the *core_shell_sphere*, which has a simple effective radius 
    1031 equal to the radius of the core plus the thickness of the shell, as 
    1032 shown above. Given polydispersity over *(r1, r2, ..., rm)* in radius and 
    1033 *(t1, t2, ..., tn)* in thickness, *ER* is called with a mesh 
    1034 grid covering all possible combinations of radius and thickness. 
    1035 That is, *radius* is *(r1, r2, ..., rm, r1, r2, ..., rm, ...)* 
    1036 and *thickness* is *(t1, t1, ... t1, t2, t2, ..., t2, ...)*. 
    1037 The *ER* function returns one effective radius for each combination. 
    1038 The effective radius calculator weights each of these according to 
    1039 the polydispersity distributions and calls the structure factor 
    1040 with the average *ER*. 
    1041  
    1042 :: 
    1043  
    1044     def VR(radius, thickness): 
    1045         """Sphere and shell volumes for a core-shell sphere.""" 
    1046         whole = 4.0/3.0 * pi * (radius + thickness)**3 
    1047         core = 4.0/3.0 * pi * radius**3 
    1048         return whole, whole - core 
    1049  
    1050 Core-shell type models have an additional volume ratio which scales 
    1051 the structure factor.  The *VR* function returns the volume of 
    1052 the whole sphere and the volume of the shell. Like *ER*, there is 
    1053 one return value for each point in the mesh grid. 
    1054  
    1055 *NOTE: we may be removing or modifying this feature soon. As of the 
    1056 time of writing, core-shell sphere returns (1., 1.) for VR, giving a volume 
    1057 ratio of 1.0.* 
     1036factor model.  The effective radius is the weighted average over all 
     1037values of the shape in polydisperse systems. 
     1038 
     1039There can be many notions of effective radius, depending on the shape.  For 
     1040a sphere it is clearly just the radius, but for an ellipsoid of revolution 
     1041we provide average curvature, equivalent sphere radius, minimum radius and 
     1042maximum radius.  These options are listed as *radius_effective_modes* in 
     1043the python model defintion, and must be computed by the *radius_effective* 
     1044function which takes the *radius_effective_mode* parameter as an integer, 
     1045along with the various model parameters.  Unlike normal C/Python arrays, 
     1046the first mode is 1, the second is 2, etc.  Mode 0 indicates that the 
     1047effective radius from the shape is to be ignored in favour of the the 
     1048effective radius parameter in the structure factor model. 
     1049 
     1050 
     1051Consider the core-shell sphere, which defines the following effective radius 
     1052modes in the python model:: 
     1053 
     1054    radius_effective_modes = [ 
     1055        "outer radius", 
     1056        "core radius", 
     1057    ] 
     1058 
     1059and the following function in the C-file for the model: 
     1060 
     1061.. code-block:: c 
     1062 
     1063    static double 
     1064    radius_effective(int mode, double radius, double thickness) 
     1065    { 
     1066        switch (mode) { 
     1067            case 0: return radius + thickness; 
     1068            case 1: return radius; 
     1069            default: return 0.; 
     1070        } 
     1071    } 
     1072 
     1073    static double 
     1074    form_volume(double radius, double thickness) 
     1075    { 
     1076        return M_4PI_3 * cube(radius + thickness); 
     1077    } 
     1078 
     1079Given polydispersity over *(r1, r2, ..., rm)* in radius and *(t1, t2, ..., tn)* 
     1080in thickness, *radius_effective* is called over a mesh grid covering all 
     1081possible combinations of radius and thickness, with a single *(ri, tj)* pair 
     1082in each call. The weights each of these results according to the 
     1083polydispersity distributions and calls the structure factor with the average 
     1084effective radius.  Similarly, for *form_volume*. 
     1085 
     1086Hollow models have an additional volume ratio which is needed to scale the 
     1087structure factor.  The structure factor uses the volume fraction of the filled 
     1088particles as part of its density estimate, but the scale factor for the 
     1089scattering intensity (as non-solvent volume fraction / volume) is determined 
     1090by the shell volume only.  Therefore the *shell_volume* function is 
     1091needed to compute the form:shell volume ratio, which then scales the 
     1092*volfraction* parameter prior to calling the structure factor calculator. 
     1093In the case of a hollow sphere, this would be: 
     1094 
     1095.. code-block:: c 
     1096 
     1097    static double 
     1098    shell_volume(double radius, double thickness) 
     1099    { 
     1100        double whole = M_4PI_3 * cube(radius + thickness); 
     1101        double core = M_4PI_3 * cube(radius); 
     1102        return whole - core; 
     1103    } 
     1104 
     1105If *shell_volume* is not present, then *form_volume* and *shell_volume* are 
     1106assumed to be equal, and the shape is considered solid. 
    10581107 
    10591108Unit Tests 
     
    11151164................... 
    11161165 
    1117 **NB: For now, this more detailed testing is only possible if you have a  
     1166**NB: For now, this more detailed testing is only possible if you have a 
    11181167SasView build environment available!** 
    11191168 
     
    12531302| 2016-10-25 Steve King 
    12541303| 2017-05-07 Paul Kienzle - Moved from sasview to sasmodels docs 
     1304| 2019-03-28 Paul Kienzle - Update docs for radius_effective and shell_volume 
  • doc/guide/resolution.rst

    r8d2df05 rdb1d9d5  
    11.. resolution.rst 
    22 
    3 .. This is a port of the original SasView html help file sm_help to ReSTructured  
     3.. This is a port of the original SasView html help file sm_help to ReSTructured 
    44.. text by S King, ISIS, during SasView CodeCamp-III in Feb 2015. 
    55 
     
    1717resolution contribution into a model calculation/simulation (which by definition 
    1818will be exact) to make it more representative of what has been measured 
    19 experimentally - a process called *smearing*. The Sasmodels component of SasView  
     19experimentally - a process called *smearing*. The Sasmodels component of SasView 
    2020does the latter. 
    2121 
     
    3232 
    3333.. note:: 
    34     Problems may be encountered if the data set loaded by SasView is a  
    35     concatenation of SANS data from several detector distances where, of  
    36     course, the worst Q resolution is next to the beam stop at each detector  
    37     distance. (This will also be noticeable in the residuals plot where  
    38     there will be poor overlap). SasView sensibly orders all the input  
    39     data points by increasing Q for nicer-looking plots, however, the dQ  
    40     data can then vary considerably from point to point. If 'Use dQ data'  
    41     smearing is selected then spikes may appear in the model fits, whereas  
     34    Problems may be encountered if the data set loaded by SasView is a 
     35    concatenation of SANS data from several detector distances where, of 
     36    course, the worst Q resolution is next to the beam stop at each detector 
     37    distance. (This will also be noticeable in the residuals plot where 
     38    there will be poor overlap). SasView sensibly orders all the input 
     39    data points by increasing Q for nicer-looking plots, however, the dQ 
     40    data can then vary considerably from point to point. If 'Use dQ data' 
     41    smearing is selected then spikes may appear in the model fits, whereas 
    4242    if 'None' or 'Custom Pinhole Smear' are selected the fits look normal. 
    43      
    44     In such instances, possible solutions are to simply remove the data  
    45     with poor Q resolution from the shorter detector distances, or to fit  
     43 
     44    In such instances, possible solutions are to simply remove the data 
     45    with poor Q resolution from the shorter detector distances, or to fit 
    4646    the data from different detector distances simultaneously. 
    4747 
  • explore/beta/sasfit_compare.py

    r119073a ra34b811  
    408408        #radius_effective=12.59921049894873, 
    409409        ) 
    410     target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars) 
     410    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars) 
    411411    actual = ellipsoid_pe(q, norm='sasview', **pars) 
    412412    title = " ".join(("sasmodels", model, pd_type)) 
  • explore/beta/sasfit_compare_new.py

    rb6422c7 ra34b811  
    360360#polydispersity for hollow_cylinder 
    361361def hollow_cylinder_pe(q,radius=20, thickness=10, length=80, sld=4, sld_solvent=1, volfraction=0.15, 
    362         radius_pd=0.1, thickness_pd=0.2, length_pd=0.05, radius_pd_type="gaussian", length_pd_type="gaussian",  
     362        radius_pd=0.1, thickness_pd=0.2, length_pd=0.05, radius_pd_type="gaussian", length_pd_type="gaussian", 
    363363        thickness_pd_type="gaussian", radius_effective=None, background=0, scale=1, 
    364364                 norm='sasview'): 
     
    595595#       this one is only used locally for "actual" 
    596596        ) 
    597     target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars) 
     597    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars) 
    598598    actual = sphere_r(q, norm='sasview', **pars) 
    599599    title = " ".join(("sasmodels", model, pd_type)) 
     
    612612        background=0, 
    613613        radius_pd=0.01, thickness_pd=0.01, radius_pd_type=pd_type, thickness_pd_type=pd_type, 
    614         radius_effective=30. )  
     614        radius_effective=30. ) 
    615615        # equivalent average sphere radius for local "actual" to match what sasview uses, use None to compute average outer radius here, 
    616616 
    617     target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars) 
     617    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars) 
    618618    actual = vesicle_pe(q, norm='sasview', **pars) 
    619619    title = " ".join(("sasmodels", model, pd_type)) 
     
    633633        background=0, 
    634634        radius_pd=0.1, thickness_pd=0.0, length_pd=0.0, radius_pd_type=pd_type, thickness_pd_type=pd_type, length_pd_type=pd_type, 
    635         radius_effective=40.687)   
     635        radius_effective=40.687) 
    636636        # equivalent average sphere radius for local "actual" to match what sasview uses 
    637     target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars) 
     637    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars) 
    638638    actual = hollow_cylinder_pe(q, norm='sasview', **pars) 
    639639# RKH monodisp was OK,    actual = hollow_cylinder_theta(q,radius=20, thickness=10, length=80, sld=4, sld_solvent=1 ) 
     
    656656# if change radius_effective to some other value, the S(Q) from sasview does not agree 
    657657        ) 
    658     target = sasmodels_theory(q, model, effective_radius_mode=0, structure_factor_mode=1, **pars) 
     658    target = sasmodels_theory(q, model, radius_effective_mode=0, structure_factor_mode=1, **pars) 
    659659    actual = ellipsoid_pe(q, norm='sasview', **pars) 
    660660# RKH test       actual = ellipsoid_theta(q, radius_polar=20, radius_equatorial=400, sld=4, sld_solvent=1, volfraction=0.15, radius_effective=270.) 
  • sasmodels/core.py

    rb297ba9 r9562dd2  
    376376    # type: () -> None 
    377377    """Check that model load works""" 
     378    from .product import RADIUS_ID, VOLFRAC_ID, STRUCTURE_MODE_ID, RADIUS_MODE_ID 
    378379    #Test the the model produces the parameters that we would expect 
    379380    model = load_model("cylinder@hardsphere*sphere") 
    380381    actual = [p.name for p in model.info.parameters.kernel_parameters] 
    381     target = ("sld sld_solvent radius length theta phi" 
    382               " radius_effective volfraction " 
    383               " structure_factor_mode radius_effective_mode" 
    384               " A_sld A_sld_solvent A_radius").split() 
     382    target = ["sld", "sld_solvent", "radius", "length", "theta", "phi", 
     383              RADIUS_ID, VOLFRAC_ID, STRUCTURE_MODE_ID, RADIUS_MODE_ID, 
     384              "A_sld", "A_sld_solvent", "A_radius"] 
    385385    assert target == actual, "%s != %s"%(target, actual) 
    386386 
  • sasmodels/direct_model.py

    rb297ba9 re220acc  
    5959    """ 
    6060    mesh = get_mesh(calculator.info, pars, dim=calculator.dim, mono=mono) 
    61     #print("pars", list(zip(*mesh))[0]) 
     61    #print("in call_kernel: pars:", list(zip(*mesh))[0]) 
    6262    call_details, values, is_magnetic = make_kernel_args(calculator, mesh) 
    63     #print("values:", values) 
     63    #print("in call_kernel: values:", values) 
    6464    return calculator(call_details, values, cutoff, is_magnetic) 
    6565 
     
    7272 
    7373    Use parameter *radius_effective_mode* to select the effective radius 
    74     calculation. 
     74    calculation to use amongst the *radius_effective_modes* list given in the 
     75    model. 
    7576    """ 
    7677    R_eff_type = int(pars.pop(RADIUS_MODE_ID, 1.0)) 
    7778    mesh = get_mesh(calculator.info, pars, dim=calculator.dim, mono=mono) 
    78     #print("pars", list(zip(*mesh))[0]) 
     79    #print("in call_Fq: pars", list(zip(*mesh))[0]) 
    7980    call_details, values, is_magnetic = make_kernel_args(calculator, mesh) 
    80     #print("values:", values) 
     81    #print("in call_Fq: values:", values) 
    8182    return calculator.Fq(call_details, values, cutoff, is_magnetic, R_eff_type) 
    8283 
     
    118119        active = lambda name: True 
    119120 
    120     #print("pars",[p.id for p in parameters.call_parameters]) 
     121    #print("in get_mesh: pars:",[p.id for p in parameters.call_parameters]) 
    121122    mesh = [_get_par_weights(p, values, active(p.name)) 
    122123            for p in parameters.call_parameters] 
  • sasmodels/generate.py

    rb297ba9 ra34b811  
    2727    which are hollow. 
    2828 
    29     *effective_radius(mode, p1, p2, ...)* returns the effective radius of 
     29    *radius_effective(mode, p1, p2, ...)* returns the effective radius of 
    3030    the form with particular dimensions.  Mode determines the type of 
    3131    effective radius returned, with mode=1 for equivalent volume. 
     
    820820                              for p in partable.kernel_parameters)) 
    821821    # Define the function calls 
    822     call_effective_radius = "#define CALL_EFFECTIVE_RADIUS(_mode, _v) 0.0" 
     822    call_radius_effective = "#define CALL_RADIUS_EFFECTIVE(_mode, _v) 0.0" 
    823823    if partable.form_volume_parameters: 
    824824        refs = _call_pars("_v.", partable.form_volume_parameters) 
     
    833833                "do { _form = _shell = form_volume(%s); } " 
    834834                "while (0)") % (",".join(refs)) 
    835         if model_info.effective_radius_type: 
    836             call_effective_radius = ( 
    837                 "#define CALL_EFFECTIVE_RADIUS(_mode, _v) " 
    838                 "effective_radius(_mode, %s)") % (",".join(refs)) 
     835        if model_info.radius_effective_modes: 
     836            call_radius_effective = ( 
     837                "#define CALL_RADIUS_EFFECTIVE(_mode, _v) " 
     838                "radius_effective(_mode, %s)") % (",".join(refs)) 
    839839    else: 
    840840        # Model doesn't have volume.  We could make the kernel run a little 
     
    845845            "do { _form = _shell = 1.0; } while (0)") 
    846846    source.append(call_volume) 
    847     source.append(call_effective_radius) 
     847    source.append(call_radius_effective) 
    848848    model_refs = _call_pars("_v.", partable.iq_parameters) 
    849849 
  • sasmodels/kernel.py

    rb297ba9 ra34b811  
    7878        """ 
    7979        _, F2, _, shell_volume, _ = self.Fq(call_details, values, cutoff, 
    80                                             magnetic, effective_radius_type=0) 
     80                                            magnetic, radius_effective_mode=0) 
    8181        combined_scale = values[0]/shell_volume 
    8282        background = values[1] 
     
    8585 
    8686    def Fq(self, call_details, values, cutoff, magnetic, 
    87            effective_radius_type=0): 
     87           radius_effective_mode=0): 
    8888        # type: (CallDetails, np.ndarray, np.ndarray, float, bool, int) -> np.ndarray 
    8989        r""" 
     
    143143        volume fraction of the particles.  The model can have several 
    144144        different ways to compute effective radius, with the 
    145         *effective_radius_type* parameter used to select amongst them.  The 
     145        *radius_effective_mode* parameter used to select amongst them.  The 
    146146        volume fraction of particles should be determined from the total 
    147147        volume fraction of the form, not just the shell volume fraction. 
     
    153153        """ 
    154154        self._call_kernel(call_details, values, cutoff, magnetic, 
    155                           effective_radius_type) 
     155                          radius_effective_mode) 
    156156        #print("returned",self.q_input.q, self.result) 
    157157        nout = 2 if self.info.have_Fq and self.dim == '1d' else 1 
     
    165165        form_volume = self.result[nout*self.q_input.nq + 1]/total_weight 
    166166        shell_volume = self.result[nout*self.q_input.nq + 2]/total_weight 
    167         effective_radius = self.result[nout*self.q_input.nq + 3]/total_weight 
     167        radius_effective = self.result[nout*self.q_input.nq + 3]/total_weight 
    168168        if shell_volume == 0.: 
    169169            shell_volume = 1. 
     
    171171              if nout == 2 else None) 
    172172        F2 = self.result[0:nout*self.q_input.nq:nout]/total_weight 
    173         return F1, F2, effective_radius, shell_volume, form_volume/shell_volume 
     173        return F1, F2, radius_effective, shell_volume, form_volume/shell_volume 
    174174 
    175175    def release(self): 
     
    181181 
    182182    def _call_kernel(self, call_details, values, cutoff, magnetic, 
    183                      effective_radius_type): 
     183                     radius_effective_mode): 
    184184        # type: (CallDetails, np.ndarray, np.ndarray, float, bool, int) -> np.ndarray 
    185185        """ 
  • sasmodels/kernel_iq.c

    r12f4c19 ra34b811  
    2727//      parameters in the parameter table. 
    2828//  CALL_VOLUME(form, shell, table) : assign form and shell values 
    29 //  CALL_EFFECTIVE_RADIUS(type, table) : call the R_eff function 
     29//  CALL_RADIUS_EFFECTIVE(mode, table) : call the R_eff function 
    3030//  CALL_IQ(q, table) : call the Iq function for 1D calcs. 
    3131//  CALL_IQ_A(q, table) : call the Iq function with |q| for 2D data. 
     
    285285    pglobal double *result,       // nq+1 return values, again with padding 
    286286    const double cutoff,          // cutoff in the dispersity weight product 
    287     int32_t effective_radius_type // which effective radius to compute 
     287    int32_t radius_effective_mode // which effective radius to compute 
    288288    ) 
    289289{ 
     
    703703      weighted_form += weight * form; 
    704704      weighted_shell += weight * shell; 
    705       if (effective_radius_type != 0) { 
    706         weighted_radius += weight * CALL_EFFECTIVE_RADIUS(effective_radius_type, local_values.table); 
     705      if (radius_effective_mode != 0) { 
     706        weighted_radius += weight * CALL_RADIUS_EFFECTIVE(radius_effective_mode, local_values.table); 
    707707      } 
    708708      BUILD_ROTATION(); 
  • sasmodels/kernelcl.py

    r069743a ra34b811  
    577577 
    578578    def _call_kernel(self, call_details, values, cutoff, magnetic, 
    579                      effective_radius_type): 
     579                     radius_effective_mode): 
    580580        # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray 
    581581        env = environment() 
     
    601601            self._result_b,   # Result storage. 
    602602            self._as_dtype(cutoff),  # Probability cutoff. 
    603             np.uint32(effective_radius_type),  # R_eff mode. 
     603            np.uint32(radius_effective_mode),  # R_eff mode. 
    604604        ] 
    605605 
  • sasmodels/kernelcuda.py

    rb297ba9 ra34b811  
    473473 
    474474    def _call_kernel(self, call_details, values, cutoff, magnetic, 
    475                      effective_radius_type): 
     475                     radius_effective_mode): 
    476476        # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray 
    477477 
     
    492492            self._result_b,   # Result storage. 
    493493            self._as_dtype(cutoff),  # Probability cutoff. 
    494             np.uint32(effective_radius_type),  # R_eff mode. 
     494            np.uint32(radius_effective_mode),  # R_eff mode. 
    495495        ] 
    496496        grid = partition(self.q_input.nq) 
  • sasmodels/kerneldll.py

    rb297ba9 ra34b811  
    403403 
    404404    def _call_kernel(self, call_details, values, cutoff, magnetic, 
    405                      effective_radius_type): 
     405                     radius_effective_mode): 
    406406        # type: (CallDetails, np.ndarray, float, bool, int) -> np.ndarray 
    407407 
     
    417417            self.result.ctypes.data,   # Result storage. 
    418418            self._as_dtype(cutoff),  # Probability cutoff. 
    419             effective_radius_type,  # R_eff mode. 
     419            radius_effective_mode,  # R_eff mode. 
    420420        ] 
    421421 
  • sasmodels/kernelpy.py

    rb297ba9 ra34b811  
    172172        volume = model_info.form_volume 
    173173        shell = model_info.shell_volume 
    174         radius = model_info.effective_radius 
     174        radius = model_info.radius_effective 
    175175        self._volume = ((lambda: (shell(*volume_args), volume(*volume_args))) if shell and volume 
    176176                        else (lambda: [volume(*volume_args)]*2) if volume 
     
    180180                        else (lambda mode: 1.0)) 
    181181 
    182     def _call_kernel(self, call_details, values, cutoff, magnetic, effective_radius_type): 
     182    def _call_kernel(self, call_details, values, cutoff, magnetic, radius_effective_mode): 
    183183        # type: (CallDetails, np.ndarray, np.ndarray, float, bool) -> np.ndarray 
    184184        if magnetic: 
     
    186186        #print("Calling python kernel") 
    187187        #call_details.show(values) 
    188         radius = ((lambda: 0.0) if effective_radius_type == 0 
    189                   else (lambda: self._radius(effective_radius_type))) 
     188        radius = ((lambda: 0.0) if radius_effective_mode == 0 
     189                  else (lambda: self._radius(radius_effective_mode))) 
    190190        self.result = _loops( 
    191191            self._parameter_vector, self._form, self._volume, radius, 
  • sasmodels/model_test.py

    rb297ba9 r8795b6f  
    240240                    s_name = pars.pop('@S') 
    241241                    ps_test = [pars] + list(test[1:]) 
     242                    #print("PS TEST PARAMS!!!",ps_test) 
    242243                    # build the P@S model 
    243244                    s_info = load_model_info(s_name) 
     
    246247                                           platform=self.platform) 
    247248                    # run the tests 
     249                    #self.info = ps_model.info 
     250                    #print("SELF.INFO PARAMS!!!",[p.id for p in self.info.parameters.call_parameters]) 
     251                    #print("PS MODEL PARAMETERS:",[p.id for p in ps_model.info.parameters.call_parameters]) 
    248252                    results.append(self.run_one(ps_model, ps_test)) 
    249253 
     
    303307            """Run a single test case.""" 
    304308            user_pars, x, y = test[:3] 
    305             pars = expand_pars(self.info.parameters, user_pars) 
    306             invalid = invalid_pars(self.info.parameters, pars) 
     309            #print("PS MODEL PARAMETERS:",[p.id for p in model.info.parameters.call_parameters]) 
     310            pars = expand_pars(model.info.parameters, user_pars) 
     311            invalid = invalid_pars(model.info.parameters, pars) 
    307312            if invalid: 
    308313                raise ValueError("Unknown parameters in test: " + ", ".join(invalid)) 
     
    328333            else: 
    329334                y1 = y 
    330                 y2 = test[3] if not isinstance(test[3], list) else [test[3]] 
    331                 F1, F2, R_eff, volume, volume_ratio = call_Fq(kernel, pars) 
    332                 if F1 is not None:  # F1 is none for models with Iq instead of Fq 
    333                     self._check_vectors(x, y1, F1, 'F') 
    334                 self._check_vectors(x, y2, F2, 'F^2') 
     335                y2 = test[3] if isinstance(test[3], list) else [test[3]] 
     336                F, Fsq, R_eff, volume, volume_ratio = call_Fq(kernel, pars) 
     337                if F is not None:  # F is none for models with Iq instead of Fq 
     338                    self._check_vectors(x, y1, F, 'F') 
     339                self._check_vectors(x, y2, Fsq, 'F^2') 
    335340                self._check_scalar(test[4], R_eff, 'R_eff') 
    336341                self._check_scalar(test[5], volume, 'volume') 
    337342                self._check_scalar(test[6], volume_ratio, 'form:shell ratio') 
    338                 return F2 
     343                return Fsq 
    339344 
    340345        def _check_scalar(self, target, actual, name): 
    341             if target is None: 
    342                 # smoke test --- make sure it runs and produces a value 
    343                 self.assertTrue(not np.isnan(actual), 
    344                                 'invalid %s: %s' % (name, actual)) 
    345             elif np.isnan(target): 
    346                 # make sure nans match 
    347                 self.assertTrue(np.isnan(actual), 
    348                                 '%s: expected:%s; actual:%s' 
    349                                 % (name, target, actual)) 
    350             else: 
    351                 # is_near does not work for infinite values, so also test 
    352                 # for exact values. 
    353                 self.assertTrue(target == actual or is_near(target, actual, 5), 
    354                                 '%s: expected:%s; actual:%s' 
    355                                 % (name, target, actual)) 
     346            self.assertTrue(is_near(target, actual, 5), 
     347                            '%s: expected:%s; actual:%s' 
     348                            % (name, target, actual)) 
    356349 
    357350        def _check_vectors(self, x, target, actual, name='I'): 
     
    363356                             '%s(...) returned wrong length'%name) 
    364357            for xi, yi, actual_yi in zip(x, target, actual): 
    365                 if yi is None: 
    366                     # smoke test --- make sure it runs and produces a value 
    367                     self.assertTrue(not np.isnan(actual_yi), 
    368                                     'invalid %s(%s): %s' % (name, xi, actual_yi)) 
    369                 elif np.isnan(yi): 
    370                     # make sure nans match 
    371                     self.assertTrue(np.isnan(actual_yi), 
    372                                     '%s(%s): expected:%s; actual:%s' 
    373                                     % (name, xi, yi, actual_yi)) 
    374                 else: 
    375                     # is_near does not work for infinite values, so also test 
    376                     # for exact values. 
    377                     self.assertTrue(yi == actual_yi or is_near(yi, actual_yi, 5), 
    378                                     '%s(%s); expected:%s; actual:%s' 
    379                                     % (name, xi, yi, actual_yi)) 
     358                self.assertTrue(is_near(yi, actual_yi, 5), 
     359                                '%s(%s): expected:%s; actual:%s' 
     360                                % (name, xi, target, actual)) 
    380361 
    381362    return ModelTestCase 
     
    389370    invalid = [] 
    390371    for par in sorted(pars.keys()): 
    391         # special handling of R_eff mode, which is not a usual parameter 
     372        # Ignore the R_eff mode parameter when checking for valid parameters. 
     373        # It is an allowed parameter for a model even though it does not exist 
     374        # in the parameter table.  The call_Fq() function pops it from the 
     375        # parameter list and sends it directly to kernel.Fq(). 
    392376        if par == product.RADIUS_MODE_ID: 
    393377            continue 
     
    405389    """ 
    406390    Returns true if *actual* is within *digits* significant digits of *target*. 
    407     """ 
    408     import math 
    409     shift = 10**math.ceil(math.log10(abs(target))) 
    410     return abs(target-actual)/shift < 1.5*10**-digits 
     391 
     392    *taget* zero and inf should match *actual* zero and inf.  If you want to 
     393    accept eps for zero, choose a value such as 1e-10, which must match up to 
     394    +/- 1e-15 when *digits* is the default value of 5. 
     395 
     396    If *target* is None, then just make sure that *actual* is not NaN. 
     397 
     398    If *target* is NaN, make sure *actual* is NaN. 
     399    """ 
     400    if target is None: 
     401        # target is None => actual cannot be NaN 
     402        return not np.isnan(actual) 
     403    elif target == 0.: 
     404        # target is 0. => actual must be 0. 
     405        # Note: if small values are allowed, then use maybe test zero against eps instead? 
     406        return actual == 0. 
     407    elif np.isfinite(target): 
     408        shift = np.ceil(np.log10(abs(target))) 
     409        return abs(target-actual) < 1.5*10**(shift-digits) 
     410    elif target == actual: 
     411        # target is inf => actual must be inf of same sign 
     412        return True 
     413    else: 
     414        # target is NaN => actual must be NaN 
     415        return np.isnan(target) == np.isnan(actual) 
    411416 
    412417# CRUFT: old interface; should be deprecated and removed 
  • sasmodels/modelinfo.py

    rb297ba9 ra34b811  
    265265    other sld parameters. The volume parameters are used for calls 
    266266    to form_volume within the kernel (required for volume normalization), 
    267     to shell_volume (for hollow shapes), and to effective_radius (for 
     267    to shell_volume (for hollow shapes), and to radius_effective (for 
    268268    structure factor interactions) respectively. 
    269269 
     
    841841    info.structure_factor = getattr(kernel_module, 'structure_factor', False) 
    842842    # TODO: find Fq by inspection 
    843     info.effective_radius_type = getattr(kernel_module, 'effective_radius_type', None) 
     843    info.radius_effective_modes = getattr(kernel_module, 'radius_effective_modes', None) 
    844844    info.have_Fq = getattr(kernel_module, 'have_Fq', False) 
    845845    info.profile_axes = getattr(kernel_module, 'profile_axes', ['x', 'y']) 
     
    848848    info.source = getattr(kernel_module, 'source', []) 
    849849    info.c_code = getattr(kernel_module, 'c_code', None) 
    850     info.effective_radius = getattr(kernel_module, 'effective_radius', None) 
     850    info.radius_effective = getattr(kernel_module, 'radius_effective', None) 
    851851    # TODO: check the structure of the tests 
    852852    info.tests = getattr(kernel_module, 'tests', []) 
     
    961961    #: List of options for computing the effective radius of the shape, 
    962962    #: or None if the model is not usable as a form factor model. 
    963     effective_radius_type = None   # type: List[str] 
     963    radius_effective_modes = None   # type: List[str] 
    964964    #: List of C source files used to define the model.  The source files 
    965965    #: should define the *Iq* function, and possibly *Iqac* or *Iqabc* if the 
     
    989989    #: monodisperse approximation for non-dilute solutions, P@S.  The first 
    990990    #: argument is the integer effective radius mode, with default 0. 
    991     effective_radius = None  # type: Union[None, Callable[[int, np.ndarray], float]] 
     991    radius_effective = None  # type: Union[None, Callable[[int, np.ndarray], float]] 
    992992    #: Returns *I(q, a, b, ...)* for parameters *a*, *b*, etc. defined 
    993993    #: by the parameter table.  *Iq* can be defined as a python function, or 
  • sasmodels/models/_spherepy.py

    r0507e09 ra34b811  
    4848---------------------------- 
    4949 
    50 * **Author: P Kienzle**  
    51 * **Last Modified by:**  
     50* **Author: P Kienzle** 
     51* **Last Modified by:** 
    5252* **Last Reviewed by:** S King and P Parker **Date:** 2013/09/09 and 2014/01/06 
    5353* **Source added by :** Steve King **Date:** March 25, 2019 
     
    8383    return 1.333333333333333 * pi * radius ** 3 
    8484 
    85 def effective_radius(mode, radius): 
     85def radius_effective(mode, radius): 
    8686    """Calculate R_eff for sphere""" 
    87     return radius 
     87    return radius if mode else 0. 
    8888 
    8989def Iq(q, sld, sld_solvent, radius): 
  • sasmodels/models/barbell.c

    r99658f6 ra34b811  
    8585 
    8686static double 
    87 effective_radius(int mode, double radius_bell, double radius, double length) 
     87radius_effective(int mode, double radius_bell, double radius, double length) 
    8888{ 
    8989    switch (mode) { 
  • sasmodels/models/barbell.py

    r0507e09 ra34b811  
    126126source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "barbell.c"] 
    127127have_Fq = True 
    128 effective_radius_type = [ 
     128radius_effective_modes = [ 
    129129    "equivalent cylinder excluded volume", "equivalent volume sphere", 
    130130    "radius", "half length", "half total length", 
  • sasmodels/models/capped_cylinder.c

    r99658f6 ra34b811  
    107107 
    108108static double 
    109 effective_radius(int mode, double radius, double radius_cap, double length) 
     109radius_effective(int mode, double radius, double radius_cap, double length) 
    110110{ 
    111111    switch (mode) { 
  • sasmodels/models/capped_cylinder.py

    r0507e09 ra34b811  
    146146source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "capped_cylinder.c"] 
    147147have_Fq = True 
    148 effective_radius_type = [ 
     148radius_effective_modes = [ 
    149149    "equivalent cylinder excluded volume", "equivalent volume sphere", 
    150150    "radius", "half length", "half total length", 
  • sasmodels/models/core_multi_shell.c

    rd42dd4a ra34b811  
    2626 
    2727static double 
    28 effective_radius(int mode, double core_radius, double fp_n, double thickness[]) 
     28radius_effective(int mode, double core_radius, double fp_n, double thickness[]) 
    2929{ 
    3030  switch (mode) { 
  • sasmodels/models/core_multi_shell.py

    r0507e09 ra34b811  
    108108source = ["lib/sas_3j1x_x.c", "core_multi_shell.c"] 
    109109have_Fq = True 
    110 effective_radius_type = ["outer radius", "core radius"] 
     110radius_effective_modes = ["outer radius", "core radius"] 
    111111 
    112112def random(): 
  • sasmodels/models/core_shell_bicelle.c

    r99658f6 ra34b811  
    6060 
    6161static double 
    62 effective_radius(int mode, double radius, double thick_rim, double thick_face, double length) 
     62radius_effective(int mode, double radius, double thick_rim, double thick_face, double length) 
    6363{ 
    6464    switch (mode) { 
  • sasmodels/models/core_shell_bicelle.py

    r0507e09 ra34b811  
    165165          "core_shell_bicelle.c"] 
    166166have_Fq = True 
    167 effective_radius_type = [ 
     167radius_effective_modes = [ 
    168168    "excluded volume", "equivalent volume sphere", "outer rim radius", 
    169169    "half outer thickness", "half diagonal", 
  • sasmodels/models/core_shell_bicelle_elliptical.c

    r99658f6 ra34b811  
    3535 
    3636static double 
    37 effective_radius(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length) 
     37radius_effective(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length) 
    3838{ 
    3939    switch (mode) { 
  • sasmodels/models/core_shell_bicelle_elliptical.py

    r0507e09 ra34b811  
    155155          "core_shell_bicelle_elliptical.c"] 
    156156have_Fq = True 
    157 effective_radius_type = [ 
     157radius_effective_modes = [ 
    158158    "equivalent cylinder excluded volume", "equivalent volume sphere", 
    159159    "outer rim average radius", "outer rim min radius", 
  • sasmodels/models/core_shell_bicelle_elliptical_belt_rough.c

    r99658f6 ra34b811  
    3636 
    3737static double 
    38 effective_radius(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length) 
     38radius_effective(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length) 
    3939{ 
    4040    switch (mode) { 
  • sasmodels/models/core_shell_bicelle_elliptical_belt_rough.py

    r0507e09 ra34b811  
    168168          "core_shell_bicelle_elliptical_belt_rough.c"] 
    169169have_Fq = True 
    170 effective_radius_type = [ 
     170radius_effective_modes = [ 
    171171    "equivalent cylinder excluded volume", "equivalent volume sphere", 
    172172    "outer rim average radius", "outer rim min radius", 
  • sasmodels/models/core_shell_cylinder.c

    r99658f6 ra34b811  
    3737 
    3838static double 
    39 effective_radius(int mode, double radius, double thickness, double length) 
     39radius_effective(int mode, double radius, double thickness, double length) 
    4040{ 
    4141    switch (mode) { 
  • sasmodels/models/core_shell_cylinder.py

    r81d0b9b rdb1d9d5  
    141141source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "core_shell_cylinder.c"] 
    142142have_Fq = True 
    143 effective_radius_type = [ 
     143radius_effective_modes = [ 
    144144    "excluded volume", "equivalent volume sphere", "outer radius", "half outer length", 
    145145    "half min outer dimension", "half max outer dimension", "half outer diagonal", 
  • sasmodels/models/core_shell_ellipsoid.c

    r99658f6 ra34b811  
    6868 
    6969static double 
    70 effective_radius(int mode, double radius_equat_core, double x_core, double thick_shell, double x_polar_shell) 
     70radius_effective(int mode, double radius_equat_core, double x_core, double thick_shell, double x_polar_shell) 
    7171{ 
    7272    const double radius_equat_tot = radius_equat_core + thick_shell; 
  • sasmodels/models/core_shell_parallelepiped.c

    r99658f6 ra34b811  
    7575 
    7676static double 
    77 effective_radius(int mode, double length_a, double length_b, double length_c, 
     77radius_effective(int mode, double length_a, double length_b, double length_c, 
    7878                 double thick_rim_a, double thick_rim_b, double thick_rim_c) 
    7979{ 
  • sasmodels/models/core_shell_parallelepiped.py

    r0507e09 ra34b811  
    236236source = ["lib/gauss76.c", "core_shell_parallelepiped.c"] 
    237237have_Fq = True 
    238 effective_radius_type = [ 
     238radius_effective_modes = [ 
    239239    "equivalent cylinder excluded volume", 
    240240    "equivalent volume sphere", 
  • sasmodels/models/core_shell_sphere.c

    rd42dd4a ra34b811  
    66 
    77static double 
    8 effective_radius(int mode, double radius, double thickness) 
     8radius_effective(int mode, double radius, double thickness) 
    99{ 
    1010    switch (mode) { 
  • sasmodels/models/core_shell_sphere.py

    r0507e09 ra34b811  
    6060---------------------------- 
    6161 
    62 * **Author:**  
    63 * **Last Modified by:**  
    64 * **Last Reviewed by:**  
     62* **Author:** 
     63* **Last Modified by:** 
     64* **Last Reviewed by:** 
    6565* **Source added by :** Steve King **Date:** March 25, 2019 
    6666""" 
     
    9292source = ["lib/sas_3j1x_x.c", "lib/core_shell.c", "core_shell_sphere.c"] 
    9393have_Fq = True 
    94 effective_radius_type = ["outer radius", "core radius"] 
     94radius_effective_modes = ["outer radius", "core radius"] 
    9595 
    9696demo = dict(scale=1, background=0, radius=60, thickness=10, 
  • sasmodels/models/cylinder.c

    r99658f6 ra34b811  
    3232 
    3333static double 
    34 effective_radius(int mode, double radius, double length) 
     34radius_effective(int mode, double radius, double length) 
    3535{ 
    3636    switch (mode) { 
  • sasmodels/models/cylinder.py

    r0507e09 ra34b811  
    110110---------------------------- 
    111111 
    112 * **Author:**  
    113 * **Last Modified by:**  
    114 * **Last Reviewed by:**  
     112* **Author:** 
     113* **Last Modified by:** 
     114* **Last Reviewed by:** 
    115115* **Source added by :** Steve King **Date:** March 25, 2019 
    116116""" 
     
    155155source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "cylinder.c"] 
    156156have_Fq = True 
    157 effective_radius_type = [ 
     157radius_effective_modes = [ 
    158158    "excluded volume", "equivalent volume sphere", "radius", 
    159159    "half length", "half min dimension", "half max dimension", "half diagonal", 
     
    184184            phi_pd=10, phi_pd_n=5) 
    185185 
    186 # pylint: disable=bad-whitespace, line-too-long 
     186# Test 1-D and 2-D models 
    187187qx, qy = 0.2 * np.cos(2.5), 0.2 * np.sin(2.5) 
    188 # After redefinition of angles, find new tests values.  Was 10 10 in old coords 
     188theta, phi = 80.1534480601659, 10.1510817110481  # (10, 10) in sasview 3.x 
    189189tests = [ 
    190190    [{}, 0.2, 0.042761386790780453], 
    191191    [{}, [0.2], [0.042761386790780453]], 
    192     #  new coords 
    193     [{'theta':80.1534480601659, 'phi':10.1510817110481}, (qx, qy), 0.03514647218513852], 
    194     [{'theta':80.1534480601659, 'phi':10.1510817110481}, [(qx, qy)], [0.03514647218513852]], 
    195     # old coords 
    196     #[{'theta':10.0, 'phi':10.0}, (qx, qy), 0.03514647218513852], 
    197     #[{'theta':10.0, 'phi':10.0}, [(qx, qy)], [0.03514647218513852]], 
     192    [{'theta': theta, 'phi': phi}, (qx, qy), 0.03514647218513852], 
     193    [{'theta': theta, 'phi': phi}, [(qx, qy)], [0.03514647218513852]], 
    198194] 
    199 del qx, qy  # not necessary to delete, but cleaner 
    200  
    201 # Default radius and length 
    202 def calc_volume(radius, length): 
    203     """Return form volume for cylinder.""" 
    204     return pi*radius**2*length 
    205 def calc_r_effs(radius, length): 
    206     """Return effective radii for modes 0-7 of cylinder.""" 
    207     return [ 
     195del qx, qy, theta, phi  # not necessary to delete, but cleaner 
     196 
     197def _extend_with_reff_tests(radius, length): 
     198    """Test R_eff and form volume calculations""" 
     199    # V and Vr are the same for each R_eff mode 
     200    V = pi*radius**2*length  # shell volume = form volume for solid objects 
     201    Vr = 1.0  # form:shell volume ratio 
     202    # Use test value for I(0.2) from above to check Fsq value.  Need to 
     203    # remove scale and background before testing. 
     204    q = 0.2 
     205    scale, background = V, 0.001 
     206    Fsq = (0.042761386790780453 - background)*scale 
     207    F = None  # Need target value for <F> 
     208    # Various values for R_eff, depending on mode 
     209    r_effs = [ 
    208210        0., 
    209211        0.5*(0.75*radius*(2.0*radius*length 
     
    216218        np.sqrt(4*radius**2 + length**2)/2., 
    217219    ] 
    218 r_effs = calc_r_effs(parameters[2][2], parameters[3][2]) 
    219 cyl_vol = calc_volume(parameters[2][2], parameters[3][2]) 
    220 tests.extend([ 
    221     ({'radius_effective_mode': 0}, 0.1, None, None, r_effs[0], cyl_vol, 1.0), 
    222     ({'radius_effective_mode': 1}, 0.1, None, None, r_effs[1], None, None), 
    223     ({'radius_effective_mode': 2}, 0.1, None, None, r_effs[2], None, None), 
    224     ({'radius_effective_mode': 3}, 0.1, None, None, r_effs[3], None, None), 
    225     ({'radius_effective_mode': 4}, 0.1, None, None, r_effs[4], None, None), 
    226     ({'radius_effective_mode': 5}, 0.1, None, None, r_effs[5], None, None), 
    227     ({'radius_effective_mode': 6}, 0.1, None, None, r_effs[6], None, None), 
    228     ({'radius_effective_mode': 7}, 0.1, None, None, r_effs[7], None, None), 
    229 ]) 
    230 del r_effs, cyl_vol 
    231 # pylint: enable=bad-whitespace, line-too-long 
     220    tests.extend([ 
     221        ({'radius_effective_mode': 0}, q, F, Fsq, r_effs[0], V, Vr), 
     222        ({'radius_effective_mode': 1}, q, F, Fsq, r_effs[1], V, Vr), 
     223        ({'radius_effective_mode': 2}, q, F, Fsq, r_effs[2], V, Vr), 
     224        ({'radius_effective_mode': 3}, q, F, Fsq, r_effs[3], V, Vr), 
     225        ({'radius_effective_mode': 4}, q, F, Fsq, r_effs[4], V, Vr), 
     226        ({'radius_effective_mode': 5}, q, F, Fsq, r_effs[5], V, Vr), 
     227        ({'radius_effective_mode': 6}, q, F, Fsq, r_effs[6], V, Vr), 
     228        ({'radius_effective_mode': 7}, q, F, Fsq, r_effs[7], V, Vr), 
     229    ]) 
     230 
     231# Test Reff and volume with default model parameters 
     232_extend_with_reff_tests(parameters[2][2], parameters[3][2]) 
     233del _extend_with_reff_tests 
    232234 
    233235# ADDED by:  RKH  ON: 18Mar2016 renamed sld's etc 
  • sasmodels/models/ellipsoid.c

    r99658f6 ra34b811  
    3232 
    3333static double 
    34 effective_radius(int mode, double radius_polar, double radius_equatorial) 
     34radius_effective(int mode, double radius_polar, double radius_equatorial) 
    3535{ 
    3636    switch (mode) { 
  • sasmodels/models/ellipsoid.py

    r0507e09 ra34b811  
    167167source = ["lib/sas_3j1x_x.c", "lib/gauss76.c", "ellipsoid.c"] 
    168168have_Fq = True 
    169 effective_radius_type = [ 
     169radius_effective_modes = [ 
    170170    "average curvature", "equivalent volume sphere", "min radius", "max radius", 
    171171    ] 
  • sasmodels/models/elliptical_cylinder.c

    r99658f6 ra34b811  
    4141 
    4242static double 
    43 effective_radius(int mode, double radius_minor, double r_ratio, double length) 
     43radius_effective(int mode, double radius_minor, double r_ratio, double length) 
    4444{ 
    4545    switch (mode) { 
  • sasmodels/models/elliptical_cylinder.py

    r0507e09 ra34b811  
    131131source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "elliptical_cylinder.c"] 
    132132have_Fq = True 
    133 effective_radius_type = [ 
     133radius_effective_modes = [ 
    134134    "equivalent cylinder excluded volume", 
    135135    "equivalent volume sphere", "average radius", "min radius", "max radius", 
  • sasmodels/models/flexible_cylinder_elliptical.py

    r40c9825 rdb1d9d5  
    2626----------- 
    2727 
    28 The function is calculated in a similar way to that for the  
    29 :ref:`flexible-cylinder` model in reference [1] below using the author's  
     28The function is calculated in a similar way to that for the 
     29:ref:`flexible-cylinder` model in reference [1] below using the author's 
    3030"Method 3 With Excluded Volume". 
    3131 
     
    7171these parameters must be held fixed during model fitting. 
    7272 
    73 **This is a model with complex behaviour depending on the ratio of** $L/b$ **and the  
     73**This is a model with complex behaviour depending on the ratio of** $L/b$ **and the 
    7474reader is strongly encouraged to read reference [1] before use.** 
    7575 
     
    9595---------------------------- 
    9696 
    97 * **Author:**  
     97* **Author:** 
    9898* **Last Modified by:** Richard Heenan **Date:** December, 2016 
    9999* **Last Reviewed by:** Steve King **Date:** March 26, 2019 
  • sasmodels/models/fuzzy_sphere.c

    rd42dd4a ra34b811  
    55 
    66static double 
    7 effective_radius(int mode, double radius, double fuzziness) 
     7radius_effective(int mode, double radius, double fuzziness) 
    88{ 
    99    switch (mode) { 
  • sasmodels/models/fuzzy_sphere.py

    r0507e09 ra34b811  
    6363---------------------------- 
    6464 
    65 * **Author:**  
    66 * **Last Modified by:**  
    67 * **Last Reviewed by:**  
     65* **Author:** 
     66* **Last Modified by:** 
     67* **Last Reviewed by:** 
    6868* **Source added by :** Steve King **Date:** March 25, 2019 
    6969""" 
     
    9898source = ["lib/sas_3j1x_x.c", "fuzzy_sphere.c"] 
    9999have_Fq = True 
    100 effective_radius_type = ["radius", "radius + fuzziness"] 
     100radius_effective_modes = ["radius", "radius + fuzziness"] 
    101101 
    102102def random(): 
  • sasmodels/models/hardsphere.py

    r5f3c534 rdb1d9d5  
    33Calculates the interparticle structure factor for monodisperse 
    44spherical particles interacting through hard sphere (excluded volume) 
    5 interactions. This $S(q)$ may also be a reasonable approximation for  
    6 other particle shapes that freely rotate (but see the note below),  
     5interactions. This $S(q)$ may also be a reasonable approximation for 
     6other particle shapes that freely rotate (but see the note below), 
    77and for moderately polydisperse systems. 
    88 
    99.. note:: 
    1010 
    11    This routine is intended for uncharged particles! For charged  
     11   This routine is intended for uncharged particles! For charged 
    1212   particles try using the :ref:`hayter-msa` $S(q)$ instead. 
    13     
     13 
    1414.. note:: 
    1515 
    16    Earlier versions of SasView did not incorporate the so-called  
    17    $\beta(q)$ ("beta") correction [1] for polydispersity and non-sphericity.  
     16   Earlier versions of SasView did not incorporate the so-called 
     17   $\beta(q)$ ("beta") correction [1] for polydispersity and non-sphericity. 
    1818   This is only available in SasView versions 4.2.2 and higher. 
    1919 
     
    2525 
    2626For numerical stability the computation uses a Taylor series expansion 
    27 at very small $qR$, but there may be a very minor glitch at the  
     27at very small $qR$, but there may be a very minor glitch at the 
    2828transition point in some circumstances. 
    2929 
    30 This S(q) uses the Percus-Yevick closure relationship [2] where the  
     30This S(q) uses the Percus-Yevick closure relationship [2] where the 
    3131interparticle potential $U(r)$ is 
    3232 
     
    6262---------------------------- 
    6363 
    64 * **Author:**  
    65 * **Last Modified by:**  
    66 * **Last Reviewed by:**  
     64* **Author:** 
     65* **Last Modified by:** 
     66* **Last Reviewed by:** 
    6767* **Source added by :** Steve King **Date:** March 25, 2019 
    6868""" 
  • sasmodels/models/hayter_msa.py

    r9947865 rdb1d9d5  
    11# Note: model title and parameter table are inserted automatically 
    22r""" 
    3 Calculates the interparticle structure factor for a system of charged,  
    4 spheroidal, objects in a dielectric medium [1,2]. When combined with an  
    5 appropriate form factor $P(q)$, this allows for inclusion of the  
    6 interparticle interference effects due to screened Coulombic  
     3Calculates the interparticle structure factor for a system of charged, 
     4spheroidal, objects in a dielectric medium [1,2]. When combined with an 
     5appropriate form factor $P(q)$, this allows for inclusion of the 
     6interparticle interference effects due to screened Coulombic 
    77repulsion between the charged particles. 
    88 
    99.. note:: 
    1010 
    11    This routine only works for charged particles! If the charge is set  
    12    to zero the routine may self-destruct! For uncharged particles use  
     11   This routine only works for charged particles! If the charge is set 
     12   to zero the routine may self-destruct! For uncharged particles use 
    1313   the :ref:`hardsphere` $S(q)$ instead. The upper limit for the charge 
    1414   is limited to 200e to avoid numerical instabilities. 
    15     
     15 
    1616.. note:: 
    1717 
    18    Earlier versions of SasView did not incorporate the so-called  
    19    $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity.  
     18   Earlier versions of SasView did not incorporate the so-called 
     19   $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity. 
    2020   This is only available in SasView versions 4.2.2 and higher. 
    2121 
    2222The salt concentration is used to compute the ionic strength of the solution 
    23 which in turn is used to compute the Debye screening length. There is no  
    24 provision for entering the ionic strength directly. **At present the  
    25 counterions are assumed to be monovalent**, though it should be possible  
    26 to simulate the effect of multivalent counterions by increasing the salt  
     23which in turn is used to compute the Debye screening length. There is no 
     24provision for entering the ionic strength directly. **At present the 
     25counterions are assumed to be monovalent**, though it should be possible 
     26to simulate the effect of multivalent counterions by increasing the salt 
    2727concentration. 
    2828 
    29 Over the range 0 - 100 C the dielectric constant $\kappa$ of water may be  
    30 approximated with a maximum deviation of 0.01 units by the empirical  
     29Over the range 0 - 100 C the dielectric constant $\kappa$ of water may be 
     30approximated with a maximum deviation of 0.01 units by the empirical 
    3131formula [4] 
    3232 
     
    3434 
    3535    \kappa = 87.740 - 0.40008 T + 9.398x10^{-4} T^2 - 1.410x10^{-6} T^3 
    36      
     36 
    3737where $T$ is the temperature in celsius. 
    3838 
     
    7373---------------------------- 
    7474 
    75 * **Author:**  
    76 * **Last Modified by:**  
     75* **Author:** 
     76* **Last Modified by:** 
    7777* **Last Reviewed by:** Steve King **Date:** March 28, 2019 
    7878* **Source added by :** Steve King **Date:** March 25, 2019 
     
    101101    [Hayter-Penfold RMSA charged sphere interparticle S(Q) structure factor] 
    102102        Interparticle structure factor S(Q) for charged hard spheres. 
    103     This routine only works for charged particles! For uncharged particles  
    104     use the hardsphere S(q) instead. The "beta(q)" correction is available  
     103    This routine only works for charged particles! For uncharged particles 
     104    use the hardsphere S(q) instead. The "beta(q)" correction is available 
    105105    in versions 4.2.2 and higher. 
    106106""" 
     
    110110#             [ "name", "units", default, [lower, upper], "type", "description" ], 
    111111# 
    112 # NOTE: SMK, 28Mar19 The upper limit for charge is set to 200 to avoid instabilities noted by PK in  
    113 #       Ticket #1152. Also see the thread in Ticket 859. The docs above also note that charge=0 will  
     112# NOTE: SMK, 28Mar19 The upper limit for charge is set to 200 to avoid instabilities noted by PK in 
     113#       Ticket #1152. Also see the thread in Ticket 859. The docs above also note that charge=0 will 
    114114#       cause problems, yet the default parameters allowed it! After discussions with PK I have 
    115 #       changed it to (an arbitarily) small but non-zero value.  But I haven't changed the low limit  
     115#       changed it to (an arbitarily) small but non-zero value.  But I haven't changed the low limit 
    116116#       in function random() below. 
    117117# 
  • sasmodels/models/hollow_cylinder.c

    r99658f6 ra34b811  
    3434 
    3535static double 
    36 effective_radius(int mode, double radius, double thickness, double length) 
     36radius_effective(int mode, double radius, double thickness, double length) 
    3737{ 
    3838    switch (mode) { 
  • sasmodels/models/hollow_cylinder.py

    r0507e09 ra34b811  
    110110source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "hollow_cylinder.c"] 
    111111have_Fq = True 
    112 effective_radius_type = [ 
     112radius_effective_modes = [ 
    113113    "excluded volume", "equivalent outer volume sphere", 
    114114    "outer radius", "half length", 
  • sasmodels/models/hollow_rectangular_prism.c

    r99658f6 ra34b811  
    3030 
    3131static double 
    32 effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio, double thickness) 
     32radius_effective(int mode, double length_a, double b2a_ratio, double c2a_ratio, double thickness) 
    3333// NOTE length_a is external dimension! 
    3434{ 
  • sasmodels/models/hollow_rectangular_prism.py

    r0507e09 ra34b811  
    157157source = ["lib/gauss76.c", "hollow_rectangular_prism.c"] 
    158158have_Fq = True 
    159 effective_radius_type = [ 
     159radius_effective_modes = [ 
    160160    "equivalent cylinder excluded volume", "equivalent outer volume sphere", 
    161161    "half length_a", "half length_b", "half length_c", 
  • sasmodels/models/hollow_rectangular_prism_thin_walls.c

    r99658f6 ra34b811  
    2626 
    2727static double 
    28 effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio) 
     28radius_effective(int mode, double length_a, double b2a_ratio, double c2a_ratio) 
    2929{ 
    3030    switch (mode) { 
  • sasmodels/models/hollow_rectangular_prism_thin_walls.py

    r0507e09 ra34b811  
    117117source = ["lib/gauss76.c", "hollow_rectangular_prism_thin_walls.c"] 
    118118have_Fq = True 
    119 effective_radius_type = [ 
     119radius_effective_modes = [ 
    120120    "equivalent cylinder excluded volume", "equivalent outer volume sphere", 
    121121    "half length_a", "half length_b", "half length_c", 
  • sasmodels/models/mono_gauss_coil.c

    r153f8f6 ra34b811  
    66 
    77static double 
    8 effective_radius(int mode, double rg) 
     8radius_effective(int mode, double rg) 
    99{ 
    1010    switch (mode) { 
  • sasmodels/models/mono_gauss_coil.py

    r0507e09 ra34b811  
    5959---------------------------- 
    6060 
    61 * **Author:**  
    62 * **Last Modified by:**  
    63 * **Last Reviewed by:**  
     61* **Author:** 
     62* **Last Modified by:** 
     63* **Last Reviewed by:** 
    6464* **Source added by :** Steve King **Date:** March 25, 2019""" 
    6565 
     
    8686source = ["mono_gauss_coil.c"] 
    8787have_Fq = False 
    88 effective_radius_type = ["R_g", "2R_g", "3R_g", "sqrt(5/3)*R_g"] 
     88radius_effective_modes = ["R_g", "2R_g", "3R_g", "sqrt(5/3)*R_g"] 
    8989 
    9090 
  • sasmodels/models/multilayer_vesicle.c

    ree60aa7 ra34b811  
    4848 
    4949static double 
    50 effective_radius(int mode, double radius, double thick_shell, double thick_solvent, double fp_n_shells) 
     50radius_effective(int mode, double radius, double thick_shell, double thick_solvent, double fp_n_shells) 
    5151{ 
    5252    // case 1: outer radius 
  • sasmodels/models/multilayer_vesicle.py

    r6607260 rdb1d9d5  
    154154source = ["lib/sas_3j1x_x.c", "multilayer_vesicle.c"] 
    155155have_Fq = True 
    156 effective_radius_type = ["outer radius"] 
     156radius_effective_modes = ["outer radius"] 
    157157 
    158158def random(): 
  • sasmodels/models/onion.c

    ree60aa7 ra34b811  
    4747 
    4848static double 
    49 effective_radius(int mode, double radius_core, double n_shells, double thickness[]) 
     49radius_effective(int mode, double radius_core, double n_shells, double thickness[]) 
    5050{ 
    5151  // case 1: outer radius 
  • sasmodels/models/onion.py

    r62dc889 rdb1d9d5  
    88.. note:: 
    99 
    10     *radius* represents the core radius $r_0$ and *thickness[k]* represents  
     10    *radius* represents the core radius $r_0$ and *thickness[k]* represents 
    1111    the thickness of the shell, $r_{k+1} - r_k$. 
    1212 
     
    6060and the volume is $V(r) = \frac{4\pi}{3}r^3$. 
    6161 
    62 The volume of the particle is determined by the radius of the outer  
     62The volume of the particle is determined by the radius of the outer 
    6363shell, so $V_\text{particle} = V(r_N)$. 
    6464 
     
    104104    B&=\frac{\rho_\text{out} - \rho_\text{in}}{e^A-1} 
    105105         & C &= \frac{\rho_\text{in}e^A - \rho_\text{out}}{e^A-1} \\ 
    106           
     106 
    107107    \alpha_\text{in} &= A\frac{r_{\text{shell}-1}}{\Delta t_\text{shell}} 
    108108         & \alpha_\text{out} &= A\frac{r_\text{shell}}{\Delta t_\text{shell}} \\ 
    109           
     109 
    110110    \beta_\text{in} &= qr_{\text{shell}-1} 
    111111        & \beta_\text{out} &= qr_\text{shell} \\ 
     
    123123**Linear SLD profile** ($A \sim 0$): 
    124124 
    125 For small $A$, say, $A = -0.0001$, the function converges to that of of a linear  
     125For small $A$, say, $A = -0.0001$, the function converges to that of of a linear 
    126126SLD profile with 
    127127 
     
    159159**Constant SLD** ($A = 0$): 
    160160 
    161 When $A = 0$ the exponential function has no dependence on the radius (meaning  
     161When $A = 0$ the exponential function has no dependence on the radius (meaning 
    162162$\rho_\text{out}$ is ignored in this case) and becomes flat. We set the constant 
    163163to $\rho_\text{in}$ for convenience, and thus the form factor contributed by 
     
    197197---------------------------- 
    198198 
    199 * **Author:**  
    200 * **Last Modified by:**  
     199* **Author:** 
     200* **Last Modified by:** 
    201201* **Last Reviewed by:** Steve King **Date:** March 28, 2019 
    202202* **Source added by :** Steve King **Date:** March 25, 2019 
     
    347347single = False 
    348348have_Fq = True 
    349 effective_radius_type = ["outer radius"] 
     349radius_effective_modes = ["outer radius"] 
    350350 
    351351profile_axes = ['Radius (A)', 'SLD (1e-6/A^2)'] 
  • sasmodels/models/parallelepiped.c

    r99658f6 ra34b811  
    3737 
    3838static double 
    39 effective_radius(int mode, double length_a, double length_b, double length_c) 
     39radius_effective(int mode, double length_a, double length_b, double length_c) 
    4040{ 
    4141    switch (mode) { 
  • sasmodels/models/parallelepiped.py

    r0507e09 ra34b811  
    240240source = ["lib/gauss76.c", "parallelepiped.c"] 
    241241have_Fq = True 
    242 effective_radius_type = [ 
     242radius_effective_modes = [ 
    243243    "equivalent cylinder excluded volume", "equivalent volume sphere", 
    244244    "half length_a", "half length_b", "half length_c", 
  • sasmodels/models/pearl_necklace.c

    r9b5fd42 ra34b811  
    8686 
    8787static double 
    88 effective_radius(int mode, double radius, double edge_sep, double thick_string, double fp_num_pearls) 
     88radius_effective(int mode, double radius, double edge_sep, double thick_string, double fp_num_pearls) 
    8989{ 
    9090    switch (mode) { 
  • sasmodels/models/pearl_necklace.py

    rc0136c72 rdb1d9d5  
    111111source = ["lib/sas_Si.c", "lib/sas_3j1x_x.c", "pearl_necklace.c"] 
    112112single = False  # use double precision unless told otherwise 
    113 effective_radius_type = ["equivalent volume sphere"] 
     113radius_effective_modes = ["equivalent volume sphere"] 
    114114 
    115115def random(): 
  • sasmodels/models/poly_gauss_coil.py

    r0507e09 ra34b811  
    5858---------------------------- 
    5959 
    60 * **Author:**  
    61 * **Last Modified by:**  
    62 * **Last Reviewed by:**  
     60* **Author:** 
     61* **Last Modified by:** 
     62* **Last Reviewed by:** 
    6363* **Source added by :** Steve King **Date:** March 25, 2019 
    6464""" 
  • sasmodels/models/pringle.c

    r99658f6 ra34b811  
    111111 
    112112static double 
    113 effective_radius(int mode, double radius, double thickness, double alpha, double beta) 
     113radius_effective(int mode, double radius, double thickness, double alpha, double beta) 
    114114{ 
    115115    switch (mode) { 
  • sasmodels/models/pringle.py

    r0507e09 ra34b811  
    8585source = ["lib/polevl.c", "lib/sas_J0.c", "lib/sas_J1.c", 
    8686          "lib/sas_JN.c", "lib/gauss76.c", "pringle.c"] 
    87 effective_radius_type = [ 
     87radius_effective_modes = [ 
    8888    "equivalent cylinder excluded volume", 
    8989    "equivalent volume sphere", 
  • sasmodels/models/raspberry.c

    rd42dd4a ra34b811  
    1515 
    1616static double 
    17 effective_radius(int mode, double radius_lg, double radius_sm, double penetration) 
     17radius_effective(int mode, double radius_lg, double radius_sm, double penetration) 
    1818{ 
    1919    switch (mode) { 
  • sasmodels/models/raspberry.py

    r0507e09 ra34b811  
    161161 
    162162source = ["lib/sas_3j1x_x.c", "raspberry.c"] 
    163 effective_radius_type = ["radius_large", "radius_outer"] 
     163radius_effective_modes = ["radius_large", "radius_outer"] 
    164164 
    165165def random(): 
  • sasmodels/models/rectangular_prism.c

    r99658f6 ra34b811  
    1414 
    1515static double 
    16 effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio) 
     16radius_effective(int mode, double length_a, double b2a_ratio, double c2a_ratio) 
    1717{ 
    1818    switch (mode) { 
  • sasmodels/models/rectangular_prism.py

    r0507e09 ra34b811  
    110110---------------------------- 
    111111 
    112 * **Author:**  
    113 * **Last Modified by:**  
    114 * **Last Reviewed by:**  
     112* **Author:** 
     113* **Last Modified by:** 
     114* **Last Reviewed by:** 
    115115* **Source added by :** Steve King **Date:** March 25, 2019 
    116116""" 
     
    151151source = ["lib/gauss76.c", "rectangular_prism.c"] 
    152152have_Fq = True 
    153 effective_radius_type = [ 
     153radius_effective_modes = [ 
    154154    "equivalent cylinder excluded volume", "equivalent volume sphere", 
    155155    "half length_a", "half length_b", "half length_c", 
  • sasmodels/models/rpa.py

    r055ec4f rdb1d9d5  
    3434that $R_g^2 = n b^2/6$ where $b$ is the statistical segment length and $n$ is 
    3535the number of statistical segment lengths. A nice tutorial on how these are 
    36 constructed and implemented can be found in chapters 28, 31 and 34, and Part H,  
     36constructed and implemented can be found in chapters 28, 31 and 34, and Part H, 
    3737of Hammouda's 'SANS Toolbox' [3]. 
    3838 
  • sasmodels/models/sphere.c

    ree60aa7 ra34b811  
    55 
    66static double 
    7 effective_radius(int mode, double radius) 
     7radius_effective(int mode, double radius) 
    88{ 
    99    // case 1: radius 
  • sasmodels/models/sphere.py

    r0507e09 ra34b811  
    4949---------------------------- 
    5050 
    51 * **Author:**  
    52 * **Last Modified by:**  
     51* **Author:** 
     52* **Last Modified by:** 
    5353* **Last Reviewed by:** S King and P Parker **Date:** 2013/09/09 and 2014/01/06 
    5454* **Source added by :** Steve King **Date:** March 25, 2019 
     
    8181source = ["lib/sas_3j1x_x.c", "sphere.c"] 
    8282have_Fq = True 
    83 effective_radius_type = ["radius"] 
     83radius_effective_modes = ["radius"] 
    8484 
    8585def random(): 
     
    9292 
    9393tests = [ 
    94     [{}, 0.2, 0.726362], 
    95     [{"scale": 1., "background": 0., "sld": 6., "sld_solvent": 1., 
    96       "radius": 120., "radius_pd": 0.2, "radius_pd_n":45}, 
    97      0.2, 0.228843], 
    98     [{"radius": 120., "radius_pd": 0.2, "radius_pd_n":45}, 
    99      0.1, None, None, 120., None, 1.0], 
    100     [{"@S": "hardsphere"}, 0.1, None], 
     94     [{}, 0.2, 0.726362], # each test starts with default parameter values inside { }, unless modified. Then Q and expected value of I(Q) 
     95     [{"scale": 1., "background": 0., "sld": 6., "sld_solvent": 1., 
     96       "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) 
     100   #  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. 
     103   #  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 
     113    [{"@S": "hardsphere", 
     114     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45, 
     115     "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? 
     119     }, 0.01, 1316.2990966463444 ], 
     120    [{"@S": "hardsphere", 
     121     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45, 
     122     "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 ], 
     127    [{"@S": "hardsphere", 
     128     "radius": 120., "radius_pd": 0.2, "radius_pd_n":45, 
     129     "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 ] 
    101134] 
     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 
  • sasmodels/models/spherical_sld.c

    ree60aa7 ra34b811  
    1919 
    2020static double 
    21 effective_radius(int mode, double fp_n_shells, double thickness[], double interface[]) 
     21radius_effective(int mode, double fp_n_shells, double thickness[], double interface[]) 
    2222{ 
    2323    // case 1: outer radius 
  • sasmodels/models/spherical_sld.py

    r0507e09 ra34b811  
    232232single = False  # TODO: fix low q behaviour 
    233233have_Fq = True 
    234 effective_radius_type = ["outer radius"] 
     234radius_effective_modes = ["outer radius"] 
    235235 
    236236profile_axes = ['Radius (A)', 'SLD (1e-6/A^2)'] 
  • sasmodels/models/squarewell.py

    r5f3c534 rdb1d9d5  
    11# Note: model title and parameter table are inserted automatically 
    22r""" 
    3 Calculates the interparticle structure factor for a hard sphere fluid  
    4 with a narrow, attractive, square well potential. **The Mean Spherical  
    5 Approximation (MSA) closure relationship is used, but it is not the most  
    6 appropriate closure for an attractive interparticle potential.** However,  
    7 the solution has been compared to Monte Carlo simulations for a square  
    8 well fluid and these show the MSA calculation to be limited to well  
     3Calculates the interparticle structure factor for a hard sphere fluid 
     4with a narrow, attractive, square well potential. **The Mean Spherical 
     5Approximation (MSA) closure relationship is used, but it is not the most 
     6appropriate closure for an attractive interparticle potential.** However, 
     7the solution has been compared to Monte Carlo simulations for a square 
     8well fluid and these show the MSA calculation to be limited to well 
    99depths $\epsilon < 1.5$ kT and volume fractions $\phi < 0.08$. 
    1010 
    1111Positive well depths correspond to an attractive potential well. Negative 
    1212well depths correspond to a potential "shoulder", which may or may not be 
    13 physically reasonable. The :ref:`stickyhardsphere` model may be a better  
     13physically reasonable. The :ref:`stickyhardsphere` model may be a better 
    1414choice in some circumstances. 
    1515 
     
    1818.. note:: 
    1919 
    20    Earlier versions of SasView did not incorporate the so-called  
    21    $\beta(q)$ ("beta") correction [2] for polydispersity and non-sphericity.  
     20   Earlier versions of SasView did not incorporate the so-called 
     21   $\beta(q)$ ("beta") correction [2] for polydispersity and non-sphericity. 
    2222   This is only available in SasView versions 4.2.2 and higher. 
    2323 
     
    6262---------------------------- 
    6363 
    64 * **Author:**  
    65 * **Last Modified by:**  
     64* **Author:** 
     65* **Last Modified by:** 
    6666* **Last Reviewed by:** Steve King **Date:** March 27, 2019 
    6767* **Source added by :** Steve King **Date:** March 25, 2019 
     
    7575description = """\ 
    7676    [Square well structure factor, with MSA closure] 
    77         Interparticle structure factor S(Q) for a hard sphere fluid  
     77        Interparticle structure factor S(Q) for a hard sphere fluid 
    7878    with a narrow attractive well. Fits are prone to deliver non- 
    79     physical parameters; use with care and read the references in  
    80     the model documentation.The "beta(q)" correction is available  
     79    physical parameters; use with care and read the references in 
     80    the model documentation.The "beta(q)" correction is available 
    8181    in versions 4.2.2 and higher. 
    8282""" 
  • sasmodels/models/stickyhardsphere.py

    r5f3c534 rdb1d9d5  
    11# Note: model title and parameter table are inserted automatically 
    22r""" 
    3 Calculates the interparticle structure factor for a hard sphere fluid  
    4 with a narrow, attractive, potential well. Unlike the :ref:`squarewell`  
    5 model, here a perturbative solution of the Percus-Yevick closure  
    6 relationship is used. The strength of the attractive well is described  
     3Calculates the interparticle structure factor for a hard sphere fluid 
     4with a narrow, attractive, potential well. Unlike the :ref:`squarewell` 
     5model, here a perturbative solution of the Percus-Yevick closure 
     6relationship is used. The strength of the attractive well is described 
    77in terms of "stickiness" as defined below. 
    88 
    99The perturbation parameter (perturb), $\tau$, should be fixed between 0.01 
    10 and 0.1 and the "stickiness", $\epsilon$, allowed to vary to adjust the  
    11 interaction strength. The "stickiness" is defined in the equation below and is  
    12 a function of both the perturbation parameter and the interaction strength.  
    13 $\epsilon$ and $\tau$ are defined in terms of the hard sphere diameter $(\sigma = 2 R)$,  
    14 the width of the square well, $\Delta$ (having the same units as $R$\ ),  
    15 and the depth of the well, $U_o$, in units of $kT$. From the definition, it  
     10and 0.1 and the "stickiness", $\epsilon$, allowed to vary to adjust the 
     11interaction strength. The "stickiness" is defined in the equation below and is 
     12a function of both the perturbation parameter and the interaction strength. 
     13$\epsilon$ and $\tau$ are defined in terms of the hard sphere diameter $(\sigma = 2 R)$, 
     14the width of the square well, $\Delta$ (having the same units as $R$\ ), 
     15and the depth of the well, $U_o$, in units of $kT$. From the definition, it 
    1616is clear that smaller $\epsilon$ means a stronger attraction. 
    1717 
     
    3737 
    3838The true particle volume fraction, $\phi$, is not equal to $h$ which appears 
    39 in most of reference [1]. The two are related in equation (24). Reference  
    40 [1] also describes the relationship between this perturbative solution and  
     39in most of reference [1]. The two are related in equation (24). Reference 
     40[1] also describes the relationship between this perturbative solution and 
    4141the original sticky hard sphere (or "adhesive sphere") model of Baxter [2]. 
    4242 
     
    4747   reported to the command window and $S(q)$ is set to -1 (so it will 
    4848   disappear on a log-log plot!). 
    49     
    50    Use tight bounds to keep the parameters to values that you know are  
    51    physical (test them), and keep nudging them until the optimization  
     49 
     50   Use tight bounds to keep the parameters to values that you know are 
     51   physical (test them), and keep nudging them until the optimization 
    5252   does not hit the constraints. 
    5353 
    5454.. note:: 
    5555 
    56    Earlier versions of SasView did not incorporate the so-called  
    57    $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity.  
     56   Earlier versions of SasView did not incorporate the so-called 
     57   $\beta(q)$ ("beta") correction [3] for polydispersity and non-sphericity. 
    5858   This is only available in SasView versions 4.2.2 and higher. 
    59     
     59 
    6060In SasView the effective radius may be calculated from the parameters 
    6161used in the form factor $P(q)$ that this $S(q)$ is combined with. 
     
    8686---------------------------- 
    8787 
    88 * **Author:**  
    89 * **Last Modified by:**  
     88* **Author:** 
     89* **Last Modified by:** 
    9090* **Last Reviewed by:** Steve King **Date:** March 27, 2019 
    9191* **Source added by :** Steve King **Date:** March 25, 2019 
     
    101101description = """\ 
    102102    [Sticky hard sphere structure factor, with Percus-Yevick closure] 
    103         Interparticle structure factor S(Q) for a hard sphere fluid  
     103        Interparticle structure factor S(Q) for a hard sphere fluid 
    104104    with a narrow attractive well. Fits are prone to deliver non- 
    105     physical parameters; use with care and read the references in  
    106     the model documentation.The "beta(q)" correction is available  
     105    physical parameters; use with care and read the references in 
     106    the model documentation.The "beta(q)" correction is available 
    107107    in versions 4.2.2 and higher. 
    108108""" 
  • sasmodels/models/triaxial_ellipsoid.c

    r99658f6 ra34b811  
    7676 
    7777static double 
    78 effective_radius(int mode, double radius_equat_minor, double radius_equat_major, double radius_polar) 
     78radius_effective(int mode, double radius_equat_minor, double radius_equat_major, double radius_polar) 
    7979{ 
    8080    switch (mode) { 
  • sasmodels/models/triaxial_ellipsoid.py

    r0507e09 ra34b811  
    164164source = ["lib/sas_3j1x_x.c", "lib/gauss76.c", "triaxial_ellipsoid.c"] 
    165165have_Fq = True 
    166 effective_radius_type = [ 
     166radius_effective_modes = [ 
    167167    "equivalent biaxial ellipsoid average curvature", 
    168168    "equivalent volume sphere", "min radius", "max radius", 
  • sasmodels/models/vesicle.c

    r12f4c19 ra34b811  
    1313 
    1414static double 
    15 effective_radius(int mode, double radius, double thickness) 
     15radius_effective(int mode, double radius, double thickness) 
    1616{ 
    1717    // case 1: outer radius 
  • sasmodels/models/vesicle.py

    r0507e09 ra34b811  
    107107source = ["lib/sas_3j1x_x.c", "vesicle.c"] 
    108108have_Fq = True 
    109 effective_radius_type = ["outer radius"] 
     109radius_effective_modes = ["outer radius"] 
    110110 
    111111def random(): 
  • sasmodels/product.py

    rb297ba9 r8795b6f  
    3131# pylint: enable=unused-import 
    3232 
    33 # TODO: make estimates available to constraints 
     33# TODO: make shape averages available to constraints 
    3434#ESTIMATED_PARAMETERS = [ 
    35 #    ["est_radius_effective", "A", 0.0, [0, np.inf], "", "Estimated effective radius"], 
    36 #    ["est_volume_ratio", "", 1.0, [0, np.inf], "", "Estimated volume ratio"], 
     35#    ["mean_radius_effective", "A", 0.0, [0, np.inf], "", "mean effective radius"], 
     36#    ["mean_volume", "A", 0.0, [0, np.inf], "", "mean volume"], 
     37#    ["mean_volume_ratio", "", 1.0, [0, np.inf], "", "mean form: mean shell volume ratio"], 
    3738#] 
    38  
    3939STRUCTURE_MODE_ID = "structure_factor_mode" 
    4040RADIUS_MODE_ID = "radius_effective_mode" 
     
    4444    # type: (ModelInfo) -> List[Parameter] 
    4545    """ 
    46     Create parameters for structure_factor_mode and radius_effective_mode. 
     46    Create parameters for structure factor and effective radius modes. 
    4747    """ 
    4848    pars = [] 
     
    5656            "Structure factor calculation") 
    5757        pars.append(par) 
    58     if p_info.effective_radius_type is not None: 
     58    if p_info.radius_effective_modes is not None: 
    5959        par = parse_parameter( 
    6060            RADIUS_MODE_ID, 
    6161            "", 
    6262            1, 
    63             [["unconstrained"] + p_info.effective_radius_type], 
     63            [["unconstrained"] + p_info.radius_effective_modes], 
    6464            "", 
    6565            "Effective radius calculation") 
     
    177177        S,                # type: np.ndarray 
    178178        scale,            # type: float 
    179         effective_radius, # type: float 
     179        radius_effective, # type: float 
    180180        beta_mode,        # type: bool 
    181181    ): 
     
    193193            ("beta(Q)", F1**2 / F2), 
    194194            ("S_eff(Q)", 1 + (F1**2 / F2)*(S-1)), 
    195             ("effective_radius", effective_radius), 
     195            ("effective_radius", radius_effective), 
    196196            # ("I(Q)", scale*(F2 + (F1**2)*(S-1)) + bg), 
    197197        )) 
     
    200200            ("P(Q)", scale*F2), 
    201201            ("S(Q)", S), 
    202             ("effective_radius", effective_radius), 
     202            ("effective_radius", radius_effective), 
    203203        )) 
    204204    return parts 
     
    281281        # R_eff type parameter is the second parameter after P and S parameters 
    282282        # unless the model doesn't support beta mode, in which case it is first 
    283         have_radius_type = p_info.effective_radius_type is not None 
     283        have_radius_type = p_info.radius_effective_modes is not None 
     284        #print(p_npars,s_npars) 
    284285        radius_type_offset = 2+p_npars+s_npars + (1 if have_beta_mode else 0) 
     286        #print(values[radius_type_offset]) 
    285287        radius_type = int(values[radius_type_offset]) if have_radius_type else 0 
    286288 
     
    331333        # Call the form factor kernel to compute <F> and <F^2>. 
    332334        # If the model doesn't support Fq the returned <F> will be None. 
    333         F1, F2, effective_radius, shell_volume, volume_ratio = self.p_kernel.Fq( 
     335        F1, F2, radius_effective, shell_volume, volume_ratio = self.p_kernel.Fq( 
    334336            p_details, p_values, cutoff, magnetic, radius_type) 
    335337 
     
    341343        # implementation details in kernel_iq.c. 
    342344        #print("R_eff=%d:%g, volfrac=%g, volume ratio=%g" 
    343         #      % (radius_type, effective_radius, volfrac, volume_ratio)) 
     345        #      % (radius_type, radius_effective, volfrac, volume_ratio)) 
    344346        if radius_type > 0: 
    345347            # set the value to the model R_eff and set the weight to 1 
    346             s_values[2] = s_values[2+s_npars+s_offset[0]] = effective_radius 
     348            s_values[2] = s_values[2+s_npars+s_offset[0]] = radius_effective 
    347349            s_values[2+s_npars+s_offset[0]+nweights] = 1.0 
    348350        s_values[3] = s_values[2+s_npars+s_offset[1]] = volfrac*volume_ratio 
     
    370372        # the results directly rather than through a lazy evaluator. 
    371373        self.results = lambda: _intermediates( 
    372             F1, F2, S, combined_scale, effective_radius, beta_mode) 
     374            F1, F2, S, combined_scale, radius_effective, beta_mode) 
    373375 
    374376        return final_result 
  • sasmodels/sasview_model.py

    rb297ba9 ra34b811  
    299299    attrs['category'] = model_info.category 
    300300    attrs['is_structure_factor'] = model_info.structure_factor 
    301     attrs['is_form_factor'] = model_info.effective_radius_type is not None 
     301    attrs['is_form_factor'] = model_info.radius_effective_modes is not None 
    302302    attrs['is_multiplicity_model'] = variants[0] > 1 
    303303    attrs['multiplicity_info'] = variants 
     
    763763        #    if er_mode > 0: 
    764764        #        res = calculator.Fq(call_details, values, cutoff=self.cutoff, 
    765         #                            magnetic=False, effective_radius_type=mode) 
     765        #                            magnetic=False, radius_effective_mode=mode) 
    766766        #        R_eff, form_shell_ratio = res[2], res[4] 
    767767        #        return R_eff, form_shell_ratio 
Note: See TracChangeset for help on using the changeset viewer.