Changeset 85a3b46 in sasview


Ignore:
Timestamp:
May 19, 2014 5:31:28 PM (11 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:
233c121
Parents:
eff93b8 (diff), 69ef722 (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:

merge from trunk

Files:
3 added
27 edited
5 moved

Legend:

Unmodified
Added
Removed

  • sansview/README.txt

    r7a67f4da r69ef722  
    66    - The GUI look and feel has been refactored to be more familiar for Windows 
    77      users by using MDI frames. Graph windows are also now free-floating 
    8     - Four new models have been added: CoreShellEllipsoidXTModel, 
     8    - Five new models have been added: PringlesModel, CoreShellEllipsoidXTModel, 
    99      RectangularPrismModel, RectangularHollowPrismModel and  
    1010      RectangularHollowPrismInfThinWallsModel 
    1111    - The data loader now supports ILL DAT data files and reads the full meta  
    1212      information from canSAS file formats 
    13     - Redefined angles of angular parameters for anisotropic models 
     13    - Redefined convention for specifying angular parameters for anisotropic models 
    1414    - A number of minor features have been added such as permitting a log  
    1515      distribution of points when using a model to simulate data, and the  

  • sansview/default_categories.json

    r02cc1ea ree60435  
    1 {"Shapes": [["PearlNecklaceModel", true], ["HollowCylinderModel", true], ["CoreMultiShellModel", true], ["FCCrystalModel", true], ["FuzzySphereModel", true], ["CSParallelepipedModel", true], ["EllipticalCylinderModel", true], ["BCCrystalModel", true], ["LamellarFFHGModel", true], ["RectangularHollowPrismInfThinWallsModel", true], ["LamellarPCrystalModel", true], ["OnionExpShellModel", true], ["VesicleModel", true], ["MultiShellModel", true], ["RaspBerryModel", true], ["CoreShellEllipsoidModel", true], ["CoreShellEllipsoidXTModel", true], ["CappedCylinderModel", true], ["CylinderModel", true], ["SphericalSLDModel", true], ["StackedDisksModel", true], ["LamellarPSHGModel", true], ["CoreShellBicelleModel", true], ["RectangularHollowPrismModel", true], ["LamellarPSModel", true], ["EllipsoidModel", true], ["SphereModel", true], ["ParallelepipedModel", true], ["TriaxialEllipsoidModel", true], ["LamellarModel", true], ["RectangularPrismModel", true], ["BarBellModel", true], ["CoreShellCylinderModel", true], ["BinaryHSModel", true], ["FlexibleCylinderModel", true], ["SCCrystalModel", true], ["FlexCylEllipXModel", true], ["LinearPearlsModel", true], ["CoreShellModel", true]], "Structure Factor": [["SquareWellStructure", true], ["HayterMSAStructure", true], ["HardsphereStructure", true], ["StickyHSStructure", true]], "Shape-Independent": [["TwoPowerLawModel", true], ["GelFitModel", true], ["DABModel", true], ["PowerLawAbsModel", true], ["PorodModel", true], ["MassFractalModel", true], ["RPA10Model", true], ["TeubnerStreyModel", true], ["BEPolyelectrolyte", true], ["DebyeModel", true], ["MassSurfaceFractal", true], ["Core2ndMomentModel", true], ["TwoLorentzianModel", true], ["UnifiedPowerRgModel", true], ["PolymerExclVolume", true], ["GuinierModel", true], ["GuinierPorodModel", true], ["CorrLengthModel", true], ["StarPolymer", true], ["FractalModel", true], ["PeakLorentzModel", true], ["BroadPeakModel", true], ["PeakGaussModel", true], ["FractalCoreShellModel", true], ["Poly_GaussCoil", true], ["SurfaceFractalModel", true], ["GaussLorentzGelModel", true], ["LorentzModel", true]], "Uncategorized": [["ReflectivityModel", true], ["ReflectivityIIModel", true], ["PringlesModel", true], ["LineModel", true]]} 
     1{"Shapes": [["PearlNecklaceModel", true], ["HollowCylinderModel", true], ["CoreMultiShellModel", true], ["FCCrystalModel", true], ["FuzzySphereModel", true], ["CSParallelepipedModel", true], ["EllipticalCylinderModel", true], ["BCCrystalModel", true], ["LamellarFFHGModel", true], ["RectangularHollowPrismInfThinWallsModel", true], ["LamellarPCrystalModel", true], ["OnionExpShellModel", true], ["PringlesModel", true], ["VesicleModel", true], ["MultiShellModel", true], ["RaspBerryModel", true], ["CoreShellEllipsoidModel", true], ["CoreShellEllipsoidXTModel", true], ["CappedCylinderModel", true], ["CylinderModel", true], ["SphericalSLDModel", true], ["StackedDisksModel", true], ["LamellarPSHGModel", true], ["CoreShellBicelleModel", true], ["RectangularHollowPrismModel", true], ["LamellarPSModel", true], ["EllipsoidModel", true], ["SphereModel", true], ["ParallelepipedModel", true], ["TriaxialEllipsoidModel", true], ["LamellarModel", true], ["RectangularPrismModel", true], ["BarBellModel", true], ["CoreShellCylinderModel", true], ["BinaryHSModel", true], ["FlexibleCylinderModel", true], ["SCCrystalModel", true], ["FlexCylEllipXModel", true], ["LinearPearlsModel", true], ["CoreShellModel", true]], "Structure Factor": [["SquareWellStructure", true], ["HayterMSAStructure", true], ["HardsphereStructure", true], ["StickyHSStructure", true]], "Shape-Independent": [["TwoPowerLawModel", true], ["GelFitModel", true], ["DABModel", true], ["PowerLawAbsModel", true], ["PorodModel", true], ["MassFractalModel", true], ["RPA10Model", true], ["TeubnerStreyModel", true], ["BEPolyelectrolyte", true], ["DebyeModel", true], ["MassSurfaceFractal", true], ["Core2ndMomentModel", true], ["TwoLorentzianModel", true], ["UnifiedPowerRgModel", true], ["PolymerExclVolume", true], ["GuinierModel", true], ["GuinierPorodModel", true], ["CorrLengthModel", true], ["StarPolymer", true], ["FractalModel", true], ["PeakLorentzModel", true], ["BroadPeakModel", true], ["PeakGaussModel", true], ["FractalCoreShellModel", true], ["Poly_GaussCoil", true], ["SurfaceFractalModel", true], ["GaussLorentzGelModel", true], ["LorentzModel", true]], "Uncategorized": [["ReflectivityModel", true], ["ReflectivityIIModel", true], ["LineModel", true]]} 

  • src/sans/dataloader/readers/cansas_reader.py

    rbb1b892 r51af54b  
    860860        # If the calling function was not the cansas reader, return a minidom 
    861861        #      object rather than an lxml object.         
    862          
    863862        frm = inspect.stack()[1] 
    864863        mod_name = frm[1].replace("\\", "/").replace(".pyc", "") 
    865864        mod_name = mod_name.replace(".py", "") 
    866         mod = mod_name.split("/readers/") 
     865        mod = mod_name.split("sans/") 
    867866        mod_name = mod[1] 
    868         if mod_name != "cansas_reader": 
     867        if mod_name != "dataloader/readers/cansas_reader": 
    869868            string = self.to_string(doc, pp=False) 
    870869            doc = parseString(string) 

  • src/sans/guiframe/gui_manager.py

    ra3b635b r51af54b  
    19581958                wx.PostEvent(self, StatusEvent(status="Completed Saving.")) 
    19591959            else: 
    1960                 msg = "%s cannot read %s\n" % (str(APPLICATION_NAME), str(path)) 
     1960                msg = "No perspective windows are loaded. " 
     1961                msg += "No data was saved to %s\n" % (str(path)) 
    19611962                logging.error(msg) 
     1963                wx.PostEvent(self,StatusEvent(status=msg)) 
    19621964        except: 
    19631965            msg = "Error occurred while saving: " 

  • 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 r499639c  
    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 
    … …  
    4952    return mod 
    5053 
    51 def import_dll(modname): 
     54def import_dll(modname, build_path): 
    5255    """Import a DLL from the build directory""" 
     56    import sysconfig 
     57    ext = sysconfig.get_config_var('SO') 
    5358    # build_path comes from context 
    54     path = glob(joinpath(build_path, *modname.split('.'))+'.*')[0] 
     59    path = joinpath(build_path, *modname.split('.'))+ext 
    5560    #print "importing", modname, "from", path 
    5661    return imp.load_dynamic(modname, path) 
    … …  
    8186    except: addpath(joinpath(root, '..','periodictable')) 
    8287 
     88    try: import bumps 
     89    except: addpath(joinpath(root, '..','bumps')) 
     90 
    8391    # select wx version 
    8492    #addpath(os.path.join(root, '..','wxPython-src-3.0.0.0','wxPython')) 
    … …  
    107115    sans.pr.core = import_package('sans.pr.core', 
    108116                                  joinpath(build_path, 'sans', 'pr', 'core')) 
    109     #import_dll('park._modeling') 
     117    #import_dll('park._modeling', build_path) 
    110118 
    111119    #park = import_package('park',os.path.join(build_path,'park')) 
    … …  
    122130 
    123131if __name__ == "__main__": 
    124     # start sasview 
    125     #import multiprocessing 
    126     #multiprocessing.freeze_support() 
    127132    prepare() 
    128     from sans.sansview.sansview import SasView 
    129     SasView() 
     133    from sans.sansview.sansview import run 
     134    run() 

  • sansview/sansview.py

    re2271c5 r6fe5100  
    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    """ 
    … …  
    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        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() 
    124126 
    125     
     127if __name__ == "__main__": 
     128    run() 
     129 

  • sansview/setup_exe.py

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

  • setup.py

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

  • src/sans/fit/AbstractFitEngine.py

    r6c00702 r8d074d9  
    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): 
    … …  
    571421         
    572422        """ 
    573         if model == None: 
    574             raise ValueError, "AbstractFitEngine: Need to set model to fit" 
    575          
    576         new_model = model 
     423        if not pars: 
     424            raise ValueError("no fitting parameters") 
     425 
     426        if model is None: 
     427            raise ValueError("no model to fit") 
     428 
    577429        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      
     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 
    621449    def set_data(self, data, id, smearer=None, qmin=None, qmax=None): 
    622450        """ 
    … …  
    700528        self.vals = [] 
    701529        self.selected = 0 
    702          
     530 
    703531    def set_model(self, model): 
    704532        """ 
    … …  
    752580        """ 
    753581        return self.selected 
    754      
    755      
    756 IS_MAC = True 
    757 if sys.platform.count("win32") > 0: 
    758     IS_MAC = False 
    759  
    760582 
    761583class FResult(object): 
    … …  
    765587    def __init__(self, model=None, param_list=None, data=None): 
    766588        self.calls = None 
    767         self.pars = [] 
    768589        self.fitness = None 
    769590        self.chisqr = None 
    … …  
    776597        self.residuals = [] 
    777598        self.index = [] 
    778         self.parameters = None 
    779         self.is_mac = IS_MAC 
    780599        self.model = model 
    781600        self.data = data 
    … …  
    803622        if self.pvec == None and self.model is None and self.param_list is None: 
    804623            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 
     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) 
    819633     
    820634    def print_summary(self): 
    821635        """ 
    822636        """ 
    823         print self 
     637        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/perspectives/fitting/basepage.py

    r116e1a7 r5bf0331  
    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)) 

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

    r5777106 r644ca73  
    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                      
    … …  
    137136        self.fit_duration += self.elapsed_time 
    138137        str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1)) 
    139         UPDATE_INTERVAL = 0.5 
     138        UPDATE_INTERVAL = 5.0 
    140139        u_flag = False 
    141140        if self.fit_duration >= UPDATE_INTERVAL: 

  • 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 r4e9f227  
    661661                          wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    662662         
    663         if self.engine_type == "park": 
     663        if self.engine_type in ("park","bumps"): 
    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 == "park": 
     740                        if self.engine_type in ("park","bumps"): 
    741741                            ctl3.Show(True) 
    742742                            ctl4.Show(True) 
    … …  
    10051005            return 
    10061006 
    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: 
     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): 
    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 == "park": 
     2110            if self.engine_type in ("park","bumps"): 
    21112111                npt_fit = float(self.get_npts2fit()) 
    21122112            chi2 = format_number(chisqr, True) 

  • 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

    r767514a reff93b8  
    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 
    8388        #let fit ready 
    … …  
    8893        self.closed_page_dict = {} 
    8994        ## Fit engine 
    90         self._fit_engine = 'scipy' 
     95        self._fit_engine = 'bumps' 
    9196        self._gui_engine = None 
    9297        ## Relative error desired in the sum of squares (float); scipy only 
    … …  
    111116        self.scipy_id = wx.NewId() 
    112117        self.park_id = wx.NewId() 
     118        self.bumps_id = wx.NewId() 
    113119        self.menu1 = None 
    114120        self.new_model_frame = None 
    … …  
    198204        wx.EVT_MENU(owner, self.park_id, self._onset_engine_park) 
    199205         
    200         self.menu1.FindItemById(self.scipy_id).Check(True) 
    201         self.menu1.FindItemById(self.park_id).Check(False) 
     206        bumps_help = "Bumps: fitting and uncertainty analysis. More in Help window...." 
     207        self.menu1.AppendCheckItem(self.bumps_id, "Bumps fit", 
     208                                   bumps_help) 
     209        wx.EVT_MENU(owner, self.bumps_id, self._onset_engine_bumps) 
     210         
     211        self.menu1.FindItemById(self.scipy_id).Check(self._fit_engine=="scipy") 
     212        self.menu1.FindItemById(self.park_id).Check(self._fit_engine=="park") 
     213        self.menu1.FindItemById(self.bumps_id).Check(self._fit_engine=="bumps") 
    202214        self.menu1.AppendSeparator() 
    203215        self.id_tol = wx.NewId() 
    … …  
    207219                                   ftol_help) 
    208220        wx.EVT_MENU(owner, self.id_tol, self.show_ftol_dialog) 
     221 
     222        self.id_bumps_options = wx.NewId() 
     223        bopts_help = "Bumps fitting options" 
     224        self.menu1.Append(self.id_bumps_options, 'Bumps &Options', bopts_help) 
     225        wx.EVT_MENU(owner, self.id_bumps_options, self.on_bumps_options) 
     226        self.bumps_options_menu = self.menu1.FindItemById(self.id_bumps_options) 
     227        self.bumps_options_menu.Enable(True) 
     228 
     229        self.id_result_panel = wx.NewId() 
     230        self.menu1.Append(self.id_result_panel, "Fit Results", "Show fit results panel") 
     231        wx.EVT_MENU(owner, self.id_result_panel, lambda ev: self.result_frame.Show()) 
    209232        self.menu1.AppendSeparator() 
    210233         
    … …  
    511534        self.perspective = [] 
    512535        self.perspective.append(self.fit_panel.window_name) 
     536 
     537        self.result_frame = MDIFrame(self.parent, None, ResultPanel.window_caption, (220, 200)) 
     538        self.result_panel = ResultPanel(parent=self.result_frame, manager=self) 
     539        self.perspective.append(self.result_panel.window_name) 
    513540        
    514541        #index number to create random model name 
    … …  
    525552        #Send the fitting panel to guiframe 
    526553        self.mypanels.append(self.fit_panel) 
     554        self.mypanels.append(self.result_panel) 
    527555        return self.mypanels 
    528556     
    … …  
    818846                         StatusEvent(status=msg, info='warning')) 
    819847        dialog.Destroy() 
     848 
     849    def on_bumps_options(self, event=None): 
     850        from bumps.gui.fit_dialog import OpenFitOptions 
     851        OpenFitOptions() 
    820852 
    821853    def stop_fit(self, uid): 
    … …  
    957989            if value.get_scheduled() == 1: 
    958990                fitproblem_count += 1 
    959         self._gui_engine = self._return_engine_type() 
     991        # Remember the user selected fit engine before the fit.  Simultaneous 
     992        # fitting may change the selected engine, so it needs to be restored 
     993        # when the fit is complete. 
     994        self._gui_engine = self._fit_engine 
    960995        self.fitproblem_count = fitproblem_count 
    961         if self._fit_engine == "park": 
     996        if self._fit_engine in ("park","bumps"): 
    962997            engineType = "Simultaneous Fit" 
    963998        else: 
    … …  
    9701005            #simulatanous fit only one engine need to be created 
    9711006            ## if simultaneous fit change automatically the engine to park 
    972             self._on_change_engine(engine='park') 
     1007            if self._fit_engine not in ("park","bumps"): 
     1008                self._on_change_engine(engine='park') 
    9731009            sim_fitter = Fit(self._fit_engine) 
    9741010            sim_fitter.fitter_id = self.sim_page.uid 
    … …  
    9781014             
    9791015        self.fitproblem_count = fitproblem_count 
    980         if self._fit_engine == "park": 
     1016        if self._fit_engine in ("park","bumps"): 
    9811017            engineType = "Simultaneous Fit" 
    9821018        else: 
    … …  
    15711607        wx.PostEvent(self.parent, StatusEvent(status=msg, info="info", 
    15721608                                                      type="stop")) 
     1609        wx.PostEvent(self.result_panel, PlotResultEvent(result=result)) 
    15731610        # reset fit_engine if changed by simul_fit 
    15741611        if self._fit_engine != self._gui_engine: 
    … …  
    16821719        self._on_change_engine('scipy') 
    16831720        
     1721    def _onset_engine_bumps(self, event): 
     1722        """  
     1723        set engine to bumps 
     1724        """ 
     1725        self._on_change_engine('bumps') 
     1726        
    16841727    def _on_slicer_event(self, event): 
    16851728        """ 
    … …  
    17141757                break 
    17151758     
    1716     def _return_engine_type(self): 
    1717         """ 
    1718         return the current type of engine 
    1719         """ 
    1720         return self._fit_engine 
    1721       
    17221759    def _on_change_engine(self, engine='park'): 
    17231760        """ 
    … …  
    17331770            self.menu1.FindItemById(self.park_id).Check(True) 
    17341771            self.menu1.FindItemById(self.scipy_id).Check(False) 
     1772            self.menu1.FindItemById(self.bumps_id).Check(False) 
     1773        elif engine == "scipy": 
     1774            self.menu1.FindItemById(self.park_id).Check(False) 
     1775            self.menu1.FindItemById(self.scipy_id).Check(True) 
     1776            self.menu1.FindItemById(self.bumps_id).Check(False) 
    17351777        else: 
    17361778            self.menu1.FindItemById(self.park_id).Check(False) 
    1737             self.menu1.FindItemById(self.scipy_id).Check(True) 
     1779            self.menu1.FindItemById(self.scipy_id).Check(False) 
     1780            self.menu1.FindItemById(self.bumps_id).Check(True) 
    17381781        ## post a message to status bar 
    17391782        msg = "Engine set to: %s" % self._fit_engine 

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

    r5777106 r4e9f227  
    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 != "park" and flag: 
     154        if self.parent._manager._fit_engine not in ("park","bumps") 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|wx.LEFT|wx.RIGHT|wx.EXPAND) 
     380        sizer_constraint = wx.BoxSizer(wx.HORIZONTAL) 
    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

    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.