Changeset 786685e in sasview for test


Ignore:
Timestamp:
May 15, 2014 5:08:38 PM (10 years ago)
Author:
pkienzle
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
4a0dc427
Parents:
4e9f227 (diff), bb1b892 (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

Location:
test
Files:
3 edited
5 moved

Legend:

Unmodified
Added
Removed

  • test/sansdataloader/test/utest_cansas.py

    r2e3b055 rac5b69d  
    55warnings.simplefilter("ignore") 
    66 
    7 import unittest 
    8 import numpy 
    97import sans.dataloader.readers.cansas_reader as cansas 
    108from sans.dataloader.loader import Loader 
    … …  
    1210from sans.dataloader.readers.xml_reader import XMLreader 
    1311from sans.dataloader.readers.cansas_reader import Reader 
    14 from sans.dataloader.readers.cansas_constants import cansasConstants 
     12from sans.dataloader.readers.cansas_constants import CansasConstants 
    1513 
    1614import os 
    … …  
    1816import urllib2 
    1917import StringIO 
     18import pylint as pylint 
     19import unittest 
     20import numpy 
    2021 
    2122from lxml import etree 
    2223from xml.dom import minidom 
    2324  
    24 CANSAS_FORMAT = cansasConstants.CANSAS_FORMAT 
    25 CANSAS_NS = cansasConstants.CANSAS_NS 
     25CANSAS_FORMAT = CansasConstants.CANSAS_FORMAT 
     26CANSAS_NS = CansasConstants.CANSAS_NS 
    2627     
    2728class cansas_reader(unittest.TestCase): 
    … …  
    7273    def test_real_xml(self): 
    7374        reader = XMLreader(self.xml_valid, self.schema_1_0) 
    74         valid = reader.validateXML() 
     75        valid = reader.validate_xml() 
    7576        if valid: 
    7677            self.assertTrue(valid) 
    … …  
    101102        filename = "isis_1_1_write_test.xml" 
    102103        xmlreader = XMLreader(self.isis_1_1, self.schema_1_1) 
    103         valid = xmlreader.validateXML() 
    104         xmlreader.setProcessingInstructions() 
     104        valid = xmlreader.validate_xml() 
     105        xmlreader.set_processing_instructions() 
    105106        self.assertTrue(valid) 
    106107        fo = open(self.isis_1_1) 
    … …  
    126127    def test_double_trans_spectra(self): 
    127128        xmlreader = XMLreader(self.isis_1_1_doubletrans, self.schema_1_1) 
    128         self.assertTrue(xmlreader.validateXML()) 
     129        self.assertTrue(xmlreader.validate_xml()) 
    129130        reader = Loader() 
    130131        data = reader.load(self.isis_1_1_doubletrans) 
    … …  
    146147        valid = [] 
    147148        reader1 = XMLreader(self.xml_valid, self.schema_1_0) 
    148         self.assertTrue(reader1.validateXML()) 
     149        self.assertTrue(reader1.validate_xml()) 
    149150        reader2 = XMLreader(self.xml_invalid, self.schema_1_0) 
    150         self.assertFalse(reader2.validateXML()) 
     151        self.assertFalse(reader2.validate_xml()) 
    151152        reader3 = XMLreader(self.xml_valid, self.schema_1_1) 
    152         self.assertFalse(reader3.validateXML()) 
     153        self.assertFalse(reader3.validate_xml()) 
    153154        reader4 = XMLreader(self.xml_invalid, self.schema_1_1) 
    154         self.assertFalse(reader4.validateXML()) 
     155        self.assertFalse(reader4.validate_xml()) 
    155156        reader5 = XMLreader(self.isis_1_0, self.schema_1_0) 
    156         self.assertTrue(reader5.validateXML()) 
     157        self.assertTrue(reader5.validate_xml()) 
    157158        reader6 = XMLreader(self.isis_1_1, self.schema_1_1) 
    158         self.assertTrue(reader6.validateXML()) 
     159        self.assertTrue(reader6.validate_xml()) 
    159160        reader7 = XMLreader(self.isis_1_1, self.schema_1_0) 
    160         self.assertFalse(reader7.validateXML()) 
     161        self.assertFalse(reader7.validate_xml()) 
    161162         
    162163        
    163164    def test_old_cansas_files(self): 
    164165        reader1 = XMLreader(self.cansas1d, self.schema_1_0) 
    165         self.assertTrue(reader1.validateXML()) 
     166        self.assertTrue(reader1.validate_xml()) 
    166167        file_loader = Loader() 
    167168        file1 = file_loader.load(self.cansas1d) 
    168169        reader2 = XMLreader(self.cansas1d_units, self.schema_1_0) 
    169         self.assertTrue(reader2.validateXML()) 
     170        self.assertTrue(reader2.validate_xml()) 
    170171        reader3 = XMLreader(self.cansas1d_badunits, self.schema_1_0) 
    171         self.assertTrue(reader3.validateXML()) 
     172        self.assertTrue(reader3.validate_xml()) 
    172173        reader4 = XMLreader(self.cansas1d_slit, self.schema_1_0) 
    173         self.assertTrue(reader4.validateXML()) 
     174        self.assertTrue(reader4.validate_xml()) 
    174175         
    175176     
    … …  
    177178        filename = "isis_1_0_write_test.xml" 
    178179        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0) 
    179         valid = xmlreader.validateXML() 
     180        valid = xmlreader.validate_xml() 
    180181        self.assertTrue(valid) 
    181182        reader_generic = Loader() 
    … …  
    191192            written_data = return_data[0] 
    192193            xmlwrite = XMLreader(filename, self.schema_1_0) 
    193             valid = xmlreader.validateXML() 
     194            valid = xmlreader.validate_xml() 
    194195            self.assertTrue(valid) 
    195196            self._check_data(written_data) 
    … …  
    198199    def test_processing_instructions(self): 
    199200        reader = XMLreader(self.isis_1_1, self.schema_1_1) 
    200         valid = reader.validateXML() 
     201        valid = reader.validate_xml() 
    201202        if valid: 
    202203            ## find the processing instructions and make into a dictionary 
    203             dic = self.getProcessingInstructions(reader) 
     204            dic = self.get_processing_instructions(reader) 
    204205            self.assertTrue(dic == {'xml-stylesheet': 'type="text/xsl" href="cansas1d.xsl" '}) 
    205206             
    … …  
    208209             
    209210            ## take the processing instructions and put them back in 
    210             xmldoc = self.setProcessingInstructions(xmldoc, dic) 
     211            xmldoc = self.set_processing_instructions(xmldoc, dic) 
    211212            xml_output = xmldoc.toprettyxml() 
    212213             
    213214     
    214     def setProcessingInstructions(self, minidomObject, dic): 
    215         xmlroot = minidomObject.firstChild 
     215    def set_processing_instructions(self, minidom_object, dic): 
     216        xmlroot = minidom_object.firstChild 
    216217        for item in dic: 
    217             pi = minidomObject.createProcessingInstruction(item, dic[item]) 
    218             minidomObject.insertBefore(pi, xmlroot) 
    219         return minidomObject 
    220      
    221      
    222     def getProcessingInstructions(self, XMLreaderObject): 
     218            pi = minidom_object.createProcessingInstruction(item, dic[item]) 
     219            minidom_object.insertBefore(pi, xmlroot) 
     220        return minidom_object 
     221     
     222     
     223    def get_processing_instructions(self, xml_reader_object): 
    223224        dict = {} 
    224         pi = XMLreaderObject.xmlroot.getprevious() 
     225        pi = xml_reader_object.xmlroot.getprevious() 
    225226        i = 0 
    226227        while pi is not None: 

  • 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 r4e9f227  
    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, ['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.