Changeset 2c74c11 in sasmodels


Ignore:
Timestamp:
Jul 24, 2016 10:56:45 PM (8 years ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
master, core_shell_microgels, costrafo411, magnetic_model, release_v0.94, release_v0.95, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests
Children:
a4280bd
Parents:
f1765a2
Message:

implicit Iqxy; fix divide by 0 for q=0

Location:
sasmodels
Files:
41 edited

Legend:

Unmodified
Added
Removed

  • sasmodels/convert.py

    rf1765a2 r2c74c11  
    282282        suppress_magnetism = False 
    283283        for key in pars.keys(): 
    284             suppress_magnetism = suppress_magnetism or (pars[key] != 0) 
    285284            if key.startswith("M0:"): 
     285                suppress_magnetism = suppress_magnetism or (pars[key] != 0) 
    286286                pars[key] = 0 
    287287        if suppress_magnetism: 

  • sasmodels/generate.py

    r9eb3632 r2c74c11  
    565565    else: 
    566566        # Call 1D model with sqrt(qx^2 + qy^2) 
    567         warnings.warn("Creating Iqxy = Iq(sqrt(qx^2 + qy^2))") 
     567        #warnings.warn("Creating Iqxy = Iq(sqrt(qx^2 + qy^2))") 
    568568        # still defined:: refs = ["q[i]"] + _call_pars("v", iq_parameters) 
    569569        pars_sqrt = ["sqrt(_q[2*_i]*_q[2*_i]+_q[2*_i+1]*_q[2*_i+1])"] + refs[1:] 

  • sasmodels/model_test.py

    r9eb3632 r2c74c11  
    201201                #({}, 0.0, None), 
    202202                #({}, (0.0, 0.0), None), 
     203                # test vector form 
     204                ({}, [0.1]*2, [None]*2), 
     205                ({}, [(0.1, 0.1)]*2, [None]*2), 
    203206                # test that ER/VR will run if they exist 
    204207                ({}, 'ER', None), 
    … …  
    257260                if yi is None: 
    258261                    # smoke test --- make sure it runs and produces a value 
    259                     self.assertTrue(np.isfinite(actual_yi), 
     262                    self.assertTrue(not np.isnan(actual_yi), 
    260263                                    'invalid f(%s): %s' % (xi, actual_yi)) 
    261264                elif np.isnan(yi): 

  • sasmodels/models/adsorbed_layer.py

    r42356c8 r2c74c11  
    5151""" 
    5252 
    53 from numpy import inf, sqrt, pi, exp 
     53from numpy import inf, pi, exp, errstate 
    5454 
    5555name = "adsorbed_layer" 
    … …  
    8787    ##scale by 10^-2 for units conversion to cm^-1 
    8888    #inten =  1.0e-02 * deltarhosqrd * ((numerator / denominator) * eterm) 
    89     aa = (sld_shell - sld_solvent) * adsorbed_amount / q / density_shell 
     89    with errstate(divide='ignore'): 
     90        aa = ((sld_shell - sld_solvent)/density_shell * adsorbed_amount) / q 
    9091    bb = q * second_moment 
    9192    #scale by 10^-2 for units conversion to cm^-1 
    92     inten = 6.0e-02 * pi * volfraction * aa * aa * exp(-bb * bb) / radius 
     93    inten = 6.0e-02 * pi * volfraction * aa**2 * exp(-bb**2) / radius 
    9394    return inten 
    9495Iq.vectorized =  True  # Iq accepts an array of q values 

  • sasmodels/models/be_polyelectrolyte.py

    rec45c4f r2c74c11  
    116116 
    117117 
    118 def Iqxy(qx, qy, *args): 
    119     """ 
    120     :param qx:   Input q_x-value 
    121     :param qy:   Input q_y-value 
    122     :param args: Remaining arguments 
    123     :return:     2D-Intensity 
    124     """ 
    125     intensity = Iq(sqrt(qx**2 + qy**2), *args) 
    126     return intensity 
    127  
    128 Iqxy.vectorized = True  # Iqxy accepts an array of qx, qy values 
    129  
    130  
    131118demo = dict(scale=1, background=0.1, 
    132119            contrast_factor=10.0, 

  • sasmodels/models/broad_peak.py

    r65279d8 r2c74c11  
    4141""" 
    4242 
    43 from numpy import inf, sqrt 
     43from numpy import inf, errstate 
    4444 
    4545name = "broad_peak" 
    … …  
    8787    :return:               Calculated intensity 
    8888    """ 
    89  
    90     inten = (porod_scale / q ** porod_exp + lorentz_scale 
    91              / (1.0 + (abs(q - peak_pos) * lorentz_length) ** lorentz_exp)) 
     89    z = abs(q - peak_pos) * lorentz_length 
     90    with errstate(divide='ignore'): 
     91        inten = (porod_scale / q ** porod_exp 
     92                 + lorentz_scale / (1 + z ** lorentz_exp)) 
    9293    return inten 
    9394Iq.vectorized = True  # Iq accepts an array of q values 
    94  
    95 def Iqxy(qx, qy, *args): 
    96     """ 
    97     :param qx:   Input q_x-value 
    98     :param qy:   Input q_y-value 
    99     :param args: Remaining arguments 
    100     :return:     2D-Intensity 
    101     """ 
    102     return Iq(sqrt(qx ** 2 + qy ** 2), *args) 
    103 Iqxy.vectorized = True # Iqxy accepts an array of qx, qy values 
    10495 
    10596demo = dict(scale=1, background=0, 

  • sasmodels/models/core_shell_sphere.c

    r7d4b2ae r2c74c11  
    11double form_volume(double radius, double thickness); 
    22double Iq(double q, double radius, double thickness, double core_sld, double shell_sld, double solvent_sld); 
    3 double Iqxy(double qx, double qy, double radius, double thickness, double core_sld, double shell_sld, double solvent_sld); 
    4  
    53 
    64double Iq(double q, double radius, double thickness, double core_sld, double shell_sld, double solvent_sld) { 
    … …  
    1614} 
    1715 
    18 double Iqxy(double qx, double qy, double radius, double thickness, double core_sld, double shell_sld, double solvent_sld) { 
    19     const double q = sqrt(qx*qx+qy*qy); 
    20     return Iq(q, radius, thickness, core_sld, shell_sld, solvent_sld); 
    21 } 
    22  
    2316double form_volume(double radius, double thickness) 
    2417{ 

  • sasmodels/models/correlation_length.py

    rec45c4f r2c74c11  
    3434""" 
    3535 
    36 from numpy import inf, sqrt 
     36from numpy import inf, errstate 
    3737 
    3838name = "correlation_length" 
    … …  
    5757    1D calculation of the Correlation length model 
    5858    """ 
    59     porod = porod_scale / pow(q, exponent_p) 
    60     lorentz = lorentz_scale / (1.0 + pow(q * cor_length, exponent_l)) 
     59    with errstate(divide='ignore'): 
     60        porod = porod_scale / q**exponent_p 
     61        lorentz = lorentz_scale / (1.0 + (q * cor_length)**exponent_l) 
    6162    inten = porod + lorentz 
    6263    return inten 
    63  
    64 def Iqxy(qx, qy, lorentz_scale, porod_scale, cor_length, exponent_p, exponent_l): 
    65     """ 
    66     2D calculation of the Correlation length model 
    67     There is no orientation contribution. 
    68     """ 
    69     q = sqrt(qx ** 2 + qy ** 2) 
    70     return Iq(q, lorentz_scale, porod_scale, cor_length, exponent_p, exponent_l) 
     64Iq.vectorized = True 
    7165 
    7266# parameters for demo 

  • sasmodels/models/dab.py

    rec45c4f r2c74c11  
    6565    """ 
    6666 
    67 Iqxy = """ 
    68     // never called since no orientation or magnetic parameters. 
    69     //return -1.0; 
    70     return Iq(sqrt(qx*qx + qy*qy), length); 
    71     """ 
    72  
    7367# ER defaults to 1.0 
    7468 

  • sasmodels/models/fractal.c

    r12dbc90 r2c74c11  
    1 double form_volume(double radius); 
    2  
    31double Iq(double q, 
    42          double volfraction, 
    … …  
    86          double sld_block, 
    97          double sld_solvent); 
    10  
    11 double Iqxy(double qx, double qy, 
    12           double volfraction, 
    13           double radius, 
    14           double fractal_dim, 
    15           double cor_length, 
    16           double sld_block, 
    17           double sld_solvent); 
    18  
    198 
    209double Iq(double q, 
    … …  
    6453} 
    6554 
    66  
    67 // Iqxy is never called since no orientation or magnetic parameters. 
    68 double Iqxy(double qx, double qy, 
    69           double volfraction, 
    70           double radius, 
    71           double fractal_dim, 
    72           double cor_length, 
    73           double sld_block, 
    74           double sld_solvent) 
    75 { 
    76     double q = sqrt(qx*qx + qy*qy); 
    77     return Iq(q, 
    78         volfraction, radius, 
    79         fractal_dim, cor_length, 
    80         sld_block, sld_solvent); 
    81  
    82 } 
    83  

  • sasmodels/models/fractal_core_shell.c

    r6794301 r2c74c11  
    1010          double frac_dim, 
    1111          double cor_length); 
    12  
    13 double Iqxy(double qx, double qy, 
    14             double radius, 
    15             double thickness, 
    16             double core_sld, 
    17             double shell_sld, 
    18             double solvent_sld, 
    19             double volfraction, 
    20             double frac_dim, 
    21             double cor_length); 
    2212 
    2313double form_volume(double radius, double thickness) 
    … …  
    5646} 
    5747 
    58 double Iqxy(double qx, double qy, 
    59             double radius, 
    60             double thickness, 
    61             double core_sld, 
    62             double shell_sld, 
    63             double solvent_sld, 
    64             double volfraction, 
    65             double frac_dim, 
    66             double cor_length) { 
    67  
    68     const double q = sqrt(qx*qx+qy*qy); 
    69     return Iq(q, 
    70               radius, 
    71               thickness, 
    72               core_sld, 
    73               shell_sld, 
    74               solvent_sld, 
    75               volfraction, 
    76               frac_dim, 
    77               cor_length); 
    78  
    79 } 
    80  
    81  

  • sasmodels/models/fuzzy_sphere.py

    r42356c8 r2c74c11  
    9999    """ 
    100100 
    101 Iqxy = """ 
    102     // never called since no orientation or magnetic parameters. 
    103     //return -1.0; 
    104     return Iq(sqrt(qx*qx + qy*qy), sld, sld_solvent, radius, fuzziness); 
    105     """ 
    106  
    107101def ER(radius): 
    108102    """ 

  • sasmodels/models/gauss_lorentz_gel.py

    rec45c4f r2c74c11  
    4343""" 
    4444 
    45 from numpy import inf, sqrt, exp 
     45from numpy import inf, exp 
    4646 
    4747name = "gauss_lorentz_gel" 
    … …  
    9494 
    9595 
    96 def Iqxy(qx, qy, *args): 
    97     """ 
    98     :param qx:   Input q_x-value 
    99     :param qy:   Input q_y-value 
    100     :param args: Remaining aruments 
    101     :return:     2-D intensity 
    102     """ 
    103  
    104     return Iq(sqrt(qx**2 + qy**2), *args) 
    105  
    106 Iqxy.vectorized = True  # Iqxy accepts an array of qx, qy values 
    107  
    108  
    10996demo = dict(scale=1, background=0.1, 
    11097            gauss_scale_factor=100.0, 

  • sasmodels/models/gaussian_peak.py

    rec45c4f r2c74c11  
    4545             ] 
    4646 
    47 # No volume normalization despite having a volume parameter 
    48 # This should perhaps be volume normalized? 
    49 form_volume = """ 
    50     return 1.0; 
    51     """ 
    52  
    5347Iq = """ 
    5448    double scaled_dq = (q - q0)/sigma; 
    … …  
    5650    """ 
    5751 
    58  
    59 Iqxy = """ 
    60     // never called since no orientation or magnetic parameters. 
    61     //return -1.0; 
    62     return Iq(sqrt(qx*qx + qy*qy), q0, sigma); 
    63     """ 
    64  
    65  
    6652# VR defaults to 1.0 
    6753 

  • sasmodels/models/guinier.py

    rec45c4f r2c74c11  
    4646""" 
    4747 
    48 Iqxy = """ 
    49     return Iq(sqrt(qx*qx + qy*qy), rg); 
    50     """ 
    51  
    5248# parameters for demo 
    5349demo = dict(scale=1.0, rg=60.0) 

  • sasmodels/models/guinier_porod.py

    rec45c4f r2c74c11  
    6363""" 
    6464 
    65 from numpy import inf, sqrt, power, exp 
     65from numpy import inf, sqrt, exp, errstate 
    6666 
    6767name = "guinier_porod" 
    … …  
    9393    """ 
    9494    n = 3.0 - s 
     95    ms = 0.5*(m-s) # =(n-3+m)/2 
     96 
     97    # preallocate return value 
     98    iq = 0.0*q 
    9599 
    96100    # Take care of the singular points 
    97     if rg <= 0.0: 
    98         return 0.0 
    99     if (n-3.0+m) <= 0.0: 
    100         return 0.0 
     101    if rg <= 0.0 or ms <= 0.0: 
     102        return iq 
    101103 
    102104    # Do the calculation and return the function value 
    103     q1 = sqrt((n-3.0+m)*n/2.0)/rg 
    104     if q < q1: 
    105         iq = (1.0/power(q, (3.0-n)))*exp((-q*q*rg*rg)/n) 
    106     else: 
    107         iq = (1.0/power(q, m))*exp(-(n-3.0+m)/2.0)*power(((n-3.0+m)*n/2.0), 
    108                                                          ((n-3.0+m)/2.0))/power(rg, (n-3.0+m)) 
     105    idx = q < sqrt(n*ms)/rg 
     106    with errstate(divide='ignore'): 
     107        iq[idx] = q[idx]**-s * exp(-(q[idx]*rg)**2/n) 
     108        iq[~idx] = q[~idx]**-m * (exp(-ms) * (n*ms/rg**2)**ms) 
    109109    return iq 
    110110 
    111 Iq.vectorized = False  # Iq accepts an array of q values 
    112  
    113 def Iqxy(qx, qy, *args): 
    114     """ 
    115     @param qx:   Input q_x-value 
    116     @param qy:   Input q_y-value 
    117     @param args: Remaining arguments 
    118     """ 
    119     return Iq(sqrt(qx ** 2 + qy ** 2), *args) 
    120  
    121 Iqxy.vectorized = False # Iqxy accepts an array of qx, qy values 
     111Iq.vectorized = True # Iq accepts an array of q values 
    122112 
    123113demo = dict(scale=1.5, background=0.5, rg=60, s=1.0, m=3.0) 

  • sasmodels/models/line.py

    r416609b r2c74c11  
    6666    return Iq(qx, *args)*Iq(qy, *args) 
    6767 
    68 Iqxy.vectorized = True  # Iqxy accepts an array of qx, qy values 
     68Iqxy.vectorized = True  # Iqxy accepts an array of qx qy values 
     69 
    6970 
    7071tests = [ 

  • sasmodels/models/linear_pearls.c

    rcf85329 r2c74c11  
    22 
    33double Iq(double q, 
    4             double radius, 
    5             double edge_sep, 
    6             double num_pearls, 
    7             double pearl_sld, 
    8             double solvent_sld); 
    9  
    10 double Iqxy(double qx, double qy, 
    114            double radius, 
    125            double edge_sep, 
    … …  
    9285        return result; 
    9386} 
    94  
    95 double Iqxy(double qx, double qy, 
    96             double radius, 
    97             double edge_sep, 
    98             double num_pearls, 
    99             double pearl_sld, 
    100             double solvent_sld) 
    101 { 
    102         double q; 
    103         q = sqrt(qx*qx+qy*qy); 
    104  
    105         double result = linear_pearls_kernel(q, 
    106                     radius, 
    107                     edge_sep, 
    108                     num_pearls, 
    109                     pearl_sld, 
    110                     solvent_sld); 
    111  
    112         return result; 
    113 } 

  • sasmodels/models/lorentz.py

    rec45c4f r2c74c11  
    4848""" 
    4949 
    50 Iqxy = """ 
    51     return Iq(sqrt(qx*qx + qy*qy), cor_length); 
    52     """ 
    53  
    5450# parameters for demo 
    5551demo = dict(scale=1.0, background=0.0, cor_length=50.0) 

  • sasmodels/models/mass_fractal.c

    r6794301 r2c74c11  
    55          double mass_dim, 
    66          double cutoff_length); 
    7  
    8 double Iqxy(double qx, double qy, 
    9           double radius, 
    10           double mass_dim, 
    11           double cutoff_length); 
    12  
    137 
    148static double _mass_fractal_kernel(double q, 
    … …  
    5347           cutoff_length); 
    5448} 
    55  
    56 // Iqxy is never called since no orientation or magnetic parameters. 
    57 double Iqxy(double qx, double qy, 
    58           double radius, 
    59           double mass_dim, 
    60           double cutoff_length) 
    61 { 
    62     double q = sqrt(qx*qx + qy*qy); 
    63     return _mass_fractal_kernel(q, 
    64            radius, 
    65            mass_dim, 
    66            cutoff_length); 
    67 } 
    68  

  • sasmodels/models/mass_surface_fractal.c

    r7ed702f r2c74c11  
    66          double cluster_rg, 
    77          double primary_rg); 
    8  
    9 double Iqxy(double qx, double qy, 
    10           double mass_dim, 
    11           double surface_dim, 
    12           double cluster_rg, 
    13           double primary_rg); 
    14  
    158 
    169static double _mass_surface_fractal_kernel(double q, 
    … …  
    5952            primary_rg); 
    6053} 
    61  
    62 // Iqxy is never called since no orientation or magnetic parameters. 
    63 double Iqxy(double qx, double qy, 
    64           double mass_dim, 
    65           double surface_dim, 
    66           double cluster_rg, 
    67           double primary_rg) 
    68 { 
    69     double q = sqrt(qx*qx + qy*qy); 
    70     return _mass_surface_fractal_kernel(q, 
    71            mass_dim, 
    72            surface_dim, 
    73            cluster_rg, 
    74            primary_rg); 
    75 } 
    76  

  • sasmodels/models/mono_gauss_coil.py

    rec45c4f r2c74c11  
    4545""" 
    4646 
    47 from numpy import inf, sqrt, exp 
     47from numpy import inf, exp, errstate 
    4848 
    4949name =  "mono_gauss_coil" 
    … …  
    6363def Iq(q, i_zero, radius_gyration): 
    6464    # pylint: disable = missing-docstring 
    65     z = (q * radius_gyration) * (q * radius_gyration) 
    66     if (q == 0).any(): 
    67        inten = i_zero 
    68     else: 
    69        inten = i_zero * 2.0 * (exp(-z) + z - 1.0 ) / (z * z) 
     65    z = (q * radius_gyration)**2 
     66 
     67    with errstate(invalid='ignore'): 
     68        inten = (i_zero * 2.0) * (exp(-z) + z - 1.0)/z**2 
     69        inten[q == 0] = i_zero 
    7070    return inten 
    71 #Iq.vectorized = True # Iq accepts an array of q values 
    72  
    73 def Iqxy(qx, qy, *args): 
    74     # pylint: disable = missing-docstring 
    75     return Iq(sqrt(qx ** 2 + qy ** 2), *args) 
    76 #Iqxy.vectorized = True # Iqxy accepts an array of qx, qy values 
     71Iq.vectorized = True # Iq accepts an array of q values 
    7772 
    7873demo =  dict(scale = 1.0, 

  • sasmodels/models/multilayer_vesicle.c

    rc6ca41e r2c74c11  
    5959} 
    6060 
    61 static 
    62 double Iqxy(double qx, double qy, 
    63           double volfraction, 
    64           double radius, 
    65           double thick_shell, 
    66           double thick_solvent, 
    67           double sld_solvent, 
    68           double sld, 
    69           double n_pairs) 
    70 { 
    71     double q = sqrt(qx*qx + qy*qy); 
    72  
    73     return multilayer_vesicle_kernel(q, 
    74            volfraction, 
    75            radius, 
    76            thick_shell, 
    77            thick_solvent, 
    78            sld_solvent, 
    79            sld, 
    80            n_pairs); 
    81 } 

  • sasmodels/models/peak_lorentz.py

    rec45c4f r2c74c11  
    2929""" 
    3030 
    31 from numpy import inf, sqrt 
     31from numpy import inf 
    3232 
    3333name = "peak_lorentz" 
    … …  
    5959Iq.vectorized = True  # Iq accepts an array of q values 
    6060 
    61 def Iqxy(qx, qy, *args): 
    62     """ 
    63         Return I(qx, qy) 
    64     """ 
    65     return Iq(sqrt(qx ** 2 + qy ** 2), *args) 
    66 Iqxy.vectorized = True # Iqxy accepts an array of qx, qy values 
    67  
    68  
    6961demo = dict(scale=100, background=1.0, 
    7062            peak_pos=0.05, peak_hwhm=0.005) 

  • sasmodels/models/pearl_necklace.c

    rcf85329 r2c74c11  
    66 
    77double Iq(double q, double radius, double edge_separation, 
    8         double string_thickness, double number_of_pearls, double sld,  
    9         double string_sld, double solvent_sld); 
    10 double Iqxy(double qx, double qy, double radius, double edge_separation, 
    118        double string_thickness, double number_of_pearls, double sld,  
    129        double string_sld, double solvent_sld); 
    … …  
    139136        return value*tot_vol; 
    140137} 
    141  
    142 double Iqxy(double qx, double qy, double radius, double edge_separation, 
    143         double string_thickness, double number_of_pearls, double sld,  
    144         double string_sld, double solvent_sld) 
    145 { 
    146     double q = sqrt(qx*qx + qy*qy); 
    147     return(Iq(q, radius, edge_separation, string_thickness, number_of_pearls,  
    148                 sld, string_sld, solvent_sld)); 
    149 } 

  • sasmodels/models/poly_gauss_coil.py

    r65279d8 r2c74c11  
    5050""" 
    5151 
    52 import numpy as np 
    53 from numpy import inf, exp, power, sqrt 
     52from numpy import inf, exp, power 
    5453 
    5554name =  "poly_gauss_coil" 
    … …  
    8382Iq.vectorized =  True  # Iq accepts an array of q values 
    8483 
    85 def Iqxy(qx, qy, *args): 
    86     # pylint: disable = missing-docstring 
    87     return Iq(sqrt(qx ** 2 + qy ** 2), *args) 
    88 Iqxy.vectorized = True # Iqxy accepts an array of qx, qy values 
    89  
    9084demo =  dict(scale = 1.0, 
    9185            i_zero = 70.0, 

  • sasmodels/models/polymer_excl_volume.py

    r416609b r2c74c11  
    9393""" 
    9494 
    95 from numpy import inf, power, sqrt 
     95from numpy import inf, power, errstate 
    9696from scipy.special import gammainc, gamma 
    9797 
    … …  
    120120    :return:          Calculated intensity 
    121121    """ 
    122     nu = 1.0/porod_exp 
    123     u = q*q*rg*rg*(2.0*nu+1.0) * (2.0*nu+2.0)/6.0 
    124     o2nu = 1.0/(2.0*nu) 
     122    u = (q*rg)**2 * (2.0/porod_exp + 1.0) * (2.0/porod_exp + 2.0)/6.0 
     123    with errstate(divide='ignore', invalid='ignore'): 
     124        upow = power(u, -0.5*porod_exp) 
     125        iq = (porod_exp*upow * 
     126              (gamma(0.5*porod_exp)*gammainc(0.5*porod_exp, u) - 
     127               upow*gamma(porod_exp)*gammainc(porod_exp, u))) 
     128    iq[q <= 0] = 1.0 
    125129 
    126     intensity = ((1.0/(nu*power(u, o2nu))) * 
    127                  (gamma(o2nu)*gammainc(o2nu, u) - 
    128                   1.0/power(u, o2nu) * gamma(porod_exp) * 
    129                   gammainc(porod_exp, u))) * (q > 0) + 1.0*(q <= 0) 
    130  
    131     return intensity 
     130    return iq 
    132131 
    133132Iq.vectorized = True  # Iq accepts an array of q values 
    134  
    135  
    136 def Iqxy(qx, qy, *args): 
    137     """ 
    138     :param qx:   Input q_x-value 
    139     :param qy:   Input q_y-value 
    140     :param args: Remaining arguments 
    141     :return:     2D-Intensity 
    142     """ 
    143     return Iq(sqrt(qx**2 + qy**2), *args) 
    144  
    145 Iqxy.vectorized = True  # Iqxy accepts an array of qx, qy values 
    146133 
    147134 

  • sasmodels/models/polymer_micelle_kernel.c

    r1e9a108 r2c74c11  
    1010        double d_penetration, 
    1111        double n_aggreg); 
    12  
    13  
    14 double Iqxy(double qx, double qy, 
    15             double ndensity, 
    16             double v_core, 
    17             double v_corona, 
    18             double solvent_sld, 
    19             double core_sld, 
    20             double corona_sld, 
    21             double radius_core, 
    22             double radius_gyr, 
    23             double d_penetration, 
    24             double n_aggreg); 
    25  
    2612 
    2713static double micelle_spherical_kernel(double q, 
    … …  
    10086            n_aggreg); 
    10187} 
    102  
    103 double Iqxy(double qx, double qy, 
    104             double ndensity, 
    105             double v_core, 
    106             double v_corona, 
    107             double solvent_sld, 
    108             double core_sld, 
    109             double corona_sld, 
    110             double radius_core, 
    111             double radius_gyr, 
    112             double d_penetration, 
    113             double n_aggreg) 
    114 { 
    115     double q = sqrt(qx*qx + qy*qy); 
    116     return micelle_spherical_kernel(q, 
    117             ndensity, 
    118             v_core, 
    119             v_corona, 
    120             solvent_sld, 
    121             core_sld, 
    122             corona_sld, 
    123             radius_core, 
    124             radius_gyr, 
    125             d_penetration, 
    126             n_aggreg); 
    127  
    128 } 
    129  

  • sasmodels/models/porod.py

    r82923a6 r2c74c11  
    2626""" 
    2727 
    28 from numpy import sqrt, power, inf, errstate 
     28from numpy import power, inf, errstate 
    2929 
    3030name = "porod" 
    … …  
    4747Iq.vectorized = True  # Iq accepts an array of q values 
    4848 
    49 def Iqxy(qx, qy, *args): 
    50     """ 
    51     @param qx:   Input q_x-value 
    52     @param qy:   Input q_y-value 
    53     @param args: Remaining arguments 
    54     """ 
    55     return Iq(sqrt(qx ** 2 + qy ** 2), *args) 
    56  
    57 Iqxy.vectorized = True # Iqxy accepts an array of qx, qy values 
    58  
    5949demo = dict(scale=1.5, background=0.5) 
    6050 

  • sasmodels/models/power_law.py

    rec45c4f r2c74c11  
    2727""" 
    2828 
    29 from numpy import inf, sqrt 
     29from numpy import inf, errstate 
    3030 
    3131name = "power_law" 
    … …  
    4545def Iq(q, power): 
    4646    # pylint: disable=missing-docstring 
    47     inten = (q**-power) 
    48     return inten 
     47    with errstate(divide='ignore'): 
     48        iq = q**-power 
     49    return iq 
    4950Iq.vectorized = True  # Iq accepts an array of q values 
    50  
    51 def Iqxy(qx, qy, *args): 
    52     # pylint: disable=missing-docstring 
    53     return Iq(sqrt(qx ** 2 + qy ** 2), *args) 
    54 Iqxy.vectorized = True # Iqxy accepts an array of qx, qy values 
    5551 
    5652demo = dict(scale=1.0, 

  • sasmodels/models/pringle.c

    rb70cb3b r2c74c11  
    33 
    44double Iq(double q, 
    5           double radius, 
    6           double thickness, 
    7           double alpha, 
    8           double beta, 
    9           double sld_pringle, 
    10           double sld_solvent); 
    11  
    12 double Iqxy(double qx, double qy, 
    135          double radius, 
    146          double thickness, 
    … …  
    187179    return 1.0e-4*form*M_PI*radius*radius*thickness; 
    188180} 
    189  
    190 double Iqxy(double qx, double qy, 
    191             double radius, 
    192             double thickness, 
    193             double alpha, 
    194             double beta, 
    195             double sld_pringle, 
    196             double sld_solvent) 
    197 { 
    198     double q = sqrt(qx*qx + qy*qy); 
    199     return Iq(q, 
    200             radius, 
    201             thickness, 
    202             alpha, 
    203             beta, 
    204             sld_pringle, 
    205             sld_solvent); 
    206 } 
    207  

  • sasmodels/models/raspberry.c

    r616df8f r2c74c11  
    22 
    33double Iq(double q,  
    4           double sld_lg, double sld_sm, double sld_solvent, 
    5           double volfraction_lg, double volfraction_sm, double surf_fraction, 
    6           double radius_lg, double radius_sm, double penetration); 
    7  
    8 double Iqxy(double qx, double qy, 
    94          double sld_lg, double sld_sm, double sld_solvent, 
    105          double volfraction_lg, double volfraction_sm, double surf_fraction, 
    … …  
    8883    return f2; 
    8984} 
    90  
    91  
    92  
    93 double Iqxy(double qx, double qy, 
    94           double sld_lg, double sld_sm, double sld_solvent, 
    95           double volfraction_lg, double volfraction_sm, double surf_fraction, 
    96           double radius_lg, double radius_sm, double penetration) 
    97            
    98 { 
    99     double q = sqrt(qx*qx + qy*qy); 
    100     return Iq(q, 
    101           sld_lg, sld_sm, sld_solvent, 
    102           volfraction_lg, volfraction_sm, surf_fraction, 
    103           radius_lg, radius_sm, penetration); 
    104  
    105 } 

  • sasmodels/models/sphere.py

    r42356c8 r2c74c11  
    7878    """ 
    7979 
    80 Iqxy = """ 
    81     // never called since no orientation or magnetic parameters. 
    82     //return -1.0; 
    83     return Iq(sqrt(qx*qx + qy*qy), sld, sld_solvent, radius); 
    84     """ 
    85  
    8680def ER(radius): 
    8781    """ 

  • sasmodels/models/stacked_disks.c

    r43b7eea r2c74c11  
    1313          double layer_sld, 
    1414          double solvent_sld); 
    15  
    16 double Iqxy(double qx, double qy, 
    17             double core_thick, 
    18             double layer_thick, 
    19             double radius, 
    20             double n_stacking, 
    21             double sigma_d, 
    22             double core_sld, 
    23             double layer_sld, 
    24             double solvent_sld, 
    25             double theta, 
    26             double phi); 
    2715 
    2816static 
    … …  
    5240        const double sinarg2 = qq*(halfheight+layer_thick)*cos(zi); 
    5341 
    54     const double be1 = sas_J1c(besarg1); 
     42        const double be1 = sas_J1c(besarg1); 
    5543        const double be2 = sas_J1c(besarg2); 
    5644        const double si1 = sin(sinarg1)/sinarg1; 
    … …  
    215203                    solvent_sld); 
    216204} 
    217  
    218 // Iqxy is never called since no orientation or magnetic parameters. 
    219 double Iqxy(double qx, double qy, 
    220             double core_thick, 
    221             double layer_thick, 
    222             double radius, 
    223             double n_stacking, 
    224             double sigma_d, 
    225             double core_sld, 
    226             double layer_sld, 
    227             double solvent_sld, 
    228             double theta, 
    229             double phi) 
    230 { 
    231     double q = sqrt(qx*qx + qy*qy); 
    232     return stacked_disks_kernel_2d(q, qx/q, qy/q, 
    233                     core_thick, 
    234                     layer_thick, 
    235                     radius, 
    236                     n_stacking, 
    237                     sigma_d, 
    238                     core_sld, 
    239                     layer_sld, 
    240                     solvent_sld, 
    241                     theta, 
    242                     phi); 
    243 } 
    244  

  • sasmodels/models/star_polymer.c

    r55b283e8 r2c74c11  
    22 
    33double Iq(double q, double radius2, double arms); 
    4  
    5 double Iqxy(double qx, double qy, double radius2, double arms); 
    6  
    74 
    85static double _mass_fractal_kernel(double q, double radius2, double arms) 
    … …  
    2825    return _mass_fractal_kernel(q, radius2, arms); 
    2926} 
    30  
    31 // Iqxy is never called since no orientation or magnetic parameters. 
    32 double Iqxy(double qx, double qy, double radius2, double arms) 
    33 { 
    34     double q = sqrt(qx*qx + qy*qy); 
    35     return _mass_fractal_kernel(q, radius2, arms); 
    36 } 
    37  

  • sasmodels/models/surface_fractal.c

    r6794301 r2c74c11  
    55          double surface_dim, 
    66          double cutoff_length); 
    7  
    8 double Iqxy(double qx, double qy, 
    9             double radius, 
    10             double surface_dim, 
    11             double cutoff_length); 
    127 
    138static double _surface_fractal_kernel(double q, 
    … …  
    4944    return _surface_fractal_kernel(q, radius, surface_dim, cutoff_length); 
    5045} 
    51  
    52 // Iqxy is never called since no orientation or magnetic parameters. 
    53 double Iqxy(double qx, double qy, 
    54     double radius, 
    55     double surface_dim, 
    56     double cutoff_length) 
    57 { 
    58     double q = sqrt(qx*qx + qy*qy); 
    59     return _surface_fractal_kernel(q, radius, surface_dim, cutoff_length); 
    60 } 
    61  

  • sasmodels/models/teubner_strey.py

    rec45c4f r2c74c11  
    6868 
    6969 
    70 def form_volume(radius): 
    71     return 1.0 
    72  
    7370def Iq(q, a2, c1, c2): 
    7471    return 1. / np.polyval([c2, c1, a2], q**2) 
    7572Iq.vectorized = True  # Iq accepts an array of q values 
    7673 
    77 def Iqxy(qx, qy, a2, c1, c2): 
    78     return Iq(sqrt(qx**2 + qy**2), a2, c1, c2) 
    79 Iqxy.vectorized = True  # Iqxy accepts arrays of qx, qy values 
    80  
    81 # ER defaults to 0.0 
    82  
    83 # VR defaults to 1.0 
    84  
    8574demo = dict(scale=1, background=0, a2=0.1, c1=-30.0, c2=5000.0) 
    8675tests = [[{}, 0.2, 0.145927536232]] 

  • sasmodels/models/two_lorentzian.py

    r416609b r2c74c11  
    3434""" 
    3535 
    36 from numpy import inf, power, sqrt 
     36from numpy import inf, power 
    3737 
    3838name = "two_lorentzian" 
    … …  
    9292 
    9393Iq.vectorized = True  # Iq accepts an array of q values 
    94  
    95  
    96 def Iqxy(qx, qy, *args): 
    97     """ 
    98     :param qx:   Input q_x-value 
    99     :param qy:   Input q_y-value 
    100     :param args: Remaining arguments 
    101     :return:     2D-Intensity 
    102     """ 
    103  
    104     return Iq(sqrt(qx**2 + qy**2), *args) 
    105  
    106 Iqxy.vectorized = True  # Iqxy accepts an array of qx, qy values 
    10794 
    10895 

  • sasmodels/models/two_power_law.py

    rec45c4f r2c74c11  
    4444""" 
    4545 
    46 from numpy import power 
    47 from numpy import sqrt 
    48 from numpy import inf 
    49 from numpy import concatenate 
     46from numpy import inf, power, empty, errstate 
    5047 
    5148name = "two_power_law" 
    … …  
    9289    :return:                    Calculated intensity 
    9390    """ 
    94  
    95     #Two sub vectors are created to treat crossover values 
    96     q_lower = q[q <= crossover] 
    97     q_upper = q[q > crossover] 
    98     coefficent_2 = coefficent_1*power(crossover, -1.0*power_1)/power(crossover, -1.0*power_2) 
    99     intensity_lower = coefficent_1*power(q_lower, -1.0*power_1) 
    100     intensity_upper = coefficent_2*power(q_upper, -1.0*power_2) 
    101     intensity = concatenate((intensity_lower, intensity_upper), axis=0) 
    102  
    103     return intensity 
     91    iq = empty(q.shape, 'd') 
     92    idx = (q <= crossover) 
     93    with errstate(divide='ignore'): 
     94        coefficent_2 = coefficent_1 * power(crossover, power_2 - power_1) 
     95        iq[idx] = coefficent_1 * power(q[idx], -power_1) 
     96        iq[~idx] = coefficent_2 * power(q[~idx], -power_2) 
     97    return iq 
    10498 
    10599Iq.vectorized = True  # Iq accepts an array of q values 
    106  
    107 def Iqxy(qx, qy, *args): 
    108     """ 
    109     :param qx:   Input q_x-value 
    110     :param qy:   Input q_y-value 
    111     :param args: Remaining arguments 
    112     :return:     2D-Intensity 
    113     """ 
    114  
    115     return Iq(sqrt(qx**2 + qy**2), *args) 
    116  
    117 Iqxy.vectorized = True  # Iqxy accepts an array of qx, qy values 
    118100 
    119101demo = dict(scale=1, background=0.0, 

  • sasmodels/models/unified_power_Rg.py

    r42356c8 r2c74c11  
    6262 
    6363import numpy as np 
    64 from numpy import inf, exp, sqrt 
     64from numpy import inf, exp, sqrt, errstate 
    6565from scipy.special import erf 
    6666 
    … …  
    7676    ilevel = int(level) 
    7777    if ilevel == 0: 
    78         return 1./q 
     78        with errstate(divide='ignore'): 
     79            return 1./q 
    7980 
    80     result = np.zeros_like(q) 
    81     for i in range(ilevel): 
    82         exp_now = exp(-(q*rg[i])**2/3.) 
    83         pow_now = (erf(q*rg[i]/sqrt(6.))**3/q)**power[i] 
    84         exp_next = exp(-(q*rg[i+1])**2/3.) if i < ilevel-1 else 1. 
    85         result += G[i]*exp_now + B[i]*exp_next*pow_now 
     81    with errstate(divide='ignore', invalid='ignore'): 
     82        result = np.empty(q.shape, 'd') 
     83        for i in range(ilevel): 
     84            exp_now = exp(-(q*rg[i])**2/3.) 
     85            pow_now = (erf(q*rg[i]/sqrt(6.))**3/q)**power[i] 
     86            exp_next = exp(-(q*rg[i+1])**2/3.) if i < ilevel-1 else 1. 
     87            result += G[i]*exp_now + B[i]*exp_next*pow_now 
    8688    result[q==0] = np.sum(G[:ilevel]) 
    8789    return result 
     90 
    8891Iq.vectorized = True 
    8992 

  • sasmodels/models/vesicle.c

    r062db5a r2c74c11  
    22 
    33double Iq(double q,  
    4           double sld, double sld_solvent, double volfraction, 
    5           double radius, double thickness); 
    6  
    7 double Iqxy(double qx, double qy, 
    84          double sld, double sld_solvent, double volfraction, 
    95          double radius, double thickness); 
    … …  
    4945    return(f2); 
    5046} 
    51  
    52  
    53 double Iqxy(double qx, double qy, 
    54           double sld, double sld_solvent, double volfraction, 
    55           double radius, double thickness) 
    56            
    57 { 
    58     double q = sqrt(qx*qx + qy*qy); 
    59     return Iq(q, 
    60         sld, sld_solvent, volfraction, 
    61         radius,thickness); 
    62  
    63 } 
Note: See TracChangeset for help on using the changeset viewer.