Changeset 5e903e8b in sasview for test/sasdataloader/test


Ignore:
Timestamp:
May 2, 2017 6:07:40 AM (7 years ago)
Author:
Paul Kienzle <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.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
e123eb9
Parents:
b290a9e (diff), 658dd57 (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 branch 'master' into log_binning

Location:
test/sasdataloader/test
Files:
1 added
3 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • test/sasdataloader/test/sequence_tests.py

    r959eb01 raaf5e49  
     1from __future__ import print_function 
     2 
    13from DataLoader.loader import Loader 
    24from DataLoader.readers.IgorReader import Reader as igor_reader 
    … …  
    810    out2 = Loader().load("MAR07232_rest.ASC") 
    911    if len(out2.detector)>1: 
    10         print "Consecutive reads using Loader failed" 
     12        print("Consecutive reads using Loader failed") 
    1113 
    1214def consecutive_reader(): 
    … …  
    1416    out2 = igor_reader().read("MAR07232_rest.ASC") 
    1517    if len(out2.detector)>1: 
    16         print "Consecutive reads using Readers failed" 
    17         print out1 
    18         print out2 
     18        print("Consecutive reads using Readers failed") 
     19        print(out1) 
     20        print(out2) 
    1921 
    2022def single_abs(): 
    … …  
    2931    single_igor() 
    3032    single_abs() 
    31     print "Test passed" 
     33    print("Test passed") 

  • test/sasdataloader/test/testplugings.py

    r959eb01 r17c9436  
    33""" 
    44 
     5import os 
    56import unittest 
    67from sas.sascalc.dataloader.loader import  Loader, Registry 
    … …  
    4142        # Create module 
    4243        import zipfile 
    43         z = zipfile.PyZipFile("plugins.zip", 'w') 
     44        f_name = "plugins.zip" 
     45        z = zipfile.PyZipFile(f_name, 'w') 
    4446        z.writepy("../plugins", "") 
    4547        z.close() 
     48        if os.path.isfile(f_name): 
     49            os.remove(f_name) 
    4650         
    4751    def testplugin_checksetup(self): 

  • test/sasdataloader/test/utest_abs_reader.py

    rdd11014 rc551bb3  
    22    Unit tests for data manipulations 
    33""" 
     4from __future__ import print_function 
    45 
    56import unittest 
    … …  
    89from sas.sascalc.dataloader.loader import Loader 
    910from sas.sascalc.dataloader.readers.IgorReader import Reader as IgorReader 
     11from sas.sascalc.dataloader.readers.abs_reader import Reader as AbsReader 
     12from sas.sascalc.dataloader.readers.hfir1d_reader import Reader as HFIRReader 
     13from sas.sascalc.dataloader.readers.danse_reader import Reader as DANSEReader 
     14from sas.sascalc.dataloader.readers.cansas_reader import Reader as CANSASReader 
     15 
    1016from sas.sascalc.dataloader.data_info import Data1D 
    1117  
    1218import os.path 
    1319 
     20 
    1421class abs_reader(unittest.TestCase): 
    1522     
    1623    def setUp(self): 
    17         from sas.sascalc.dataloader.readers.abs_reader import Reader 
    18         self.data = Reader().read("jan08002.ABS") 
    19          
     24        reader = AbsReader() 
     25        self.data = reader.read("jan08002.ABS") 
     26 
    2027    def test_abs_checkdata(self): 
    2128        """ 
    … …  
    6168    def test_checkdata2(self): 
    6269        self.assertEqual(self.data.dy[126], 1) 
    63          
     70 
     71    def test_generic_loader(self): 
     72        # the generic loader should work as well 
     73        data = Loader().load("jan08002.ABS") 
     74        self.assertEqual(data.meta_data['loader'], "IGOR 1D") 
     75 
     76 
    6477class hfir_reader(unittest.TestCase): 
    65      
     78 
    6679    def setUp(self): 
    67         self.data = Loader().load("S2-30dq.d1d") 
    68          
     80        reader = HFIRReader() 
     81        self.data = reader.read("S2-30dq.d1d") 
     82 
    6983    def test_hfir_checkdata(self): 
    7084        """ 
    … …  
    8397        self.assertEqual(self.data.dy[1], 0.000315) 
    8498        self.assertEqual(self.data.dx[1], 0.008249) 
    85          
     99 
     100    def test_generic_loader(self): 
     101        # the generic loader should work as well 
     102        data = Loader().load("S2-30dq.d1d") 
     103        self.assertEqual(data.meta_data['loader'], "HFIR 1D") 
     104 
    86105 
    87106class igor_reader(unittest.TestCase): 
    … …  
    137156     
    138157    def setUp(self): 
    139         self.data = Loader().load("MP_New.sans") 
     158        reader = DANSEReader() 
     159        self.data = reader.read("MP_New.sans") 
    140160 
    141161    def test_checkdata(self): 
    … …  
    171191        self.assertEqual(self.data.err_data[2], 2.06313) 
    172192 
     193    def test_generic_loader(self): 
     194        # the generic loader should work as well 
     195        data = Loader().load("MP_New.sans") 
     196        self.assertEqual(data.meta_data['loader'], "DANSE") 
     197 
    173198  
    174199class cansas_reader(unittest.TestCase): 
    175200     
    176201    def setUp(self): 
     202        reader = CANSASReader() 
     203        data = reader.read("cansas1d.xml") 
     204        self.data = data[0] 
     205 
     206    def test_generic_loader(self): 
     207        # the generic loader should work as well 
    177208        data = Loader().load("cansas1d.xml") 
    178         self.data = data[0] 
    179   
     209        self.assertEqual(data[0].meta_data['loader'], "CanSAS XML 1D") 
     210 
    180211    def test_cansas_checkdata(self): 
    181212        self.assertEqual(self.data.filename, "cansas1d.xml") 
    … …  
    190221            tests won't pass 
    191222        """ 
    192          
    193223        self.assertEqual(self.data.run[0], "1234") 
    194224        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    … …  
    264294            self.assertEqual(item.distance_unit,'mm') 
    265295 
    266             if item.size.x==50 \ 
    267                 and item.distance==11000.0 \ 
    268                 and item.name=='source' \ 
    269                 and item.type=='radius': 
     296            if item.size.x == 50 \ 
     297                and item.distance == 11000.0 \ 
     298                and item.name == 'source' \ 
     299                and item.type == 'radius': 
    270300                _found1 = True 
    271             elif item.size.x==1.0 \ 
    272                 and item.name=='sample' \ 
    273                 and item.type=='radius': 
     301            elif item.size.x == 1.0 \ 
     302                and item.name == 'sample' \ 
     303                and item.type == 'radius': 
    274304                _found2 = True 
    275305                 
    276         if _found1==False or _found2==False: 
     306        if _found1 == False or _found2 == False: 
    277307            raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2)  
    278308             
    … …  
    309339            self.assertTrue(item.date in ['04-Sep-2007 18:35:02', 
    310340                                          '03-SEP-2006 11:42:47']) 
    311             print item.term 
     341            print(item.term) 
    312342            for t in item.term: 
    313                 if t['name']=="ABS:DSTAND" \ 
    314                     and t['unit']=='mm' \ 
    315                     and float(t['value'])==1.0: 
     343                if (t['name'] == "ABS:DSTAND" 
     344                    and t['unit'] == 'mm' 
     345                    and float(t['value']) == 1.0): 
    316346                    _found_term2 = True 
    317                 elif t['name']=="radialstep" \ 
    318                     and t['unit']=='mm' \ 
    319                     and float(t['value'])==10.0: 
     347                elif (t['name'] == "radialstep" 
     348                      and t['unit'] == 'mm' 
     349                      and float(t['value']) == 10.0): 
    320350                    _found_term1 = True 
    321351                     
    322         if _found_term1==False or _found_term2==False: 
    323             raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2)  
    324              
    325          
    326          
     352        if _found_term1 == False or _found_term2 == False: 
     353            raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2) 
    327354         
    328355    def test_writer(self): 
    329         from sas.sascalc.dataloader.readers.cansas_reader import Reader 
    330         r = Reader() 
    331         x = np.ones(5) 
    332         y = np.ones(5) 
    333         dy = np.ones(5) 
    334          
     356        r = CANSASReader() 
     357 
    335358        filename = "write_test.xml" 
    336359        r.write(filename, self.data) 
    … …  
    339362        self.assertEqual(self.data.filename, filename) 
    340363        self._checkdata() 
     364        if os.path.isfile(filename): 
     365            os.remove(filename) 
    341366         
    342367    def test_units(self): 
    … …  
    346371        """ 
    347372        filename = "cansas1d_units.xml" 
    348         data = Loader().load(filename) 
     373        data = CANSASReader().read(filename) 
    349374        self.data = data[0] 
    350375        self.assertEqual(self.data.filename, filename) 
    … …  
    357382        """ 
    358383        filename = "cansas1d_badunits.xml" 
    359         data = Loader().load(filename) 
     384        data = CANSASReader().read(filename) 
    360385        self.data = data[0] 
    361386        self.assertEqual(self.data.filename, filename) 
    … …  
    366391         
    367392        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    368         print self.data.errors 
     393        print(self.data.errors) 
    369394        self.assertEqual(len(self.data.errors), 1) 
    370          
    371          
     395 
    372396    def test_slits(self): 
    373397        """ 
    … …  
    375399        """ 
    376400        filename = "cansas1d_slit.xml" 
    377         data = Loader().load(filename) 
     401        data = CANSASReader().read(filename) 
    378402        self.data = data[0] 
    379403        self.assertEqual(self.data.filename, filename) 
    … …  
    397421        self.assertEqual(self.data.run_name['1234'], 'run name') 
    398422        self.assertEqual(self.data.title, "Test title") 
    399          
    400              
     423 
    401424 
    402425if __name__ == '__main__': 

  • test/sasdataloader/test/utest_cansas.py

    r7432acb r1fc50fb2  
    4646        self.schema_1_0 = "cansas1d_v1_0.xsd" 
    4747        self.schema_1_1 = "cansas1d_v1_1.xsd" 
    48  
     48        self.write_1_0_filename = "isis_1_0_write_test.xml" 
     49        self.write_1_1_filename = "isis_1_1_write_test.xml" 
    4950 
    5051    def get_number_of_entries(self, dictionary, name, i): 
    … …  
    5657        return name 
    5758 
    58  
    5959    def test_invalid_xml(self): 
    6060        """ 
    … …  
    6262        """ 
    6363        invalid = StringIO.StringIO('<a><c></b></a>') 
    64         reader = XMLreader(invalid) 
    65  
     64        XMLreader(invalid) 
    6665 
    6766    def test_xml_validate(self): 
    … …  
    8281        self.assertFalse(xmlschema.validate(invalid)) 
    8382 
    84  
    8583    def test_real_xml(self): 
    8684        reader = XMLreader(self.xml_valid, self.schema_1_0) 
    … …  
    9088        else: 
    9189            self.assertFalse(valid) 
    92  
    9390 
    9491    def _check_data(self, data): 
    … …  
    105102        self.assertTrue(data.meta_data["xmlpreprocess"] is not None) 
    106103 
    107  
    108104    def _check_data_1_1(self, data): 
    109105        spectrum = data.trans_spectrum[0] 
    110106        self.assertTrue(len(spectrum.wavelength) == 138) 
    111107 
    112  
    113108    def test_cansas_xml(self): 
    114         filename = "isis_1_1_write_test.xml" 
    115109        xmlreader = XMLreader(self.isis_1_1, self.schema_1_1) 
    116110        valid = xmlreader.validate_xml() 
    117111        xmlreader.set_processing_instructions() 
    118112        self.assertTrue(valid) 
    119         fo = open(self.isis_1_1) 
    120         str = fo.read() 
    121113        reader_generic = Loader() 
    122114        dataloader = reader_generic.load(self.isis_1_1) 
    … …  
    128120            self._check_data(cansasreader[i]) 
    129121            self._check_data_1_1(cansasreader[i]) 
    130             reader_generic.save(filename, dataloader[i], None) 
    131             fo = open(filename) 
    132             str = fo.read() 
     122            reader_generic.save(self.write_1_1_filename, dataloader[i], None) 
    133123            reader2 = Loader() 
    134             return_data = reader2.load(filename) 
     124            self.assertTrue(os.path.isfile(self.write_1_1_filename)) 
     125            return_data = reader2.load(self.write_1_1_filename) 
    135126            written_data = return_data[0] 
    136127            self._check_data(written_data) 
    137  
     128        if os.path.isfile(self.write_1_1_filename): 
     129            os.remove(self.write_1_1_filename) 
    138130 
    139131    def test_double_trans_spectra(self): 
    … …  
    144136        for item in data: 
    145137            self._check_data(item) 
    146  
    147138 
    148139    def test_entry_name_recurse(self): 
    … …  
    155146        self.assertTrue(len(d) == 6) 
    156147 
    157  
    158148    def test_load_cansas_file(self): 
    159         valid = [] 
    160149        reader1 = XMLreader(self.xml_valid, self.schema_1_0) 
    161150        self.assertTrue(reader1.validate_xml()) 
    … …  
    173162        self.assertFalse(reader7.validate_xml()) 
    174163 
    175  
    176164    def test_invalid_cansas(self): 
    177165        list = self.loader.load(self.cansas1d_notitle) 
    … …  
    184172        self.assertTrue(data.detector[0].distance == 4150) 
    185173 
    186  
    187174    def test_old_cansas_files(self): 
    188175        reader1 = XMLreader(self.cansas1d, self.schema_1_0) 
    189176        self.assertTrue(reader1.validate_xml()) 
    190177        file_loader = Loader() 
    191         file1 = file_loader.load(self.cansas1d) 
     178        file_loader.load(self.cansas1d) 
    192179        reader2 = XMLreader(self.cansas1d_units, self.schema_1_0) 
    193180        self.assertTrue(reader2.validate_xml()) 
    … …  
    197184        self.assertTrue(reader4.validate_xml()) 
    198185 
    199  
    200186    def test_save_cansas_v1_0(self): 
    201         filename = "isis_1_0_write_test.xml" 
    202187        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0) 
    203188        valid = xmlreader.validate_xml() 
    … …  
    210195            self._check_data(dataloader[i]) 
    211196            self._check_data(cansasreader[i]) 
    212             reader_generic.save(filename, dataloader[i], None) 
     197            reader_generic.save(self.write_1_0_filename, dataloader[i], None) 
    213198            reader2 = Reader() 
    214             return_data = reader2.read(filename) 
     199            self.assertTrue(os.path.isfile(self.write_1_0_filename)) 
     200            return_data = reader2.read(self.write_1_0_filename) 
    215201            written_data = return_data[0] 
    216             xmlwrite = XMLreader(filename, self.schema_1_0) 
     202            XMLreader(self.write_1_0_filename, self.schema_1_0) 
    217203            valid = xmlreader.validate_xml() 
    218204            self.assertTrue(valid) 
    219205            self._check_data(written_data) 
    220  
     206        if os.path.isfile(self.write_1_0_filename): 
     207            os.remove(self.write_1_0_filename) 
    221208 
    222209    def test_processing_instructions(self): 
    … …  
    224211        valid = reader.validate_xml() 
    225212        if valid: 
    226             ## find the processing instructions and make into a dictionary 
     213            # find the processing instructions and make into a dictionary 
    227214            dic = self.get_processing_instructions(reader) 
    228215            self.assertTrue(dic == {'xml-stylesheet': \ 
    … …  
    232219            xmldoc = minidom.parseString(xml) 
    233220 
    234             ## take the processing instructions and put them back in 
     221            # take the processing instructions and put them back in 
    235222            xmldoc = self.set_processing_instructions(xmldoc, dic) 
    236             xml_output = xmldoc.toprettyxml() 
    237  
     223            xmldoc.toprettyxml() 
    238224 
    239225    def set_processing_instructions(self, minidom_object, dic): 
    … …  
    243229            minidom_object.insertBefore(pi, xmlroot) 
    244230        return minidom_object 
    245  
    246231 
    247232    def get_processing_instructions(self, xml_reader_object): 

  • test/sasdataloader/test/utest_averaging.py

    r9a5097c rfa4af76  
    11 
     2import math 
     3import os 
    24import unittest 
    3 import math 
    4  
    5 from sas.sascalc.dataloader.loader import  Loader 
    6 from sas.sascalc.dataloader.manipulations import Ring, CircularAverage, SectorPhi, get_q,reader2D_converter 
    75 
    86import numpy as np 
     7 
    98import sas.sascalc.dataloader.data_info as data_info 
     9from sas.sascalc.dataloader.loader import Loader 
     10from sas.sascalc.dataloader.manipulations import (Boxavg, Boxsum, 
     11                                                  CircularAverage, Ring, 
     12                                                  SectorPhi, SectorQ, SlabX, 
     13                                                  SlabY, get_q, 
     14                                                  reader2D_converter) 
     15 
    1016 
    1117class Averaging(unittest.TestCase): 
    … …  
    1319        Test averaging manipulations on a flat distribution 
    1420    """ 
     21 
    1522    def setUp(self): 
    1623        """ 
    … …  
    1825            should return the predefined height of the distribution (1.0). 
    1926        """ 
    20         x_0  = np.ones([100,100]) 
    21         dx_0 = np.ones([100,100]) 
    22          
     27        x_0 = np.ones([100, 100]) 
     28        dx_0 = np.ones([100, 100]) 
     29 
    2330        self.data = data_info.Data2D(data=x_0, err_data=dx_0) 
    2431        detector = data_info.Detector() 
    25         detector.distance = 1000.0  #mm 
    26         detector.pixel_size.x = 1.0 #mm 
    27         detector.pixel_size.y = 1.0 #mm 
    28          
     32        detector.distance = 1000.0  # mm 
     33        detector.pixel_size.x = 1.0  # mm 
     34        detector.pixel_size.y = 1.0  # mm 
     35 
    2936        # center in pixel position = (len(x_0)-1)/2 
    30         detector.beam_center.x = (len(x_0)-1)/2 #pixel number 
    31         detector.beam_center.y = (len(x_0)-1)/2 #pixel number 
     37        detector.beam_center.x = (len(x_0) - 1) / 2  # pixel number 
     38        detector.beam_center.y = (len(x_0) - 1) / 2  # pixel number 
    3239        self.data.detector.append(detector) 
    33          
     40 
    3441        source = data_info.Source() 
    35         source.wavelength = 10.0 #A 
     42        source.wavelength = 10.0  # A 
    3643        self.data.source = source 
    37          
    38         # get_q(dx, dy, det_dist, wavelength) where units are mm,mm,mm,and A respectively. 
     44 
     45        # get_q(dx, dy, det_dist, wavelength) where units are mm,mm,mm,and A 
     46        # respectively. 
    3947        self.qmin = get_q(1.0, 1.0, detector.distance, source.wavelength) 
    4048 
    4149        self.qmax = get_q(49.5, 49.5, detector.distance, source.wavelength) 
    42          
     50 
    4351        self.qstep = len(x_0) 
    44         x=  np.linspace(start= -1*self.qmax, 
    45                                stop= self.qmax, 
    46                                num= self.qstep, 
    47                                endpoint=True )   
    48         y = np.linspace(start= -1*self.qmax, 
    49                                stop= self.qmax, 
    50                                num= self.qstep, 
    51                                endpoint=True ) 
    52         self.data.x_bins=x 
    53         self.data.y_bins=y 
     52        x = np.linspace(start=-1 * self.qmax, 
     53                        stop=self.qmax, 
     54                        num=self.qstep, 
     55                        endpoint=True) 
     56        y = np.linspace(start=-1 * self.qmax, 
     57                        stop=self.qmax, 
     58                        num=self.qstep, 
     59                        endpoint=True) 
     60        self.data.x_bins = x 
     61        self.data.y_bins = y 
    5462        self.data = reader2D_converter(self.data) 
    55              
     63 
    5664    def test_ring_flat_distribution(self): 
    5765        """ 
    5866            Test ring averaging 
    5967        """ 
    60         r = Ring(r_min=2*self.qmin, r_max=5*self.qmin,  
    61                  center_x=self.data.detector[0].beam_center.x,  
     68        r = Ring(r_min=2 * self.qmin, r_max=5 * self.qmin, 
     69                 center_x=self.data.detector[0].beam_center.x, 
    6270                 center_y=self.data.detector[0].beam_center.y) 
    6371        r.nbins_phi = 20 
    64          
     72 
    6573        o = r(self.data) 
    6674        for i in range(20): 
    6775            self.assertEqual(o.y[i], 1.0) 
    68              
     76 
    6977    def test_sectorphi_full(self): 
    7078        """ 
    7179            Test sector averaging 
    7280        """ 
    73         r = SectorPhi(r_min=self.qmin, r_max=3*self.qmin,  
    74                       phi_min=0, phi_max=math.pi*2.0) 
     81        r = SectorPhi(r_min=self.qmin, r_max=3 * self.qmin, 
     82                      phi_min=0, phi_max=math.pi * 2.0) 
    7583        r.nbins_phi = 20 
    7684        o = r(self.data) 
    7785        for i in range(7): 
    7886            self.assertEqual(o.y[i], 1.0) 
    79              
    80              
     87 
    8188    def test_sectorphi_partial(self): 
    8289        """ 
    8390        """ 
    8491        phi_max = math.pi * 1.5 
    85         r = SectorPhi(r_min=self.qmin, r_max=3*self.qmin,  
     92        r = SectorPhi(r_min=self.qmin, r_max=3 * self.qmin, 
    8693                      phi_min=0, phi_max=phi_max) 
    8794        self.assertEqual(r.phi_max, phi_max) 
    … …  
    9198        for i in range(17): 
    9299            self.assertEqual(o.y[i], 1.0) 
    93              
    94              
    95  
    96 class data_info_tests(unittest.TestCase): 
    97      
     100 
     101 
     102class DataInfoTests(unittest.TestCase): 
     103 
    98104    def setUp(self): 
    99         self.data = Loader().load('MAR07232_rest.ASC') 
    100          
     105        filepath = os.path.join(os.path.dirname( 
     106            os.path.realpath(__file__)), 'MAR07232_rest.ASC') 
     107        self.data = Loader().load(filepath) 
     108 
    101109    def test_ring(self): 
    102110        """ 
    103111            Test ring averaging 
    104112        """ 
    105         r = Ring(r_min=.005, r_max=.01,  
    106                  center_x=self.data.detector[0].beam_center.x,  
     113        r = Ring(r_min=.005, r_max=.01, 
     114                 center_x=self.data.detector[0].beam_center.x, 
    107115                 center_y=self.data.detector[0].beam_center.y, 
    108                  nbins = 20) 
     116                 nbins=20) 
    109117        ##r.nbins_phi = 20 
    110          
    111         o = r(self.data) 
    112         answer = Loader().load('ring_testdata.txt') 
    113          
     118 
     119        o = r(self.data) 
     120        filepath = os.path.join(os.path.dirname( 
     121            os.path.realpath(__file__)), 'ring_testdata.txt') 
     122        answer = Loader().load(filepath) 
     123 
    114124        for i in range(r.nbins_phi - 1): 
    115125            self.assertAlmostEqual(o.x[i + 1], answer.x[i], 4) 
    116126            self.assertAlmostEqual(o.y[i + 1], answer.y[i], 4) 
    117127            self.assertAlmostEqual(o.dy[i + 1], answer.dy[i], 4) 
    118              
     128 
    119129    def test_circularavg(self): 
    120130        """ 
     131        Test circular averaging 
     132        The test data was not generated by IGOR. 
     133        """ 
     134        r = CircularAverage(r_min=.00, r_max=.025, 
     135                            bin_width=0.0003) 
     136        r.nbins_phi = 20 
     137 
     138        o = r(self.data) 
     139 
     140        filepath = os.path.join(os.path.dirname( 
     141            os.path.realpath(__file__)), 'avg_testdata.txt') 
     142        answer = Loader().load(filepath) 
     143        for i in range(r.nbins_phi): 
     144            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     145            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     146            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     147 
     148    def test_box(self): 
     149        """ 
    121150            Test circular averaging 
    122151            The test data was not generated by IGOR. 
    123152        """ 
    124         r = CircularAverage(r_min=.00, r_max=.025,  
    125                  bin_width=0.0003) 
    126         r.nbins_phi = 20 
    127          
    128         o = r(self.data) 
    129  
    130         answer = Loader().load('avg_testdata.txt') 
    131         for i in range(r.nbins_phi): 
    132             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    133             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    134             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    135              
    136     def test_box(self): 
    137         """ 
    138             Test circular averaging 
    139             The test data was not generated by IGOR. 
    140         """ 
    141         from sas.sascalc.dataloader.manipulations import Boxsum, Boxavg 
    142          
     153 
    143154        r = Boxsum(x_min=.01, x_max=.015, y_min=0.01, y_max=0.015) 
    144155        s, ds, npoints = r(self.data) 
    145156        self.assertAlmostEqual(s, 34.278990899999997, 4) 
    146157        self.assertAlmostEqual(ds, 7.8007981835194293, 4) 
    147         self.assertAlmostEqual(npoints, 324.0000, 4)         
    148      
     158        self.assertAlmostEqual(npoints, 324.0000, 4) 
     159 
    149160        r = Boxavg(x_min=.01, x_max=.015, y_min=0.01, y_max=0.015) 
    150161        s, ds = r(self.data) 
    151162        self.assertAlmostEqual(s, 0.10579935462962962, 4) 
    152163        self.assertAlmostEqual(ds, 0.024076537603455028, 4) 
    153              
     164 
    154165    def test_slabX(self): 
    155166        """ 
    … …  
    157168            The test data was not generated by IGOR. 
    158169        """ 
    159         from sas.sascalc.dataloader.manipulations import SlabX 
    160          
    161         r = SlabX(x_min=-.01, x_max=.01, y_min=-0.0002, y_max=0.0002, bin_width=0.0004) 
     170 
     171        r = SlabX(x_min=-.01, x_max=.01, y_min=-0.0002, 
     172                  y_max=0.0002, bin_width=0.0004) 
    162173        r.fold = False 
    163174        o = r(self.data) 
    164175 
    165         answer = Loader().load('slabx_testdata.txt') 
    166         for i in range(len(o.x)): 
    167             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    168             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    169             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    170              
     176        filepath = os.path.join(os.path.dirname( 
     177            os.path.realpath(__file__)), 'slabx_testdata.txt') 
     178        answer = Loader().load(filepath) 
     179        for i in range(len(o.x)): 
     180            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     181            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     182            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     183 
    171184    def test_slabY(self): 
    172185        """ 
    … …  
    174187            The test data was not generated by IGOR. 
    175188        """ 
    176         from sas.sascalc.dataloader.manipulations import SlabY 
    177          
    178         r = SlabY(x_min=.005, x_max=.01, y_min=-0.01, y_max=0.01, bin_width=0.0004) 
     189 
     190        r = SlabY(x_min=.005, x_max=.01, y_min=- 
     191                  0.01, y_max=0.01, bin_width=0.0004) 
    179192        r.fold = False 
    180193        o = r(self.data) 
    181194 
    182         answer = Loader().load('slaby_testdata.txt') 
    183         for i in range(len(o.x)): 
    184             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    185             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    186             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    187              
     195        filepath = os.path.join(os.path.dirname( 
     196            os.path.realpath(__file__)), 'slaby_testdata.txt') 
     197        answer = Loader().load(filepath) 
     198        for i in range(len(o.x)): 
     199            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     200            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     201            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     202 
    188203    def test_sectorphi_full(self): 
    189204        """ 
    … …  
    193208            The test data was not generated by IGOR. 
    194209        """ 
    195         from sas.sascalc.dataloader.manipulations import SectorPhi 
    196         import math 
    197          
     210 
    198211        nbins = 19 
    199212        phi_min = math.pi / (nbins + 1) 
    200213        phi_max = math.pi * 2 - phi_min 
    201          
     214 
    202215        r = SectorPhi(r_min=.005, 
    203216                      r_max=.01, 
    … …  
    207220        o = r(self.data) 
    208221 
    209         answer = Loader().load('ring_testdata.txt') 
    210         for i in range(len(o.x)): 
    211             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    212             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    213             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    214              
     222        filepath = os.path.join(os.path.dirname( 
     223            os.path.realpath(__file__)), 'ring_testdata.txt') 
     224        answer = Loader().load(filepath) 
     225        for i in range(len(o.x)): 
     226            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     227            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     228            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     229 
    215230    def test_sectorphi_quarter(self): 
    216231        """ 
    … …  
    218233            The test data was not generated by IGOR. 
    219234        """ 
    220         from sas.sascalc.dataloader.manipulations import SectorPhi 
    221         import math 
    222          
    223         r = SectorPhi(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi/2.0) 
    224         r.nbins_phi = 20 
    225         o = r(self.data) 
    226  
    227         answer = Loader().load('sectorphi_testdata.txt') 
    228         for i in range(len(o.x)): 
    229             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    230             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    231             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    232              
     235 
     236        r = SectorPhi(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0) 
     237        r.nbins_phi = 20 
     238        o = r(self.data) 
     239 
     240        filepath = os.path.join(os.path.dirname( 
     241            os.path.realpath(__file__)), 'sectorphi_testdata.txt') 
     242        answer = Loader().load(filepath) 
     243        for i in range(len(o.x)): 
     244            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     245            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     246            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     247 
    233248    def test_sectorq_full(self): 
    234249        """ 
    … …  
    236251            The test data was not generated by IGOR. 
    237252        """ 
    238         from sas.sascalc.dataloader.manipulations import SectorQ 
    239         import math 
    240          
    241         r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi/2.0) 
    242         r.nbins_phi = 20 
    243         o = r(self.data) 
    244  
    245         answer = Loader().load('sectorq_testdata.txt') 
    246         for i in range(len(o.x)): 
    247             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    248             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    249             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    250              
     253 
     254        r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0) 
     255        r.nbins_phi = 20 
     256        o = r(self.data) 
     257 
     258        filepath = os.path.join(os.path.dirname( 
     259            os.path.realpath(__file__)), 'sectorq_testdata.txt') 
     260        answer = Loader().load(filepath) 
     261        for i in range(len(o.x)): 
     262            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     263            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     264            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     265 
    251266 
    252267if __name__ == '__main__': 
Note: See TracChangeset for help on using the changeset viewer.