Changeset d15a908 in sasmodels


Ignore:
Timestamp:
Jan 27, 2016 5:35:15 PM (9 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:
fdc538a
Parents:
37a7252
Message:

doc and delint

Location:
sasmodels
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • sasmodels/compare.py

    r608e31e rd15a908  
    7272# doc string so that we can display it at run time if there is an error. 
    7373# lin 
    74 __doc__ = __doc__ + """ 
     74__doc__ = (__doc__  # pylint: disable=redefined-builtin 
     75           + """ 
    7576Program description 
    7677------------------- 
    7778 
    78 """ + USAGE 
     79""" 
     80           + USAGE) 
    7981 
    8082 
    … …  
    281283            theory = lambda: smearer.get_value() 
    282284        else: 
    283             theory = lambda: model.evalDistribution([data.qx_data[index], data.qy_data[index]]) 
     285            theory = lambda: model.evalDistribution([data.qx_data[index], 
     286                                                     data.qy_data[index]]) 
    284287    elif smearer is not None: 
    285288        theory = lambda: smearer(model.evalDistribution(data.x)) 
    … …  
    416419        try: 
    417420            base_value, base_time = time_calculation(base, pars, Nbase) 
    418             print("%s t=%.1f ms, intensity=%.0f"%(base.engine, base_time, sum(base_value))) 
     421            print("%s t=%.1f ms, intensity=%.0f" 
     422                  % (base.engine, base_time, sum(base_value))) 
    419423        except ImportError: 
    420424            traceback.print_exc() 
    … …  
    426430        try: 
    427431            comp_value, comp_time = time_calculation(comp, pars, Ncomp) 
    428             print("%s t=%.1f ms, intensity=%.0f"%(comp.engine, comp_time, sum(comp_value))) 
     432            print("%s t=%.1f ms, intensity=%.0f" 
     433                  % (comp.engine, comp_time, sum(comp_value))) 
    429434        except ImportError: 
    430435            traceback.print_exc() 
    … …  
    433438    # Compare, but only if computing both forms 
    434439    if Nbase > 0 and Ncomp > 0: 
    435         #print("speedup %.2g"%(comp_time/base_time)) 
    436         #print("max |base/comp|", max(abs(base_value/comp_value)), "%.15g"%max(abs(base_value)), "%.15g"%max(abs(comp_value))) 
    437         #comp *= max(base_value/comp_value) 
    438440        resid = (base_value - comp_value) 
    439441        relerr = resid/comp_value 
    440         _print_stats("|%s-%s|"%(base.engine, comp.engine) + (" "*(3+len(comp.engine))), 
     442        _print_stats("|%s-%s|" 
     443                     % (base.engine, comp.engine) + (" "*(3+len(comp.engine))), 
    441444                     resid) 
    442         _print_stats("|(%s-%s)/%s|"%(base.engine, comp.engine, comp.engine), 
     445        _print_stats("|(%s-%s)/%s|" 
     446                     % (base.engine, comp.engine, comp.engine), 
    443447                     relerr) 
    444448 
    … …  
    591595    invalid = [o[1:] for o in flags 
    592596               if o[1:] not in NAME_OPTIONS 
    593                    and not any(o.startswith('-%s='%t) for t in VALUE_OPTIONS)] 
     597               and not any(o.startswith('-%s='%t) for t in VALUE_OPTIONS)] 
    594598    if invalid: 
    595599        print("Invalid options: %s"%(", ".join(invalid))) 
    … …  
    597601 
    598602 
     603    # pylint: disable=bad-whitespace 
    599604    # Interpret the flags 
    600605    opts = { 
    … …  
    651656        elif arg == '-sasview': engines.append(arg[1:]) 
    652657        elif arg == '-edit':    opts['explore'] = True 
     658    # pylint: enable=bad-whitespace 
    653659 
    654660    if len(engines) == 0: 
    … …  
    675681    presets = {} 
    676682    for arg in values: 
    677         k,v = arg.split('=',1) 
     683        k, v = arg.split('=', 1) 
    678684        if k not in pars: 
    679685            # extract base name without polydispersity info 
    680686            s = set(p.split('_pd')[0] for p in pars) 
    681             print("%r invalid; parameters are: %s"%(k,", ".join(sorted(s)))) 
     687            print("%r invalid; parameters are: %s"%(k, ", ".join(sorted(s)))) 
    682688            sys.exit(1) 
    683689        presets[k] = float(v) if not k.endswith('type') else v 
    … …  
    697703 
    698704    # Create the computational engines 
    699     data, _index = make_data(opts) 
     705    data, _ = make_data(opts) 
    700706    if n1: 
    701707        base = make_engine(model_definition, data, engines[0], opts['cutoff']) 
    … …  
    707713        comp = None 
    708714 
     715    # pylint: disable=bad-whitespace 
    709716    # Remember it all 
    710717    opts.update({ 
    … …  
    718725        'engines'   : [base, comp], 
    719726    }) 
     727    # pylint: enable=bad-whitespace 
    720728 
    721729    return opts 
    722730 
    723 def main(): 
    724     opts = parse_opts() 
    725     if opts['explore']: 
    726         explore(opts) 
    727     else: 
    728         compare(opts) 
    729  
    730731def explore(opts): 
     732    """ 
     733    Explore the model using the Bumps GUI. 
     734    """ 
    731735    import wx 
    732736    from bumps.names import FitProblem 
    … …  
    734738 
    735739    problem = FitProblem(Explore(opts)) 
    736     isMac = "cocoa" in wx.version() 
     740    is_mac = "cocoa" in wx.version() 
    737741    app = wx.App() 
    738742    frame = AppFrame(parent=None, title="explore") 
    739     if not isMac: frame.Show() 
     743    if not is_mac: frame.Show() 
    740744    frame.panel.set_model(model=problem) 
    741745    frame.panel.Layout() 
    742746    frame.panel.aui.Split(0, wx.TOP) 
    743     if isMac: frame.Show() 
     747    if is_mac: frame.Show() 
    744748    app.MainLoop() 
    745749 
    746750class Explore(object): 
    747751    """ 
    748     Return a bumps wrapper for a SAS model comparison. 
     752    Bumps wrapper for a SAS model comparison. 
     753 
     754    The resulting object can be used as a Bumps fit problem so that 
     755    parameters can be adjusted in the GUI, with plots updated on the fly. 
    749756    """ 
    750757    def __init__(self, opts): 
    … …  
    787794        Return cost. 
    788795        """ 
     796        # pylint: disable=no-self-use 
    789797        return 0.  # No nllf 
    790798 
    … …  
    804812 
    805813 
     814def main(): 
     815    """ 
     816    Main program. 
     817    """ 
     818    opts = parse_opts() 
     819    if opts['explore']: 
     820        explore(opts) 
     821    else: 
     822        compare(opts) 
     823 
    806824if __name__ == "__main__": 
    807825    main() 

  • sasmodels/compare_many.py

    r6458608 rd15a908  
    11#!/usr/bin/env python 
     2""" 
     3Program to compare results from many random parameter sets for a given model. 
     4 
     5The result is a comma separated value (CSV) table that can be redirected 
     6from standard output into a file and loaded into a spreadsheet. 
     7 
     8The models are compared for each parameter set and if the difference is 
     9greater than expected for that precision, the parameter set is labeled 
     10as bad and written to the output, along with the random seed used to 
     11generate that parameter value.  This seed can be used with :mod:`compare` 
     12to reload and display the details of the model. 
     13""" 
    214from __future__ import print_function 
    315 
    … …  
    1426 
    1527def calc_stats(target, value, index): 
     28    """ 
     29    Calculate statistics between the target value and the computed value. 
     30 
     31    *target* and *value* are the vectors being compared, with the 
     32    difference normalized by *target* to get relative error.  Only 
     33    the elements listed in *index* are used, though index may be 
     34    and empty slice defined by *slice(None, None)*. 
     35 
     36    Returns: 
     37 
     38        *maxrel* the maximum relative difference 
     39 
     40        *rel95* the relative difference with the 5% biggest differences ignored 
     41 
     42        *maxabs* the maximum absolute difference for the 5% biggest differences 
     43 
     44        *maxval* the maximum value for the 5% biggest differences 
     45    """ 
    1646    resid = abs(value-target)[index] 
    1747    relerr = resid/target[index] 
    18     srel = np.argsort(relerr) 
     48    sorted_rel_index = np.argsort(relerr) 
    1949    #p90 = int(len(relerr)*0.90) 
    2050    p95 = int(len(relerr)*0.95) 
    2151    maxrel = np.max(relerr) 
    22     rel95 = relerr[srel[p95]] 
    23     maxabs = np.max(resid[srel[p95:]]) 
    24     maxval = np.max(value[srel[p95:]]) 
    25     return maxrel,rel95,maxabs,maxval 
     52    rel95 = relerr[sorted_rel_index[p95]] 
     53    maxabs = np.max(resid[sorted_rel_index[p95:]]) 
     54    maxval = np.max(value[sorted_rel_index[p95:]]) 
     55    return maxrel, rel95, maxabs, maxval 
    2656 
    2757def print_column_headers(pars, parts): 
     58    """ 
     59    Generate column headers for the differences and for the parameters, 
     60    and print them to standard output. 
     61    """ 
    2862    stats = list('Max rel err|95% rel err|Max abs err above 90% rel|Max value above 90% rel'.split('|')) 
    2963    groups = [''] 
    … …  
    3670    print(','.join('"%s"'%c for c in columns)) 
    3771 
     72# Target 'good' value for various precision levels. 
    3873PRECISION = { 
    3974    'fast': 1e-3, 
    … …  
    4883def compare_instance(name, data, index, N=1, mono=True, cutoff=1e-5, 
    4984                     base='sasview', comp='double'): 
    50     is2D = hasattr(data, 'qx_data') 
     85    r""" 
     86    Compare the model under different calculation engines. 
     87 
     88    *name* is the name of the model. 
     89 
     90    *data* is the data object giving $q, \Delta q$ calculation points. 
     91 
     92    *index* is the active set of points. 
     93 
     94    *N* is the number of comparisons to make. 
     95 
     96    *cutoff* is the polydispersity weight cutoff to make the calculation 
     97    a little bit faster. 
     98 
     99    *base* and *comp* are the names of the calculation engines to compare. 
     100    """ 
     101 
     102    is_2d = hasattr(data, 'qx_data') 
    51103    model_definition = core.load_model_definition(name) 
    52104    pars = get_demo_pars(model_definition) 
    53105    header = ('\n"Model","%s","Count","%d","Dimension","%s"' 
    54               % (name, N, "2D" if is2D else "1D")) 
     106              % (name, N, "2D" if is_2d else "1D")) 
    55107    if not mono: header += ',"Cutoff",%g'%(cutoff,) 
    56108    print(header) 
    57109 
    58     if is2D: 
     110    if is_2d: 
    59111        info = generate.make_info(model_definition) 
    60112        partype = info['partype'] 
    … …  
    69121    # declarations are not available in python 2.7. 
    70122    def try_model(fn, pars): 
     123        """ 
     124        Return the model evaluated at *pars*.  If there is an exception, 
     125        print it and return NaN of the right shape. 
     126        """ 
    71127        try: 
    72128            result = fn(**pars) 
    … …  
    82138        return result 
    83139    def check_model(pars): 
     140        """ 
     141        Run the two calculators against *pars*, returning statistics 
     142        on the differences.  See :func:`calc_stats` for the list of stats. 
     143        """ 
    84144        base_value = try_model(calc_base, pars) 
    85145        comp_value = try_model(calc_comp, pars) 
    … …  
    108168        good = [True] 
    109169        columns = check_model(pars_i) 
    110         columns += [v for _,v in sorted(pars_i.items())] 
     170        columns += [v for _, v in sorted(pars_i.items())] 
    111171        if first: 
    112172            labels = [" vs. ".join((calc_base.engine, calc_comp.engine))] 
    … …  
    121181 
    122182def print_usage(): 
     183    """ 
     184    Print the command usage string. 
     185    """ 
    123186    print("usage: compare_many.py MODEL COUNT (1dNQ|2dNQ) (CUTOFF|mono) (single|double|quad)") 
    124187 
    125188 
    126189def print_models(): 
     190    """ 
     191    Print the list of available models in columns. 
     192    """ 
    127193    print(columnize(MODELS, indent="  ")) 
    128194 
    129195 
    130196def print_help(): 
     197    """ 
     198    Print usage string, the option description and the list of available models. 
     199    """ 
    131200    print_usage() 
    132201    print("""\ 
    … …  
    158227 
    159228def main(): 
    160     if len(sys.argv) not in (6,7): 
     229    """ 
     230    Main program. 
     231    """ 
     232    if len(sys.argv) not in (6, 7): 
    161233        print_help() 
    162234        sys.exit(1) 
    … …  
    182254 
    183255    data, index = make_data({'qmax':1.0, 'is2d':is2D, 'nq':Nq, 'res':0., 
    184                               'accuracy': 'Low', 'view':'log'}) 
     256                             'accuracy': 'Low', 'view':'log'}) 
    185257    model_list = [model] if model != "all" else MODELS 
    186258    for model in model_list: 

  • sasmodels/convert.py

    r29da213 rd15a908  
    4949    """ 
    5050    return dict((p, (v*1e6 if p.endswith('sld') else v)) 
    51                 for p,v in pars.items()) 
     51                for p, v in pars.items()) 
    5252 
    5353def convert_model(name, pars): 
    … …  
    5555    Convert model from old style parameter names to new style. 
    5656    """ 
    57     _,_ = name,pars # lint 
     57    _, _ = name, pars # lint 
    5858    raise NotImplementedError 
    5959    # need to load all new models in order to determine old=>new 
    … …  
    6767    """ 
    6868    return dict((p, (v*1e-6 if p.endswith('sld') else v)) 
    69                 for p,v in pars.items()) 
     69                for p, v in pars.items()) 
    7070 
    7171def _remove_pd(pars, key, name): 

  • sasmodels/core.py

    rcde11f0f rd15a908  
    22Core model handling routines. 
    33""" 
    4 __all__ = ["list_models", "load_model_definition",  "precompile_dll", 
    5            "load_model", "make_kernel", "call_kernel", "call_ER", "call_VR" ] 
     4__all__ = [ 
     5    "list_models", "load_model_definition", "precompile_dll", 
     6    "load_model", "make_kernel", "call_kernel", "call_ER", "call_VR", 
     7    ] 
    68 
    79from os.path import basename, dirname, join as joinpath 
    … …  
    6163 
    6264def isstr(s): 
     65    """ 
     66    Return True if *s* is a string-like object. 
     67    """ 
    6368    try: s + '' 
    6469    except: return False 
    … …  
    99104    # source = open(info['name']+'.cl','r').read() 
    100105 
    101     if (platform=="dll" 
     106    if (platform == "dll" 
    102107            or not HAVE_OPENCL 
    103108            or not kernelcl.environment().has_type(dtype)): 
    … …  
    128133    width = pars.get(name+'_pd', 0.0) 
    129134    nsigma = pars.get(name+'_pd_nsigma', 3.0) 
    130     value,weight = weights.get_weights( 
     135    value, weight = weights.get_weights( 
    131136        disperser, npts, width, nsigma, value, limits, relative) 
    132137    return value, weight / np.sum(weight) 
    … …  
    195200                    for name in info['partype']['volume']] 
    196201        value, weight = dispersion_mesh(vol_pars) 
    197         whole,part = VR(*value) 
     202        whole, part = VR(*value) 
    198203        return np.sum(weight*part)/np.sum(weight*whole) 
    199204 

  • sasmodels/data.py

    r013adb7 rd15a908  
    284284                mdata[mdata <= 0] = masked 
    285285            plt.errorbar(data.x/10, scale*mdata, yerr=data.dy, fmt='.') 
    286             all_positive = all_positive and (mdata>0).all() 
     286            all_positive = all_positive and (mdata > 0).all() 
    287287            some_present = some_present or (mdata.count() > 0) 
    288288 
    … …  
    292292            mtheory[~np.isfinite(mtheory)] = masked 
    293293            if view is 'log': 
    294                 mtheory[mtheory<=0] = masked 
     294                mtheory[mtheory <= 0] = masked 
    295295            plt.plot(data.x/10, scale*mtheory, '-', hold=True) 
    296             all_positive = all_positive and (mtheory>0).all() 
     296            all_positive = all_positive and (mtheory > 0).all() 
    297297            some_present = some_present or (mtheory.count() > 0) 
    298298 
    … …  
    396396        plt.title('theory') 
    397397        h = plt.colorbar() 
    398         h.set_label(r'$\log_{10}I(q)$' if view=='log' 
     398        h.set_label(r'$\log_{10}I(q)$' if view == 'log' 
    399399                    else r'$q^4 I(q)$' if view == 'q4' 
    400400                    else '$I(q)$') 
    … …  
    411411        plt.title('residuals') 
    412412        h = plt.colorbar() 
    413         h.set_label('$\Delta I(q)$') 
     413        h.set_label(r'$\Delta I(q)$') 
    414414 
    415415 
Note: See TracChangeset for help on using the changeset viewer.