Changeset d277229 in sasmodels


Ignore:
Timestamp:
Sep 7, 2018 5:29:38 AM (6 years ago)
Author:
grethevj
Branches:
master, core_shell_microgels, magnetic_model, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests
Children:
3c60146
Parents:
2a12351b
Message:

Models updated to include choices for effective interaction radii

Location:
sasmodels/models
Files:
3 added
53 edited

Legend:

Unmodified
Added
Removed

  • sasmodels/models/barbell.c

    r71b751d rd277229  
    6262} 
    6363 
     64static double 
     65radius_from_volume(double radius_bell, double radius, double length) 
     66{ 
     67    const double vol_barbell = form_volume(radius_bell,radius,length); 
     68    return cbrt(0.75*vol_barbell/M_PI); 
     69} 
     70 
     71static double 
     72radius_from_totallength(double radius_bell, double radius, double length) 
     73{ 
     74    const double hdist = sqrt(square(radius_bell) - square(radius)); 
     75    return 0.5*length + hdist + radius_bell; 
     76} 
     77 
     78static double 
     79effective_radius(int mode, double radius_bell, double radius, double length) 
     80{ 
     81    if (mode == 1) { 
     82        return radius_from_volume(radius_bell, radius , length); 
     83    } else if (mode == 2) { 
     84        return radius; 
     85    } else if (mode == 3) { 
     86        return 0.5*length; 
     87    } else { 
     88        return radius_from_totallength(radius_bell,radius,length); 
     89    } 
     90} 
     91 
    6492static void 
    6593Fq(double q,double *F1, double *F2, double sld, double solvent_sld, 

  • sasmodels/models/barbell.py

    r71b751d rd277229  
    117117source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "barbell.c"] 
    118118have_Fq = True 
     119effective_radius_type = ["equivalent sphere","radius","half length","half total length"] 
    119120 
    120121def random(): 

  • sasmodels/models/capped_cylinder.c

    r71b751d rd277229  
    8484} 
    8585 
     86static double 
     87radius_from_volume(double radius, double radius_cap, double length) 
     88{ 
     89    const double vol_cappedcyl = form_volume(radius,radius_cap,length); 
     90    return cbrt(0.75*vol_cappedcyl/M_PI); 
     91} 
     92 
     93static double 
     94radius_from_totallength(double radius, double radius_cap, double length) 
     95{ 
     96    const double hc = radius_cap - sqrt(radius_cap*radius_cap - radius*radius); 
     97    return 0.5*length + hc; 
     98} 
     99 
     100static double 
     101effective_radius(int mode, double radius, double radius_cap, double length) 
     102{ 
     103    if (mode == 1) { 
     104        return radius_from_volume(radius, radius_cap, length); 
     105    } else if (mode == 2) { 
     106        return radius; 
     107    } else if (mode == 3) { 
     108        return 0.5*length; 
     109    } else { 
     110        return radius_from_totallength(radius, radius_cap,length); 
     111    } 
     112} 
     113 
    86114static void 
    87115Fq(double q,double *F1, double *F2, double sld, double solvent_sld, 

  • sasmodels/models/capped_cylinder.py

    r71b751d rd277229  
    137137source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "capped_cylinder.c"] 
    138138have_Fq = True 
     139effective_radius_type = ["equivalent sphere","radius","half length","half total length"] 
    139140 
    140141def random(): 

  • sasmodels/models/core_multi_shell.c

    r71b751d rd277229  
    1919} 
    2020 
     21static double 
     22outer_radius(double core_radius, double fp_n, double thickness[]) 
     23{ 
     24  double r = core_radius; 
     25  int n = (int)(fp_n+0.5); 
     26  for (int i=0; i < n; i++) { 
     27    r += thickness[i]; 
     28  } 
     29  return r; 
     30} 
     31 
     32static double 
     33effective_radius(int mode, double core_radius, double fp_n, double thickness[]) 
     34{ 
     35    if (mode == 1) { 
     36        double r = core_radius; 
     37        int n = (int)(fp_n+0.5); 
     38        for (int i=0; i < n; i++) { 
     39            r += thickness[i]; 
     40        } 
     41        return r; 
     42        //return outer_radius(core_radius,fp_n,thickness); 
     43    } else { 
     44        return core_radius; 
     45    } 
     46} 
     47 
    2148static void 
    2249Fq(double q, double *F1, double *F2, double core_sld, double core_radius, 

  • sasmodels/models/core_multi_shell.py

    r71b751d rd277229  
    100100source = ["lib/sas_3j1x_x.c", "core_multi_shell.c"] 
    101101have_Fq = True 
     102effective_radius_type = ["outer radius", "core radius"] 
    102103 
    103104def random(): 
    … …  
    144145    return np.asarray(z), np.asarray(rho) 
    145146 
    146 def ER(radius, n, thickness): 
    147     """Effective radius""" 
    148     n = int(n[0]+0.5)  # n is a control parameter and is not polydisperse 
    149     return np.sum(thickness[:n], axis=0) + radius 
     147#def ER(radius, n, thickness): 
     148#    """Effective radius""" 
     149#    n = int(n[0]+0.5)  # n is a control parameter and is not polydisperse 
     150#    return np.sum(thickness[:n], axis=0) + radius 
    150151 
    151152demo = dict(sld_core=6.4, 

  • sasmodels/models/core_shell_bicelle.c

    r71b751d rd277229  
    3434 
    3535    return t; 
     36} 
     37 
     38static double 
     39radius_from_volume(double radius, double thick_rim, double thick_face, double length) 
     40{ 
     41    const double volume_bicelle = form_volume(radius,thick_rim,thick_face,length); 
     42    return cbrt(0.75*volume_bicelle/M_PI); 
     43} 
     44 
     45static double 
     46radius_from_diagonal(double radius, double thick_rim, double thick_face, double length) 
     47{ 
     48    const double radius_tot = radius + thick_rim; 
     49    const double length_tot = length + 2.0*thick_face; 
     50    return sqrt(radius_tot*radius_tot + 0.25*length_tot*length_tot); 
     51} 
     52 
     53static double 
     54effective_radius(int mode, double radius, double thick_rim, double thick_face, double length) 
     55{ 
     56    if (mode == 1) { 
     57        return radius_from_volume(radius, thick_rim, thick_face, length); 
     58    } else if (mode == 2) { 
     59        return radius + thick_rim; 
     60    } else if (mode == 3) { 
     61        return 0.5*length + thick_face; 
     62    } else { 
     63        return radius_from_diagonal(radius,thick_rim,thick_face,length); 
     64    } 
    3665} 
    3766 

  • sasmodels/models/core_shell_bicelle.py

    r71b751d rd277229  
    155155          "core_shell_bicelle.c"] 
    156156have_Fq = True 
     157effective_radius_type = ["equivalent sphere","outer rim radius", "half outer thickness","half diagonal"] 
    157158 
    158159def random(): 

  • sasmodels/models/core_shell_bicelle_elliptical.c

    r71b751d rd277229  
    88{ 
    99    return M_PI*(r_minor+thick_rim)*(r_minor*x_core+thick_rim)*(length+2.0*thick_face); 
     10} 
     11 
     12static double 
     13radius_from_volume(double r_minor, double x_core, double thick_rim, double thick_face, double length) 
     14{ 
     15    const double volume_bicelle = form_volume(r_minor, x_core, thick_rim,thick_face,length); 
     16    return cbrt(0.75*volume_bicelle/M_PI); 
     17} 
     18 
     19static double 
     20radius_from_diagonal(double r_minor, double x_core, double thick_rim, double thick_face, double length) 
     21{ 
     22    const double radius_max = (x_core < 1.0 ? r_minor : x_core*r_minor); 
     23    const double radius_max_tot = radius_max + thick_rim; 
     24    const double length_tot = length + 2.0*thick_face; 
     25    return sqrt(radius_max_tot*radius_max_tot + 0.25*length_tot*length_tot); 
     26} 
     27 
     28static double 
     29effective_radius(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length) 
     30{ 
     31    if (mode == 1) { 
     32        return radius_from_volume(r_minor, x_core, thick_rim, thick_face, length); 
     33    } else if (mode == 2) { 
     34        return 0.5*r_minor*(1.0 + x_core) + thick_rim; 
     35    } else if (mode == 3) { 
     36        return (x_core < 1.0 ? x_core*r_minor+thick_rim : r_minor+thick_rim); 
     37    } else if (mode == 4) { 
     38        return (x_core > 1.0 ? x_core*r_minor+thick_rim : r_minor+thick_rim); 
     39    } else if (mode ==5) { 
     40        return 0.5*length + thick_face; 
     41    } else { 
     42        return radius_from_diagonal(r_minor,x_core,thick_rim,thick_face,length); 
     43    } 
    1044} 
    1145 

  • sasmodels/models/core_shell_bicelle_elliptical.py

    r71b751d rd277229  
    147147          "core_shell_bicelle_elliptical.c"] 
    148148have_Fq = True 
     149effective_radius_type = ["equivalent sphere","outer rim average radius","outer rim min radius", 
     150                         "outer max radius", "half outer thickness","half diagonal"] 
    149151 
    150152def random(): 

  • sasmodels/models/core_shell_bicelle_elliptical_belt_rough.c

    r71b751d rd277229  
    99    return M_PI*(  (r_minor + thick_rim)*(r_minor*x_core + thick_rim)* length + 
    1010                 square(r_minor)*x_core*2.0*thick_face  ); 
     11} 
     12 
     13static double 
     14radius_from_volume(double r_minor, double x_core, double thick_rim, double thick_face, double length) 
     15{ 
     16    const double volume_bicelle = form_volume(r_minor, x_core, thick_rim,thick_face,length); 
     17    return cbrt(0.75*volume_bicelle/M_PI); 
     18} 
     19 
     20static double 
     21radius_from_diagonal(double r_minor, double x_core, double thick_rim, double thick_face, double length) 
     22{ 
     23    const double radius_max = (x_core < 1.0 ? r_minor : x_core*r_minor); 
     24    const double radius_max_tot = radius_max + thick_rim; 
     25    const double length_tot = length + 2.0*thick_face; 
     26    return sqrt(radius_max_tot*radius_max_tot + 0.25*length_tot*length_tot); 
     27} 
     28 
     29static double 
     30effective_radius(int mode, double r_minor, double x_core, double thick_rim, double thick_face, double length) 
     31{ 
     32    if (mode == 1) { 
     33        return radius_from_volume(r_minor, x_core, thick_rim, thick_face, length); 
     34    } else if (mode == 2) { 
     35        return 0.5*r_minor*(1.0 + x_core) + thick_rim; 
     36    } else if (mode == 3) { 
     37        return (x_core < 1.0 ? x_core*r_minor+thick_rim : r_minor+thick_rim); 
     38    } else if (mode == 4) { 
     39        return (x_core > 1.0 ? x_core*r_minor+thick_rim : r_minor+thick_rim); 
     40    } else if (mode ==5) { 
     41        return 0.5*length + thick_face; 
     42    } else { 
     43        return radius_from_diagonal(r_minor,x_core,thick_rim,thick_face,length); 
     44    } 
    1145} 
    1246 

  • sasmodels/models/core_shell_bicelle_elliptical_belt_rough.py

    r71b751d rd277229  
    160160          "core_shell_bicelle_elliptical_belt_rough.c"] 
    161161have_Fq = True 
     162effective_radius_type = ["equivalent sphere","outer rim average radius","outer rim min radius", 
     163                         "outer max radius", "half outer thickness","half diagonal"] 
    162164 
    163165demo = dict(scale=1, background=0, 

  • sasmodels/models/core_shell_cylinder.c

    r71b751d rd277229  
    1111{ 
    1212    return M_PI*square(radius+thickness)*(length+2.0*thickness); 
     13} 
     14 
     15static double 
     16radius_from_volume(double radius, double thickness, double length) 
     17{ 
     18    const double volume_outer_cyl = form_volume(radius,thickness,length); 
     19    return cbrt(0.75*volume_outer_cyl/M_PI); 
     20} 
     21 
     22static double 
     23radius_from_diagonal(double radius, double thickness, double length) 
     24{ 
     25    const double radius_outer = radius + thickness; 
     26    const double length_outer = length + thickness; 
     27    return sqrt(radius_outer*radius_outer + 0.25*length_outer*length_outer); 
     28} 
     29 
     30static double 
     31effective_radius(int mode, double radius, double thickness, double length) 
     32{ 
     33    if (mode == 1) { 
     34        return radius_from_volume(radius, thickness, length); 
     35    } else if (mode == 2) { 
     36        return radius + thickness; 
     37    } else if (mode == 3) { 
     38        return 0.5*length + thickness; 
     39    } else if (mode == 4) { 
     40        return (radius < 0.5*length ? radius + thickness : 0.5*length + thickness); 
     41    } else if (mode == 5) { 
     42        return (radius > 0.5*length ? radius + thickness : 0.5*length + thickness); 
     43    } else { 
     44        return radius_from_diagonal(radius,thickness,length); 
     45    } 
    1346} 
    1447 

  • sasmodels/models/core_shell_cylinder.py

    r71b751d rd277229  
    126126source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "core_shell_cylinder.c"] 
    127127have_Fq = True 
     128effective_radius_type = ["equivalent sphere","outer radius","half outer length","half min outer dimension", 
     129                         "half max outer dimension","half outer diagonal"] 
    128130 
    129 def ER(radius, thickness, length): 
    130     """ 
    131     Returns the effective radius used in the S*P calculation 
    132     """ 
    133     radius = radius + thickness 
    134     length = length + 2 * thickness 
    135     ddd = 0.75 * radius * (2 * radius * length + (length + radius) * (length + pi * radius)) 
    136     return 0.5 * (ddd) ** (1. / 3.) 
     131#def ER(radius, thickness, length): 
     132#    """ 
     133#    Returns the effective radius used in the S*P calculation 
     134#    """ 
     135#    radius = radius + thickness 
     136#    length = length + 2 * thickness 
     137#    ddd = 0.75 * radius * (2 * radius * length + (length + radius) * (length + pi * radius)) 
     138#    return 0.5 * (ddd) ** (1. / 3.) 
    137139 
    138140def VR(radius, thickness, length): 

  • sasmodels/models/core_shell_ellipsoid.c

    r71b751d rd277229  
    3636    double vol = M_4PI_3*equat_shell*equat_shell*polar_shell; 
    3737    return vol; 
     38} 
     39 
     40static double 
     41radius_from_volume(double radius_equat_core, double x_core, double thick_shell, double x_polar_shell) 
     42{ 
     43    const double volume_ellipsoid = form_volume(radius_equat_core, x_core, thick_shell, x_polar_shell); 
     44    return cbrt(0.75*volume_ellipsoid/M_PI); 
     45} 
     46 
     47static double 
     48radius_from_curvature(double radius_equat_core, double x_core, double thick_shell, double x_polar_shell) 
     49{ 
     50    // Trivial cases 
     51    if (x_core == x_polar_shell == 1.0) return radius_equat_core + thick_shell; 
     52    if ((radius_equat_core + thick_shell)*(radius_equat_core*x_core + thick_shell*x_polar_shell) == 0.)  return 0.; 
     53 
     54    // see equation (26) in A.Isihara, J.Chem.Phys. 18(1950)1446-1449 
     55    const double radius_equat_tot = radius_equat_core + thick_shell; 
     56    const double radius_polar_tot = radius_equat_core*x_core + thick_shell*x_polar_shell; 
     57    const double ratio = (radius_polar_tot < radius_equat_tot 
     58                          ? radius_polar_tot / radius_equat_tot 
     59                          : radius_equat_tot / radius_polar_tot); 
     60    const double e1 = sqrt(1.0 - ratio*ratio); 
     61    const double b1 = 1.0 + asin(e1) / (e1 * ratio); 
     62    const double bL = (1.0 + e1) / (1.0 - e1); 
     63    const double b2 = 1.0 + 0.5 * ratio * ratio / e1 * log(bL); 
     64    const double delta = 0.75 * b1 * b2; 
     65    const double ddd = 2.0 * (delta + 1.0) * radius_polar_tot * radius_equat_tot * radius_equat_tot; 
     66    return 0.5 * cbrt(ddd); 
     67} 
     68 
     69static double 
     70effective_radius(int mode, double radius_equat_core, double x_core, double thick_shell, double x_polar_shell) 
     71{ 
     72    if (mode == 1) { 
     73        return radius_from_volume(radius_equat_core, x_core, thick_shell, x_polar_shell); 
     74    } else if (mode == 2) { 
     75        return radius_from_curvature(radius_equat_core, x_core, thick_shell, x_polar_shell); 
     76    } else if (mode == 3) { 
     77        const double radius_equat_tot = radius_equat_core + thick_shell; 
     78        const double radius_polar_tot = radius_equat_core*x_core + thick_shell*x_polar_shell; 
     79        return (radius_polar_tot < radius_equat_tot ? radius_polar_tot : radius_equat_tot); 
     80    } else { 
     81        const double radius_equat_tot = radius_equat_core + thick_shell; 
     82        const double radius_polar_tot = radius_equat_core*x_core + thick_shell*x_polar_shell; 
     83        return (radius_polar_tot > radius_equat_tot ? radius_polar_tot : radius_equat_tot); 
     84    } 
    3885} 
    3986 

  • sasmodels/models/core_shell_ellipsoid.py

    r71b751d rd277229  
    146146source = ["lib/sas_3j1x_x.c", "lib/gauss76.c", "core_shell_ellipsoid.c"] 
    147147have_Fq = True 
    148  
    149 def ER(radius_equat_core, x_core, thick_shell, x_polar_shell): 
    150     """ 
    151         Returns the effective radius used in the S*P calculation 
    152     """ 
    153     from .ellipsoid import ER as ellipsoid_ER 
    154     polar_outer = radius_equat_core*x_core + thick_shell*x_polar_shell 
    155     equat_outer = radius_equat_core + thick_shell 
    156     return ellipsoid_ER(polar_outer, equat_outer) 
     148effective_radius_type = ["equivalent sphere","average outer curvature", "min outer radius", "max outer radius"] 
     149 
     150#def ER(radius_equat_core, x_core, thick_shell, x_polar_shell): 
     151#    """ 
     152#        Returns the effective radius used in the S*P calculation 
     153#    """ 
     154#    from .ellipsoid import ER as ellipsoid_ER 
     155#    polar_outer = radius_equat_core*x_core + thick_shell*x_polar_shell 
     156#    equat_outer = radius_equat_core + thick_shell 
     157#    return ellipsoid_ER(polar_outer, equat_outer) 
    157158 
    158159def random(): 

  • sasmodels/models/core_shell_parallelepiped.c

    r71b751d rd277229  
    2525        2.0 * length_a * length_b * thick_rim_c; 
    2626#endif 
     27} 
     28 
     29static double 
     30radius_from_volume(double length_a, double length_b, double length_c, 
     31                   double thick_rim_a, double thick_rim_b, double thick_rim_c) 
     32{ 
     33    const double volume_paral = form_volume(length_a, length_b, length_c, thick_rim_a, thick_rim_b, thick_rim_c); 
     34    return cbrt(0.75*volume_paral/M_PI); 
     35} 
     36 
     37static double 
     38radius_from_crosssection(double length_a, double length_b, double thick_rim_a, double thick_rim_b) 
     39{ 
     40    const double area_xsec_paral = length_a*length_b + 2.0*thick_rim_a*length_b + 2.0*thick_rim_b*length_a; 
     41    return sqrt(area_xsec_paral/M_PI); 
     42} 
     43 
     44static double 
     45effective_radius(int mode, double length_a, double length_b, double length_c, 
     46                 double thick_rim_a, double thick_rim_b, double thick_rim_c) 
     47{ 
     48    if (mode == 1) { 
     49        return radius_from_volume(length_a, length_b, length_c, thick_rim_a, thick_rim_b, thick_rim_c); 
     50    } else if (mode == 2) { 
     51        return 0.5 * (length_a + thick_rim_a); 
     52    } else if (mode == 3) { 
     53        return 0.5 * (length_b + thick_rim_b); 
     54    } else if (mode == 4) { 
     55        return 0.5 * (length_c + thick_rim_c); 
     56    } else if (mode == 5) { 
     57        return radius_from_crosssection(length_a, length_b, thick_rim_a, thick_rim_b); 
     58    } else if (mode == 6) { 
     59        return 0.5*sqrt(square(length_a+thick_rim_a) + square(length_b+thick_rim_b)); 
     60    } else { 
     61        return 0.5*sqrt(square(length_a+thick_rim_a) + square(length_b+thick_rim_b) + square(length_c+thick_rim_c)); 
     62    } 
    2763} 
    2864 

  • sasmodels/models/core_shell_parallelepiped.py

    r71b751d rd277229  
    227227source = ["lib/gauss76.c", "core_shell_parallelepiped.c"] 
    228228have_Fq = True 
    229  
    230  
    231 def ER(length_a, length_b, length_c, thick_rim_a, thick_rim_b, thick_rim_c): 
    232     """ 
    233         Return equivalent radius (ER) 
    234     """ 
    235     from .parallelepiped import ER as ER_p 
    236  
    237     a = length_a + 2*thick_rim_a 
    238     b = length_b + 2*thick_rim_b 
    239     c = length_c + 2*thick_rim_c 
    240     return ER_p(a, b, c) 
     229effective_radius_type = ["equivalent sphere","half outer length_a", "half outer length_b", "half outer length_c", 
     230                         "equivalent circular cross-section","half outer ab diagonal","half outer diagonal"] 
     231 
     232#def ER(length_a, length_b, length_c, thick_rim_a, thick_rim_b, thick_rim_c): 
     233#    """ 
     234#        Return equivalent radius (ER) 
     235#    """ 
     236#    from .parallelepiped import ER as ER_p 
     237# 
     238#    a = length_a + 2*thick_rim_a 
     239#    b = length_b + 2*thick_rim_b 
     240#    c = length_c + 2*thick_rim_c 
     241#    return ER_p(a, b, c) 
    241242 
    242243# VR defaults to 1.0 

  • sasmodels/models/core_shell_sphere.c

    r71b751d rd277229  
    33{ 
    44    return M_4PI_3 * cube(radius + thickness); 
     5} 
     6 
     7static double 
     8effective_radius(int mode, double radius, double thickness) 
     9{ 
     10    if (mode == 1) { 
     11        return radius + thickness; 
     12    } else { 
     13        return radius; 
     14    } 
    515} 
    616 

  • sasmodels/models/core_shell_sphere.py

    r71b751d rd277229  
    7878source = ["lib/sas_3j1x_x.c", "lib/core_shell.c", "core_shell_sphere.c"] 
    7979have_Fq = True 
     80effective_radius_type = ["outer radius", "core radius"] 
    8081 
    8182demo = dict(scale=1, background=0, radius=60, thickness=10, 
    8283            sld_core=1.0, sld_shell=2.0, sld_solvent=0.0) 
    8384 
    84 def ER(radius, thickness): 
    85     """ 
    86         Equivalent radius 
    87         @param radius: core radius 
    88         @param thickness: shell thickness 
    89     """ 
    90     return radius + thickness 
     85#def ER(radius, thickness): 
     86#    """ 
     87#        Equivalent radius 
     88#        @param radius: core radius 
     89#        @param thickness: shell thickness 
     90#    """ 
     91#    return radius + thickness 
    9192 
    9293def VR(radius, thickness): 

  • sasmodels/models/cylinder.c

    r71b751d rd277229  
    1111{ 
    1212    return sas_2J1x_x(qab*radius) * sas_sinx_x(qc*0.5*length); 
     13} 
     14 
     15static double 
     16radius_from_volume(double radius, double length) 
     17{ 
     18    return cbrt(0.75*radius*radius*length); 
     19} 
     20 
     21static double 
     22radius_from_diagonal(double radius, double length) 
     23{ 
     24    return sqrt(radius*radius + 0.25*length*length); 
     25} 
     26 
     27static double 
     28effective_radius(int mode, double radius, double length) 
     29{ 
     30    if (mode == 1) { 
     31        return radius_from_volume(radius, length); 
     32    } else if (mode == 2) { 
     33        return radius; 
     34    } else if (mode == 3) { 
     35        return 0.5*length; 
     36    } else if (mode == 4) { 
     37        return (radius < 0.5*length ? radius : 0.5*length); 
     38    } else if (mode == 5) { 
     39        return (radius > 0.5*length ? radius : 0.5*length); 
     40    } else { 
     41        return radius_from_diagonal(radius,length); 
     42    } 
    1343} 
    1444 

  • sasmodels/models/cylinder.py

    r71b751d rd277229  
    139139source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "cylinder.c"] 
    140140have_Fq = True 
     141effective_radius_type = ["equivalent sphere","radius","half length","half min dimension","half max dimension","half diagonal"] 
    141142 
    142 def ER(radius, length): 
    143     """ 
    144         Return equivalent radius (ER) 
    145     """ 
    146     ddd = 0.75 * radius * (2 * radius * length + (length + radius) * (length + pi * radius)) 
    147     return 0.5 * (ddd) ** (1. / 3.) 
     143#def ER(radius, length): 
     144#    """ 
     145#        Return equivalent radius (ER) 
     146#    """ 
     147#    ddd = 0.75 * radius * (2 * radius * length + (length + radius) * (length + pi * radius)) 
     148#    return 0.5 * (ddd) ** (1. / 3.) 
    148149 
    149150def random(): 

  • sasmodels/models/ellipsoid.c

    r6e7ba14 rd277229  
    44    return M_4PI_3*radius_polar*radius_equatorial*radius_equatorial; 
    55} 
    6  
    76 
    87static double 
    … …  
    2019 
    2120    // see equation (26) in A.Isihara, J.Chem.Phys. 18(1950)1446-1449 
    22     const double ratio = (radius_polar < radius_equatorial  
     21    const double ratio = (radius_polar < radius_equatorial 
    2322                          ? radius_polar / radius_equatorial 
    2423                          : radius_equatorial / radius_polar); 
    … …  
    3635{ 
    3736    if (mode == 1) { 
     37        return radius_from_volume(radius_polar, radius_equatorial); 
     38    } else if (mode == 2) { 
    3839        return radius_from_curvature(radius_polar, radius_equatorial); 
    39     } else if (mode == 2) { 
    40         return radius_from_volume(radius_polar, radius_equatorial); 
    4140    } else if (mode == 3) { 
    4241        return (radius_polar < radius_equatorial ? radius_polar : radius_equatorial); 

  • sasmodels/models/ellipsoid.py

    r6e7ba14 rd277229  
    164164source = ["lib/sas_3j1x_x.c", "lib/gauss76.c", "ellipsoid.c"] 
    165165have_Fq = True 
    166 effective_radius_type = ["average curvature", "equivalent sphere", "min radius", "max radius"] 
     166effective_radius_type = ["equivalent sphere","average curvature", "min radius", "max radius"] 
    167167 
    168168def random(): 

  • sasmodels/models/elliptical_cylinder.c

    r71b751d rd277229  
    33{ 
    44    return M_PI * radius_minor * radius_minor * r_ratio * length; 
     5} 
     6 
     7static double 
     8radius_from_volume(double radius_minor, double r_ratio, double length) 
     9{ 
     10    const double volume_ellcyl = form_volume(radius_minor,r_ratio,length); 
     11    return cbrt(0.75*volume_ellcyl/M_PI); 
     12} 
     13 
     14static double 
     15radius_from_min_dimension(double radius_minor, double r_ratio, double length) 
     16{ 
     17    const double rad_min = (r_ratio > 1.0 ? radius_minor : r_ratio*radius_minor); 
     18    return (rad_min < length ? rad_min : length); 
     19} 
     20 
     21static double 
     22radius_from_max_dimension(double radius_minor, double r_ratio, double length) 
     23{ 
     24    const double rad_max = (r_ratio < 1.0 ? radius_minor : r_ratio*radius_minor); 
     25    return (rad_max > length ? rad_max : length); 
     26} 
     27 
     28static double 
     29radius_from_diagonal(double radius_minor, double r_ratio, double length) 
     30{ 
     31    const double radius_max = (r_ratio > 1.0 ? radius_minor*r_ratio : radius_minor); 
     32    return sqrt(radius_max*radius_max + 0.25*length*length); 
     33} 
     34 
     35static double 
     36effective_radius(int mode, double radius_minor, double r_ratio, double length) 
     37{ 
     38    if (mode == 1) { 
     39        return radius_from_volume(radius_minor, r_ratio, length); 
     40    } else if (mode == 2) { 
     41        return 0.5*radius_minor*(1.0 + r_ratio); 
     42    } else if (mode == 3) { 
     43        return (r_ratio > 1.0 ? radius_minor : r_ratio*radius_minor); 
     44    } else if (mode == 4) { 
     45        return (r_ratio < 1.0 ? radius_minor : r_ratio*radius_minor); 
     46    } else if (mode == 5) { 
     47        return sqrt(radius_minor*radius_minor*r_ratio); 
     48    } else if (mode == 6) { 
     49        return 0.5*length; 
     50    } else if (mode == 7) { 
     51        return radius_from_min_dimension(radius_minor,r_ratio,length); 
     52    } else if (mode == 8) { 
     53        return radius_from_max_dimension(radius_minor,r_ratio,length); 
     54    } else { 
     55        return radius_from_diagonal(radius_minor,r_ratio,length); 
     56    } 
    557} 
    658 

  • sasmodels/models/elliptical_cylinder.py

    r71b751d rd277229  
    123123source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "elliptical_cylinder.c"] 
    124124have_Fq = True 
     125effective_radius_type = ["equivalent sphere","average radius","min radius","max radius", 
     126                         "equivalent circular cross-section","half length","half min dimension","half max dimension","half diagonal"] 
    125127 
    126128demo = dict(scale=1, background=0, radius_minor=100, axis_ratio=1.5, length=400.0, 
    … …  
    128130            theta_pd=10, phi_pd=2, psi_pd=3) 
    129131 
    130 def ER(radius_minor, axis_ratio, length): 
    131     """ 
    132         Equivalent radius 
    133         @param radius_minor: Ellipse minor radius 
    134         @param axis_ratio: Ratio of major radius over minor radius 
    135         @param length: Length of the cylinder 
    136     """ 
    137     radius = sqrt(radius_minor * radius_minor * axis_ratio) 
    138     ddd = 0.75 * radius * (2 * radius * length 
    139                            + (length + radius) * (length + pi * radius)) 
    140     return 0.5 * (ddd) ** (1. / 3.) 
     132#def ER(radius_minor, axis_ratio, length): 
     133#    """ 
     134#        Equivalent radius 
     135#        @param radius_minor: Ellipse minor radius 
     136#        @param axis_ratio: Ratio of major radius over minor radius 
     137#        @param length: Length of the cylinder 
     138#    """ 
     139#    radius = sqrt(radius_minor * radius_minor * axis_ratio) 
     140#    ddd = 0.75 * radius * (2 * radius * length 
     141#                           + (length + radius) * (length + pi * radius)) 
     142#    return 0.5 * (ddd) ** (1. / 3.) 
    141143 
    142144def random(): 

  • sasmodels/models/fuzzy_sphere.py

    r71b751d rd277229  
    7878              ["sld_solvent", "1e-6/Ang^2",  3, [-inf, inf], "sld",    "Solvent scattering length density"], 
    7979              ["radius",      "Ang",        60, [0, inf],    "volume", "Sphere radius"], 
    80               ["fuzziness",   "Ang",        10, [0, inf],    "",       "std deviation of Gaussian convolution for interface (must be << radius)"], 
     80              ["fuzziness",   "Ang",        10, [0, inf],    "volume",       "std deviation of Gaussian convolution for interface (must be << radius)"], 
    8181             ] 
    8282# pylint: enable=bad-whitespace,line-too-long 
    8383 
    84 source = ["lib/sas_3j1x_x.c"] 
     84source = ["lib/sas_3j1x_x.c","fuzzy_sphere.c"] 
    8585have_Fq = True 
     86effective_radius_type = ["radius","radius + fuzziness"] 
    8687 
    87 c_code = """ 
    88 static double form_volume(double radius) 
    89 { 
    90     return M_4PI_3*cube(radius); 
    91 } 
    92  
    93 static void Fq(double q, double *F1, double *F2, double sld, double sld_solvent, 
    94                double radius, double fuzziness) 
    95 { 
    96     const double qr = q*radius; 
    97     const double bes = sas_3j1x_x(qr); 
    98     const double qf = exp(-0.5*square(q*fuzziness)); 
    99     const double contrast = (sld - sld_solvent); 
    100     const double form = contrast * form_volume(radius) * bes * qf; 
    101     *F1 = 1.0e-2*form; 
    102     *F2 = 1.0e-4*form*form; 
    103 } 
    104 """ 
    105  
    106 def ER(radius): 
    107     """ 
    108     Return radius 
    109     """ 
    110     return radius 
     88#def ER(radius): 
     89#    """ 
     90#    Return radius 
     91#    """ 
     92#    return radius 
    11193 
    11294# VR defaults to 1.0 

  • sasmodels/models/hollow_cylinder.c

    r71b751d rd277229  
    2222} 
    2323 
     24static double 
     25radius_from_volume(double radius, double thickness, double length) 
     26{ 
     27    const double volume_outer_cyl = M_PI*square(radius + thickness)*length; 
     28    return cbrt(0.75*volume_outer_cyl/M_PI); 
     29} 
     30 
     31static double 
     32radius_from_diagonal(double radius, double thickness, double length) 
     33{ 
     34    return sqrt(square(radius + thickness) + 0.25*square(length)); 
     35} 
     36 
     37static double 
     38effective_radius(int mode, double radius, double thickness, double length) 
     39{ 
     40    if (mode == 1) { 
     41        return radius_from_volume(radius, thickness, length); 
     42    } else if (mode == 2) { 
     43        return radius + thickness; 
     44    } else if (mode == 3) { 
     45        return 0.5*length; 
     46    } else if (mode == 4) { 
     47        return (radius + thickness < 0.5*length ? radius + thickness : 0.5*length); 
     48    } else if (mode == 5) { 
     49        return (radius + thickness > 0.5*length ? radius + thickness : 0.5*length); 
     50    } else { 
     51        return radius_from_diagonal(radius,thickness,length); 
     52    } 
     53} 
    2454 
    2555static void 

  • sasmodels/models/hollow_cylinder.py

    r71b751d rd277229  
    9090source = ["lib/polevl.c", "lib/sas_J1.c", "lib/gauss76.c", "hollow_cylinder.c"] 
    9191have_Fq = True 
     92effective_radius_type = ["equivalent sphere","outer radius","half length", 
     93                         "half outer min dimension","half outer max dimension","half outer diagonal"] 
    9294 
    9395# pylint: disable=W0613 
    94 def ER(radius, thickness, length): 
    95     """ 
    96     :param radius:      Cylinder core radius 
    97     :param thickness:   Cylinder wall thickness 
    98     :param length:      Cylinder length 
    99     :return:            Effective radius 
    100     """ 
    101     router = radius + thickness 
    102     if router == 0 or length == 0: 
    103         return 0.0 
    104     len1 = router 
    105     len2 = length/2.0 
    106     term1 = len1*len1*2.0*len2/2.0 
    107     term2 = 1.0 + (len2/len1)*(1.0 + 1/len2/2.0)*(1.0 + pi*len1/len2/2.0) 
    108     ddd = 3.0*term1*term2 
    109     diam = pow(ddd, (1.0/3.0)) 
    110     return diam 
     96#def ER(radius, thickness, length): 
     97#    """ 
     98#    :param radius:      Cylinder core radius 
     99#    :param thickness:   Cylinder wall thickness 
     100#    :param length:      Cylinder length 
     101#    :return:            Effective radius 
     102#    """ 
     103#    router = radius + thickness 
     104#    if router == 0 or length == 0: 
     105#        return 0.0 
     106#    len1 = router 
     107#    len2 = length/2.0 
     108#    term1 = len1*len1*2.0*len2/2.0 
     109#    term2 = 1.0 + (len2/len1)*(1.0 + 1/len2/2.0)*(1.0 + pi*len1/len2/2.0) 
     110#    ddd = 3.0*term1*term2 
     111#    diam = pow(ddd, (1.0/3.0)) 
     112#    return diam 
    111113 
    112114def VR(radius, thickness, length): 

  • sasmodels/models/hollow_rectangular_prism.c

    r71b751d rd277229  
    1111    double vol_shell = vol_total - vol_core; 
    1212    return vol_shell; 
     13} 
     14 
     15static double 
     16effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio, double thickness) 
     17{ 
     18    if (mode == 1) { 
     19        return cbrt(0.75*cube(length_a)*b2a_ratio*c2a_ratio/M_PI); 
     20    } else if (mode == 2) { 
     21        return 0.5 * length_a; 
     22    } else if (mode == 3) { 
     23        return 0.5 * length_a*b2a_ratio; 
     24    } else if (mode == 4) { 
     25        return 0.5 * length_a*c2a_ratio; 
     26    } else if (mode == 5) { 
     27        return length_a*sqrt(b2a_ratio/M_PI); 
     28    } else if (mode == 6) { 
     29        return 0.5*sqrt(square(length_a) * (1.0 + square(b2a_ratio))); 
     30    } else { 
     31        return 0.5*sqrt(square(length_a) * (1.0 + square(b2a_ratio) + square(c2a_ratio))); 
     32    } 
    1333} 
    1434 

  • sasmodels/models/hollow_rectangular_prism.py

    r71b751d rd277229  
    143143source = ["lib/gauss76.c", "hollow_rectangular_prism.c"] 
    144144have_Fq = True 
    145  
    146 def ER(length_a, b2a_ratio, c2a_ratio, thickness): 
    147     """ 
    148     Return equivalent radius (ER) 
    149     thickness parameter not used 
    150     """ 
    151     b_side = length_a * b2a_ratio 
    152     c_side = length_a * c2a_ratio 
    153  
    154     # surface average radius (rough approximation) 
    155     surf_rad = sqrt(length_a * b_side / pi) 
    156  
    157     ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad)) 
    158     return 0.5 * (ddd) ** (1. / 3.) 
     145effective_radius_type = ["equivalent sphere","half length_a", "half length_b", "half length_c", 
     146                         "equivalent outer circular cross-section","half ab diagonal","half diagonal"] 
     147 
     148#def ER(length_a, b2a_ratio, c2a_ratio, thickness): 
     149#    """ 
     150#    Return equivalent radius (ER) 
     151#    thickness parameter not used 
     152#    """ 
     153#    b_side = length_a * b2a_ratio 
     154#    c_side = length_a * c2a_ratio 
     155# 
     156#    # surface average radius (rough approximation) 
     157#    surf_rad = sqrt(length_a * b_side / pi) 
     158# 
     159#    ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad)) 
     160#    return 0.5 * (ddd) ** (1. / 3.) 
    159161 
    160162def VR(length_a, b2a_ratio, c2a_ratio, thickness): 

  • sasmodels/models/hollow_rectangular_prism_thin_walls.c

    r71b751d rd277229  
    66    double vol_shell = 2.0 * (length_a*length_b + length_a*length_c + length_b*length_c); 
    77    return vol_shell; 
     8} 
     9 
     10static double 
     11effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio) 
     12{ 
     13    if (mode == 1) { 
     14        return cbrt(0.75*cube(length_a)*b2a_ratio*c2a_ratio/M_PI); 
     15    } else if (mode == 2) { 
     16        return 0.5 * length_a; 
     17    } else if (mode == 3) { 
     18        return 0.5 * length_a*b2a_ratio; 
     19    } else if (mode == 4) { 
     20        return 0.5 * length_a*c2a_ratio; 
     21    } else if (mode == 5) { 
     22        return length_a*sqrt(b2a_ratio/M_PI); 
     23    } else if (mode == 6) { 
     24        return 0.5*sqrt(square(length_a) * (1.0 + square(b2a_ratio))); 
     25    } else { 
     26        return 0.5*sqrt(square(length_a) * (1.0 + square(b2a_ratio) + square(c2a_ratio))); 
     27    } 
    828} 
    929 

  • sasmodels/models/hollow_rectangular_prism_thin_walls.py

    r71b751d rd277229  
    103103source = ["lib/gauss76.c", "hollow_rectangular_prism_thin_walls.c"] 
    104104have_Fq = True 
     105effective_radius_type = ["equivalent sphere","half length_a", "half length_b", "half length_c", 
     106                         "equivalent outer circular cross-section","half ab diagonal","half diagonal"] 
    105107 
    106 def ER(length_a, b2a_ratio, c2a_ratio): 
    107     """ 
    108         Return equivalent radius (ER) 
    109     """ 
    110     b_side = length_a * b2a_ratio 
    111     c_side = length_a * c2a_ratio 
    112  
    113     # surface average radius (rough approximation) 
    114     surf_rad = sqrt(length_a * b_side / pi) 
    115  
    116     ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad)) 
    117     return 0.5 * (ddd) ** (1. / 3.) 
     108#def ER(length_a, b2a_ratio, c2a_ratio): 
     109#    """ 
     110#        Return equivalent radius (ER) 
     111#    """ 
     112#    b_side = length_a * b2a_ratio 
     113#    c_side = length_a * c2a_ratio 
     114# 
     115#    # surface average radius (rough approximation) 
     116#    surf_rad = sqrt(length_a * b_side / pi) 
     117# 
     118#    ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad)) 
     119#    return 0.5 * (ddd) ** (1. / 3.) 
    118120 
    119121def VR(length_a, b2a_ratio, c2a_ratio): 

  • sasmodels/models/mono_gauss_coil.py

    r2d81cfe rd277229  
    5454 
    5555import numpy as np 
    56 from numpy import inf, exp, errstate 
     56from numpy import inf 
    5757 
    5858name = "mono_gauss_coil" 
    … …  
    6969parameters = [ 
    7070    ["i_zero", "1/cm", 70.0, [0.0, inf], "", "Intensity at q=0"], 
    71     ["rg", "Ang", 75.0, [0.0, inf], "", "Radius of gyration"], 
     71    ["rg", "Ang", 75.0, [0.0, inf], "volume", "Radius of gyration"], 
    7272    ] 
     73 
     74source = ["mono_gauss_coil.c"] 
     75have_Fq = False 
     76effective_radius_type = ["R_g","2R_g","3R_g","(5/3)^0.5*R_g"] 
     77 
     78 
    7379# pylint: enable=bad-whitespace, line-too-long 
    7480 
    75 # NB: Scale and Background are implicit parameters on every model 
    76 def Iq(q, i_zero, rg): 
    77     # pylint: disable = missing-docstring 
    78     z = (q * rg)**2 
    79  
    80     with errstate(invalid='ignore'): 
    81         inten = (i_zero * 2.0) * (exp(-z) + z - 1.0)/z**2 
    82         inten[q == 0] = i_zero 
    83     return inten 
    84 Iq.vectorized = True # Iq accepts an array of q values 
     81## NB: Scale and Background are implicit parameters on every model 
     82#def Iq(q, i_zero, rg): 
     83#    # pylint: disable = missing-docstring 
     84#    z = (q * rg)**2 
     85# 
     86#    with errstate(invalid='ignore'): 
     87#        inten = (i_zero * 2.0) * (exp(-z) + z - 1.0)/z**2 
     88#        inten[q == 0] = i_zero 
     89#    return inten 
     90#Iq.vectorized = True # Iq accepts an array of q values 
    8591 
    8692def random(): 

  • sasmodels/models/multilayer_vesicle.c

    r71b751d rd277229  
    4747} 
    4848 
     49static double 
     50effective_radius(int mode, double radius, double thick_shell, double thick_solvent, double fp_n_shells) 
     51{ 
     52    return radius + fp_n_shells*thick_shell + (fp_n_shells - 1.0)*thick_solvent; 
     53} 
     54 
    4955static void 
    5056Fq(double q, 

  • sasmodels/models/multilayer_vesicle.py

    r71b751d rd277229  
    146146source = ["lib/sas_3j1x_x.c", "multilayer_vesicle.c"] 
    147147have_Fq = True 
     148effective_radius_type = ["outer radius"] 
    148149 
    149 def ER(radius, thick_shell, thick_solvent, n_shells): 
    150     n_shells = int(n_shells+0.5) 
    151     return radius + n_shells * (thick_shell + thick_solvent) - thick_solvent 
     150#def ER(radius, thick_shell, thick_solvent, n_shells): 
     151#    n_shells = int(n_shells+0.5) 
     152#    return radius + n_shells * (thick_shell + thick_solvent) - thick_solvent 
    152153 
    153154def random(): 

  • sasmodels/models/onion.c

    r71b751d rd277229  
    4040} 
    4141 
     42static double 
     43effective_radius(int mode, double radius_core, double n_shells, double thickness[]) 
     44{ 
     45  int n = (int)(n_shells+0.5); 
     46  double r = radius_core; 
     47  for (int i=0; i < n; i++) { 
     48    r += thickness[i]; 
     49  } 
     50  return r; 
     51} 
     52 
    4253static void 
    4354Fq(double q, double *F1, double *F2, double sld_core, double radius_core, double sld_solvent, 

  • sasmodels/models/onion.py

    r71b751d rd277229  
    316316single = False 
    317317have_Fq = True 
     318effective_radius_type = ["outer radius"] 
    318319 
    319320profile_axes = ['Radius (A)', 'SLD (1e-6/A^2)'] 
    … …  
    366367    return np.asarray(z), np.asarray(rho) 
    367368 
    368 def ER(radius_core, n_shells, thickness): 
    369     """Effective radius""" 
    370     n = int(n_shells[0]+0.5) 
    371     return np.sum(thickness[:n], axis=0) + radius_core 
     369#def ER(radius_core, n_shells, thickness): 
     370#    """Effective radius""" 
     371#    n = int(n_shells[0]+0.5) 
     372#    return np.sum(thickness[:n], axis=0) + radius_core 
    372373 
    373374demo = { 

  • sasmodels/models/parallelepiped.c

    r71b751d rd277229  
    33{ 
    44    return length_a * length_b * length_c; 
     5} 
     6 
     7static double 
     8effective_radius(int mode, double length_a, double length_b, double length_c) 
     9{ 
     10    if (mode == 1) { 
     11        return cbrt(0.75*length_a*length_b*length_c/M_PI); 
     12    } else if (mode == 2) { 
     13        return 0.5 * length_a; 
     14    } else if (mode == 3) { 
     15        return 0.5 * length_b; 
     16    } else if (mode == 4) { 
     17        return 0.5 * length_c; 
     18    } else if (mode == 5) { 
     19        return sqrt(length_a*length_b/M_PI); 
     20    } else if (mode == 6) { 
     21        return 0.5*sqrt(length_a*length_a + length_b*length_b); 
     22    } else { 
     23        return 0.5*sqrt(length_a*length_a + length_b*length_b + length_c*length_c); 
     24    } 
    525} 
    626 

  • sasmodels/models/parallelepiped.py

    r71b751d rd277229  
    231231source = ["lib/gauss76.c", "parallelepiped.c"] 
    232232have_Fq = True 
    233  
    234 def ER(length_a, length_b, length_c): 
    235     """ 
    236     Return effective radius (ER) for P(q)*S(q) 
    237     """ 
    238     # now that axes can be in any size order, need to sort a,b,c 
    239     # where a~b and c is either much smaller or much larger 
    240     abc = np.vstack((length_a, length_b, length_c)) 
    241     abc = np.sort(abc, axis=0) 
    242     selector = (abc[1] - abc[0]) > (abc[2] - abc[1]) 
    243     length = np.where(selector, abc[0], abc[2]) 
    244     # surface average radius (rough approximation) 
    245     radius = sqrt(np.where(~selector, abc[0]*abc[1], abc[1]*abc[2]) / pi) 
    246  
    247     ddd = 0.75 * radius * (2*radius*length + (length + radius)*(length + pi*radius)) 
    248     return 0.5 * (ddd) ** (1. / 3.) 
     233effective_radius_type = ["equivalent sphere","half length_a", "half length_b", "half length_c", 
     234                         "equivalent circular cross-section","half ab diagonal","half diagonal"] 
     235 
     236#def ER(length_a, length_b, length_c): 
     237#    """ 
     238#    Return effective radius (ER) for P(q)*S(q) 
     239#    """ 
     240#    # now that axes can be in any size order, need to sort a,b,c 
     241#    # where a~b and c is either much smaller or much larger 
     242#    abc = np.vstack((length_a, length_b, length_c)) 
     243#    abc = np.sort(abc, axis=0) 
     244#    selector = (abc[1] - abc[0]) > (abc[2] - abc[1]) 
     245#    length = np.where(selector, abc[0], abc[2]) 
     246#    # surface average radius (rough approximation) 
     247#    radius = sqrt(np.where(~selector, abc[0]*abc[1], abc[1]*abc[2]) / pi) 
     248# 
     249#    ddd = 0.75 * radius * (2*radius*length + (length + radius)*(length + pi*radius)) 
     250#    return 0.5 * (ddd) ** (1. / 3.) 
    249251 
    250252# VR defaults to 1.0 

  • sasmodels/models/pringle.c

    r74768cb rd277229  
    104104} 
    105105 
     106static double 
     107effective_radius(int mode, double radius, double thickness, double alpha, double beta) 
     108{ 
     109    if (mode == 1) { 
     110        return cbrt(0.75*radius*radius*thickness); 
     111    } else { 
     112        return radius; 
     113    } 
     114} 
     115 
    106116double Iq( 
    107117    double q, 

  • sasmodels/models/pringle.py

    ref07e95 rd277229  
    7474source = ["lib/polevl.c", "lib/sas_J0.c", "lib/sas_J1.c", \ 
    7575          "lib/sas_JN.c", "lib/gauss76.c", "pringle.c"] 
     76effective_radius_type = ["equivalent sphere","radius"] 
    7677 
    77 def ER(radius, thickness, alpha, beta): 
    78     """ 
    79     Return equivalent radius (ER) 
    80     """ 
    81     ddd = 0.75 * radius * (2 * radius * thickness + (thickness + radius) \ 
    82                            * (thickness + pi * radius)) 
    83     return 0.5 * (ddd) ** (1. / 3.) 
     78#def ER(radius, thickness, alpha, beta): 
     79#    """ 
     80#    Return equivalent radius (ER) 
     81#    """ 
     82#    ddd = 0.75 * radius * (2 * radius * thickness + (thickness + radius) \ 
     83#                           * (thickness + pi * radius)) 
     84#    return 0.5 * (ddd) ** (1. / 3.) 
    8485 
    8586def random(): 

  • sasmodels/models/raspberry.c

    r71b751d rd277229  
    1 double form_volume(double radius_lg); 
     1double form_volume(double radius_lg, double radius_sm, double penetration); 
    22 
    33double Iq(double q, 
    … …  
    66          double radius_lg, double radius_sm, double penetration); 
    77 
    8 double form_volume(double radius_lg) 
     8double form_volume(double radius_lg, double radius_sm, double penetration) 
    99{ 
    1010    //Because of the complex structure, volume normalization must 
    … …  
    1212    double volume=1.0; 
    1313    return volume; 
     14} 
     15 
     16static double 
     17effective_radius(int mode, double radius_lg, double radius_sm, double penetration) 
     18{ 
     19    if (mode == 1) { 
     20        return radius_lg; 
     21    } else { 
     22        return radius_lg + 2.0*radius_sm - penetration; 
     23    } 
    1424} 
    1525 

  • sasmodels/models/raspberry.py

    ref07e95 rd277229  
    145145              ["radius_lg", "Ang", 5000, [0, inf], "volume", 
    146146               "radius of large spheres"], 
    147               ["radius_sm", "Ang", 100, [0, inf], "", 
     147              ["radius_sm", "Ang", 100, [0, inf], "volume", 
    148148               "radius of small spheres"], 
    149               ["penetration", "Ang", 0, [-1, 1], "", 
     149              ["penetration", "Ang", 0, [-1, 1], "volume", 
    150150               "fractional penetration depth of small spheres into large sphere"], 
    151151             ] 
    152152 
    153153source = ["lib/sas_3j1x_x.c", "raspberry.c"] 
     154effective_radius_type = ["radius_large","radius_outer"] 
    154155 
    155156def random(): 

  • sasmodels/models/rectangular_prism.c

    r71b751d rd277229  
    33{ 
    44    return length_a * (length_a*b2a_ratio) * (length_a*c2a_ratio); 
     5} 
     6 
     7static double 
     8effective_radius(int mode, double length_a, double b2a_ratio, double c2a_ratio) 
     9{ 
     10    if (mode == 1) { 
     11        return cbrt(0.75*cube(length_a)*b2a_ratio*c2a_ratio/M_PI); 
     12    } else if (mode == 2) { 
     13        return 0.5 * length_a; 
     14    } else if (mode == 3) { 
     15        return 0.5 * length_a*b2a_ratio; 
     16    } else if (mode == 4) { 
     17        return 0.5 * length_a*c2a_ratio; 
     18    } else if (mode == 5) { 
     19        return length_a*sqrt(b2a_ratio/M_PI); 
     20    } else if (mode == 6) { 
     21        return 0.5*sqrt(square(length_a) * (1.0 + square(b2a_ratio))); 
     22    } else { 
     23        return 0.5*sqrt(square(length_a) * (1.0 + square(b2a_ratio) + square(c2a_ratio))); 
     24    } 
    525} 
    626 

  • sasmodels/models/rectangular_prism.py

    r71b751d rd277229  
    136136source = ["lib/gauss76.c", "rectangular_prism.c"] 
    137137have_Fq = True 
     138effective_radius_type = ["equivalent sphere","half length_a", "half length_b", "half length_c", 
     139                         "equivalent circular cross-section","half ab diagonal","half diagonal"] 
    138140 
    139 def ER(length_a, b2a_ratio, c2a_ratio): 
    140     """ 
    141         Return equivalent radius (ER) 
    142     """ 
    143     b_side = length_a * b2a_ratio 
    144     c_side = length_a * c2a_ratio 
    145  
    146     # surface average radius (rough approximation) 
    147     surf_rad = sqrt(length_a * b_side / pi) 
    148  
    149     ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad)) 
    150     return 0.5 * (ddd) ** (1. / 3.) 
     141#def ER(length_a, b2a_ratio, c2a_ratio): 
     142#    """ 
     143#        Return equivalent radius (ER) 
     144#    """ 
     145#    b_side = length_a * b2a_ratio 
     146#    c_side = length_a * c2a_ratio 
     147# 
     148#    # surface average radius (rough approximation) 
     149#    surf_rad = sqrt(length_a * b_side / pi) 
     150# 
     151#    ddd = 0.75 * surf_rad * (2 * surf_rad * c_side + (c_side + surf_rad) * (c_side + pi * surf_rad)) 
     152#    return 0.5 * (ddd) ** (1. / 3.) 
    151153 
    152154def random(): 

  • sasmodels/models/sphere.py

    r71b751d rd277229  
    6767             ] 
    6868 
    69 source = ["lib/sas_3j1x_x.c"] 
     69source = ["lib/sas_3j1x_x.c","sphere.c"] 
    7070have_Fq = True 
     71effective_radius_type = ["radius"] 
    7172 
    72 c_code = """ 
    73 static double form_volume(double radius) 
    74 { 
    75     return M_4PI_3*cube(radius); 
    76 } 
    77  
    78 static void Fq(double q, double *f1, double *f2, double sld, double sld_solvent, double radius) 
    79 { 
    80     const double bes = sas_3j1x_x(q*radius); 
    81     const double contrast = (sld - sld_solvent); 
    82     const double form = contrast * form_volume(radius) * bes; 
    83     *f1 = 1.0e-2*form; 
    84     *f2 = 1.0e-4*form*form; 
    85 } 
    86 """ 
    87  
    88 def ER(radius): 
    89     """ 
    90     Return equivalent radius (ER) 
    91     """ 
    92     return radius 
     73#def ER(radius): 
     74#    """ 
     75#    Return equivalent radius (ER) 
     76#    """ 
     77#    return radius 
    9378 
    9479# VR defaults to 1.0 

  • sasmodels/models/spherical_sld.c

    r71b751d rd277229  
    1010    } 
    1111    return M_4PI_3*cube(r); 
     12} 
     13 
     14static double 
     15effective_radius(int mode, double fp_n_shells, double thickness[], double interface[]) 
     16{ 
     17    int n_shells= (int)(fp_n_shells + 0.5); 
     18    double r = 0.0; 
     19    for (int i=0; i < n_shells; i++) { 
     20        r += thickness[i] + interface[i]; 
     21    } 
     22    return r; 
    1223} 
    1324 

  • sasmodels/models/spherical_sld.py

    r71b751d rd277229  
    210210single = False  # TODO: fix low q behaviour 
    211211have_Fq = True 
     212effective_radius_type = ["outer radius"] 
    212213 
    213214profile_axes = ['Radius (A)', 'SLD (1e-6/A^2)'] 
    … …  
    255256 
    256257 
    257 def ER(n_shells, thickness, interface): 
    258     """Effective radius""" 
    259     n_shells = int(n_shells + 0.5) 
    260     total = (np.sum(thickness[:n_shells], axis=1) 
    261              + np.sum(interface[:n_shells], axis=1)) 
    262     return total 
     258#def ER(n_shells, thickness, interface): 
     259#    """Effective radius""" 
     260#    n_shells = int(n_shells + 0.5) 
     261#    total = (np.sum(thickness[:n_shells], axis=1) 
     262#             + np.sum(interface[:n_shells], axis=1)) 
     263#    return total 
    263264 
    264265 

  • sasmodels/models/triaxial_ellipsoid.c

    r71b751d rd277229  
    77} 
    88 
     9static double 
     10radius_from_volume(double radius_equat_minor, double radius_equat_major, double radius_polar) 
     11{ 
     12    return cbrt(radius_equat_minor*radius_equat_major*radius_polar); 
     13} 
     14 
     15static double 
     16radius_from_min_dimension(double radius_equat_minor, double radius_equat_major, double radius_polar) 
     17{ 
     18    const double rad_equat_min = (radius_equat_minor < radius_equat_major ? radius_equat_minor : radius_equat_major); 
     19    return (rad_equat_min < radius_polar ? rad_equat_min : radius_polar); 
     20} 
     21 
     22static double 
     23radius_from_max_dimension(double radius_equat_minor, double radius_equat_major, double radius_polar) 
     24{ 
     25    const double rad_equat_max = (radius_equat_minor < radius_equat_major ? radius_equat_major : radius_equat_minor); 
     26    return (rad_equat_max > radius_polar ? rad_equat_max : radius_polar); 
     27} 
     28 
     29static double 
     30effective_radius(int mode, double radius_equat_minor, double radius_equat_major, double radius_polar) 
     31{ 
     32    if (mode == 1) { 
     33        return radius_from_volume(radius_equat_minor,radius_equat_major, radius_polar); 
     34    } else if (mode == 2) { 
     35        return radius_from_min_dimension(radius_equat_minor,radius_equat_major, radius_polar); 
     36    } else { 
     37        return radius_from_max_dimension(radius_equat_minor,radius_equat_major, radius_polar); 
     38    } 
     39} 
    940 
    1041static void 

  • sasmodels/models/triaxial_ellipsoid.py

    r71b751d rd277229  
    158158source = ["lib/sas_3j1x_x.c", "lib/gauss76.c", "triaxial_ellipsoid.c"] 
    159159have_Fq = True 
     160effective_radius_type = ["equivalent sphere","min radius", "max radius"] 
    160161 
    161162def ER(radius_equat_minor, radius_equat_major, radius_polar): 

  • sasmodels/models/vesicle.c

    r71b751d rd277229  
    66} 
    77 
     8static double 
     9effective_radius(int mode, double radius, double thickness) 
     10{ 
     11    return radius + thickness; 
     12} 
    813 
    914static void 

  • sasmodels/models/vesicle.py

    r71b751d rd277229  
    9595source = ["lib/sas_3j1x_x.c", "vesicle.c"] 
    9696have_Fq = True 
     97effective_radius_type = ["outer radius"] 
    9798 
    98 def ER(radius, thickness): 
    99     ''' 
    100     returns the effective radius used in the S*P calculation 
    101  
    102     :param radius: core radius 
    103     :param thickness: shell thickness 
    104     ''' 
    105     return radius + thickness 
     99#def ER(radius, thickness): 
     100#    ''' 
     101#    returns the effective radius used in the S*P calculation 
     102# 
     103#    :param radius: core radius 
     104#    :param thickness: shell thickness 
     105#    ''' 
     106#    return radius + thickness 
    106107 
    107108def VR(radius, thickness): 
Note: See TracChangeset for help on using the changeset viewer.