Changes in / [1a580fb:94d13f1] in sasmodels


Ignore:
Location:
sasmodels
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • sasmodels/conversion_table.py

    rbb584b3 rfa6d6fc  
    55names for each parameter in sasmodels.  This is used by :mod:`convert` to 
    66determine the equivalent parameter set when comparing a sasmodels model to 
    7 the models defined in previous versions of SasView and sasmodels. This is now 
    8 versioned based on the version number of SasView. 
    9  
    10 When any sasmodels parameter or model name is changed, this must be modified to 
    11 account for that. 
    12  
    13 Usage: 
    14 <old_Sasview_version> : { 
    15     <new_model_name> : [ 
    16         <old_model_name> , 
    17         { 
    18             <new_param_name_1> : <old_param_name_1>, 
    19             ... 
    20             <new_param_name_n> : <old_param_name_n> 
    21         } 
    22     ] 
    23 } 
    24  
    25 Any future parameter and model name changes can and should be given in this 
    26 table for future compatibility. 
     7the models defined in SasView 3.1. 
    278""" 
    289 
     10 
    2911CONVERSION_TABLE = { 
    30     (3,1,2) : { 
    3112    "adsorbed_layer": [ 
    3213        "Core2ndMomentModel", 
    … …  
    230211    ], 
    231212    "correlation_length": [ 
    232         "CorrLength", 
     213        "CorrLengthModel", 
    233214        { 
    234215            "porod_scale": "scale_p", 
    … …  
    237218            "lorentz_exp": "exponent_l", 
    238219            "cor_length": "length_l" 
    239         }, 
    240         "CorrLengthModel" 
     220        } 
    241221    ], 
    242222    "cylinder": [ 
    … …  
    319299    ], 
    320300    "fractal_core_shell": [ 
    321         "FractalCoreShell", 
     301        "FractalCoreShellModel", 
    322302        { 
    323303            "sld_core": "core_sld", 
    … …  
    329309            "cor_length": "cor_length", 
    330310            "volfraction": "volfraction", 
    331         }, 
    332         "FractalCoreShellModel" 
     311        } 
    333312    ], 
    334313    "fuzzy_sphere": [ 
    … …  
    342321    ], 
    343322    "gauss_lorentz_gel": [ 
    344         "GaussLorentzGel", 
     323        "GaussLorentzGelModel", 
    345324        { 
    346325            "gauss_scale": "scale_g", 
    … …  
    349328            "background": "background", 
    350329            "lorentz_scale": "scale_l" 
    351         }, 
    352         "GaussLorentzGelModel" 
     330        } 
    353331    ], 
    354332    "gaussian_peak": [ 
    355         "Peak Gauss Model", 
     333        "PeakGaussModel", 
    356334        { 
    357335            "peak_pos": "q0", 
    358336            "sigma": "B", 
    359         }, 
    360         "PeakGaussModel", 
     337        } 
    361338    ], 
    362339    "gel_fit": [ 
    … …  
    366343            "lorentz_scale": "lScale", 
    367344            "guinier_scale": "gScale", 
    368             "fractal_dim": "FractalExp", 
     345            "fractal_dim": "scale", 
    369346            "cor_length": "zeta", 
    370347        } 
    371348    ], 
    372349    "guinier": [ 
    373         "Guinier", 
     350        "GuinierModel", 
    374351        { 
    375352            "rg": "rg" 
    376         }, 
    377         "GuinierModel", 
     353        } 
    378354    ], 
    379355    "guinier_porod": [ 
    380         "GuinierPorod", 
     356        "GuinierPorodModel", 
    381357        { 
    382358            "s": "dim", 
    … …  
    385361            "scale": "scale", 
    386362            "background": "background" 
    387         }, 
    388         "GuinierPorodModel", 
     363        } 
    389364    ], 
    390365    "hardsphere": [ 
    … …  
    479454            "d_spacing": "spacing", 
    480455            "Caille_parameter": "caille", 
    481             "Nlayers": "n_plates", 
     456            "Nlayers": "N_plates", 
    482457        } 
    483458    ], 
    … …  
    511486    ], 
    512487    "lorentz": [ 
    513         "Lorentz", 
     488        "LorentzModel", 
    514489        { 
    515490            "cor_length": "length" 
    516         }, 
    517         "LorentzModel", 
     491        } 
    518492    ], 
    519493    "mass_fractal": [ 
    … …  
    536510    ], 
    537511    "mono_gauss_coil": [ 
    538         "Debye", 
     512        "DebyeModel", 
    539513        { 
    540514            "rg": "rg", 
    541515            "i_zero": "scale", 
    542516            "background": "background", 
    543         }, 
    544         "DebyeModel", 
     517        } 
    545518    ], 
    546519    "multilayer_vesicle": [ 
    … …  
    591564    ], 
    592565    "peak_lorentz": [ 
    593         "Peak Lorentz Model", 
     566        "PeakLorentzModel", 
    594567        { 
    595568            "peak_pos": "q0", 
    596569            "peak_hwhm": "B" 
    597         }, 
    598         "PeakLorentzModel", 
     570        } 
    599571    ], 
    600572    "pearl_necklace": [ 
    … …  
    830802    ], 
    831803    "two_lorentzian": [ 
    832         "TwoLorentzian", 
     804        "TwoLorentzianModel", 
    833805        { 
    834806            "lorentz_scale_1": "scale_1", 
    … …  
    839811            "lorentz_length_1": "length_1", 
    840812            "background": "background" 
    841         }, 
    842         "TwoLorentzianModel", 
     813        } 
    843814    ], 
    844815    "two_power_law": [ 
    845         "TwoPowerLaw", 
     816        "TwoPowerLawModel", 
    846817        { 
    847818            "coefficent_1": "coef_A", 
    … …  
    850821            "background": "background", 
    851822            "crossover": "qc" 
    852         }, 
    853         "TwoPowerLawModel", 
     823        } 
    854824    ], 
    855825    "unified_power_Rg": [ 
    856         "UnifiedPowerRg", 
    857         dict(((field_new+str(index), field_old+str(index)) 
    858               for field_new, field_old in [("rg", "Rg"), 
    859                                            ("power", "power"), 
    860                                            ("G", "G"), 
    861                                            ("B", "B"),] 
    862               for index in range(11)), 
    863              **{ 
    864                    "background": "background", 
    865                    "scale": "scale", 
    866                }), 
    867826        "UnifiedPowerRgModel", 
     827        { 
     828        } 
    868829    ], 
    869830    "vesicle": [ 
    … …  
    874835        } 
    875836    ] 
    876     } 
    877837} 

  • sasmodels/convert.py

    r07c8d46 rf80f334  
    5353    ("_pd_nsigma", ".nsigmas"), 
    5454    ("_pd_type", ".type"), 
    55     (".lower", ".lower"), 
    56     (".upper", ".upper"), 
    57     (".fittable", ".fittable"), 
    58     (".std", ".std"), 
    59     (".units", ".units"), 
    60     ("", "") 
    6155    ] 
    6256 
    … …  
    7064    if id.startswith('M0:'): 
    7165        return True 
     66    if id.startswith('volfraction') or id.startswith('radius_effective'): 
     67        return False 
    7268    if '_pd' in id or '.' in id: 
    7369        return False 
    … …  
    7975        if p.id == id: 
    8076            return p.type == 'sld' 
    81     return False 
     77    raise ValueError("unknown parameter %r in conversion"%id) 
    8278 
    8379def _rescale_sld(model_info, pars, scale): 
    … …  
    9288 
    9389 
    94 def _get_translation_table(model_info, version=(3,1,2)): 
    95     conv_param = CONVERSION_TABLE.get(version, {}).get(model_info.id, [None, {}]) 
    96     translation = conv_param[1].copy() 
     90def _get_translation_table(model_info): 
     91    _, translation = CONVERSION_TABLE.get(model_info.id, [None, {}]) 
     92    translation = translation.copy() 
    9793    for p in model_info.parameters.kernel_parameters: 
    9894        if p.length > 1: 
    … …  
    123119def _pd_to_underscores(pars): 
    124120    return dict((_dot_pd_to_underscore_pd(k), v) for k, v in pars.items()) 
     121 
     122def _convert_name(conv_dict, pars): 
     123    """ 
     124    Renames parameter values (upper, lower, etc) to v4.0 names 
     125    :param conv_dict: conversion dictionary mapping new name : old name 
     126    :param pars: parameters to convert 
     127    :return: 
     128    """ 
     129    new_pars = {} 
     130    i = 0 
     131    j = 0 
     132    for key_par, value_par in pars.iteritems(): 
     133        j += 1 
     134        for key_conv, value_conv in conv_dict.iteritems(): 
     135            if re.search(value_conv, key_par): 
     136                new_pars[key_par.replace(value_conv, key_conv)] = value_par 
     137                i += 1 
     138                break 
     139            elif re.search("background", key_par) or re.search("scale", key_par): 
     140                new_pars[key_par] = value_par 
     141                i += 1 
     142                break 
     143        if i != j: 
     144            new_pars[key_par] = value_par 
     145            i += 1 
     146    return new_pars 
    125147 
    126148def _convert_pars(pars, mapping): 
    … …  
    145167    return newpars 
    146168 
    147 def _conversion_target(model_name, version=(3,1,2)): 
     169 
     170def _conversion_target(model_name): 
    148171    """ 
    149172    Find the sasmodel name which translates into the sasview name. 
    … …  
    153176    two variants in sasview. 
    154177    """ 
    155     for sasmodels_name, sasview_dict in \ 
    156             CONVERSION_TABLE.get(version, {}).items(): 
    157         if sasview_dict[0] == model_name: 
     178    for sasmodels_name, [sasview_name, _] in CONVERSION_TABLE.items(): 
     179        if sasview_name == model_name: 
    158180            return sasmodels_name 
    159181    return None 
    160182 
    161 def _hand_convert(name, oldpars, version=(3,1,2)): 
    162     if version == (3,1,2): 
    163         oldpars = _hand_convert_3_1_2_to_4_1(name, oldpars) 
    164     return oldpars 
    165  
    166 def _hand_convert_3_1_2_to_4_1(name, oldpars): 
     183 
     184def _hand_convert(name, oldpars): 
    167185    if name == 'core_shell_parallelepiped': 
    168186        # Make sure pd on rim parameters defaults to zero 
    … …  
    197215            pd = oldpars['radius.width']*oldpars['radius']/thickness 
    198216            oldpars['radius.width'] = pd 
    199     elif name == 'multilayer_vesicle': 
    200         if 'scale' in oldpars: 
    201             oldpars['volfraction'] = oldpars['scale'] 
    202             oldpars['scale'] = 1.0 
    203         if 'scale.lower' in oldpars: 
    204             oldpars['volfraction.lower'] = oldpars['scale.lower'] 
    205         if 'scale.upper' in oldpars: 
    206             oldpars['volfraction.upper'] = oldpars['scale.upper'] 
    207         if 'scale.fittable' in oldpars: 
    208             oldpars['volfraction.fittable'] = oldpars['scale.fittable'] 
    209         if 'scale.std' in oldpars: 
    210             oldpars['volfraction.std'] = oldpars['scale.std'] 
    211         if 'scale.units' in oldpars: 
    212             oldpars['volfraction.units'] = oldpars['scale.units'] 
    213217    elif name == 'pearl_necklace': 
    214218        pass 
    … …  
    232236                oldpars[p + ".upper"] /= 1e-13 
    233237    elif name == 'spherical_sld': 
    234         j = 0 
    235         while "func_inter" + str(j) in oldpars: 
    236             name = "func_inter" + str(j) 
    237             new_name = "shape" + str(j + 1) 
    238             if oldpars[name] == 'Erf(|nu|*z)': 
    239                 oldpars[new_name] = int(0) 
    240             elif oldpars[name] == 'RPower(z^|nu|)': 
    241                 oldpars[new_name] = int(1) 
    242             elif oldpars[name] == 'LPower(z^|nu|)': 
    243                 oldpars[new_name] = int(2) 
    244             elif oldpars[name] == 'RExp(-|nu|*z)': 
    245                 oldpars[new_name] = int(3) 
    246             elif oldpars[name] == 'LExp(-|nu|*z)': 
    247                 oldpars[new_name] = int(4) 
    248             else: 
    249                 oldpars[new_name] = int(0) 
    250             oldpars.pop(name) 
    251             oldpars['n_shells'] = str(j + 1) 
    252             j += 1 
     238        oldpars["CONTROL"] += 1 
    253239    elif name == 'teubner_strey': 
    254240        # basically undoing the entire Teubner-Strey calculations here. 
    … …  
    295281    return oldpars 
    296282 
    297 def convert_model(name, pars, use_underscore=False, model_version=(3,1,2)): 
     283def convert_model(name, pars, use_underscore=False): 
    298284    """ 
    299285    Convert model from old style parameter names to new style. 
    300286    """ 
    301     newpars = pars 
    302     keys = sorted(CONVERSION_TABLE.keys()) 
    303     for i, version in enumerate(keys): 
    304         # Don't allow indices outside list 
    305         next_i = i + 1 
    306         if next_i == len(keys): 
    307             next_i = i 
    308         # If the save state is from a later version, skip the check 
    309         if model_version <= keys[next_i]: 
    310             newname = _conversion_target(name, version) 
    311         else: 
    312             newname = None 
    313         # If no conversion is found, move on 
    314         if newname is None: 
    315             newname = name 
    316             continue 
    317         if ':' in newname:   # core_shell_ellipsoid:1 
    318             model_info = load_model_info(newname[:-2]) 
    319             # Know the table exists and isn't multiplicity so grab it directly 
    320             # Can't use _get_translation_table since that will return the 'bare' 
    321             # version. 
    322             translation = CONVERSION_TABLE.get(version, {})[newname][1] 
    323         else: 
    324             model_info = load_model_info(newname) 
    325             translation = _get_translation_table(model_info, version) 
    326         newpars = _hand_convert(newname, newpars, version) 
    327         newpars = _convert_pars(newpars, translation) 
    328         # TODO: Still not convinced this is the best check 
    329         if not model_info.structure_factor and version == (3,1,2): 
    330             newpars = _rescale_sld(model_info, newpars, 1e6) 
    331         newpars.setdefault('scale', 1.0) 
    332         newpars.setdefault('background', 0.0) 
    333         if use_underscore: 
    334             newpars = _pd_to_underscores(newpars) 
    335         name = newname 
     287    newname = _conversion_target(name) 
     288    if newname is None: 
     289        return name, pars 
     290    if ':' in newname:   # core_shell_ellipsoid:1 
     291        model_info = load_model_info(newname[:-2]) 
     292        # Know that the table exists and isn't multiplicity so grab it directly 
     293        # Can't use _get_translation_table since that will return the 'bare' 
     294        # version. 
     295        translation = CONVERSION_TABLE[newname][1] 
     296    else: 
     297        model_info = load_model_info(newname) 
     298        translation = _get_translation_table(model_info) 
     299    newpars = _hand_convert(newname, pars.copy()) 
     300    newpars = _convert_name(translation, newpars) 
     301    newpars = _convert_pars(newpars, translation) 
     302    if not model_info.structure_factor: 
     303        newpars = _rescale_sld(model_info, newpars, 1e6) 
     304    newpars.setdefault('scale', 1.0) 
     305    newpars.setdefault('background', 0.0) 
     306    if use_underscore: 
     307        newpars = _pd_to_underscores(newpars) 
    336308    return newname, newpars 
     309 
    337310 
    338311# ========= BACKWARD CONVERSION sasmodels => sasview 3.x =========== 

  • sasmodels/kernelcl.py

    rb8ddf2e r7fcdc9f  
    465465        # architectures tested so far. 
    466466        if self.is_2d: 
    467             # Note: 16 rather than 15 because result is 1 longer than input. 
    468             width = ((self.nq+16)//16)*16 
     467            # Note: 17 rather than 15 because results is 2 elements 
     468            # longer than input. 
     469            width = ((self.nq+17)//16)*16 
    469470            self.q = np.empty((width, 2), dtype=dtype) 
    470471            self.q[:self.nq, 0] = q_vectors[0] 
    471472            self.q[:self.nq, 1] = q_vectors[1] 
    472473        else: 
    473             # Note: 32 rather than 31 because result is 1 longer than input. 
    474             width = ((self.nq+32)//32)*32 
     474            # Note: 33 rather than 31 because results is 2 elements 
     475            # longer than input. 
     476            width = ((self.nq+33)//32)*32 
    475477            self.q = np.empty(width, dtype=dtype) 
    476478            self.q[:self.nq] = q_vectors[0] 
    … …  
    522524        self.dim = '2d' if q_input.is_2d else '1d' 
    523525        # plus three for the normalization values 
    524         self.result = np.empty(q_input.nq+1, dtype) 
     526        self.result = np.empty(q_input.nq+3, dtype) 
    525527 
    526528        # Inputs and outputs for each kernel call 

  • sasmodels/models/core_shell_bicelle.py

    r8afefae r4b541ac  
    156156            phi=0) 
    157157 
    158 #qx, qy = 0.4 * cos(pi/2.0), 0.5 * sin(0) 
     158qx, qy = 0.4 * cos(90), 0.5 * sin(0) 

  • sasmodels/models/core_shell_bicelle_elliptical.py

    r8afefae r8e68ea0  
    8383 
    8484    Definition of the angles for the oriented core_shell_bicelle_elliptical model. 
    85     Note that *theta* and *phi* are currently defined differently to those for the core_shell_bicelle model. 
    8685 
    8786 
    … …  
    150149            psi=0) 
    151150 
    152 #qx, qy = 0.4 * cos(pi/2.0), 0.5 * sin(0) 
     151qx, qy = 0.4 * cos(90), 0.5 * sin(0) 
    153152 
    154153tests = [ 

  • sasmodels/models/ellipsoid.c

    r130d4c7 r925ad6e  
    44    double radius_polar, double radius_equatorial, double theta, double phi); 
    55 
    6 static double 
    7 _ellipsoid_kernel(double q, double radius_polar, double radius_equatorial, double cos_alpha) 
     6double _ellipsoid_kernel(double q, double radius_polar, double radius_equatorial, double sin_alpha); 
     7double _ellipsoid_kernel(double q, double radius_polar, double radius_equatorial, double sin_alpha) 
    88{ 
    99    double ratio = radius_polar/radius_equatorial; 
    10     // Using ratio v = Rp/Re, we can expand the following to match the 
    11     // form given in Guinier (1955) 
    12     //     r = Re * sqrt(1 + cos^2(T) (v^2 - 1)) 
    13     //       = Re * sqrt( (1 - cos^2(T)) + v^2 cos^2(T) ) 
    14     //       = Re * sqrt( sin^2(T) + v^2 cos^2(T) ) 
    15     //       = sqrt( Re^2 sin^2(T) + Rp^2 cos^2(T) ) 
    16     // 
     10    // Given the following under the radical: 
     11    //     1 + sin^2(T) (v^2 - 1) 
     12    // we can expand to match the form given in Guinier (1955) 
     13    //     = (1 - sin^2(T)) + v^2 sin^2(T) = cos^2(T) + sin^2(T) 
    1714    // Instead of using pythagoras we could pass in sin and cos; this may be 
    1815    // slightly better for 2D which has already computed it, but it introduces 
    … …  
    2017    // leave it as is. 
    2118    const double r = radius_equatorial 
    22                      * sqrt(1.0 + cos_alpha*cos_alpha*(ratio*ratio - 1.0)); 
     19                     * sqrt(1.0 + sin_alpha*sin_alpha*(ratio*ratio - 1.0)); 
    2320    const double f = sas_3j1x_x(q*r); 
    2421 
    … …  
    4239    double total = 0.0; 
    4340    for (int i=0;i<76;i++) { 
    44         //const double cos_alpha = (Gauss76Z[i]*(upper-lower) + upper + lower)/2; 
    45         const double cos_alpha = Gauss76Z[i]*zm + zb; 
    46         total += Gauss76Wt[i] * _ellipsoid_kernel(q, radius_polar, radius_equatorial, cos_alpha); 
     41        //const double sin_alpha = (Gauss76Z[i]*(upper-lower) + upper + lower)/2; 
     42        const double sin_alpha = Gauss76Z[i]*zm + zb; 
     43        total += Gauss76Wt[i] * _ellipsoid_kernel(q, radius_polar, radius_equatorial, sin_alpha); 
    4744    } 
    4845    // translate dx in [-1,1] to dx in [lower,upper] 
    … …  
    6259    double q, sin_alpha, cos_alpha; 
    6360    ORIENT_SYMMETRIC(qx, qy, theta, phi, q, sin_alpha, cos_alpha); 
    64     const double form = _ellipsoid_kernel(q, radius_polar, radius_equatorial, cos_alpha); 
     61    const double form = _ellipsoid_kernel(q, radius_polar, radius_equatorial, sin_alpha); 
    6562    const double s = (sld - sld_solvent) * form_volume(radius_polar, radius_equatorial); 
    6663 

  • sasmodels/models/guinier_porod.py

    rcdcebf1 ra807206  
    44and dimensionality of scattering objects, including asymmetric objects 
    55such as rods or platelets, and shapes intermediate between spheres 
    6 and rods or between rods and platelets, and overcomes some of the  
    7 deficiencies of the (Beaucage) Unified_Power_Rg model (see Hammouda, 2010). 
     6and rods or between rods and platelets. 
    87 
    98Definition 
    … …  
    6059--------- 
    6160 
    62 B Hammouda, *A new Guinier-Porod model, J. Appl. Cryst.*, (2010), 43, 716-719 
     61A Guinier, G Fournet, *Small-Angle Scattering of X-Rays*, 
     62John Wiley and Sons, New York, (1955) 
    6363 
    64 B Hammouda, *Analysis of the Beaucage model, J. Appl. Cryst.*, (2010), 43, 1474-1478 
    65  
     64O Glatter, O Kratky, *Small-Angle X-Ray Scattering*, Academic Press (1982) 
     65Check out Chapter 4 on Data Treatment, pages 155-156. 
    6666""" 
    6767 

  • sasmodels/models/unified_power_Rg.py

    r66ca2a6 rb3f2a24  
    33---------- 
    44 
    5 This model employs the empirical multiple level unified Exponential/Power-law  
    6 fit method developed by Beaucage. Four functions are included so that 1, 2, 3,  
    7 or 4 levels can be used. In addition a 0 level has been added which simply  
    8 calculates 
     5The Beaucage model employs the empirical multiple level unified 
     6Exponential/Power-law fit method developed by G. Beaucage. Four functions 
     7are included so that 1, 2, 3, or 4 levels can be used. In addition a 0 level 
     8has been added which simply calculates 
    99 
    1010.. math:: 
    … …  
    1515many different types of particles, including fractal clusters, random coils 
    1616(Debye equation), ellipsoidal particles, etc. 
    17  
    18 The model works best for mass fractal systems characterized by Porod exponents  
    19 between 5/3 and 3. It should not be used for surface fractal systems. Hammouda  
    20 (2010) has pointed out a deficiency in the way this model handles the  
    21 transitioning between the Guinier and Porod regimes and which can create  
    22 artefacts that appear as kinks in the fitted model function. 
    23  
    24 Also see the Guinier_Porod model. 
    2517 
    2618The empirical fit function is: 
    … …  
    3830.. math:: 
    3931 
    40     q_i^* = q \left[\operatorname{erf} 
    41             \left(\frac{q R_{gi}}{\sqrt{6}}\right) 
    42         \right]^{-3} 
     32    q_i^* = \frac{q}{\operatorname{erf}^3(q R_{gi}/\sqrt{6}} 
    4333 
    4434 
    … …  
    6656 
    6757G Beaucage, *J. Appl. Cryst.*, 29 (1996) 134-146 
    68  
    69 B Hammouda, *Analysis of the Beaucage model, J. Appl. Cryst.*, (2010), 43, 1474-1478 
    7058 
    7159""" 

  • sasmodels/sasview_model.py

    ra38b065 r64614ad  
    1616import logging 
    1717from os.path import basename, splitext 
    18 import thread 
    1918 
    2019import numpy as np  # type: ignore 
    … …  
    4039    pass 
    4140 
    42 calculation_lock = thread.allocate_lock() 
    43  
    4441SUPPORT_OLD_STYLE_PLUGINS = True 
    4542 
    … …  
    6057    import sas.models 
    6158    from sasmodels.conversion_table import CONVERSION_TABLE 
    62     for new_name, conversion in CONVERSION_TABLE.get((3,1,2), {}).items(): 
     59    for new_name, conversion in CONVERSION_TABLE.items(): 
    6360        # CoreShellEllipsoidModel => core_shell_ellipsoid:1 
    6461        new_name = new_name.split(':')[0] 
    65         old_name = conversion[0] if len(conversion) < 3 else conversion[2] 
     62        old_name = conversion[0] 
    6663        module_attrs = {old_name: find_model(new_name)} 
    6764        ConstructedModule = type(old_name, (), module_attrs) 
    … …  
    608605        to the card for each evaluation. 
    609606        """ 
    610         ## uncomment the following when trying to debug the uncoordinated calls 
    611         ## to calculate_Iq 
    612         #if calculation_lock.locked(): 
    613         #    logging.info("calculation waiting for another thread to complete") 
    614         #    logging.info("\n".join(traceback.format_stack())) 
    615  
    616         with calculation_lock: 
    617             return self._calculate_Iq(qx, qy) 
    618  
    619     def _calculate_Iq(self, qx, qy=None): 
    620607        #core.HAVE_OPENCL = False 
    621608        if self._model is None: 
Note: See TracChangeset for help on using the changeset viewer.