Changes in / [786685e:bb1b892] in sasview


Ignore:
Files:
5 added
8 deleted
22 edited

Legend:

Unmodified
Added
Removed

  • park-1.2.1/park/expression.py

    re3efa6b3 r3570545  
    160160"""%("\n    ".join(exprs),"\n    ".join(code)) 
    161161 
    162     #print "Function:",functiondef 
     162    #print "Function:",function 
    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' 
    188187 
    189188 
    … …  
    250249    for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',  
    251250                 'piddle', 
    252                  '5; import sys; print "p0wned"', 
     251                 'import sys; print "p0wned"', 
    253252                 '__import__("sys").argv']: 
    254253        try: 

  • park-1.2.1/park/fitresult.py

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

  • park-1.2.1/park/parameter.py

    rfb7180c r3570545  
    1515__all__ = ['Parameter', 'ParameterSet'] 
    1616 
    17 import math 
    1817import numpy 
    1918import expression         
    … …  
    163162        """ 
    164163        range = ['.']*10 
    165         lo,hi = self.range 
    166         portion = (self.value-lo)/(hi-lo) 
     164        lo,hi = p.range 
     165        portion = (p.value-lo)/(hi-lo) 
    167166        if portion < 0: portion = 0. 
    168167        elif portion >= 1: portion = 0.99999999 
    … …  
    170169        range[bar] = '|' 
    171170        range = "".join(range) 
    172         return "%25s %s %g in [%g,%g]"  % (self.name,range,self.value,lo,hi) 
     171        return "%25s %s %g in [%g,%g]"  % (p.name,range,p.value,lo,hi) 
    173172 
    174173    def isfitted(self): return self.status == 'fitted' 
    … …  
    274273        for p in self: 
    275274            if parts[1] == p.name: 
    276                 if len(parts) == 2: 
     275                if len(pars) == 2: 
    277276                    return p 
    278277                elif isinstance(p, ParameterSet): 
    279278                    return p._byname(parts[1:]) 
    280                 else: 
    281                     raise 
    282279        return None 
    283280 
    … …  
    286283        parts = name.split('.') 
    287284        if parts[0] == self.name: 
    288             p =  self._byname(name.split('.')) 
     285            p =  _byname(self, name.split('.')) 
    289286            if p: return p 
    290287        raise KeyError("parameter %s not in parameter set"%name) 

  • run.py

    r499639c rbbd97e5  
    88Usage: 
    99 
    10 ./run.py [(module|script) args...] 
    11  
    12 Without arguments run.py runs sasview.  With arguments, run.py will run 
    13 the given module or script. 
     10./run.py [args] 
    1411""" 
    1512 
    … …  
    5249    return mod 
    5350 
    54 def import_dll(modname, build_path): 
     51def import_dll(modname): 
    5552    """Import a DLL from the build directory""" 
    56     import sysconfig 
    57     ext = sysconfig.get_config_var('SO') 
    5853    # build_path comes from context 
    59     path = joinpath(build_path, *modname.split('.'))+ext 
     54    path = glob(joinpath(build_path, *modname.split('.'))+'.*')[0] 
    6055    #print "importing", modname, "from", path 
    6156    return imp.load_dynamic(modname, path) 
    … …  
    8681    except: addpath(joinpath(root, '..','periodictable')) 
    8782 
    88     try: import bumps 
    89     except: addpath(joinpath(root, '..','bumps')) 
    90  
    9183    # select wx version 
    9284    #addpath(os.path.join(root, '..','wxPython-src-3.0.0.0','wxPython')) 
    … …  
    115107    sans.pr.core = import_package('sans.pr.core', 
    116108                                  joinpath(build_path, 'sans', 'pr', 'core')) 
    117     #import_dll('park._modeling', build_path) 
     109    #import_dll('park._modeling') 
    118110 
    119111    #park = import_package('park',os.path.join(build_path,'park')) 
    … …  
    130122 
    131123if __name__ == "__main__": 
     124    # start sasview 
     125    #import multiprocessing 
     126    #multiprocessing.freeze_support() 
    132127    prepare() 
    133     from sans.sansview.sansview import run 
    134     run() 
     128    from sans.sansview.sansview import SasView 
     129    SasView() 

  • sansview/sansview.py

    r6fe5100 re2271c5  
    3636PLUGIN_MODEL_DIR = 'plugin_models' 
    3737APP_NAME = 'SasView' 
    38  
     38def run(): 
     39    sys.path.append(os.path.join("..","..","..")) 
     40    from multiprocessing import freeze_support 
     41    freeze_support() 
     42    sasview = SasView() 
     43         
    3944class SasViewApp(gui_manager.ViewApp): 
    4045    """ 
    … …  
    108113        self.gui.clean_plugin_models(PLUGIN_MODEL_DIR) 
    109114        # Start the main loop 
    110         self.gui.MainLoop() 
     115        self.gui.MainLoop()   
     116        
    111117 
    112118 
    113 def run(): 
     119if __name__ == "__main__":  
    114120    from multiprocessing import freeze_support 
    115121    freeze_support() 
    116     if len(sys.argv) > 1: 
    117         thing_to_run = sys.argv[1] 
    118         sys.argv = sys.argv[1:] 
    119         import runpy 
    120         if os.path.exists(thing_to_run): 
    121             runpy.run_path(thing_to_run) 
    122         else: 
    123             runpy.run_module(thing_to_run) 
    124     else: 
    125         SasView() 
     122    #Process(target=SasView).start() 
     123    sasview = SasView() 
    126124 
    127 if __name__ == "__main__": 
    128     run() 
    129  
     125    

  • sansview/setup_exe.py

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

  • setup.py

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

  • src/sans/fit/AbstractFitEngine.py

    r8d074d9 r6c00702  
    33#import logging 
    44import sys 
     5import numpy 
    56import math 
    6 import numpy 
    7  
     7import park 
    88from sans.dataloader.data_info import Data1D 
    99from sans.dataloader.data_info import Data2D 
    10 _SMALLVALUE = 1.0e-10 
    11  
    12 # Note: duplicated from park 
    13 class 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  
    65 class Model: 
    66     """ 
    67     Fit wrapper for SANS models. 
     10_SMALLVALUE = 1.0e-10     
     11     
     12class 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     
     80class Model(park.Model): 
     81    """ 
     82    PARK wrapper for SANS models. 
    6883    """ 
    6984    def __init__(self, sans_model, sans_data=None, **kw): 
    7085        """ 
    7186        :param sans_model: the sans model to wrap using park interface 
    72  
    73         """ 
     87         
     88        """ 
     89        park.Model.__init__(self, **kw) 
    7490        self.model = sans_model 
    7591        self.name = sans_model.name 
    7692        self.data = sans_data 
    77  
     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   
    78101    def get_params(self, fitparams): 
    79102        """ 
    80103        return a list of value of paramter to fit 
    81  
     104         
    82105        :param fitparams: list of paramaters name to fit 
    83  
    84         """ 
    85         return [self.model.getParam(k) for k in fitparams] 
    86  
     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     
    87117    def set_params(self, paramlist, params): 
    88118        """ 
    89119        Set value for parameters to fit 
    90  
     120         
    91121        :param params: list of value for parameters to fit 
    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  
     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   
    100133    def eval(self, x): 
    101134        """ 
    102135            Override eval method of park model. 
    103  
     136         
    104137            :param x: the x value used to compute a function 
    105138        """ 
    … …  
    108141        except: 
    109142            raise 
    110  
     143         
    111144    def eval_derivs(self, x, pars=[]): 
    112145        """ 
    … …  
    121154        instead of calling eval. 
    122155        """ 
    123         raise NotImplementedError('no derivatives available') 
    124  
    125     def __call__(self, x): 
    126         return self.eval(x) 
    127  
     156        return [] 
     157 
     158     
    128159class FitData1D(Data1D): 
    129160    """ 
    … …  
    154185        """ 
    155186        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy) 
    156         self.num_points = len(x) 
    157187        self.sans_data = data 
    158188        self.smearer = smearer 
    … …  
    221251        """ 
    222252        return self.qmin, self.qmax 
    223  
    224     def size(self): 
    225         """ 
    226         Number of measurement points in data set after masking, etc. 
    227         """ 
    228         return len(self.x) 
    229  
     253         
    230254    def residuals(self, fn): 
    231255        """ 
    … …  
    269293    def __init__(self, sans_data2d, data=None, err_data=None): 
    270294        Data2D.__init__(self, data=data, err_data=err_data) 
    271         # Data can be initialized with a sans plottable or with vectors. 
     295        """ 
     296            Data can be initital with a data (sans plottable) 
     297            or with vectors. 
     298        """ 
    272299        self.res_err_image = [] 
    273         self.num_points = 0 # will be set by set_data 
    274300        self.idx = [] 
    275301        self.qmin = None 
    … …  
    313339        self.idx = (self.idx) & (self.mask) 
    314340        self.idx = (self.idx) & (numpy.isfinite(self.data)) 
    315         self.num_points = numpy.sum(self.idx) 
    316341 
    317342    def set_smearer(self, smearer): 
    … …  
    347372        """ 
    348373        return self.qmin, self.qmax 
    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  
     374      
    356375    def residuals(self, fn): 
    357376        """ 
    … …  
    390409 
    391410 
    392  
     411class 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     
    393543class FitEngine: 
    394544    def __init__(self): 
    … …  
    421571         
    422572        """ 
    423         if not pars: 
    424             raise ValueError("no fitting parameters") 
    425  
    426         if model is None: 
    427             raise ValueError("no model to fit") 
    428  
     573        if model == None: 
     574            raise ValueError, "AbstractFitEngine: Need to set model to fit" 
     575         
     576        new_model = model 
    429577        if not issubclass(model.__class__, Model): 
    430             model = Model(model, data) 
    431  
    432         sasmodel = model.model 
    433         available_parameters = sasmodel.getParamList() 
    434         for p in pars: 
    435             if p not in available_parameters: 
    436                 raise ValueError("parameter %s not available in model %s; use one of [%s] instead" 
    437                                  %(p, sasmodel.name, ", ".join(available_parameters))) 
    438  
    439         if id not in self.fit_arrange_dict: 
    440             self.fit_arrange_dict[id] = FitArrange() 
    441  
    442         self.fit_arrange_dict[id].set_model(model) 
    443         self.fit_arrange_dict[id].pars = pars 
    444         self.fit_arrange_dict[id].vals = [sasmodel.getParam(name) for name in pars] 
    445         self.fit_arrange_dict[id].constraints = constraints 
    446  
    447         self.param_list.extend(pars) 
    448  
     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     
    449621    def set_data(self, data, id, smearer=None, qmin=None, qmax=None): 
    450622        """ 
    … …  
    528700        self.vals = [] 
    529701        self.selected = 0 
    530  
     702         
    531703    def set_model(self, model): 
    532704        """ 
    … …  
    580752        """ 
    581753        return self.selected 
     754     
     755     
     756IS_MAC = True 
     757if sys.platform.count("win32") > 0: 
     758    IS_MAC = False 
     759 
    582760 
    583761class FResult(object): 
    … …  
    587765    def __init__(self, model=None, param_list=None, data=None): 
    588766        self.calls = None 
     767        self.pars = [] 
    589768        self.fitness = None 
    590769        self.chisqr = None 
    … …  
    597776        self.residuals = [] 
    598777        self.index = [] 
     778        self.parameters = None 
     779        self.is_mac = IS_MAC 
    599780        self.model = model 
    600781        self.data = data 
    … …  
    622803        if self.pvec == None and self.model is None and self.param_list is None: 
    623804            return "No results" 
    624  
    625         sasmodel = self.model.model 
    626         pars = enumerate(sasmodel.getParamList()) 
    627         msg1 = "[Iteration #: %s ]" % self.iterations 
    628         msg3 = "=== goodness of fit: %s ===" % (str(self.fitness)) 
    629         msg2 = ["P%-3d  %s......|.....%s" % (i, v, sasmodel.getParam(v)) 
    630                 for i,v in pars if v in self.param_list] 
    631         msg = [msg1, msg3] + msg2 
    632         return "\n".join(msg) 
     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 
    633819     
    634820    def print_summary(self): 
    635821        """ 
    636822        """ 
    637         print str(self) 
     823        print self 

  • src/sans/fit/Fitting.py

    re3efa6b3 r5777106  
    88from sans.fit.ScipyFitting import ScipyFit 
    99from sans.fit.ParkFitting import ParkFit 
    10 from sans.fit.BumpsFitting import BumpsFit 
    1110 
    12 ENGINES={ 
    13     'scipy': ScipyFit, 
    14     'park': ParkFit, 
    15     'bumps': BumpsFit, 
    16 } 
    1711 
    1812class Fit(object): 
    … …  
    3226         
    3327    """   
    34     def __init__(self, engine='scipy', *args, **kw): 
     28    def __init__(self, engine='scipy'): 
    3529        """ 
    3630        """ 
    … …  
    3832        self._engine = None 
    3933        self.fitter_id = None 
    40         self.set_engine(engine, *args, **kw) 
     34        self.set_engine(engine) 
    4135           
    4236    def __setattr__(self, name, value): 
    … …  
    5549            self.__dict__[name] = value 
    5650                 
    57     def set_engine(self, word, *args, **kw): 
     51    def set_engine(self, word): 
    5852        """ 
    5953        Select the type of Fit  
    … …  
    6559              
    6660        """ 
    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") 
     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" 
    7167 
    7268    def fit(self, msg_q=None, q=None, handler=None,  

  • src/sans/fit/Loader.py

    r6fe5100 r5777106  
    88    This class is loading values from given file or value giving by the user 
    99    """ 
     10     
    1011    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

    r8d074d9 r9d6d5ba  
    2424from sans.fit.AbstractFitEngine import FitEngine 
    2525from sans.fit.AbstractFitEngine import FResult 
    26  
    27 class 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  
    100 class 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  
     26   
    17827class SansFitResult(fitresult.FitResult): 
    17928    def __init__(self, *args, **kwrds): 
    … …  
    395244        return fitpars 
    396245     
    397     def extend_results_with_calculated_parameters(self, result): 
     246    def all_results(self, result): 
    398247        """ 
    399248        Extend result from the fit with the calculated parameters. 
    … …  
    443292                # dividing residuals by N in order to be consistent with Scipy 
    444293                m.chisq = numpy.sum(m.residuals**2/N)  
    445                 resid.append(m.weight*m.residuals) 
     294                resid.append(m.weight*m.residuals/math.sqrt(N)) 
    446295        self.residuals = numpy.hstack(resid) 
    447296        N = len(self.residuals) 
    448297        self.degrees_of_freedom = N-k if N>k else 1 
    449298        self.chisq = numpy.sum(self.residuals**2) 
    450         return self.chisq/self.degrees_of_freedom 
     299        return self.chisq 
    451300     
    452301class ParkFit(FitEngine): 
    … …  
    505354            if fproblem.get_to_fit() == 1: 
    506355                fitproblems.append(fproblem) 
    507         if len(fitproblems) == 0: 
     356        if len(fitproblems) == 0:  
    508357            raise RuntimeError, "No Assembly scheduled for Park fitting." 
     358            return 
    509359        for item in fitproblems: 
    510             model = item.get_model() 
    511             parkmodel = ParkModel(model.model, model.data) 
    512             parkmodel.pars = item.pars 
     360            parkmodel = item.get_model() 
    513361            if reset_flag: 
    514362                # reset the initial value; useful for batch 
    … …  
    516364                    ind = item.pars.index(name) 
    517365                    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)) 
    522366             
    523367            for p in parkmodel.parameterset: 
    524368                ## does not allow status change for constraint parameters 
    525369                if p.status != 'computed': 
    526                     if p.get_name() in item.pars: 
     370                    if p.get_name()in item.pars: 
    527371                        ## make parameters selected for  
    528372                        #fit will be between boundaries 
    … …  
    539383    def fit(self, msg_q=None,  
    540384            q=None, handler=None, curr_thread=None,  
    541             ftol=1.49012e-8, reset_flag=False): 
     385                                        ftol=1.49012e-8, reset_flag=False): 
    542386        """ 
    543387        Performs fit with park.fit module.It can  perform fit with one model 
    … …  
    563407        localfit = SansFitSimplex() 
    564408        localfit.ftol = ftol 
    565         localfit.xtol = 1e-6 
    566  
     409         
    567410        # See `park.fitresult.FitHandler` for details. 
    568411        fitter = SansFitMC(localfit=localfit, start_points=1) 
    … …  
    573416        try: 
    574417            result = fit.fit(self.problem, fitter=fitter, handler=handler) 
    575             self.problem.extend_results_with_calculated_parameters(result) 
     418            self.problem.all_results(result) 
    576419             
    577420        except LinAlgError: 
    578421            raise ValueError, "SVD did not converge" 
    579  
    580         if result is None: 
    581             raise RuntimeError("park did not return a fit result") 
    582422     
    583423        for m in self.problem.parts: 
    … …  
    587427            small_result.theory = theory 
    588428            small_result.residuals = residuals 
    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  
     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) 
    611447            result_list.append(small_result)     
    612448        if q != None: 

  • src/sans/fit/ScipyFitting.py

    r8d074d9 r5777106  
     1 
     2 
    13""" 
    24ScipyFitting module contains FitArrange , ScipyFit, 
    … …  
    46simple fit with scipy optimizer. 
    57""" 
     8 
     9import numpy  
    610import sys 
    7 import copy 
    8  
    9 import numpy  
     11 
    1012 
    1113from sans.fit.AbstractFitEngine import FitEngine 
    12 from sans.fit.AbstractFitEngine import FResult 
    13  
    14 class 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 
     14from sans.fit.AbstractFitEngine import SansAssembly 
     15from sans.fit.AbstractFitEngine import FitAbort 
     16from sans.fit.AbstractFitEngine import Model 
     17from sans.fit.AbstractFitEngine import FResult  
    13818 
    13919class ScipyFit(FitEngine): 
    … …  
    17050        """ 
    17151        FitEngine.__init__(self) 
     52        self.fit_arrange_dict = {} 
     53        self.param_list = [] 
    17254        self.curr_thread = None 
    17355    #def fit(self, *args, **kw): 
    … …  
    18668            msg = "Scipy can't fit more than a single fit problem at a time." 
    18769            raise RuntimeError, msg 
    188         elif len(fitproblem) == 0 : 
     70            return 
     71        elif len(fitproblem) == 0 :  
    18972            raise RuntimeError, "No Assembly scheduled for Scipy fitting." 
     73            return 
    19074        model = fitproblem[0].get_model() 
    19175        if reset_flag: 
    … …  
    20387         
    20488        # Check the initial value if it is within range 
    205         _check_param_range(model.model, self.param_list) 
    206          
    207         result = FResult(model=model.model, data=data, param_list=self.param_list) 
     89        self._check_param_range(model) 
     90         
     91        result = FResult(model=model, data=data, param_list=self.param_list) 
     92        result.pars = fitproblem[0].pars 
    20893        result.fitter_id = self.fitter_id 
    20994        if handler is not None: 
    21095            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) 
    21896        try: 
    21997            # This import must be here; otherwise it will be confused when more 
    … …  
    22199            from scipy import optimize 
    222100             
     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) 
    223108            out, cov_x, _, mesg, success = optimize.leastsq(functor, 
    224109                                            model.get_params(self.param_list), 
    225                                             ftol=ftol, 
    226                                             full_output=1) 
     110                                                    ftol=ftol, 
     111                                                    full_output=1) 
    227112        except: 
    228113            if hasattr(sys, 'last_type') and sys.last_type == KeyboardInterrupt: 
    … …  
    257142 
    258143         
    259 def _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  
    282 def _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  
     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     
    290198     
    291199#def profile(fn, *args, **kw): 

  • src/sans/fit/__init__.py

    r6fe5100 r5777106  
    1 from .AbstractFitEngine import FitHandler 

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

    r116e1a7 r116e1a7  
    835835            infor = "warning" 
    836836        else: 
    837             msg = "Error occured: " 
    838             msg += "No valid parameter values to paste from the clipboard..." 
     837            msg = "Error was 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 points in Q range!!!  " 
     2201                    msg = "Cannot Plot :No npts in that Qrange!!!  " 
    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 points in Q range!!!  " 
     2258                    msg = "Cannot Plot :No npts in that Qrange!!!  " 
    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 = "Data Error: " 
    2434                 msg += "Too few points in %s." % data.name 
     2433                msg = "Npts of Data Error :" 
     2434                msg += "No or too little npts of %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 = "Data Error: " 
    2469                 msg += "Too few points in %s." % data.name 
     2468                msg = "Npts of Data Error :" 
     2469                msg += "No or too little npts of %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)) 

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

    r644ca73 r5777106  
    55import time 
    66import wx 
    7 from sans.fit import FitHandler 
     7import park 
     8from park.fitresult import FitHandler 
    89 
    910class ConsoleUpdate(FitHandler): 
    … …  
    8788        Print result object 
    8889        """ 
    89         msg = " \n %s \n" % str(self.result) 
     90        msg = " \n %s \n" % self.result.__str__() 
    9091        wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    9192                      
    … …  
    136137        self.fit_duration += self.elapsed_time 
    137138        str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1)) 
    138         UPDATE_INTERVAL = 5.0 
     139        UPDATE_INTERVAL = 0.5 
    139140        u_flag = False 
    140141        if self.fit_duration >= UPDATE_INTERVAL: 

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

    re3efa6b3 ra855fec  
    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, 
    33                  completefn, 
     32        CalcThread.__init__(self,completefn, 
    3433                 updatefn, 
    3534                 yieldtime, 
    … …  
    8180                list_map_get_attr.append(map_getattr) 
    8281            #from multiprocessing import Pool 
    83             inputs = zip(list_map_get_attr, self.fitter, list_fit_function, 
    84                          list_q, list_q, list_handler,list_curr_thread,list_ftol, 
     82            inputs = zip(list_map_get_attr,self.fitter, list_fit_function, 
     83                          list_q, list_q, list_handler,list_curr_thread,list_ftol, 
    8584                         list_reset_flag) 
    8685            result =  map(map_apply, inputs) 
    … …  
    8887            self.complete(result=result, 
    8988                          batch_inputs=self.batch_inputs, 
    90                           batch_outputs=self.batch_outputs, 
     89                           batch_outputs=self.batch_outputs, 
    9190                          page_id=self.page_id, 
    9291                          pars = self.pars, 

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

    r4e9f227 rd44648e  
    661661                          wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    662662         
    663         if self.engine_type in ("park","bumps"): 
     663        if self.engine_type == "park": 
    664664            self.text_disp_max.Show(True) 
    665665            self.text_disp_min.Show(True) 
    … …  
    738738                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    739739 
    740                         if self.engine_type in ("park","bumps"): 
     740                        if self.engine_type == "park": 
    741741                            ctl3.Show(True) 
    742742                            ctl4.Show(True) 
    … …  
    10051005            return 
    10061006 
    1007         if (len(self._manager.fit_thread_list) > 0 
    1008                 and self._manager._fit_engine not in ("park","bumps") 
    1009                 and self._manager.sim_page != None 
    1010                 and self._manager.sim_page.uid == self.uid): 
     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: 
    10111011            msg = "The FitEnging will be set to 'ParkMC'\n" 
    10121012            msg += " to fit with more than one data set..." 
    … …  
    21082108        if chisqr != None and numpy.isfinite(chisqr): 
    21092109            #format chi2 
    2110             if self.engine_type in ("park","bumps"): 
     2110            if self.engine_type == "park": 
    21112111                npt_fit = float(self.get_npts2fit()) 
    21122112            chi2 = format_number(chisqr, True) 

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

    r5777106 r5777106  
    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

    r4e9f227 r767514a  
    3636from .fitproblem import FitProblemDictionary 
    3737from .fitpanel import FitPanel 
    38 from .resultpanel import ResultPanel, PlotResultEvent 
    39  
    4038from .fit_thread import FitThread 
    4139from .pagestate import Reader 
    … …  
    113111        self.scipy_id = wx.NewId() 
    114112        self.park_id = wx.NewId() 
    115         self.bumps_id = wx.NewId() 
    116113        self.menu1 = None 
    117114        self.new_model_frame = None 
    … …  
    201198        wx.EVT_MENU(owner, self.park_id, self._onset_engine_park) 
    202199         
    203         bumps_help = "Bumps: fitting and uncertainty analysis. More in Help window...." 
    204         self.menu1.AppendCheckItem(self.bumps_id, "Bumps fit", 
    205                                    bumps_help) 
    206         wx.EVT_MENU(owner, self.bumps_id, self._onset_engine_bumps) 
    207          
    208200        self.menu1.FindItemById(self.scipy_id).Check(True) 
    209201        self.menu1.FindItemById(self.park_id).Check(False) 
    210         self.menu1.FindItemById(self.bumps_id).Check(False) 
    211202        self.menu1.AppendSeparator() 
    212203        self.id_tol = wx.NewId() 
    … …  
    216207                                   ftol_help) 
    217208        wx.EVT_MENU(owner, self.id_tol, self.show_ftol_dialog) 
    218  
    219         self.id_bumps_options = wx.NewId() 
    220         bopts_help = "Bumps fitting options" 
    221         self.menu1.Append(self.id_bumps_options, 'Bumps &Options', bopts_help) 
    222         wx.EVT_MENU(owner, self.id_bumps_options, self.on_bumps_options) 
    223         self.bumps_options_menu = self.menu1.FindItemById(self.id_bumps_options) 
    224         self.bumps_options_menu.Enable(True) 
    225  
    226         self.id_result_panel = wx.NewId() 
    227         self.menu1.Append(self.id_result_panel, "Fit Results", "Show fit results panel") 
    228         wx.EVT_MENU(owner, self.id_result_panel, lambda ev: self.result_frame.Show()) 
    229209        self.menu1.AppendSeparator() 
    230210         
    … …  
    531511        self.perspective = [] 
    532512        self.perspective.append(self.fit_panel.window_name) 
    533  
    534         self.result_frame = MDIFrame(self.parent, None, ResultPanel.window_caption, (220, 200)) 
    535         self.result_panel = ResultPanel(parent=self.result_frame, manager=self) 
    536         self.perspective.append(self.result_panel.window_name) 
    537513        
    538514        #index number to create random model name 
    … …  
    549525        #Send the fitting panel to guiframe 
    550526        self.mypanels.append(self.fit_panel) 
    551         self.mypanels.append(self.result_panel) 
    552527        return self.mypanels 
    553528     
    … …  
    843818                         StatusEvent(status=msg, info='warning')) 
    844819        dialog.Destroy() 
    845  
    846     def on_bumps_options(self, event=None): 
    847         from bumps.gui.fit_dialog import OpenFitOptions 
    848         OpenFitOptions() 
    849820 
    850821    def stop_fit(self, uid): 
    … …  
    988959        self._gui_engine = self._return_engine_type() 
    989960        self.fitproblem_count = fitproblem_count 
    990         if self._fit_engine in ("park","bumps"): 
     961        if self._fit_engine == "park": 
    991962            engineType = "Simultaneous Fit" 
    992963        else: 
    … …  
    999970            #simulatanous fit only one engine need to be created 
    1000971            ## if simultaneous fit change automatically the engine to park 
    1001             if self._fit_engine not in ("park","bumps"): 
    1002                 self._on_change_engine(engine='park') 
     972            self._on_change_engine(engine='park') 
    1003973            sim_fitter = Fit(self._fit_engine) 
    1004974            sim_fitter.fitter_id = self.sim_page.uid 
    … …  
    1008978             
    1009979        self.fitproblem_count = fitproblem_count 
    1010         if self._fit_engine in ("park","bumps"): 
     980        if self._fit_engine == "park": 
    1011981            engineType = "Simultaneous Fit" 
    1012982        else: 
    … …  
    16011571        wx.PostEvent(self.parent, StatusEvent(status=msg, info="info", 
    16021572                                                      type="stop")) 
    1603         wx.PostEvent(self.result_panel, PlotResultEvent(result=result)) 
    16041573        # reset fit_engine if changed by simul_fit 
    16051574        if self._fit_engine != self._gui_engine: 
    … …  
    17131682        self._on_change_engine('scipy') 
    17141683        
    1715     def _onset_engine_bumps(self, event): 
    1716         """  
    1717         set engine to bumps 
    1718         """ 
    1719         self._on_change_engine('bumps') 
    1720         
    17211684    def _on_slicer_event(self, event): 
    17221685        """ 
    … …  
    17701733            self.menu1.FindItemById(self.park_id).Check(True) 
    17711734            self.menu1.FindItemById(self.scipy_id).Check(False) 
    1772             self.menu1.FindItemById(self.bumps_id).Check(False) 
    1773         elif engine == "scipy": 
     1735        else: 
    17741736            self.menu1.FindItemById(self.park_id).Check(False) 
    17751737            self.menu1.FindItemById(self.scipy_id).Check(True) 
    1776             self.menu1.FindItemById(self.bumps_id).Check(False) 
    1777         else: 
    1778             self.menu1.FindItemById(self.park_id).Check(False) 
    1779             self.menu1.FindItemById(self.scipy_id).Check(False) 
    1780             self.menu1.FindItemById(self.bumps_id).Check(True) 
    17811738        ## post a message to status bar 
    17821739        msg = "Engine set to: %s" % self._fit_engine 

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

    r4e9f227 r5777106  
    152152        ## making sure all parameters content a constraint 
    153153        ## validity of the constraint expression is own by fit engine 
    154         if self.parent._manager._fit_engine not in ("park","bumps") and flag: 
     154        if self.parent._manager._fit_engine != "park" and flag: 
    155155            msg = "The FitEnging will be set to 'Park' fit engine\n" 
    156156            msg += " for the simultaneous fit..." 
    … …  
    378378        box_description = wx.StaticBox(self, -1,"Easy Setup ") 
    379379        boxsizer = wx.StaticBoxSizer(box_description, wx.HORIZONTAL)      
    380         sizer_constraint = wx.BoxSizer(wx.HORIZONTAL) 
     380        sizer_constraint = wx.BoxSizer(wx.HORIZONTAL|wx.LEFT|wx.RIGHT|wx.EXPAND) 
    381381        self.model_cbox_left = wx.ComboBox(self, -1, style=wx.CB_READONLY) 
    382382        self.model_cbox_left.Clear() 

  • test/park_integration/test/batch_fit.py

    re3efa6b3 r5777106  
     1 
     2 
     3import math 
     4import numpy 
    15import copy 
    26import time 
    … …  
    1115 
    1216 
     17 
     18     
    1319def classMapper(classInstance, classFunc, *args): 
    1420    """ 
    … …  
    2228 
    2329 
    24 class BatchFit: 
     30 
     31class BatchScipyFit: 
    2532    """ 
    2633    test fit module 
    … …  
    6269            model.setParam('cyl_phi.npts', 3) 
    6370            model.setParam('cyl_theta.nsigmas', 10) 
    64             # for 2 data cyl_theta = 60.0 [deg] cyl_phi= 60.0 [deg] 
     71            """ for 2 data cyl_theta = 60.0 [deg] cyl_phi= 60.0 [deg]""" 
    6572            fitter.set_model(model, i, self.param_to_fit,  
    6673                             self.list_of_constraints) 
    … …  
    7784            self.list_of_mapper.append(classMapper) 
    7885                    
    79     def reset_value(self, engine='scipy'): 
     86    def reset_value(self): 
    8087        """ 
    8188        Initialize inputs for the map function 
    … …  
    8693        self.list_of_constraints = [] 
    8794        self.list_of_mapper = [] 
    88  
     95        engine ="scipy" 
     96         
    8997        path = "testdata_line3.txt" 
    9098        self._reset_helper(path=path, engine=engine, npts=NPTS) 
    … …  
    105113         
    106114       
    107     def test_map_fit(self, n=0): 
     115    def test_map_fit(self): 
    108116        """ 
    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 
     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 
    117122         
    118123    def test_process_map_fit(self, n=1): 
    … …  
    139144    """   
    140145    def setUp(self): 
    141         self.test = BatchFit(qmin=None, qmax=None) 
     146        self.test = BatchScipyFit(qmin=None, qmax=None) 
    142147        
    143148     
    144     def test_fit1(self): 
     149    def __test_fit1(self): 
    145150        """test fit with python built in map function---- full range of each data""" 
    146151        self.test.test_map_fit() 
    147152         
    148     def test_fit2(self): 
     153    def __test_fit2(self): 
    149154        """test fit with python built in map function---- common range for all data""" 
    150155        self.test.set_range(qmin=0.013, qmax=0.05) 
    151156        self.test.reset_value() 
    152157        self.test.test_map_fit() 
    153         raise Exception("fail") 
    154158         
    155159    def test_fit3(self): 
    … …  
    157161        self.test.set_range(qmin=None, qmax=None) 
    158162        self.test.reset_value() 
    159         self.test.test_map_fit(n=1) 
     163        self.test.test_process_map_fit(n=2) 
    160164         
    161165    def test_fit4(self): 
    … …  
    163167        self.test.set_range(qmin=-1, qmax=10) 
    164168        self.test.reset_value() 
    165         self.test.test_map_fit(n=3) 
     169        self.test.test_process_map_fit(n=1) 
    166170         
    167171             

  • test/run_one.py

    r76f132a r95fb3e8  
    11#!/usr/bin/env python 
    2  
    32import os 
    43import sys 
    … …  
    98 
    109run_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(abspath(sys.argv[1])) 
    15 print "=== testing:",sys.argv[1] 
     14test_path,test_file = splitpath(sys.argv[1]) 
     15print "test file",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.