Changeset 72c969b in sasview


Ignore:
Timestamp:
Sep 8, 2014 7:57:17 AM (10 years ago)
Author:
pkienzle
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
1792311
Parents:
a9807efa (diff), 5b1392f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

sync with trunk

Files:
3 added
26 edited
5 moved

Legend:

Unmodified
Added
Removed

  • src/sans/models/c_extension/c_models/capcyl.cpp

    r230f479 r5b1392f  
    178178  alpha = acos( cos_val ); 
    179179 
    180   // Call the IGOR library function to get the kernel 
    181   answer = capcyl2d_kernel(dp, q, alpha)/sin(alpha); 
     180  answer = capcyl2d_kernel(dp, q, alpha); 
    182181 
    183182 

  • src/sans/models/c_extension/c_models/triaxialellipsoid.cpp

    r230f479 r2b875e4c  
    342342              * weights_semi_axisA[i].value*weights_semi_axisB[j].value*weights_semi_axisC[k].value; 
    343343              if (weights_theta.size()>1) { 
    344                 _ptvalue *= fabs(cos(weights_theta[k].value*pi/180.0)); 
     344                _ptvalue *= fabs(cos(weights_theta[l].value*pi/180.0)); 
    345345              } 
    346346              sum += _ptvalue; 

  • park-1.2.1/park/expression.py

    r3570545 re3efa6b3  
    160160"""%("\n    ".join(exprs),"\n    ".join(code)) 
    161161 
    162     #print "Function:",function 
     162    #print "Function:",functiondef 
    163163    exec functiondef in globals,locals 
    164164    retfn = locals['eval_expressions'] 
    … …  
    185185    # Check symbol rename 
    186186    assert substitute(expr,{'a.b.x':'Q'}) == 'Q + sin(4*pi*a.c) + Q/a.b' 
     187    assert substitute(expr,{'a.b':'Q'}) == 'a.b.x + sin(4*pi*a.c) + a.b.x/Q' 
    187188 
    188189 
    … …  
    249250    for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',  
    250251                 'piddle', 
    251                  'import sys; print "p0wned"', 
     252                 '5; import sys; print "p0wned"', 
    252253                 '__import__("sys").argv']: 
    253254        try: 

  • park-1.2.1/park/fitresult.py

    r3570545 r95d58d3  
    6767        improvements. 
    6868        """ 
     69        #import traceback; traceback.print_stack() 
    6970        self.progress_time = time.time() 
    7071        self.progress_percent = 0 
    … …  
    228229 
    229230    def __str__(self): 
     231        #import traceback; traceback.print_stack() 
    230232        if self.parameters == None: return "No results" 
    231233        L = ["P%-3d %s"%(n+1,p.summarize()) for n,p in enumerate(self.parameters)] 

  • park-1.2.1/park/parameter.py

    r3570545 rfb7180c  
    1515__all__ = ['Parameter', 'ParameterSet'] 
    1616 
     17import math 
    1718import numpy 
    1819import expression         
    … …  
    162163        """ 
    163164        range = ['.']*10 
    164         lo,hi = p.range 
    165         portion = (p.value-lo)/(hi-lo) 
     165        lo,hi = self.range 
     166        portion = (self.value-lo)/(hi-lo) 
    166167        if portion < 0: portion = 0. 
    167168        elif portion >= 1: portion = 0.99999999 
    … …  
    169170        range[bar] = '|' 
    170171        range = "".join(range) 
    171         return "%25s %s %g in [%g,%g]"  % (p.name,range,p.value,lo,hi) 
     172        return "%25s %s %g in [%g,%g]"  % (self.name,range,self.value,lo,hi) 
    172173 
    173174    def isfitted(self): return self.status == 'fitted' 
    … …  
    273274        for p in self: 
    274275            if parts[1] == p.name: 
    275                 if len(pars) == 2: 
     276                if len(parts) == 2: 
    276277                    return p 
    277278                elif isinstance(p, ParameterSet): 
    278279                    return p._byname(parts[1:]) 
     280                else: 
     281                    raise 
    279282        return None 
    280283 
    … …  
    283286        parts = name.split('.') 
    284287        if parts[0] == self.name: 
    285             p =  _byname(self, name.split('.')) 
     288            p =  self._byname(name.split('.')) 
    286289            if p: return p 
    287290        raise KeyError("parameter %s not in parameter set"%name) 

  • run.py

    rbbd97e5 rf8940db  
    88Usage: 
    99 
    10 ./run.py [args] 
     10./run.py [(module|script) args...] 
     11 
     12Without arguments run.py runs sasview.  With arguments, run.py will run 
     13the given module or script. 
    1114""" 
    1215 
    … …  
    1417import sys 
    1518import imp 
    16 from glob import glob 
    1719from contextlib import contextmanager 
    1820from os.path import abspath, dirname, join as joinpath 
    … …  
    4951    return mod 
    5052 
    51 def import_dll(modname): 
     53def import_dll(modname, build_path): 
    5254    """Import a DLL from the build directory""" 
     55    import sysconfig 
     56    ext = sysconfig.get_config_var('SO') 
    5357    # build_path comes from context 
    54     path = glob(joinpath(build_path, *modname.split('.'))+'.*')[0] 
     58    path = joinpath(build_path, *modname.split('.'))+ext 
    5559    #print "importing", modname, "from", path 
    5660    return imp.load_dynamic(modname, path) 
    … …  
    7074 
    7175    # Make sure that we have a private version of mplconfig 
    72     mplconfig = joinpath(abspath(dirname(__file__)), '.mplconfig') 
    73     os.environ['MPLCONFIGDIR'] = mplconfig 
    74     if not os.path.exists(mplconfig): os.mkdir(mplconfig) 
     76    #mplconfig = joinpath(abspath(dirname(__file__)), '.mplconfig') 
     77    #os.environ['MPLCONFIGDIR'] = mplconfig 
     78    #if not os.path.exists(mplconfig): os.mkdir(mplconfig) 
    7579    #import matplotlib 
    7680    #matplotlib.use('Agg') 
    … …  
    8084    try: import periodictable 
    8185    except: addpath(joinpath(root, '..','periodictable')) 
     86 
     87    try: import bumps 
     88    except: addpath(joinpath(root, '..','bumps')) 
    8289 
    8390    # select wx version 
    … …  
    107114    sans.pr.core = import_package('sans.pr.core', 
    108115                                  joinpath(build_path, 'sans', 'pr', 'core')) 
    109     #import_dll('park._modeling') 
     116    #import_dll('park._modeling', build_path) 
    110117 
    111118    #park = import_package('park',os.path.join(build_path,'park')) 
    … …  
    122129 
    123130if __name__ == "__main__": 
    124     # start sasview 
    125     #import multiprocessing 
    126     #multiprocessing.freeze_support() 
    127131    prepare() 
    128     from sans.sansview.sansview import SasView 
    129     SasView() 
     132    from sans.sansview.sansview import run 
     133    run() 

  • sansview/sansview.py

    re2271c5 r1790664  
    3636PLUGIN_MODEL_DIR = 'plugin_models' 
    3737APP_NAME = 'SasView' 
    38 def run(): 
    39     sys.path.append(os.path.join("..","..","..")) 
    40     from multiprocessing import freeze_support 
    41     freeze_support() 
    42     sasview = SasView() 
    43          
     38 
    4439class SasViewApp(gui_manager.ViewApp): 
    4540    """ 
    … …  
    6358        # modules. We load the fitting module here 
    6459        # to ensure a complete Windows executable build. 
    65          
     60 
    6661        # Fitting perspective 
    6762        try: 
    … …  
    7267            logging.error("Fitting problems: " + str(inst)) 
    7368            logging.error("%s: could not find Fitting plug-in module"% APP_NAME)  
    74             logging.error(sys.exc_value)   
    75              
     69            logging.error(sys.exc_value) 
     70 
    7671        # P(r) perspective 
    7772        try: 
    … …  
    113108        self.gui.clean_plugin_models(PLUGIN_MODEL_DIR) 
    114109        # Start the main loop 
    115         self.gui.MainLoop()   
    116         
     110        self.gui.MainLoop() 
    117111 
    118112 
    119 if __name__ == "__main__":  
     113def run(): 
    120114    from multiprocessing import freeze_support 
    121115    freeze_support() 
    122     #Process(target=SasView).start() 
    123     sasview = SasView() 
     116    if len(sys.argv) > 1: 
     117        ## Run sasview as an interactive python interpreter 
     118        #if sys.argv[1] == "-i": 
     119        #    sys.argv = ["ipython", "--pylab"] 
     120        #    from IPython import start_ipython 
     121        #    sys.exit(start_ipython()) 
     122        thing_to_run = sys.argv[1] 
     123        sys.argv = sys.argv[1:] 
     124        import runpy 
     125        if os.path.exists(thing_to_run): 
     126            runpy.run_path(thing_to_run, run_name="__main__") 
     127        else: 
     128            runpy.run_module(thing_to_run, run_name="__main__") 
     129    else: 
     130        SasView() 
    124131 
    125     
     132if __name__ == "__main__": 
     133    run() 
     134 

  • sansview/setup_exe.py

    r27b7acc r6fe5100  
    319319'reportlab.platypus', 
    320320]) 
     321packages.append('IPython') 
    321322includes = ['site'] 
    322323 

  • setup.py

    r968aa6e r880f170  
    6969     
    7070     
    71 enable_openmp = True                     
     71enable_openmp = True 
    7272 
    7373if sys.platform =='darwin': 

  • src/sans/fit/AbstractFitEngine.py

    r6c00702 rbf5e985  
    33#import logging 
    44import sys 
     5import math 
    56import numpy 
    6 import math 
    7 import park 
     7 
    88from sans.dataloader.data_info import Data1D 
    99from sans.dataloader.data_info import Data2D 
    10 _SMALLVALUE = 1.0e-10     
    11      
    12 class SansParameter(park.Parameter): 
    13     """ 
    14     SANS model parameters for use in the PARK fitting service. 
    15     The parameter attribute value is redirected to the underlying 
    16     parameter value in the SANS model. 
    17     """ 
    18     def __init__(self, name, model, data): 
    19         """ 
    20             :param name: the name of the model parameter 
    21             :param model: the sans model to wrap as a park model 
    22         """ 
    23         park.Parameter.__init__(self, name) 
    24         self._model, self._name = model, name 
    25         self.data = data 
    26         self.model = model 
    27         #set the value for the parameter of the given name 
    28         self.set(model.getParam(name)) 
    29           
    30     def _getvalue(self): 
    31         """ 
    32         override the _getvalue of park parameter 
    33          
    34         :return value the parameter associates with self.name 
    35          
    36         """ 
    37         return self._model.getParam(self.name) 
    38      
    39     def _setvalue(self, value): 
    40         """ 
    41         override the _setvalue pf park parameter 
    42          
    43         :param value: the value to set on a given parameter 
    44          
    45         """ 
    46         self._model.setParam(self.name, value) 
    47          
    48     value = property(_getvalue, _setvalue) 
    49      
    50     def _getrange(self): 
    51         """ 
    52         Override _getrange of park parameter 
    53         return the range of parameter 
    54         """ 
    55         #if not  self.name in self._model.getDispParamList(): 
    56         lo, hi = self._model.details[self.name][1:3] 
    57         if lo is None: lo = -numpy.inf 
    58         if hi is None: hi = numpy.inf 
    59         if lo > hi: 
    60             raise ValueError, "wrong fit range for parameters" 
    61          
    62         return lo, hi 
    63      
    64     def get_name(self): 
    65         """ 
    66         """ 
    67         return self._getname() 
    68      
    69     def _setrange(self, r): 
    70         """ 
    71         override _setrange of park parameter 
    72          
    73         :param r: the value of the range to set 
    74          
    75         """ 
    76         self._model.details[self.name][1:3] = r 
    77     range = property(_getrange, _setrange) 
    78      
    79      
    80 class Model(park.Model): 
    81     """ 
    82     PARK wrapper for SANS models. 
     10_SMALLVALUE = 1.0e-10 
     11 
     12# Note: duplicated from park 
     13class FitHandler(object): 
     14    """ 
     15    Abstract interface for fit thread handler. 
     16 
     17    The methods in this class are called by the optimizer as the fit 
     18    progresses. 
     19 
     20    Note that it is up to the optimizer to call the fit handler correctly, 
     21    reporting all status changes and maintaining the 'done' flag. 
     22    """ 
     23    done = False 
     24    """True when the fit job is complete""" 
     25    result = None 
     26    """The current best result of the fit""" 
     27 
     28    def improvement(self): 
     29        """ 
     30        Called when a result is observed which is better than previous 
     31        results from the fit. 
     32 
     33        result is a FitResult object, with parameters, #calls and fitness. 
     34        """ 
     35    def error(self, msg): 
     36        """ 
     37        Model had an error; print traceback 
     38        """ 
     39    def progress(self, current, expected): 
     40        """ 
     41        Called each cycle of the fit, reporting the current and the 
     42        expected amount of work.   The meaning of these values is 
     43        optimizer dependent, but they can be converted into a percent 
     44        complete using (100*current)//expected. 
     45 
     46        Progress is updated each iteration of the fit, whatever that 
     47        means for the particular optimization algorithm.  It is called 
     48        after any calls to improvement for the iteration so that the 
     49        update handler can control I/O bandwidth by suppressing 
     50        intermediate improvements until the fit is complete. 
     51        """ 
     52    def finalize(self): 
     53        """ 
     54        Fit is complete; best results are reported 
     55        """ 
     56    def abort(self): 
     57        """ 
     58        Fit was aborted. 
     59        """ 
     60 
     61    # TODO: not sure how these are used, but they are needed for running the fit 
     62    def update_fit(self, last=False): pass 
     63    def set_result(self, result=None): self.result = result 
     64 
     65class Model: 
     66    """ 
     67    Fit wrapper for SANS models. 
    8368    """ 
    8469    def __init__(self, sans_model, sans_data=None, **kw): 
    8570        """ 
    8671        :param sans_model: the sans model to wrap using park interface 
    87          
    88         """ 
    89         park.Model.__init__(self, **kw) 
     72 
     73        """ 
    9074        self.model = sans_model 
    9175        self.name = sans_model.name 
    9276        self.data = sans_data 
    93         #list of parameters names 
    94         self.sansp = sans_model.getParamList() 
    95         #list of park parameter 
    96         self.parkp = [SansParameter(p, sans_model, sans_data) for p in self.sansp] 
    97         #list of parameter set 
    98         self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp) 
    99         self.pars = [] 
    100    
     77 
    10178    def get_params(self, fitparams): 
    10279        """ 
    10380        return a list of value of paramter to fit 
    104          
     81 
    10582        :param fitparams: list of paramaters name to fit 
    106          
    107         """ 
    108         list_params = [] 
    109         self.pars = [] 
    110         self.pars = fitparams 
    111         for item in fitparams: 
    112             for element in self.parkp: 
    113                 if element.name == str(item): 
    114                     list_params.append(element.value) 
    115         return list_params 
    116      
     83 
     84        """ 
     85        return [self.model.getParam(k) for k in fitparams] 
     86 
    11787    def set_params(self, paramlist, params): 
    11888        """ 
    11989        Set value for parameters to fit 
    120          
     90 
    12191        :param params: list of value for parameters to fit 
    122          
    123         """ 
    124         try: 
    125             for i in range(len(self.parkp)): 
    126                 for j in range(len(paramlist)): 
    127                     if self.parkp[i].name == paramlist[j]: 
    128                         self.parkp[i].value = params[j] 
    129                         self.model.setParam(self.parkp[i].name, params[j]) 
    130         except: 
    131             raise 
    132    
     92 
     93        """ 
     94        for k,v in zip(paramlist, params): 
     95            self.model.setParam(k,v) 
     96 
     97    def set(self, **kw): 
     98        self.set_params(*zip(*kw.items())) 
     99 
    133100    def eval(self, x): 
    134101        """ 
    135102            Override eval method of park model. 
    136          
     103 
    137104            :param x: the x value used to compute a function 
    138105        """ 
    … …  
    141108        except: 
    142109            raise 
    143          
     110 
    144111    def eval_derivs(self, x, pars=[]): 
    145112        """ 
    … …  
    154121        instead of calling eval. 
    155122        """ 
    156         return [] 
    157  
    158      
     123        raise NotImplementedError('no derivatives available') 
     124 
     125    def __call__(self, x): 
     126        return self.eval(x) 
     127 
    159128class FitData1D(Data1D): 
    160129    """ 
    … …  
    185154        """ 
    186155        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy) 
     156        self.num_points = len(x) 
    187157        self.sans_data = data 
    188158        self.smearer = smearer 
    … …  
    251221        """ 
    252222        return self.qmin, self.qmax 
    253          
     223 
     224    def size(self): 
     225        """ 
     226        Number of measurement points in data set after masking, etc. 
     227        """ 
     228        return len(self.x) 
     229 
    254230    def residuals(self, fn): 
    255231        """ 
    … …  
    293269    def __init__(self, sans_data2d, data=None, err_data=None): 
    294270        Data2D.__init__(self, data=data, err_data=err_data) 
    295         """ 
    296             Data can be initital with a data (sans plottable) 
    297             or with vectors. 
    298         """ 
     271        # Data can be initialized with a sans plottable or with vectors. 
    299272        self.res_err_image = [] 
     273        self.num_points = 0 # will be set by set_data 
    300274        self.idx = [] 
    301275        self.qmin = None 
    … …  
    339313        self.idx = (self.idx) & (self.mask) 
    340314        self.idx = (self.idx) & (numpy.isfinite(self.data)) 
     315        self.num_points = numpy.sum(self.idx) 
    341316 
    342317    def set_smearer(self, smearer): 
    … …  
    372347        """ 
    373348        return self.qmin, self.qmax 
    374       
     349 
     350    def size(self): 
     351        """ 
     352        Number of measurement points in data set after masking, etc. 
     353        """ 
     354        return numpy.sum(self.idx) 
     355 
    375356    def residuals(self, fn): 
    376357        """ 
    … …  
    409390 
    410391 
    411 class SansAssembly: 
    412     """ 
    413     Sans Assembly class a class wrapper to be call in optimizer.leastsq method 
    414     """ 
    415     def __init__(self, paramlist, model=None, data=None, fitresult=None, 
    416                  handler=None, curr_thread=None, msg_q=None): 
    417         """ 
    418         :param Model: the model wrapper fro sans -model 
    419         :param Data: the data wrapper for sans data 
    420          
    421         """ 
    422         self.model = model 
    423         self.data = data 
    424         self.paramlist = paramlist 
    425         self.msg_q = msg_q 
    426         self.curr_thread = curr_thread 
    427         self.handler = handler 
    428         self.fitresult = fitresult 
    429         self.res = [] 
    430         self.true_res = [] 
    431         self.func_name = "Functor" 
    432         self.theory = None 
    433          
    434     def chisq(self): 
    435         """ 
    436         Calculates chi^2 
    437          
    438         :param params: list of parameter values 
    439          
    440         :return: chi^2 
    441          
    442         """ 
    443         total = 0 
    444         for item in self.true_res: 
    445             total += item * item 
    446         if len(self.true_res) == 0: 
    447             return None 
    448         return total / len(self.true_res) 
    449      
    450     def __call__(self, params): 
    451         """ 
    452             Compute residuals 
    453             :param params: value of parameters to fit 
    454         """ 
    455         #import thread 
    456         self.model.set_params(self.paramlist, params) 
    457         #print "params", params 
    458         self.true_res, theory = self.data.residuals(self.model.eval) 
    459         self.theory = copy.deepcopy(theory) 
    460         # check parameters range 
    461         if self.check_param_range(): 
    462             # if the param value is outside of the bound 
    463             # just silent return res = inf 
    464             return self.res 
    465         self.res = self.true_res 
    466          
    467         if self.fitresult is not None: 
    468             self.fitresult.set_model(model=self.model) 
    469             self.fitresult.residuals = self.true_res 
    470             self.fitresult.iterations += 1 
    471             self.fitresult.theory = theory 
    472             
    473             #fitness = self.chisq(params=params) 
    474             fitness = self.chisq() 
    475             self.fitresult.pvec = params 
    476             self.fitresult.set_fitness(fitness=fitness) 
    477             if self.msg_q is not None: 
    478                 self.msg_q.put(self.fitresult) 
    479                  
    480             if self.handler is not None: 
    481                 self.handler.set_result(result=self.fitresult) 
    482                 self.handler.update_fit() 
    483  
    484             if self.curr_thread != None: 
    485                 try: 
    486                     self.curr_thread.isquit() 
    487                 except: 
    488                     #msg = "Fitting: Terminated...       Note: Forcing to stop " 
    489                     #msg += "fitting may cause a 'Functor error message' " 
    490                     #msg += "being recorded in the log file....." 
    491                     #self.handler.stop(msg) 
    492                     raise 
    493           
    494         return self.res 
    495      
    496     def check_param_range(self): 
    497         """ 
    498         Check the lower and upper bound of the parameter value 
    499         and set res to the inf if the value is outside of the 
    500         range 
    501         :limitation: the initial values must be within range. 
    502         """ 
    503  
    504         #time.sleep(0.01) 
    505         is_outofbound = False 
    506         # loop through the fit parameters 
    507         for p in self.model.parameterset: 
    508             param_name = p.get_name() 
    509             if param_name in self.paramlist: 
    510                  
    511                 # if the range was defined, check the range 
    512                 if numpy.isfinite(p.range[0]): 
    513                     if p.value == 0: 
    514                         # This value works on Scipy 
    515                         # Do not change numbers below 
    516                         value = _SMALLVALUE 
    517                     else: 
    518                         value = p.value 
    519                     # For leastsq, it needs a bit step back from the boundary 
    520                     val = p.range[0] - value * _SMALLVALUE 
    521                     if p.value < val: 
    522                         self.res *= 1e+6 
    523                          
    524                         is_outofbound = True 
    525                         break 
    526                 if numpy.isfinite(p.range[1]): 
    527                     # This value works on Scipy 
    528                     # Do not change numbers below 
    529                     if p.value == 0: 
    530                         value = _SMALLVALUE 
    531                     else: 
    532                         value = p.value 
    533                     # For leastsq, it needs a bit step back from the boundary 
    534                     val = p.range[1] + value * _SMALLVALUE 
    535                     if p.value > val: 
    536                         self.res *= 1e+6 
    537                         is_outofbound = True 
    538                         break 
    539  
    540         return is_outofbound 
    541      
    542      
     392 
    543393class FitEngine: 
    544394    def __init__(self): 
    … …  
    546396        Base class for scipy and park fit engine 
    547397        """ 
    548         #List of parameter names to fit 
    549         self.param_list = [] 
    550398        #Dictionnary of fitArrange element (fit problems) 
    551399        self.fit_arrange_dict = {} 
    … …  
    571419         
    572420        """ 
    573         if model == None: 
    574             raise ValueError, "AbstractFitEngine: Need to set model to fit" 
    575          
    576         new_model = model 
     421        if not pars: 
     422            raise ValueError("no fitting parameters") 
     423 
     424        if model is None: 
     425            raise ValueError("no model to fit") 
     426 
    577427        if not issubclass(model.__class__, Model): 
    578             new_model = Model(model, data) 
    579          
    580         if len(constraints) > 0: 
    581             for constraint in constraints: 
    582                 name, value = constraint 
    583                 try: 
    584                     new_model.parameterset[str(name)].set(str(value)) 
    585                 except: 
    586                     msg = "Fit Engine: Error occurs when setting the constraint" 
    587                     msg += " %s for parameter %s " % (value, name) 
    588                     raise ValueError, msg 
    589                  
    590         if len(pars) > 0: 
    591             temp = [] 
    592             for item in pars: 
    593                 if item in new_model.model.getParamList(): 
    594                     temp.append(item) 
    595                     self.param_list.append(item) 
    596                 else: 
    597                      
    598                     msg = "wrong parameter %s used " % str(item) 
    599                     msg += "to set model %s. Choose " % str(new_model.model.name) 
    600                     msg += "parameter name within %s" % \ 
    601                                 str(new_model.model.getParamList()) 
    602                     raise ValueError, msg 
    603                
    604             #A fitArrange is already created but contains data_list only at id 
    605             if self.fit_arrange_dict.has_key(id): 
    606                 self.fit_arrange_dict[id].set_model(new_model) 
    607                 self.fit_arrange_dict[id].pars = pars 
    608             else: 
    609             #no fitArrange object has been create with this id 
    610                 fitproblem = FitArrange() 
    611                 fitproblem.set_model(new_model) 
    612                 fitproblem.pars = pars 
    613                 self.fit_arrange_dict[id] = fitproblem 
    614                 vals = [] 
    615                 for name in pars: 
    616                     vals.append(new_model.model.getParam(name)) 
    617                 self.fit_arrange_dict[id].vals = vals 
    618         else: 
    619             raise ValueError, "park_integration:missing parameters" 
    620      
     428            model = Model(model, data) 
     429 
     430        sasmodel = model.model 
     431        available_parameters = sasmodel.getParamList() 
     432        for p in pars: 
     433            if p not in available_parameters: 
     434                raise ValueError("parameter %s not available in model %s; use one of [%s] instead" 
     435                                 %(p, sasmodel.name, ", ".join(available_parameters))) 
     436 
     437        if id not in self.fit_arrange_dict: 
     438            self.fit_arrange_dict[id] = FitArrange() 
     439 
     440        self.fit_arrange_dict[id].set_model(model) 
     441        self.fit_arrange_dict[id].pars = pars 
     442        self.fit_arrange_dict[id].vals = [sasmodel.getParam(name) for name in pars] 
     443        self.fit_arrange_dict[id].constraints = constraints 
     444 
    621445    def set_data(self, data, id, smearer=None, qmin=None, qmax=None): 
    622446        """ 
    … …  
    700524        self.vals = [] 
    701525        self.selected = 0 
    702          
     526 
    703527    def set_model(self, model): 
    704528        """ 
    … …  
    752576        """ 
    753577        return self.selected 
    754      
    755      
    756 IS_MAC = True 
    757 if sys.platform.count("win32") > 0: 
    758     IS_MAC = False 
    759  
    760578 
    761579class FResult(object): 
    … …  
    765583    def __init__(self, model=None, param_list=None, data=None): 
    766584        self.calls = None 
    767         self.pars = [] 
    768585        self.fitness = None 
    769586        self.chisqr = None 
    … …  
    776593        self.residuals = [] 
    777594        self.index = [] 
    778         self.parameters = None 
    779         self.is_mac = IS_MAC 
    780595        self.model = model 
    781596        self.data = data 
    … …  
    803618        if self.pvec == None and self.model is None and self.param_list is None: 
    804619            return "No results" 
    805         n = len(self.model.parameterset) 
    806          
    807         result_param = zip(xrange(n), self.model.parameterset) 
    808         msg1 = ["[Iteration #: %s ]" % self.iterations] 
    809         msg3 = ["=== goodness of fit: %s ===" % (str(self.fitness))] 
    810         if not self.is_mac: 
    811             msg2 = ["P%-3d  %s......|.....%s" % \ 
    812                 (p[0], p[1], p[1].value)\ 
    813                   for p in result_param if p[1].name in self.param_list] 
    814             msg = msg1 + msg3 + msg2 
    815         else: 
    816             msg = msg1 + msg3 
    817         msg = "\n".join(msg) 
    818         return msg 
     620 
     621        sasmodel = self.model.model 
     622        pars = enumerate(sasmodel.getParamList()) 
     623        msg1 = "[Iteration #: %s ]" % self.iterations 
     624        msg3 = "=== goodness of fit: %s ===" % (str(self.fitness)) 
     625        msg2 = ["P%-3d  %s......|.....%s" % (i, v, sasmodel.getParam(v)) 
     626                for i,v in pars if v in self.param_list] 
     627        msg = [msg1, msg3] + msg2 
     628        return "\n".join(msg) 
    819629     
    820630    def print_summary(self): 
    821631        """ 
    822632        """ 
    823         print self 
     633        print str(self) 

  • src/sans/fit/Fitting.py

    r5777106 re3efa6b3  
    88from sans.fit.ScipyFitting import ScipyFit 
    99from sans.fit.ParkFitting import ParkFit 
     10from sans.fit.BumpsFitting import BumpsFit 
    1011 
     12ENGINES={ 
     13    'scipy': ScipyFit, 
     14    'park': ParkFit, 
     15    'bumps': BumpsFit, 
     16} 
    1117 
    1218class Fit(object): 
    … …  
    2632         
    2733    """   
    28     def __init__(self, engine='scipy'): 
     34    def __init__(self, engine='scipy', *args, **kw): 
    2935        """ 
    3036        """ 
    … …  
    3238        self._engine = None 
    3339        self.fitter_id = None 
    34         self.set_engine(engine) 
     40        self.set_engine(engine, *args, **kw) 
    3541           
    3642    def __setattr__(self, name, value): 
    … …  
    4955            self.__dict__[name] = value 
    5056                 
    51     def set_engine(self, word): 
     57    def set_engine(self, word, *args, **kw): 
    5258        """ 
    5359        Select the type of Fit  
    … …  
    5965              
    6066        """ 
    61         if word == "scipy": 
    62             self._engine = ScipyFit() 
    63         elif word == "park": 
    64             self._engine = ParkFit() 
    65         else: 
    66             raise ValueError, "enter the keyword scipy or park" 
     67        try: 
     68            self._engine = ENGINES[word](*args, **kw) 
     69        except KeyError, exc: 
     70            raise KeyError("fit engine should be one of scipy, park or bumps") 
    6771 
    6872    def fit(self, msg_q=None, q=None, handler=None,  

  • src/sans/fit/Loader.py

    r5777106 r6fe5100  
    88    This class is loading values from given file or value giving by the user 
    99    """ 
    10      
    1110    def __init__(self, x=None, y=None, dx=None, dy=None): 
     11        raise NotImplementedError("a code search shows that this code is not active, and you are not seeing this message") 
    1212        # variable to store loaded values 
    1313        self.x = x 

  • src/sans/fit/ParkFitting.py

    r9d6d5ba r8d074d9  
    2424from sans.fit.AbstractFitEngine import FitEngine 
    2525from sans.fit.AbstractFitEngine import FResult 
    26    
     26 
     27class SansParameter(park.Parameter): 
     28    """ 
     29    SANS model parameters for use in the PARK fitting service. 
     30    The parameter attribute value is redirected to the underlying 
     31    parameter value in the SANS model. 
     32    """ 
     33    def __init__(self, name, model, data): 
     34        """ 
     35            :param name: the name of the model parameter 
     36            :param model: the sans model to wrap as a park model 
     37        """ 
     38        park.Parameter.__init__(self, name) 
     39        #self._model, self._name = model, name 
     40        self.data = data 
     41        self.model = model 
     42        #set the value for the parameter of the given name 
     43        self.set(model.getParam(name)) 
     44 
     45        # TODO: model is missing parameter ranges for dispersion parameters 
     46        if name not in model.details: 
     47            #print "setting details for",name 
     48            model.details[name] = ["", None, None] 
     49 
     50    def _getvalue(self): 
     51        """ 
     52        override the _getvalue of park parameter 
     53 
     54        :return value the parameter associates with self.name 
     55 
     56        """ 
     57        return self.model.getParam(self.name) 
     58 
     59    def _setvalue(self, value): 
     60        """ 
     61        override the _setvalue pf park parameter 
     62 
     63        :param value: the value to set on a given parameter 
     64 
     65        """ 
     66        self.model.setParam(self.name, value) 
     67 
     68    value = property(_getvalue, _setvalue) 
     69 
     70    def _getrange(self): 
     71        """ 
     72        Override _getrange of park parameter 
     73        return the range of parameter 
     74        """ 
     75        #if not  self.name in self._model.getDispParamList(): 
     76        lo, hi = self.model.details[self.name][1:3] 
     77        if lo is None: lo = -numpy.inf 
     78        if hi is None: hi = numpy.inf 
     79        if lo > hi: 
     80            raise ValueError, "wrong fit range for parameters" 
     81 
     82        return lo, hi 
     83 
     84    def get_name(self): 
     85        """ 
     86        """ 
     87        return self._getname() 
     88 
     89    def _setrange(self, r): 
     90        """ 
     91        override _setrange of park parameter 
     92 
     93        :param r: the value of the range to set 
     94 
     95        """ 
     96        self.model.details[self.name][1:3] = r 
     97    range = property(_getrange, _setrange) 
     98 
     99 
     100class ParkModel(park.Model): 
     101    """ 
     102    PARK wrapper for SANS models. 
     103    """ 
     104    def __init__(self, sans_model, sans_data=None, **kw): 
     105        """ 
     106        :param sans_model: the sans model to wrap using park interface 
     107 
     108        """ 
     109        park.Model.__init__(self, **kw) 
     110        self.model = sans_model 
     111        self.name = sans_model.name 
     112        self.data = sans_data 
     113        #list of parameters names 
     114        self.sansp = sans_model.getParamList() 
     115        #list of park parameter 
     116        self.parkp = [SansParameter(p, sans_model, sans_data) for p in self.sansp] 
     117        #list of parameter set 
     118        self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp) 
     119        self.pars = [] 
     120 
     121    def get_params(self, fitparams): 
     122        """ 
     123        return a list of value of paramter to fit 
     124 
     125        :param fitparams: list of paramaters name to fit 
     126 
     127        """ 
     128        list_params = [] 
     129        self.pars = fitparams 
     130        for item in fitparams: 
     131            for element in self.parkp: 
     132                if element.name == str(item): 
     133                    list_params.append(element.value) 
     134        return list_params 
     135 
     136    def set_params(self, paramlist, params): 
     137        """ 
     138        Set value for parameters to fit 
     139 
     140        :param params: list of value for parameters to fit 
     141 
     142        """ 
     143        try: 
     144            for i in range(len(self.parkp)): 
     145                for j in range(len(paramlist)): 
     146                    if self.parkp[i].name == paramlist[j]: 
     147                        self.parkp[i].value = params[j] 
     148                        self.model.setParam(self.parkp[i].name, params[j]) 
     149        except: 
     150            raise 
     151 
     152    def eval(self, x): 
     153        """ 
     154            Override eval method of park model. 
     155 
     156            :param x: the x value used to compute a function 
     157        """ 
     158        try: 
     159            return self.model.evalDistribution(x) 
     160        except: 
     161            raise 
     162 
     163    def eval_derivs(self, x, pars=[]): 
     164        """ 
     165        Evaluate the model and derivatives wrt pars at x. 
     166 
     167        pars is a list of the names of the parameters for which derivatives 
     168        are desired. 
     169 
     170        This method needs to be specialized in the model to evaluate the 
     171        model function.  Alternatively, the model can implement is own 
     172        version of residuals which calculates the residuals directly 
     173        instead of calling eval. 
     174        """ 
     175        return [] 
     176 
     177 
    27178class SansFitResult(fitresult.FitResult): 
    28179    def __init__(self, *args, **kwrds): 
    … …  
    244395        return fitpars 
    245396     
    246     def all_results(self, result): 
     397    def extend_results_with_calculated_parameters(self, result): 
    247398        """ 
    248399        Extend result from the fit with the calculated parameters. 
    … …  
    292443                # dividing residuals by N in order to be consistent with Scipy 
    293444                m.chisq = numpy.sum(m.residuals**2/N)  
    294                 resid.append(m.weight*m.residuals/math.sqrt(N)) 
     445                resid.append(m.weight*m.residuals) 
    295446        self.residuals = numpy.hstack(resid) 
    296447        N = len(self.residuals) 
    297448        self.degrees_of_freedom = N-k if N>k else 1 
    298449        self.chisq = numpy.sum(self.residuals**2) 
    299         return self.chisq 
     450        return self.chisq/self.degrees_of_freedom 
    300451     
    301452class ParkFit(FitEngine): 
    … …  
    354505            if fproblem.get_to_fit() == 1: 
    355506                fitproblems.append(fproblem) 
    356         if len(fitproblems) == 0:  
     507        if len(fitproblems) == 0: 
    357508            raise RuntimeError, "No Assembly scheduled for Park fitting." 
    358             return 
    359509        for item in fitproblems: 
    360             parkmodel = item.get_model() 
     510            model = item.get_model() 
     511            parkmodel = ParkModel(model.model, model.data) 
     512            parkmodel.pars = item.pars 
    361513            if reset_flag: 
    362514                # reset the initial value; useful for batch 
    … …  
    364516                    ind = item.pars.index(name) 
    365517                    parkmodel.model.setParam(name, item.vals[ind]) 
     518 
     519            # set the constraints into the model 
     520            for p,v in item.constraints: 
     521                parkmodel.parameterset[str(p)].set(str(v)) 
    366522             
    367523            for p in parkmodel.parameterset: 
    368524                ## does not allow status change for constraint parameters 
    369525                if p.status != 'computed': 
    370                     if p.get_name()in item.pars: 
     526                    if p.get_name() in item.pars: 
    371527                        ## make parameters selected for  
    372528                        #fit will be between boundaries 
    … …  
    383539    def fit(self, msg_q=None,  
    384540            q=None, handler=None, curr_thread=None,  
    385                                         ftol=1.49012e-8, reset_flag=False): 
     541            ftol=1.49012e-8, reset_flag=False): 
    386542        """ 
    387543        Performs fit with park.fit module.It can  perform fit with one model 
    … …  
    407563        localfit = SansFitSimplex() 
    408564        localfit.ftol = ftol 
    409          
     565        localfit.xtol = 1e-6 
     566 
    410567        # See `park.fitresult.FitHandler` for details. 
    411568        fitter = SansFitMC(localfit=localfit, start_points=1) 
    … …  
    416573        try: 
    417574            result = fit.fit(self.problem, fitter=fitter, handler=handler) 
    418             self.problem.all_results(result) 
     575            self.problem.extend_results_with_calculated_parameters(result) 
    419576             
    420577        except LinAlgError: 
    421578            raise ValueError, "SVD did not converge" 
     579 
     580        if result is None: 
     581            raise RuntimeError("park did not return a fit result") 
    422582     
    423583        for m in self.problem.parts: 
    … …  
    427587            small_result.theory = theory 
    428588            small_result.residuals = residuals 
    429             small_result.pvec = [] 
    430             small_result.cov = [] 
    431             small_result.stderr = [] 
    432             small_result.param_list = [] 
    433             small_result.residuals = m.residuals 
    434             if result is not None: 
    435                 for p in result.parameters: 
    436                     if p.data.name == small_result.data.name and \ 
    437                             p.model.name == small_result.model.name: 
    438                         small_result.index = m.data.idx 
    439                         small_result.fitness = result.fitness 
    440                         small_result.pvec.append(p.value) 
    441                         small_result.stderr.append(p.stderr) 
    442                         name_split = p.name.split('.') 
    443                         name = name_split[1].strip() 
    444                         if len(name_split) > 2: 
    445                             name += '.' + name_split[2].strip() 
    446                         small_result.param_list.append(name) 
     589            small_result.index = m.data.idx 
     590            small_result.fitness = result.fitness 
     591 
     592            # Extract the parameters that are part of this model; make sure 
     593            # they match the fitted parameters for this model, and place them 
     594            # in the same order as they occur in the model. 
     595            pars = {} 
     596            for p in result.parameters: 
     597                #if p.data.name == small_result.data.name and 
     598                if p.model.name == small_result.model.name: 
     599                    model_name, par_name = p.name.split('.', 1) 
     600                    pars[par_name] = (p.value, p.stderr) 
     601            #assert len(pars.keys()) == len(m.model.pars) 
     602            v,dv = zip(*[pars[p] for p in m.model.pars]) 
     603            small_result.pvec = v 
     604            small_result.stderr = dv 
     605            small_result.param_list = m.model.pars 
     606 
     607            # normalize chisq by degrees of freedom 
     608            dof = len(small_result.residuals)-len(small_result.pvec) 
     609            small_result.fitness = numpy.sum(residuals**2)/dof 
     610 
    447611            result_list.append(small_result)     
    448612        if q != None: 

  • src/sans/fit/ScipyFitting.py

    r5777106 r8d074d9  
    1  
    2  
    31""" 
    42ScipyFitting module contains FitArrange , ScipyFit, 
    … …  
    64simple fit with scipy optimizer. 
    75""" 
     6import sys 
     7import copy 
    88 
    99import numpy  
    10 import sys 
    11  
    1210 
    1311from sans.fit.AbstractFitEngine import FitEngine 
    14 from sans.fit.AbstractFitEngine import SansAssembly 
    15 from sans.fit.AbstractFitEngine import FitAbort 
    16 from sans.fit.AbstractFitEngine import Model 
    17 from sans.fit.AbstractFitEngine import FResult  
     12from sans.fit.AbstractFitEngine import FResult 
     13 
     14class SansAssembly: 
     15    """ 
     16    Sans Assembly class a class wrapper to be call in optimizer.leastsq method 
     17    """ 
     18    def __init__(self, paramlist, model=None, data=None, fitresult=None, 
     19                 handler=None, curr_thread=None, msg_q=None): 
     20        """ 
     21        :param Model: the model wrapper fro sans -model 
     22        :param Data: the data wrapper for sans data 
     23 
     24        """ 
     25        self.model = model 
     26        self.data = data 
     27        self.paramlist = paramlist 
     28        self.msg_q = msg_q 
     29        self.curr_thread = curr_thread 
     30        self.handler = handler 
     31        self.fitresult = fitresult 
     32        self.res = [] 
     33        self.true_res = [] 
     34        self.func_name = "Functor" 
     35        self.theory = None 
     36 
     37    def chisq(self): 
     38        """ 
     39        Calculates chi^2 
     40 
     41        :param params: list of parameter values 
     42 
     43        :return: chi^2 
     44 
     45        """ 
     46        total = 0 
     47        for item in self.true_res: 
     48            total += item * item 
     49        if len(self.true_res) == 0: 
     50            return None 
     51        return total / (len(self.true_res) - len(self.paramlist)) 
     52 
     53    def __call__(self, params): 
     54        """ 
     55            Compute residuals 
     56            :param params: value of parameters to fit 
     57        """ 
     58        #import thread 
     59        self.model.set_params(self.paramlist, params) 
     60        #print "params", params 
     61        self.true_res, theory = self.data.residuals(self.model.eval) 
     62        self.theory = copy.deepcopy(theory) 
     63        # check parameters range 
     64        if self.check_param_range(): 
     65            # if the param value is outside of the bound 
     66            # just silent return res = inf 
     67            return self.res 
     68        self.res = self.true_res 
     69 
     70        if self.fitresult is not None: 
     71            self.fitresult.set_model(model=self.model) 
     72            self.fitresult.residuals = self.true_res 
     73            self.fitresult.iterations += 1 
     74            self.fitresult.theory = theory 
     75 
     76            #fitness = self.chisq(params=params) 
     77            fitness = self.chisq() 
     78            self.fitresult.pvec = params 
     79            self.fitresult.set_fitness(fitness=fitness) 
     80            if self.msg_q is not None: 
     81                self.msg_q.put(self.fitresult) 
     82 
     83            if self.handler is not None: 
     84                self.handler.set_result(result=self.fitresult) 
     85                self.handler.update_fit() 
     86 
     87            if self.curr_thread != None: 
     88                try: 
     89                    self.curr_thread.isquit() 
     90                except: 
     91                    #msg = "Fitting: Terminated...       Note: Forcing to stop " 
     92                    #msg += "fitting may cause a 'Functor error message' " 
     93                    #msg += "being recorded in the log file....." 
     94                    #self.handler.stop(msg) 
     95                    raise 
     96 
     97        return self.res 
     98 
     99    def check_param_range(self): 
     100        """ 
     101        Check the lower and upper bound of the parameter value 
     102        and set res to the inf if the value is outside of the 
     103        range 
     104        :limitation: the initial values must be within range. 
     105        """ 
     106 
     107        #time.sleep(0.01) 
     108        is_outofbound = False 
     109        # loop through the fit parameters 
     110        model = self.model.model 
     111        for p in self.paramlist: 
     112            value = model.getParam(p) 
     113            low,high = model.details[p][1:3] 
     114            if low is not None and numpy.isfinite(low): 
     115                if p.value == 0: 
     116                    # This value works on Scipy 
     117                    # Do not change numbers below 
     118                    value = _SMALLVALUE 
     119                # For leastsq, it needs a bit step back from the boundary 
     120                val = low - value * _SMALLVALUE 
     121                if value < val: 
     122                    self.res *= 1e+6 
     123                    is_outofbound = True 
     124                    break 
     125            if high is not None and numpy.isfinite(high): 
     126                # This value works on Scipy 
     127                # Do not change numbers below 
     128                if value == 0: 
     129                    value = _SMALLVALUE 
     130                # For leastsq, it needs a bit step back from the boundary 
     131                val = high + value * _SMALLVALUE 
     132                if value > val: 
     133                    self.res *= 1e+6 
     134                    is_outofbound = True 
     135                    break 
     136 
     137        return is_outofbound 
    18138 
    19139class ScipyFit(FitEngine): 
    … …  
    50170        """ 
    51171        FitEngine.__init__(self) 
    52         self.fit_arrange_dict = {} 
    53         self.param_list = [] 
    54172        self.curr_thread = None 
    55173    #def fit(self, *args, **kw): 
    … …  
    68186            msg = "Scipy can't fit more than a single fit problem at a time." 
    69187            raise RuntimeError, msg 
    70             return 
    71         elif len(fitproblem) == 0 :  
     188        elif len(fitproblem) == 0 : 
    72189            raise RuntimeError, "No Assembly scheduled for Scipy fitting." 
    73             return 
    74190        model = fitproblem[0].get_model() 
    75191        if reset_flag: 
    … …  
    87203         
    88204        # Check the initial value if it is within range 
    89         self._check_param_range(model) 
     205        _check_param_range(model.model, self.param_list) 
    90206         
    91         result = FResult(model=model, data=data, param_list=self.param_list) 
    92         result.pars = fitproblem[0].pars 
     207        result = FResult(model=model.model, data=data, param_list=self.param_list) 
    93208        result.fitter_id = self.fitter_id 
    94209        if handler is not None: 
    95210            handler.set_result(result=result) 
     211        functor = SansAssembly(paramlist=self.param_list, 
     212                               model=model, 
     213                               data=data, 
     214                               handler=handler, 
     215                               fitresult=result, 
     216                               curr_thread=curr_thread, 
     217                               msg_q=msg_q) 
    96218        try: 
    97219            # This import must be here; otherwise it will be confused when more 
    … …  
    99221            from scipy import optimize 
    100222             
    101             functor = SansAssembly(paramlist=self.param_list,  
    102                                    model=model,  
    103                                    data=data, 
    104                                     handler=handler, 
    105                                     fitresult=result, 
    106                                      curr_thread=curr_thread, 
    107                                      msg_q=msg_q) 
    108223            out, cov_x, _, mesg, success = optimize.leastsq(functor, 
    109224                                            model.get_params(self.param_list), 
    110                                                     ftol=ftol, 
    111                                                     full_output=1) 
     225                                            ftol=ftol, 
     226                                            full_output=1) 
    112227        except: 
    113228            if hasattr(sys, 'last_type') and sys.last_type == KeyboardInterrupt: 
    … …  
    142257 
    143258         
    144     def _check_param_range(self, model): 
    145         """ 
    146         Check parameter range and set the initial value inside  
    147         if it is out of range. 
    148          
    149         : model: park model object 
    150         """ 
    151         is_outofbound = False 
    152         # loop through parameterset 
    153         for p in model.parameterset:         
    154             param_name = p.get_name() 
    155             # proceed only if the parameter name is in the list of fitting 
    156             if param_name in self.param_list: 
    157                 # if the range was defined, check the range 
    158                 if numpy.isfinite(p.range[0]): 
    159                     if p.value <= p.range[0]:  
    160                         # 10 % backing up from the border if not zero 
    161                         # for Scipy engine to work properly. 
    162                         shift = self._get_zero_shift(p.range[0]) 
    163                         new_value = p.range[0] + shift 
    164                         p.value =  new_value 
    165                         is_outofbound = True 
    166                 if numpy.isfinite(p.range[1]): 
    167                     if p.value >= p.range[1]: 
    168                         shift = self._get_zero_shift(p.range[1]) 
    169                         # 10 % backing up from the border if not zero 
    170                         # for Scipy engine to work properly. 
    171                         new_value = p.range[1] - shift 
    172                         # Check one more time if the new value goes below 
    173                         # the low bound, If so, re-evaluate the value  
    174                         # with the mean of the range. 
    175                         if numpy.isfinite(p.range[0]): 
    176                             if new_value < p.range[0]: 
    177                                 new_value = (p.range[0] + p.range[1]) / 2.0 
    178                         # Todo:  
    179                         # Need to think about when both min and max are same. 
    180                         p.value =  new_value 
    181                         is_outofbound = True 
    182                          
    183         return is_outofbound 
    184      
    185     def _get_zero_shift(self, range): 
    186         """ 
    187         Get 10% shift of the param value = 0 based on the range value 
    188          
    189         : param range: min or max value of the bounds 
    190         """ 
    191         if range == 0: 
    192             shift = 0.1 
    193         else: 
    194             shift = 0.1 * range 
    195              
    196         return shift 
    197      
     259def _check_param_range(model, param_list): 
     260    """ 
     261    Check parameter range and set the initial value inside 
     262    if it is out of range. 
     263 
     264    : model: park model object 
     265    """ 
     266    # loop through parameterset 
     267    for p in param_list: 
     268        value = model.getParam(p) 
     269        low,high = model.details.setdefault(p,["",None,None])[1:3] 
     270        # if the range was defined, check the range 
     271        if low is not None and value <= low: 
     272            value = low + _get_zero_shift(low) 
     273        if high is not None and value > high: 
     274            value = high - _get_zero_shift(high) 
     275            # Check one more time if the new value goes below 
     276            # the low bound, If so, re-evaluate the value 
     277            # with the mean of the range. 
     278            if low is not None and value < low: 
     279                value = 0.5 * (low+high) 
     280        model.setParam(p, value) 
     281 
     282def _get_zero_shift(limit): 
     283    """ 
     284    Get 10% shift of the param value = 0 based on the range value 
     285 
     286    : param range: min or max value of the bounds 
     287    """ 
     288    return 0.1 * (limit if limit != 0.0 else 1.0) 
     289 
    198290     
    199291#def profile(fn, *args, **kw): 

  • src/sans/fit/__init__.py

    r5777106 r6fe5100  
     1from .AbstractFitEngine import FitHandler 

  • src/sans/guiframe/gui_statusbar.py

    r8001331 r0e29289  
    211211        """ 
    212212        """ 
    213         wxStatusB.SetStatusText(self, text, number) 
     213        wxStatusB.SetStatusText(self, text.split('\n',1)[0], number) 
    214214        self.list_msg.append(text) 
    215215        self.status_color.SetBackgroundColour(GREEN) 

  • src/sans/perspectives/fitting/basepage.py

    r116e1a7 rbf5e985  
    9696        self.num_points = None 
    9797        ## default fitengine type 
    98         self.engine_type = 'scipy' 
     98        self.engine_type = 'bumps' 
    9999        ## smear default 
    100100        self.current_smearer = None 
    … …  
    835835            infor = "warning" 
    836836        else: 
    837             msg = "Error was occured " 
    838             msg += ": No valid parameter values to paste from the clipboard..." 
     837            msg = "Error occured: " 
     838            msg += "No valid parameter values to paste from the clipboard..." 
    839839            infor = "error" 
    840840            wx.PostEvent(self._manager.parent, 
    … …  
    21832183                else: 
    21842184                    tcrtl.SetBackgroundColour("pink") 
    2185                     msg = "Model Error:wrong value entered: %s" % sys.exc_value 
     2185                    msg = "Model Error: wrong value entered: %s" % sys.exc_value 
    21862186                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    21872187                    return 
    21882188            except: 
    21892189                tcrtl.SetBackgroundColour("pink") 
    2190                 msg = "Model Error:wrong value entered: %s" % sys.exc_value 
     2190                msg = "Model Error: wrong value entered: %s" % sys.exc_value 
    21912191                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    21922192                return 
    … …  
    21992199                        #is_modified = True 
    22002200                else: 
    2201                     msg = "Cannot Plot :No npts in that Qrange!!!  " 
     2201                    msg = "Cannot plot: No points in Q range!!!  " 
    22022202                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    22032203        else: 
    22042204            tcrtl.SetBackgroundColour("pink") 
    2205             msg = "Model Error:wrong value entered!!!" 
     2205            msg = "Model Error: wrong value entered!!!" 
    22062206            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    22072207        self.save_current_state() 
    … …  
    22402240                else: 
    22412241                    tcrtl.SetBackgroundColour("pink") 
    2242                     msg = "Model Error:wrong value entered: %s" % sys.exc_value 
     2242                    msg = "Model Error: wrong value entered: %s" % sys.exc_value 
    22432243                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    22442244                    return 
    22452245            except: 
    22462246                tcrtl.SetBackgroundColour("pink") 
    2247                 msg = "Model Error:wrong value entered: %s" % sys.exc_value 
     2247                msg = "Model Error: wrong value entered: %s" % sys.exc_value 
    22482248                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    22492249                return 
    … …  
    22562256                        is_modified = True 
    22572257                else: 
    2258                     msg = "Cannot Plot :No npts in that Qrange!!!  " 
     2258                    msg = "Cannot Plot: No points in Q range!!!  " 
    22592259                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    22602260        else: 
    22612261            tcrtl.SetBackgroundColour("pink") 
    2262             msg = "Model Error:wrong value entered!!!" 
     2262            msg = "Model Error: wrong value entered!!!" 
    22632263            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    22642264        self.save_current_state() 
    … …  
    24312431                self.qmax.SetBackgroundColour("pink") 
    24322432                self.qmax.Refresh() 
    2433                 msg = "Npts of Data Error :" 
    2434                 msg += "No or too little npts of %s." % data.name 
     2433                msg = "Data Error: " 
     2434                msg += "Too few points in %s." % data.name 
    24352435                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    24362436                self.fitrange = False 
    … …  
    24662466                self.qmax.SetBackgroundColour("pink") 
    24672467                self.qmax.Refresh() 
    2468                 msg = "Npts of Data Error :" 
    2469                 msg += "No or too little npts of %s." % data.name 
     2468                msg = "Data Error: " 
     2469                msg += "Too few points in %s." % data.name 
    24702470                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    24712471                self.fitrange = False 
    … …  
    25182518                                            
    25192519                        except: 
    2520                             msg = "Wrong Fit parameter range entered " 
     2520                            msg = "Wrong fit parameter range entered" 
    25212521                            wx.PostEvent(self._manager.parent, 
    25222522                                         StatusEvent(status=msg)) 
    … …  
    29862986            self.qmin.SetValue(str(self.qmin_x)) 
    29872987            self.qmax.SetValue(str(self.qmax_x)) 
    2988             self.set_npts2fit() 
     2988            self.show_npts2fit() 
    29892989            # At this point, some button and variables satatus (disabled?) 
    29902990            # should be checked such as color that should be reset to 
    … …  
    38743874        to fit if implemented 
    38753875        """ 
    3876     def set_npts2fit(self): 
     3876    def show_npts2fit(self): 
    38773877        """ 
    38783878        setValue Npts for fitting if implemented 

  • src/sans/perspectives/fitting/console.py

    r5777106 r35086c3  
    55import time 
    66import wx 
    7 import park 
    8 from park.fitresult import FitHandler 
     7from sans.fit import FitHandler 
    98 
    109class ConsoleUpdate(FitHandler): 
    … …  
    8887        Print result object 
    8988        """ 
    90         msg = " \n %s \n" % self.result.__str__() 
     89        msg = " \n %s \n" % str(self.result) 
    9190        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    9291                      
    … …  
    129128             
    130129         
    131     def update_fit(self, msg="", last=False): 
     130    def update_fit(self, last=False): 
    132131        """ 
    133132        """ 
    … …  
    136135        self.update_duration = t1 
    137136        self.fit_duration += self.elapsed_time 
    138         str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1)) 
    139         UPDATE_INTERVAL = 0.5 
     137        str_time = time.strftime("%Y-%m-%d %H:%M:%S ", time.localtime(t1)) 
     138        UPDATE_INTERVAL = 5.0 
    140139        u_flag = False 
    141140        if self.fit_duration >= UPDATE_INTERVAL: 
    142141            self.fit_duration = 0 
    143142            u_flag = True 
    144         if not last: 
    145             msg += "Fit Updates ... %s \n" % str_time     
    146         else: 
    147             msg += "Final updates ........." 
     143        msg = str_time 
    148144        if u_flag or last: 
    149145            if self.result is not None: 
    … …  
    164160                msg +=  str(self.result) 
    165161                msg += "\n" 
    166                 if not last: 
    167                     msg += "About %s s elapsed......... \n" % \ 
    168                                             str (UPDATE_INTERVAL) 
    169162            else: 
    170163                msg += "No result available\n" 

  • src/sans/perspectives/fitting/fit_thread.py

    ra855fec re3efa6b3  
    1818     
    1919    def __init__(self,  
    20                   fn, 
    21                   page_id, 
    22                    handler, 
    23                     batch_outputs, 
    24                     batch_inputs=None,              
    25                   pars=None, 
     20                 fn, 
     21                 page_id, 
     22                 handler, 
     23                 batch_outputs, 
     24                 batch_inputs=None, 
     25                 pars=None, 
    2626                 completefn = None, 
    2727                 updatefn   = None, 
    … …  
    3030                 ftol       = None, 
    3131                 reset_flag = False): 
    32         CalcThread.__init__(self,completefn, 
     32        CalcThread.__init__(self, 
     33                 completefn, 
    3334                 updatefn, 
    3435                 yieldtime, 
    … …  
    8081                list_map_get_attr.append(map_getattr) 
    8182            #from multiprocessing import Pool 
    82             inputs = zip(list_map_get_attr,self.fitter, list_fit_function, 
    83                           list_q, list_q, list_handler,list_curr_thread,list_ftol, 
     83            inputs = zip(list_map_get_attr, self.fitter, list_fit_function, 
     84                         list_q, list_q, list_handler,list_curr_thread,list_ftol, 
    8485                         list_reset_flag) 
    8586            result =  map(map_apply, inputs) 
    … …  
    8788            self.complete(result=result, 
    8889                          batch_inputs=self.batch_inputs, 
    89                            batch_outputs=self.batch_outputs, 
     90                          batch_outputs=self.batch_outputs, 
    9091                          page_id=self.page_id, 
    9192                          pars = self.pars, 

  • src/sans/perspectives/fitting/fitpage.py

    rd44648e rbf5e985  
    661661                          wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    662662         
    663         if self.engine_type == "park": 
    664             self.text_disp_max.Show(True) 
    665             self.text_disp_min.Show(True) 
     663        self.text_disp_max.Show(True) 
     664        self.text_disp_min.Show(True) 
    666665 
    667666        for item in self.model.dispersion.keys(): 
    … …  
    738737                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    739738 
    740                         if self.engine_type == "park": 
    741                             ctl3.Show(True) 
    742                             ctl4.Show(True) 
     739                        ctl3.Show(True) 
     740                        ctl4.Show(True) 
    743741                                                               
    744742                    elif p == "npts": 
    … …  
    10051003            return 
    10061004 
    1007         if len(self._manager.fit_thread_list) > 0 and\ 
    1008                     self._manager._fit_engine != "park" and\ 
    1009                     self._manager.sim_page != None and \ 
    1010                     self._manager.sim_page.uid == self.uid: 
     1005        if (len(self._manager.fit_thread_list) > 0 
     1006                and self._manager._fit_engine not in ("park","bumps") 
     1007                and self._manager.sim_page != None 
     1008                and self._manager.sim_page.uid == self.uid): 
    10111009            msg = "The FitEnging will be set to 'ParkMC'\n" 
    10121010            msg += " to fit with more than one data set..." 
    … …  
    12681266        if check_float(tcrtl): 
    12691267            flag = self._onparamEnter_helper() 
    1270             self.set_npts2fit() 
     1268            self.show_npts2fit() 
    12711269            if self.fitrange: 
    12721270                temp_smearer = None 
    … …  
    14681466                    #self.data.mask = index_data 
    14691467                    #self.Npts_fit.SetValue(str(len(self.data.mask))) 
    1470                     self.set_npts2fit() 
     1468                    self.show_npts2fit() 
    14711469            else: 
    14721470                index_data = ((self.qmin_x <= self.data.x) & \ 
    … …  
    17661764            # try re draw the model plot if it exists 
    17671765            self._draw_model() 
    1768             self.set_npts2fit() 
     1766            self.show_npts2fit() 
    17691767        elif self.model == None: 
    17701768            self.panel.MakeModal(False) 
    17711769            event.Skip() 
    1772             self.set_npts2fit() 
     1770            self.show_npts2fit() 
    17731771            msg = "No model is found on updating MASK in the model plot... " 
    17741772            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    … …  
    20562054        return npts2fit 
    20572055 
    2058     def set_npts2fit(self): 
     2056    def show_npts2fit(self): 
    20592057        """ 
    20602058        setValue Npts for fitting 
    … …  
    20682066        return self.tcChi.GetValue() 
    20692067         
    2070     def get_param_list(self): 
    2071         """ 
    2072         :return self.param_toFit: list containing  references to TextCtrl 
    2073             checked.Theses TextCtrl will allow reference to parameters to fit. 
    2074          
    2075         :raise: if return an empty list of parameter fit will nnote work 
    2076             properly so raise ValueError,"missing parameter to fit" 
    2077         """ 
    2078         if self.param_toFit != []: 
    2079             return self.param_toFit 
    2080         else: 
    2081             msg = "missing parameters to fit" 
    2082             wx.MessageBox(msg, 'warning') 
    2083             return False 
    2084        
    20852068    def onsetValues(self, chisqr, p_name, out, cov): 
    20862069        """ 
    … …  
    21082091        if chisqr != None and numpy.isfinite(chisqr): 
    21092092            #format chi2 
    2110             if self.engine_type == "park": 
    2111                 npt_fit = float(self.get_npts2fit()) 
    21122093            chi2 = format_number(chisqr, True) 
    21132094            self.tcChi.SetValue(chi2) 

  • src/sans/perspectives/fitting/fitpanel.py

    rb6a181b reff93b8  
    6464        self.sim_page = None 
    6565        self.batch_page = None 
    66         self.fit_engine_type = "scipy" 
     66        self.fit_engine_type = "bumps" 
    6767        ## get the state of a page 
    6868        self.Bind(basepage.EVT_PAGE_INFO, self._onGetstate) 

  • src/sans/perspectives/fitting/fitproblem.py

    r5777106 r5bf0331  
    454454        return self.itervalues() 
    455455     
    456     def  set_result(self, result, fid): 
     456    def set_result(self, result, fid): 
    457457        """ 
    458458        """ 

  • src/sans/perspectives/fitting/fitting.py

    r9afebe1 ra9807efa  
    3636from .fitproblem import FitProblemDictionary 
    3737from .fitpanel import FitPanel 
     38from .resultpanel import ResultPanel, PlotResultEvent 
     39 
    3840from .fit_thread import FitThread 
    3941from .pagestate import Reader 
    … …  
    4244from sans.perspectives.calculator.model_editor import EditorWindow 
    4345from sans.guiframe.gui_manager import MDIFrame 
     46 
     47# TODO: remove globals from interface to bumps options! 
     48# Default bumps to use the levenberg-marquardt optimizer 
     49import bumps.fitters 
     50bumps.fitters.FIT_DEFAULT = 'lm' 
    4451 
    4552MAX_NBR_DATA = 4 
    … …  
    7885        # Start with a good default 
    7986        self.elapsed = 0.022 
    80         # the type of optimizer selected, park or scipy 
    81         self.fitter = None 
    8287        self.fit_panel = None 
    83         #let fit ready 
    84         self.fitproblem_count = None 
    8588        #Flag to let the plug-in know that it is running stand alone 
    8689        self.standalone = True 
    … …  
    8891        self.closed_page_dict = {} 
    8992        ## Fit engine 
    90         self._fit_engine = 'scipy' 
     93        self._fit_engine = 'bumps' 
    9194        self._gui_engine = None 
    9295        ## Relative error desired in the sum of squares (float); scipy only 
    … …  
    111114        self.scipy_id = wx.NewId() 
    112115        self.park_id = wx.NewId() 
     116        self.bumps_id = wx.NewId() 
    113117        self.menu1 = None 
    114118        self.new_model_frame = None 
    … …  
    198202        wx.EVT_MENU(owner, self.park_id, self._onset_engine_park) 
    199203         
    200         self.menu1.FindItemById(self.scipy_id).Check(True) 
    201         self.menu1.FindItemById(self.park_id).Check(False) 
     204        bumps_help = "Bumps: fitting and uncertainty analysis. More in Help window...." 
     205        self.menu1.AppendCheckItem(self.bumps_id, "Bumps fit", 
     206                                   bumps_help) 
     207        wx.EVT_MENU(owner, self.bumps_id, self._onset_engine_bumps) 
     208         
     209        self.menu1.FindItemById(self.scipy_id).Check(self._fit_engine=="scipy") 
     210        self.menu1.FindItemById(self.park_id).Check(self._fit_engine=="park") 
     211        self.menu1.FindItemById(self.bumps_id).Check(self._fit_engine=="bumps") 
    202212        self.menu1.AppendSeparator() 
    203213        self.id_tol = wx.NewId() 
    … …  
    207217                                   ftol_help) 
    208218        wx.EVT_MENU(owner, self.id_tol, self.show_ftol_dialog) 
     219 
     220        self.id_bumps_options = wx.NewId() 
     221        bopts_help = "Bumps fitting options" 
     222        self.menu1.Append(self.id_bumps_options, 'Bumps &Options', bopts_help) 
     223        wx.EVT_MENU(owner, self.id_bumps_options, self.on_bumps_options) 
     224        self.bumps_options_menu = self.menu1.FindItemById(self.id_bumps_options) 
     225        self.bumps_options_menu.Enable(True) 
     226 
     227        self.id_result_panel = wx.NewId() 
     228        self.menu1.Append(self.id_result_panel, "Fit Results", "Show fit results panel") 
     229        wx.EVT_MENU(owner, self.id_result_panel, lambda ev: self.result_frame.Show()) 
    209230        self.menu1.AppendSeparator() 
    210231         
    … …  
    511532        self.perspective = [] 
    512533        self.perspective.append(self.fit_panel.window_name) 
     534 
     535        self.result_frame = MDIFrame(self.parent, None, ResultPanel.window_caption, (220, 200)) 
     536        self.result_panel = ResultPanel(parent=self.result_frame, manager=self) 
     537        self.perspective.append(self.result_panel.window_name) 
    513538        
    514539        #index number to create random model name 
    … …  
    525550        #Send the fitting panel to guiframe 
    526551        self.mypanels.append(self.fit_panel) 
     552        self.mypanels.append(self.result_panel) 
    527553        return self.mypanels 
    528554     
    … …  
    818844                         StatusEvent(status=msg, info='warning')) 
    819845        dialog.Destroy() 
     846 
     847    def on_bumps_options(self, event=None): 
     848        from bumps.gui.fit_dialog import OpenFitOptions 
     849        OpenFitOptions() 
    820850 
    821851    def stop_fit(self, uid): 
    … …  
    951981        :param uid: id related to the panel currently calling this fit function. 
    952982        """ 
    953         flag = True 
    954         ##  count the number of fitproblem schedule to fit 
    955         fitproblem_count = 0 
    956         for value in self.page_finder.values(): 
    957             if value.get_scheduled() == 1: 
    958                 fitproblem_count += 1 
    959         self._gui_engine = self._return_engine_type() 
    960         self.fitproblem_count = fitproblem_count 
    961         if self._fit_engine == "park": 
    962             engineType = "Simultaneous Fit" 
     983        if uid is None: raise RuntimeError("no page to fit") # Should never happen 
     984 
     985        # Remember the user selected fit engine before the fit.  Simultaneous 
     986        # fitting may change the selected engine, so it needs to be restored 
     987        # when the fit is complete. 
     988        self._gui_engine = self._fit_engine 
     989 
     990        sim_page_uid = getattr(self.sim_page, 'uid', None) 
     991        batch_page_uid = getattr(self.batch_page, 'uid', None) 
     992 
     993        if uid == sim_page_uid: 
     994            fit_type = 'simultaneous' 
     995        elif uid == batch_page_uid: 
     996            fit_type = 'combined_batch' 
    963997        else: 
    964             engineType = "Single Fit" 
     998            fit_type = 'single' 
     999 
     1000        # if constrained fit, don't use scipy leastsq directly 
     1001        if fit_type == 'simultaneous': 
     1002            if self._fit_engine not in ("park","bumps"): 
     1003                self._on_change_engine(engine='bumps') 
     1004 
     1005 
    9651006        fitter_list = [] 
    9661007        sim_fitter = None 
    967         is_single_fit = True 
    968         batch_on = False 
    969         if self.sim_page is not None and self.sim_page.uid == uid: 
     1008        if fit_type == 'simultaneous': 
    9701009            #simulatanous fit only one engine need to be created 
    971             ## if simultaneous fit change automatically the engine to park 
    972             self._on_change_engine(engine='park') 
    9731010            sim_fitter = Fit(self._fit_engine) 
    9741011            sim_fitter.fitter_id = self.sim_page.uid 
    9751012            fitter_list.append(sim_fitter) 
    976             is_single_fit = False 
    977             batch_on = self.sim_page.batch_on 
    978              
    979         self.fitproblem_count = fitproblem_count 
    980         if self._fit_engine == "park": 
    981             engineType = "Simultaneous Fit" 
    982         else: 
    983             engineType = "Single Fit" 
    984          
     1013 
    9851014        self.current_pg = None 
    9861015        list_page_id = [] 
    9871016        fit_id = 0 
    988         batch_inputs = {} 
    989         batch_outputs = {} 
    990         for page_id, value in self.page_finder.iteritems(): 
     1017        for page_id, page_info in self.page_finder.iteritems(): 
    9911018            # For simulfit (uid give with None), do for-loop 
    9921019            # if uid is specified (singlefit), do it only on the page. 
    993             if engineType == "Single Fit": 
    994                 #combine more than 1 batch page on single mode 
    995                 if self.batch_page is None or self.batch_page.uid != uid: 
    996                     if page_id != uid: 
    997                         continue 
     1020            if page_id in (sim_page_uid, batch_page_uid): continue 
     1021            if fit_type == "single" and page_id != uid: continue 
     1022 
    9981023            try: 
    999                 if value.get_scheduled() == 1: 
    1000                     value.nbr_residuals_computed = 0 
    1001                     #Get list of parameters name to fit 
    1002                     pars = [] 
    1003                     templist = [] 
     1024                if page_info.get_scheduled() == 1: 
     1025                    page_info.nbr_residuals_computed = 0 
    10041026                    page = self.fit_panel.get_page_by_id(page_id) 
    10051027                    self.set_fit_weight(uid=page.uid, 
    10061028                                     flag=page.get_weight_flag(), 
    10071029                                     is2d=page._is_2D()) 
    1008                     templist = page.get_param_list() 
    1009                     flag = page._update_paramv_on_fit() 
    1010                     if not flag: 
     1030                    if not page.param_toFit: 
     1031                        msg = "No fitting parameters for %s"%page.window_caption 
     1032                        wx.PostEvent(page.parent.parent, 
     1033                                     StatusEvent(status=msg, info="error", 
     1034                                                 type="stop")) 
     1035                        return False 
     1036                    if not page._update_paramv_on_fit(): 
    10111037                        msg = "Fitting range or parameter values are" 
    10121038                        msg += " invalid in %s" % \ 
    … …  
    10151041                                     StatusEvent(status=msg, info="error", 
    10161042                                     type="stop")) 
    1017                         return flag 
    1018                     for element in templist: 
    1019                         name = str(element[1]) 
    1020                         pars.append(name) 
    1021                     fitproblem_list = value.values() 
     1043                        return False 
     1044 
     1045                    pars = [str(element[1]) for element in page.param_toFit] 
     1046                    fitproblem_list = page_info.values() 
    10221047                    for fitproblem in  fitproblem_list: 
    10231048                        if sim_fitter is None: 
    10241049                            fitter = Fit(self._fit_engine) 
    10251050                            fitter.fitter_id = page_id 
    1026                             self._fit_helper(fitproblem=fitproblem, 
    1027                                              pars=pars, 
    1028                                              fitter=fitter, 
    1029                                              fit_id=fit_id, 
    1030                                              batch_inputs=batch_inputs, 
    1031                                              batch_outputs=batch_outputs) 
    10321051                            fitter_list.append(fitter) 
    10331052                        else: 
    10341053                            fitter = sim_fitter 
    1035                             self._fit_helper(fitproblem=fitproblem, 
     1054                        self._add_problem_to_fit(fitproblem=fitproblem, 
    10361055                                             pars=pars, 
    10371056                                             fitter=fitter, 
    1038                                              fit_id=fit_id, 
    1039                                              batch_inputs=batch_inputs, 
    1040                                              batch_outputs=batch_outputs) 
     1057                                             fit_id=fit_id) 
    10411058                        fit_id += 1 
    10421059                    list_page_id.append(page_id) 
    1043                     current_page_id = page_id 
    1044                     value.clear_model_param() 
     1060                    page_info.clear_model_param() 
    10451061            except KeyboardInterrupt: 
    1046                 flag = True 
    10471062                msg = "Fitting terminated" 
    10481063                wx.PostEvent(self.parent, StatusEvent(status=msg, info="info", 
    10491064                                                      type="stop")) 
    1050                 return flag 
     1065                return True 
    10511066            except: 
    1052                 flag = False 
    1053                 msg = "%s error: %s" % (engineType, sys.exc_value) 
     1067                msg = "Fitting error: %s" % str(sys.exc_value) 
    10541068                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
    10551069                                                      type="stop")) 
    1056                 return flag 
     1070                return False 
    10571071        ## If a thread is already started, stop it 
    10581072        #if self.calc_fit!= None and self.calc_fit.isrunning(): 
    … …  
    10661080                                improvement_delta=0.1) 
    10671081        self._mac_sleep(0.2) 
    1068         ## perform single fit 
    1069         try: 
     1082 
     1083        # batch fit 
     1084        batch_inputs = {} 
     1085        batch_outputs = {} 
     1086        if fit_type == "simultaneous": 
     1087            page = self.sim_page 
     1088        elif fit_type == "combined_batch": 
     1089            page = self.batch_page 
     1090        else: 
    10701091            page = self.fit_panel.get_page_by_id(uid) 
    1071             batch_on = page.batch_on 
    1072         except: 
    1073             try: 
    1074                 #if the id cannot be found then  we deal with a self.sim_page 
    1075                 #or a self.batch_page 
    1076                 if self.sim_page is not None and uid == self.sim_page.uid: 
    1077                     batch_on = self.sim_page.batch_on 
    1078                 if self.batch_page is not None and uid == self.batch_page.uid: 
    1079                     batch_on = self.batch_page.batch_on 
    1080             except: 
    1081                 batch_on = False 
    1082  
    1083         # batch fit 
    1084         if batch_on: 
     1092        if page.batch_on: 
    10851093            calc_fit = FitThread(handler=handler, 
    10861094                                 fn=fitter_list, 
    … …  
    10931101                                 reset_flag=self.batch_reset_flag) 
    10941102        else: 
    1095             # single fit: not batch and not simul fit 
    1096             if not is_single_fit: 
    1097                 current_page_id = self.sim_page.uid 
    10981103            ## Perform more than 1 fit at the time 
    10991104            calc_fit = FitThread(handler=handler, 
    … …  
    11051110                                    completefn=self._fit_completed, 
    11061111                                    ftol=self.ftol) 
    1107         self.fit_thread_list[current_page_id] = calc_fit 
     1112        #self.fit_thread_list[current_page_id] = calc_fit 
     1113        self.fit_thread_list[uid] = calc_fit 
    11081114        calc_fit.queue() 
     1115        calc_fit.ready(2.5) 
    11091116        msg = "Fitting is in progress..." 
    11101117        wx.PostEvent(self.parent, StatusEvent(status=msg, type="progress")) 
    11111118         
    1112         self.ready_fit(calc_fit=calc_fit) 
    1113         return flag 
    1114      
    1115     def ready_fit(self, calc_fit): 
    1116         """ 
    1117         Ready for another fit 
    1118         """ 
    1119         if self.fitproblem_count != None and self.fitproblem_count > 1: 
    1120             calc_fit.ready(2.5) 
    1121         else: 
    1122             time.sleep(0.4) 
    1123              
     1119        return True 
     1120 
    11241121    def remove_plot(self, uid, fid=None, theory=False): 
    11251122        """ 
    … …  
    12611258                self.page_finder[uid].schedule_tofit(value) 
    12621259                 
    1263     def _fit_helper(self, fitproblem, pars, fitter, fit_id, 
    1264                     batch_inputs, batch_outputs): 
     1260    def _add_problem_to_fit(self, fitproblem, pars, fitter, fit_id): 
    12651261        """ 
    12661262        Create and set fit engine with series of data and model 
    … …  
    15711567        wx.PostEvent(self.parent, StatusEvent(status=msg, info="info", 
    15721568                                                      type="stop")) 
     1569        wx.PostEvent(self.result_panel, PlotResultEvent(result=result)) 
    15731570        # reset fit_engine if changed by simul_fit 
    15741571        if self._fit_engine != self._gui_engine: 
    … …  
    16821679        self._on_change_engine('scipy') 
    16831680        
     1681    def _onset_engine_bumps(self, event): 
     1682        """  
     1683        set engine to bumps 
     1684        """ 
     1685        self._on_change_engine('bumps') 
     1686        
    16841687    def _on_slicer_event(self, event): 
    16851688        """ 
    … …  
    17141717                break 
    17151718     
    1716     def _return_engine_type(self): 
    1717         """ 
    1718         return the current type of engine 
    1719         """ 
    1720         return self._fit_engine 
    1721       
    17221719    def _on_change_engine(self, engine='park'): 
    17231720        """ 
    … …  
    17331730            self.menu1.FindItemById(self.park_id).Check(True) 
    17341731            self.menu1.FindItemById(self.scipy_id).Check(False) 
     1732            self.menu1.FindItemById(self.bumps_id).Check(False) 
     1733        elif engine == "scipy": 
     1734            self.menu1.FindItemById(self.park_id).Check(False) 
     1735            self.menu1.FindItemById(self.scipy_id).Check(True) 
     1736            self.menu1.FindItemById(self.bumps_id).Check(False) 
    17351737        else: 
    17361738            self.menu1.FindItemById(self.park_id).Check(False) 
    1737             self.menu1.FindItemById(self.scipy_id).Check(True) 
     1739            self.menu1.FindItemById(self.scipy_id).Check(False) 
     1740            self.menu1.FindItemById(self.bumps_id).Check(True) 
    17381741        ## post a message to status bar 
    17391742        msg = "Engine set to: %s" % self._fit_engine 

  • src/sans/perspectives/fitting/simfitpage.py

    r5777106 rbf5e985  
    138138                self.Layout() 
    139139                break 
    140         self._onAdd_constraint(None) 
     140 
     141        #self._onAdd_constraint(None) 
    141142              
    142143    def onFit(self, event): 
    … …  
    152153        ## making sure all parameters content a constraint 
    153154        ## validity of the constraint expression is own by fit engine 
    154         if self.parent._manager._fit_engine != "park" and flag: 
     155        if self.parent._manager._fit_engine not in ("park","bumps") and flag: 
    155156            msg = "The FitEnging will be set to 'Park' fit engine\n" 
    156157            msg += " for the simultaneous fit..." 
    … …  
    378379        box_description = wx.StaticBox(self, -1,"Easy Setup ") 
    379380        boxsizer = wx.StaticBoxSizer(box_description, wx.HORIZONTAL)      
    380         sizer_constraint = wx.BoxSizer(wx.HORIZONTAL|wx.LEFT|wx.RIGHT|wx.EXPAND) 
     381        sizer_constraint = wx.BoxSizer(wx.HORIZONTAL) 
    381382        self.model_cbox_left = wx.ComboBox(self, -1, style=wx.CB_READONLY) 
    382383        self.model_cbox_left.Clear() 
    … …  
    814815                         
    815816                    for fid in self.page_finder[id].iterkeys(): 
    816                         self.page_finder[id].set_model_param(param, 
    817                                                         constraint, fid=fid) 
     817                        # wrap in param/constraint in str() to remove unicode 
     818                        self.page_finder[id].set_model_param(str(param), 
     819                                                        str(constraint), fid=fid) 
    818820                    break 
    819821        return True 

  • test/park_integration/test/batch_fit.py

    r5777106 re3efa6b3  
    1  
    2  
    3 import math 
    4 import numpy 
    51import copy 
    62import time 
    … …  
    1511 
    1612 
    17  
    18      
    1913def classMapper(classInstance, classFunc, *args): 
    2014    """ 
    … …  
    2822 
    2923 
    30  
    31 class BatchScipyFit: 
     24class BatchFit: 
    3225    """ 
    3326    test fit module 
    … …  
    6962            model.setParam('cyl_phi.npts', 3) 
    7063            model.setParam('cyl_theta.nsigmas', 10) 
    71             """ for 2 data cyl_theta = 60.0 [deg] cyl_phi= 60.0 [deg]""" 
     64            # for 2 data cyl_theta = 60.0 [deg] cyl_phi= 60.0 [deg] 
    7265            fitter.set_model(model, i, self.param_to_fit,  
    7366                             self.list_of_constraints) 
    … …  
    8477            self.list_of_mapper.append(classMapper) 
    8578                    
    86     def reset_value(self): 
     79    def reset_value(self, engine='scipy'): 
    8780        """ 
    8881        Initialize inputs for the map function 
    … …  
    9386        self.list_of_constraints = [] 
    9487        self.list_of_mapper = [] 
    95         engine ="scipy" 
    96          
     88 
    9789        path = "testdata_line3.txt" 
    9890        self._reset_helper(path=path, engine=engine, npts=NPTS) 
    … …  
    113105         
    114106       
    115     def test_map_fit(self): 
     107    def test_map_fit(self, n=0): 
    116108        """ 
    117         """  
    118         results =  map(classMapper,self.list_of_fitter, self.list_of_function) 
    119         print len(results) 
    120         for result in results: 
    121             print result.fitness, result.stderr, result.pvec 
     109        """ 
     110        if n > 0: 
     111            self._test_process_map_fit(n=n) 
     112        else: 
     113            results =  map(classMapper,self.list_of_fitter, self.list_of_function) 
     114            print len(results) 
     115            for result in results: 
     116                print result.fitness, result.stderr, result.pvec 
    122117         
    123118    def test_process_map_fit(self, n=1): 
    … …  
    144139    """   
    145140    def setUp(self): 
    146         self.test = BatchScipyFit(qmin=None, qmax=None) 
     141        self.test = BatchFit(qmin=None, qmax=None) 
    147142        
    148143     
    149     def __test_fit1(self): 
     144    def test_fit1(self): 
    150145        """test fit with python built in map function---- full range of each data""" 
    151146        self.test.test_map_fit() 
    152147         
    153     def __test_fit2(self): 
     148    def test_fit2(self): 
    154149        """test fit with python built in map function---- common range for all data""" 
    155150        self.test.set_range(qmin=0.013, qmax=0.05) 
    156151        self.test.reset_value() 
    157152        self.test.test_map_fit() 
     153        raise Exception("fail") 
    158154         
    159155    def test_fit3(self): 
    … …  
    161157        self.test.set_range(qmin=None, qmax=None) 
    162158        self.test.reset_value() 
    163         self.test.test_process_map_fit(n=2) 
     159        self.test.test_map_fit(n=1) 
    164160         
    165161    def test_fit4(self): 
    … …  
    167163        self.test.set_range(qmin=-1, qmax=10) 
    168164        self.test.reset_value() 
    169         self.test.test_process_map_fit(n=1) 
     165        self.test.test_map_fit(n=3) 
    170166         
    171167             

  • test/park_integration/test/utest_fit_cylinder.py

    rda5d8e8 reff93b8  
    1010from sans.dataloader.loader import Loader 
    1111 
     12#@unittest.skip("") 
    1213class TestSingleFit(unittest.TestCase): 
    1314    """ test single fitting """ 
    … …  
    3334        fitter.set_model(self.model,1,self.pars1) 
    3435        fitter.select_problem_for_fit(id=1,value=1) 
    35         return  fitter.fit() 
    36         
     36        result1, = fitter.fit() 
    3737 
    38     def test_scipy(self): 
    39         """ Simple cylinder model fit (scipy)  """ 
    40          
    41         result1, = self._fit("scipy") 
    42          
    4338        self.assert_(result1) 
    4439        self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 ) 
    4540        self.assertTrue(len(result1.stderr)> 0 or len(result1.stderr)==0) 
    46          
     41 
    4742        self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] ) 
    4843        self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  < result1.stderr[1] ) 
    4944        self.assertTrue( math.fabs(result1.pvec[2]-1.0)/3.0   < result1.stderr[2] ) 
    5045        self.assertTrue( result1.fitness < 1.0 ) 
    51          
    52          
     46 
     47 
     48    def test_scipy(self): 
     49        """ Simple cylinder model fit (scipy)  """ 
     50        self._fit("scipy") 
     51 
     52 
    5353    def test_park(self): 
    5454        """ Simple cylinder model fit (park)  """ 
    55         #raise NotImplementedError() 
    56         result1, = self._fit("park") 
    57          
    58         self.assert_(result1) 
    59         self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 ) 
    60         self.assertTrue(len(result1.stderr)> 0 or len(result1.stderr)==0) 
    61         
    62         self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] ) 
    63         self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  < result1.stderr[1] ) 
    64         self.assertTrue( math.fabs(result1.pvec[2]-1.0)/3.0   < result1.stderr[2] ) 
    65         self.assertTrue( result1.fitness < 1.0 ) 
    66          
    67          
     55        self._fit("park") 
     56 
     57    def test_bumps(self): 
     58        """ Simple cylinder model fit (park)  """ 
     59        self._fit("bumps") 
     60 
     61 
    6862         
    6963class TestSimultaneousFit(unittest.TestCase): 
    … …  
    8276        self.model1.set(scale= 1.0) 
    8377        self.model1.set(radius=18) 
    84         self.model1.set(length=396) 
     78        self.model1.set(length=200) 
    8579        self.model1.set(sldCyl=3e-006, sldSolv=0.0) 
    8680        self.model1.set(background=0.0) 
    87          
     81 
    8882        cyl2  = CylinderModel() 
    8983        cyl2.name = "C2" 
    … …  
    9185        self.model2.set(scale= 1.0) 
    9286        self.model2.set(radius=37) 
    93         self.model2.set(length='C1.length') 
     87        self.model2.set(length=300) 
    9488        self.model2.set(sldCyl=3e-006, sldSolv=0.0) 
    9589        self.model2.set(background=0.0) 
    96         
    97     def _fit(self, name="park"): 
     90 
     91 
     92    def test_constrained_bumps(self): 
     93        """ Simultaneous cylinder model fit (park)  """ 
     94        self._run_fit(Fit('bumps')) 
     95 
     96    #@unittest.skip("") 
     97    def test_constrained_park(self): 
     98        """ Simultaneous cylinder model fit (park)  """ 
     99        self._run_fit(Fit('park')) 
     100 
     101    def _run_fit(self, fitter): 
     102        result1, result2 = self._fit(fitter) 
     103        self.assert_(result1) 
     104        self.assertTrue(len(result1.pvec)>0) 
     105        self.assertTrue(len(result1.stderr)>0) 
     106 
     107        for n, v, dv in zip(result1.param_list, result1.pvec, result1.stderr): 
     108            print "%s M1.%s = %s +/- %s"%(fitter._engine.__class__.__name__,n,v,dv) 
     109            if n == "length": 
     110                self.assertTrue( math.fabs(v-400.0)/3.0 < dv ) 
     111            elif n=='radius': 
     112                self.assertTrue( math.fabs(v-20.0)/3.0 < dv ) 
     113            elif n=='scale': 
     114                self.assertTrue( math.fabs(v-1.0)/3.0 < dv ) 
     115        for n, v, dv in zip(result2.param_list, result2.pvec, result2.stderr): 
     116            print "%s M2.%s = %s +/- %s"%(fitter._engine.__class__.__name__,n,v,dv) 
     117            if n=='radius': 
     118                self.assertTrue( math.fabs(v-40.0)/3.0 < dv ) 
     119            elif n=='scale': 
     120                self.assertTrue( math.fabs(v-1.0)/3.0 < dv ) 
     121 
     122    def _fit(self, fitter): 
    98123        """ return fit result """ 
    99         fitter = Fit(name) 
    100124        fitter.set_data(self.data1,1) 
    101125        fitter.set_model(self.model1, 1, ['length','radius','scale']) 
    102          
     126 
    103127        fitter.set_data(self.data2,2) 
    104         fitter.set_model(self.model2, 2, ['radius','scale']) 
     128        fitter.set_model(self.model2, 2, ['length','radius','scale'], 
     129                         constraints=[("length","C1.length")]) 
    105130        fitter.select_problem_for_fit(id=1,value=1) 
    106131        fitter.select_problem_for_fit(id=2,value=1) 
    107132        return fitter.fit() 
    108      
    109      
    110     def test_park2(self): 
    111         """ Simultaneous cylinder model fit (park)  """ 
    112         raise NotImplementedError() 
    113         result1,= self._fit('park') 
    114         self.assert_(result1) 
    115         self.assertTrue(len(result1.pvec)>=0  ) 
    116         self.assertTrue(len(result1.stderr)>= 0) 
    117        
    118         for par in result1.parameters: 
    119             if par.name=='C1.length': 
    120                 print par.name, par.value 
    121                 self.assertTrue( math.fabs(par.value-400.0)/3.0 < par.stderr ) 
    122             elif par.name=='C1.radius': 
    123                 print par.name, par.value 
    124                 self.assertTrue( math.fabs(par.value-20.0)/3.0 < par.stderr ) 
    125             elif par.name=='C2.radius': 
    126                 print par.name, par.value 
    127                 self.assertTrue( math.fabs(par.value-40.0)/3.0 < par.stderr ) 
    128             elif par.name=='C1.scale': 
    129                 print par.name, par.value 
    130                 self.assertTrue( math.fabs(par.value-1.0)/3.0 < par.stderr ) 
    131             elif par.name=='C2.scale': 
    132                 print par.name, par.value 
    133                 self.assertTrue( math.fabs(par.value-1.0)/3.0 < par.stderr ) 
    134              
     133 
    135134 
    136135if __name__ == '__main__': 

  • test/park_integration/test/utest_fit_line.py

    rda5d8e8 re3efa6b3  
    44""" 
    55import unittest 
    6  
    7 from sans.fit.AbstractFitEngine import Model 
     6import math 
     7 
     8from sans.fit.AbstractFitEngine import Model, FitHandler 
    89from sans.dataloader.loader import Loader 
    910from sans.fit.Fitting import Fit 
    … …  
    1112from sans.models.Constant import Constant 
    1213 
    13 import math 
    1414class testFitModule(unittest.TestCase): 
    1515    """ test fitting """ 
    16     
    17     def test1(self): 
    18         """ Fit 1 data (testdata_line.txt)and 1 model(lineModel) """ 
    19         #load data 
     16 
     17    def test_bad_pars(self): 
     18        fitter = Fit('bumps') 
     19 
    2020        data = Loader().load("testdata_line.txt") 
    2121        data.name = data.filename 
    22         #Importing the Fit module 
    23         fitter = Fit('scipy') 
     22        fitter.set_data(data,1) 
     23 
     24        model1  = LineModel() 
     25        model1.name = "M1" 
     26        model = Model(model1, data) 
     27        pars1= ['param1','param2'] 
     28        try: 
     29            fitter.set_model(model,1,pars1) 
     30        except ValueError,exc: 
     31            #print "ValueError was correctly raised: "+str(msg) 
     32            assert str(exc).startswith('parameter param1') 
     33        else: 
     34            raise AssertionError("No error raised for scipy fitting with wrong parameters name to fit") 
     35 
     36    def fit_single(self, fitter_name, isdream=False): 
     37        fitter = Fit(fitter_name) 
     38 
     39        data = Loader().load("testdata_line.txt") 
     40        data.name = data.filename 
     41        fitter.set_data(data,1) 
     42 
    2443        # Receives the type of model for the fitting 
    2544        model1  = LineModel() 
    … …  
    2746        model = Model(model1,data) 
    2847        #fit with scipy test 
    29          
    30         pars1= ['param1','param2'] 
    31         fitter.set_data(data,1) 
    32         try:fitter.set_model(model,1,pars1) 
    33         except ValueError,exc: 
    34             #print "ValueError was correctly raised: "+str(msg) 
    35             assert str(exc).startswith('wrong parameter') 
    36         else: raise AssertionError("No error raised for scipy fitting with wrong parameters name to fit") 
     48 
    3749        pars1= ['A','B'] 
    3850        fitter.set_model(model,1,pars1) 
    3951        fitter.select_problem_for_fit(id=1,value=1) 
    40         result1, = fitter.fit() 
    41  
    42         self.assertTrue( math.fabs(result1.pvec[0]-4)/3 <= result1.stderr[0] ) 
    43         self.assertTrue( math.fabs(result1.pvec[1]-2.5)/3 <= result1.stderr[1]) 
    44         self.assertTrue( result1.fitness/len(data.x) < 2 ) 
    45  
    46         #fit with park test 
    47         fitter = Fit('park') 
    48         fitter.set_data(data,1) 
    49         fitter.set_model(model,1,pars1) 
    50         fitter.select_problem_for_fit(id=1,value=1) 
    51         result2, = fitter.fit() 
    52          
    53         self.assert_(result2) 
    54         self.assertTrue( math.fabs(result2.pvec[0]-4)/3 <= result2.stderr[0] )  
    55         self.assertTrue( math.fabs(result2.pvec[1]-2.5)/3 <= result2.stderr[1] ) 
    56         self.assertTrue( result2.fitness/len(data.x) < 2) 
    57         # compare fit result result for scipy and park 
    58         self.assertAlmostEquals( result1.pvec[0], result2.pvec[0] ) 
    59         self.assertAlmostEquals( result1.pvec[1],result2.pvec[1] ) 
    60         self.assertAlmostEquals( result1.stderr[0],result2.stderr[0] ) 
    61         self.assertAlmostEquals( result1.stderr[1],result2.stderr[1] ) 
    62         self.assertAlmostEquals( result1.fitness, 
    63                                  result2.fitness/len(data.x),1 ) 
    64          
     52        result1, = fitter.fit(handler=FitHandler()) 
     53 
     54        # The target values were generated from the following statements 
     55        p,s,fx = result1.pvec, result1.stderr, result1.fitness 
     56        #print "p0,p1,s0,s1,fx = %g, %g, %g, %g, %g"%(p[0],p[1],s[0],s[1],fx) 
     57        p0,p1,s0,s1,fx_ = 3.68353, 2.61004, 0.336186, 0.105244, 1.20189 
     58 
     59        if isdream: 
     60            # Dream is not a minimizer: just check that the fit is within 
     61            # uncertainty 
     62            self.assertTrue( abs(p[0]-p0) <= s0 ) 
     63            self.assertTrue( abs(p[1]-p1) <= s1 ) 
     64        else: 
     65            self.assertTrue( abs(p[0]-p0) <= 1e-5 ) 
     66            self.assertTrue( abs(p[1]-p1) <= 1e-5 ) 
     67            self.assertTrue( abs(fx-fx_) <= 1e-5 ) 
     68 
     69    def fit_bumps(self, alg, **opts): 
     70        #Importing the Fit module 
     71        from bumps import fitters 
     72        fitters.FIT_DEFAULT = alg 
     73        fitters.FIT_OPTIONS[alg].options.update(opts) 
     74        fitters.FIT_OPTIONS[alg].options.update(monitors=[]) 
     75        #print "fitting",alg,opts 
     76        #kprint "options",fitters.FIT_OPTIONS[alg].__dict__ 
     77        self.fit_single('bumps', isdream=(alg=='dream')) 
     78 
     79    def test_bumps_de(self): 
     80        self.fit_bumps('de') 
     81 
     82    def test_bumps_dream(self): 
     83        self.fit_bumps('dream', burn=500, steps=100) 
     84 
     85    def test_bumps_amoeba(self): 
     86        self.fit_bumps('amoeba') 
     87 
     88    def test_bumps_newton(self): 
     89        self.fit_bumps('newton') 
     90 
     91    def test_bumps_lm(self): 
     92        self.fit_bumps('lm') 
     93 
     94    def test_scipy(self): 
     95        #print "fitting scipy" 
     96        self.fit_single('scipy') 
     97 
     98    def test_park(self): 
     99        #print "fitting park" 
     100        self.fit_single('park') 
     101 
    65102         
    66103    def test2(self): 
    … …  
    93130        fitter.select_problem_for_fit(id=2,value=0) 
    94131         
    95         try: result1, = fitter.fit() 
     132        try: result1, = fitter.fit(handler=FitHandler()) 
    96133        except RuntimeError,msg: 
    97134           assert str(msg)=="No Assembly scheduled for Scipy fitting." 
    … …  
    99136        fitter.select_problem_for_fit(id=1,value=1) 
    100137        fitter.select_problem_for_fit(id=2,value=1) 
    101         try: result1, = fitter.fit() 
     138        try: result1, = fitter.fit(handler=FitHandler()) 
    102139        except RuntimeError,msg: 
    103140           assert str(msg)=="Scipy can't fit more than a single fit problem at a time." 
    104141        else: raise AssertionError,"No error raised for scipy fitting with more than 2 models" 
    105          
     142 
    106143        #fit with park test 
    107144        fitter = Fit('park') 
    … …  
    112149        fitter.select_problem_for_fit(id=1,value=1) 
    113150        fitter.select_problem_for_fit(id=2,value=1) 
    114         R1,R2 = fitter.fit() 
     151        R1,R2 = fitter.fit(handler=FitHandler()) 
    115152         
    116153        self.assertTrue( math.fabs(R1.pvec[0]-4)/3 <= R1.stderr[0] ) 
    … …  
    157194        fitter.select_problem_for_fit(id=2,value=1) 
    158195         
    159         R1,R2 = fitter.fit() 
     196        R1,R2 = fitter.fit(handler=FitHandler()) 
    160197        self.assertTrue( math.fabs(R1.pvec[0]-4.0)/3. <= R1.stderr[0]) 
    161198        self.assertTrue( math.fabs(R1.pvec[1]-2.5)/3. <= R1.stderr[1]) 
    … …  
    188225        fitter.select_problem_for_fit(id=1,value=1) 
    189226         
    190         result1, = fitter.fit() 
     227        result1, = fitter.fit(handler=FitHandler()) 
     228        #print(result1) 
    191229        self.assert_(result1) 
    192230 
    … …  
    194232        self.assertTrue( math.fabs(result1.pvec[1]-2.5)/3 <= result1.stderr[1]) 
    195233        self.assertTrue( result1.fitness/len(data1.x) < 2 ) 
    196          
     234 
    197235        #fit with park test 
    198236        fitter = Fit('park') 
    … …  
    201239        fitter.set_data(data2,1,qmin=1,qmax=10) 
    202240        fitter.select_problem_for_fit(id=1,value=1) 
    203         result2, = fitter.fit() 
     241        result2, = fitter.fit(handler=FitHandler()) 
    204242         
    205243        self.assert_(result2) 
    … …  
    213251        self.assertAlmostEquals( result1.stderr[1],result2.stderr[1] ) 
    214252        self.assertTrue( result2.fitness/(len(data2.x)+len(data1.x)) < 2 ) 
    215          
    216          
     253 
     254 
     255if __name__ == "__main__": 
     256    unittest.main() 
    217257     
    218      

  • test/park_integration/test/utest_fit_smeared.py

    r6c00702 re3efa6b3  
    55import unittest 
    66import math 
     7 
    78import numpy 
    89from sans.fit.AbstractFitEngine import Model 
    … …  
    2122        out=Loader().load("cyl_400_20.txt") 
    2223        # This data file has not error, add them 
    23         out.dy = out.y 
     24        #out.dy = out.y 
    2425         
    2526        fitter = Fit('scipy') 
    … …  
    2829        # Receives the type of model for the fitting 
    2930        model1  = CylinderModel() 
    30         model1.setParam('sldCyl', 3.0e-6) 
    31         model1.setParam('sldSolv', 0.0) 
     31        model1.setParam("scale", 1.0) 
     32        model1.setParam("radius",18) 
     33        model1.setParam("length", 397) 
     34        model1.setParam("sldCyl",3e-006 ) 
     35        model1.setParam("sldSolv",0.0 ) 
     36        model1.setParam("background", 0.0) 
    3237        model = Model(model1) 
    33         model.set(scale=1e-10) 
    3438        pars1 =['length','radius','scale'] 
    3539        fitter.set_model(model,1,pars1) 
    … …  
    3842        fitter.select_problem_for_fit(id=1,value=1) 
    3943        result1, = fitter.fit() 
    40          
     44        #print "result1",result1 
     45 
    4146        self.assert_(result1) 
    42         self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 ) 
    43         self.assertTrue(len(result1.stderr)> 0 or len(result1.stderr)==0) 
     47        self.assertTrue(len(result1.pvec) > 0) 
     48        self.assertTrue(len(result1.stderr) > 0) 
    4449         
    4550        self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] ) 
    4651        self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  < result1.stderr[1] ) 
    47         self.assertTrue( math.fabs(result1.pvec[2]-9.0e-12)/3.0   < result1.stderr[2] ) 
     52        self.assertTrue( math.fabs(result1.pvec[2]-1)/3.0   < result1.stderr[2] ) 
    4853        self.assertTrue( result1.fitness < 1.0 ) 
    49          
     54 
     55    def test_park_dispersion(self): 
     56        """ 
     57            Cylinder fit with dispersion 
     58        """ 
     59        self._dispersion(fitter = Fit('park')) 
     60 
     61    def test_bumps_dispersion(self): 
     62        """ 
     63            Cylinder fit with dispersion 
     64        """ 
     65        alg = 'lm' 
     66        from bumps import fitters 
     67        fitters.FIT_DEFAULT = alg 
     68        #fitters.FIT_OPTIONS[alg].options.update(opts) 
     69        fitters.FIT_OPTIONS[alg].options.update(monitors=[]) 
     70        self._dispersion(fitter = Fit('bumps')) 
     71 
    5072    def test_scipy_dispersion(self): 
    5173        """ 
    5274            Cylinder fit with dispersion 
    5375        """ 
     76        self._dispersion(fitter = Fit('scipy')) 
     77 
     78    def _dispersion(self, fitter): 
    5479        # Load data 
    5580        # This data is for a cylinder with  
    … …  
    6085            out.dy[i] = math.sqrt(out.y[i]) 
    6186         
    62         # Set up the fit 
    63         fitter = Fit('scipy') 
    6487        # Receives the type of model for the fitting 
    6588        model1  = CylinderModel() 
    66         model1.setParam('sldCyl', 3.0e-6) 
    67         model1.setParam('sldSolv', 0.0) 
     89        model1.setParam("scale", 10.0) 
     90        model1.setParam("radius",18) 
     91        model1.setParam("length", 397) 
     92        model1.setParam("sldCyl",3e-006 ) 
     93        model1.setParam("sldSolv",0.0 ) 
     94        model1.setParam("background", 0.0) 
    6895 
    6996        # Dispersion parameters 
    70         model1.dispersion['radius']['width'] = 0.001 
    71         model1.dispersion['radius']['npts'] = 50         
    72          
     97        model1.dispersion['radius']['width'] = 0.25 
     98        model1.dispersion['radius']['npts'] = 50 
     99 
    73100        model = Model(model1) 
    74          
     101 
    75102        pars1 =['length','radius','scale','radius.width'] 
    76103        fitter.set_data(out,1) 
    77         model.set(scale=1e-10) 
    78104        fitter.set_model(model,1,pars1) 
    79105        fitter.select_problem_for_fit(id=1,value=1) 
    80         result1, = fitter.fit() 
     106        #import time; T0 = time.time() 
     107        result1, = fitter.fit() 
     108        #print "time",time.time()-T0,fitter._engine.__class__.__name__ 
    81109         
    82110        self.assert_(result1) 
    83         self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 ) 
    84         self.assertTrue(len(result1.stderr)> 0 or len(result1.stderr)==0) 
    85          
    86         self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] ) 
    87         self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  < result1.stderr[1] ) 
    88         self.assertTrue( math.fabs(result1.pvec[2]-1.0e-10)/3.0   < result1.stderr[2] ) 
    89         self.assertTrue( math.fabs(result1.pvec[3]-5.0)/3.0   < result1.stderr[3] ) 
     111        self.assertTrue(len(result1.pvec)>0) 
     112        self.assertTrue(len(result1.stderr)>0) 
     113 
     114        #print [z for z in zip(result1.param_list,result1.pvec,result1.stderr)] 
     115        self.assertTrue( math.fabs(result1.pvec[0]-399.8)/3.0 < result1.stderr[0] ) 
     116        self.assertTrue( math.fabs(result1.pvec[1]-17.5)/3.0  < result1.stderr[1] ) 
     117        self.assertTrue( math.fabs(result1.pvec[2]-11.1)/3.0   < result1.stderr[2] ) 
     118        self.assertTrue( math.fabs(result1.pvec[3]-0.276)/3.0   < result1.stderr[3] ) 
    90119        self.assertTrue( result1.fitness < 1.0 ) 
    91120         
    … …  
    98127    """ 
    99128    def setUp(self): 
    100         print "TEST DONE WITHOUT PROPER OUTPUT CHECK:" 
    101         print "   ---> TEST NEEDS TO BE COMPLETED" 
    102129        data = Loader().load("latex_smeared.xml") 
    103130        self.data_res = data[0] 
    … …  
    105132         
    106133        self.sphere = SphereModel() 
     134        self.sphere.setParam('background', 0) 
    107135        self.sphere.setParam('radius', 5000.0) 
    108         self.sphere.setParam('scale', 1.0e-13) 
    109         self.sphere.setParam('radius.npts', 30) 
    110         self.sphere.setParam('radius.width',500) 
    111          
     136        self.sphere.setParam('scale', 0.4) 
     137        self.sphere.setParam('sldSolv',0) 
     138        self.sphere.setParam('sldSph',1e-6) 
     139        #self.sphere.setParam('radius.npts', 30) 
     140        #self.sphere.setParam('radius.width',50) 
     141 
    112142    def test_reso(self): 
    113143 
    … …  
    125155        fitter.set_data(self.data_res,1) 
    126156        fitter._engine.fit_arrange_dict[1].data_list[0].smearer = smear 
    127         print "smear ",smear 
     157 
    128158        # Model: maybe there's a better way to do this. 
    129159        # Ideally we should have to create a new model from our sans model. 
    130         fitter.set_model(Model(self.sphere),1, ['radius','scale']) 
     160        fitter.set_model(Model(self.sphere),1, ['radius','scale', 'background']) 
    131161         
    132162        # Why do we have to do this...? 
    133163        fitter.select_problem_for_fit(id=1,value=1) 
    134          
     164 
    135165        # Perform the fit (might take a while) 
    136166        result1, = fitter.fit() 
    137167         
    138         # Replace this with proper test once we know what the 
    139         # result should be  
    140         print result1.pvec 
    141         print result1.stderr 
    142          
     168        #print "v",result1.pvec 
     169        #print "dv",result1.stderr 
     170        #print "chisq(v)",result1.fitness 
     171 
     172        self.assertTrue( math.fabs(result1.pvec[0]-5000) < 20 ) 
     173        self.assertTrue( math.fabs(result1.pvec[1]-0.48) < 0.02 ) 
     174        self.assertTrue( math.fabs(result1.pvec[2]-0.060)  < 0.002 ) 
     175 
     176 
    143177    def test_slit(self): 
    144178        smear = smear_selection(self.data_slit) 
    145179        self.assertEqual(smear.__class__.__name__, 'SlitSmearer') 
    146180 
    147         # Fit 
    148181        fitter = Fit('scipy') 
    149182         
    … …  
    161194        result1, = fitter.fit() 
    162195         
    163         # Replace this with proper test once we know what the 
    164         # result should be  
    165         print result1.pvec 
    166         print result1.stderr 
    167          
    168         
    169         
     196        #print "v",result1.pvec 
     197        #print "dv",result1.stderr 
     198        #print "chisq(v)",result1.fitness 
     199         
     200        self.assertTrue( math.fabs(result1.pvec[0]-2340) < 20 ) 
     201        self.assertTrue( math.fabs(result1.pvec[1]-0.010) < 0.002 ) 
     202 
    170203if __name__ == '__main__': 
    171204    unittest.main() 

  • test/park_integration/test/utest_park_scipy.py

    r6c00702 re544c84  
    4848        self.assertTrue(len(result1.stderr)>= 0) 
    4949 
    50         print "results",list(zip(result1.pvec, result1.stderr)) 
    51         self.assertTrue( math.fabs(result1.pvec[0]-605)/3.0 <= result1.stderr[0] ) 
    52         self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  <= result1.stderr[1] ) 
    53         self.assertTrue( math.fabs(result1.pvec[2]-1)/3.0 <= result1.stderr[2] ) 
     50        #print "results",list(zip(result1.pvec, result1.stderr)) 
     51        self.assertTrue( math.fabs(result1.pvec[0]-612)/3.0 <= result1.stderr[0] ) 
     52        self.assertTrue( math.fabs(result1.pvec[1]-20.3)/3.0  <= result1.stderr[1] ) 
     53        self.assertTrue( math.fabs(result1.pvec[2]-25)/3.0 <= result1.stderr[2] ) 
    5454         
    5555        self.assertTrue( result1.fitness/len(data.x) < 1.0 ) 

  • test/park_integration/test/utest_small_test.py

    r5777106 r76f132a  
    55import math 
    66from sans.fit.Fitting import Fit 
    7 from DataLoader.loader import Loader 
     7from sans.dataloader.loader import Loader 
    88 
    99class testFitModule(unittest.TestCase): 
    … …  
    1818        from sans.models.CylinderModel import CylinderModel 
    1919        model  = CylinderModel() 
    20         model.setParam('contrast', 1) 
    21         
     20        model.setParam('sldCyl', 1) 
     21        model.setParam('sldSolv', 0) 
     22 
    2223        pars1 =['length','radius','scale'] 
    2324        fitter.set_data(out,1) 
    2425        model.setParam('scale', 1e-10) 
    2526        fitter.set_model(model,1,pars1, constraints=()) 
    26         fitter.select_problem_for_fit(Uid=1,value=1) 
    27         result1 = fitter.fit() 
    28          
     27        fitter.select_problem_for_fit(id=1,value=1) 
     28        result1, = fitter.fit() 
     29        #print result1 
     30        #print result1.__dict__ 
     31 
    2932        self.assert_(result1) 
    3033        self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 ) 

  • test/run_one.py

    r95fb3e8 r76f132a  
    11#!/usr/bin/env python 
     2 
    23import os 
    34import sys 
    … …  
    89 
    910run_py = joinpath(dirname(dirname(abspath(__file__))), 'run.py') 
    10 #print run_py 
    1111run = imp.load_source('sasview_run', run_py) 
    1212run.prepare() 
    1313#print "\n".join(sys.path) 
    14 test_path,test_file = splitpath(sys.argv[1]) 
    15 print "test file",sys.argv[1] 
     14test_path,test_file = splitpath(abspath(sys.argv[1])) 
     15print "=== testing:",sys.argv[1] 
    1616#print test_path, test_file 
    1717sys.argv = [sys.argv[0]] 
    … …  
    2020test = imp.load_source('tests',test_file) 
    2121unittest.main(test, testRunner=xmlrunner.XMLTestRunner(output='logs')) 
    22  
Note: See TracChangeset for help on using the changeset viewer.