Changeset f001bc9 in sasview for test/sasdataloader


Ignore:
Timestamp:
Aug 22, 2017 12:55:17 PM (7 years ago)
Author:
GitHub <noreply@…>
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:
fca1f50, 17e257b5, f9ba422, 783c1b5
Parents:
a06ee7e (diff), dcb91cf (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.
git-author:
Jeff Krzywon <krzywon@…> (08/22/17 12:55:17)
git-committer:
GitHub <noreply@…> (08/22/17 12:55:17)
Message:

Merge pull request #95 from lewisodriscoll/ticket-876

Refactor File Loaders - fixes #889 #950 #849 #876 #922 #983 #970

Location:
test/sasdataloader/test
Files:
4 added
1 deleted
4 edited

Legend:

Unmodified
Added
Removed

  • test/sasdataloader/test/utest_abs_reader.py

    rc551bb3 rce8c7bd  
    55 
    66import unittest 
    7 import math 
    87import numpy as np 
    98from sas.sascalc.dataloader.loader import Loader 
    10 from sas.sascalc.dataloader.readers.IgorReader import Reader as IgorReader 
    119from sas.sascalc.dataloader.readers.abs_reader import Reader as AbsReader 
    12 from sas.sascalc.dataloader.readers.hfir1d_reader import Reader as HFIRReader 
    1310from sas.sascalc.dataloader.readers.danse_reader import Reader as DANSEReader 
    1411from sas.sascalc.dataloader.readers.cansas_reader import Reader as CANSASReader 
    1512 
    1613from sas.sascalc.dataloader.data_info import Data1D 
    17   
     14 
    1815import os.path 
    1916 
    2017 
    2118class abs_reader(unittest.TestCase): 
    22      
     19 
    2320    def setUp(self): 
    2421        reader = AbsReader() 
    … …  
    2724    def test_abs_checkdata(self): 
    2825        """ 
    29             Check the data content to see whether  
     26            Check the data content to see whether 
    3027            it matches the specific file we loaded. 
    3128            Check the units too to see whether the 
    … …  
    3532        self.assertEqual(self.data.filename, "jan08002.ABS") 
    3633        self.assertEqual(self.data.meta_data['loader'], "IGOR 1D") 
    37          
     34 
    3835        self.assertEqual(self.data.source.wavelength_unit, 'A') 
    3936        self.assertEqual(self.data.source.wavelength, 6.0) 
    40          
     37 
    4138        self.assertEqual(self.data.detector[0].distance_unit, 'mm') 
    4239        self.assertEqual(self.data.detector[0].distance, 1000.0) 
    43          
     40 
    4441        self.assertEqual(self.data.sample.transmission, 0.5667) 
    45          
     42 
    4643        self.assertEqual(self.data.detector[0].beam_center_unit, 'mm') 
    47         center_x = 114.58*5.0 
    48         center_y = 64.22*5.0 
     44        center_x = 114.58*5.08 
     45        center_y = 64.22*5.08 
    4946        self.assertEqual(self.data.detector[0].beam_center.x, center_x) 
    5047        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    51          
     48 
    5249        self.assertEqual(self.data.y_unit, '1/cm') 
    5350        self.assertEqual(self.data.x[0], 0.002618) 
    … …  
    5552        self.assertEqual(self.data.x[2], 0.01309) 
    5653        self.assertEqual(self.data.x[126], 0.5828) 
    57          
     54 
    5855        self.assertEqual(self.data.y[0], 0.02198) 
    5956        self.assertEqual(self.data.y[1], 0.02201) 
    6057        self.assertEqual(self.data.y[2], 0.02695) 
    6158        self.assertEqual(self.data.y[126], 0.2958) 
    62          
     59 
    6360        self.assertEqual(self.data.dy[0], 0.002704) 
    6461        self.assertEqual(self.data.dy[1], 0.001643) 
    6562        self.assertEqual(self.data.dy[2], 0.002452) 
    6663        self.assertEqual(self.data.dy[126], 1) 
    67          
     64 
    6865    def test_checkdata2(self): 
    6966        self.assertEqual(self.data.dy[126], 1) 
    … …  
    7471        self.assertEqual(data.meta_data['loader'], "IGOR 1D") 
    7572 
    76  
    77 class hfir_reader(unittest.TestCase): 
     73class DanseReaderTests(unittest.TestCase): 
    7874 
    7975    def setUp(self): 
    80         reader = HFIRReader() 
    81         self.data = reader.read("S2-30dq.d1d") 
    82  
    83     def test_hfir_checkdata(self): 
    84         """ 
    85             Check the data content to see whether  
    86             it matches the specific file we loaded. 
    87         """ 
    88         self.assertEqual(self.data.filename, "S2-30dq.d1d") 
    89         # THIS FILE FORMAT IS CURRENTLY READ BY THE ASCII READER 
    90         self.assertEqual(self.data.meta_data['loader'], "HFIR 1D") 
    91         self.assertEqual(len(self.data.x), 134) 
    92         self.assertEqual(len(self.data.y), 134) 
    93         #          Q           I               dI          dQ   
    94         # Point 1: 0.003014    0.003010        0.000315    0.008249 
    95         self.assertEqual(self.data.x[1], 0.003014) 
    96         self.assertEqual(self.data.y[1], 0.003010) 
    97         self.assertEqual(self.data.dy[1], 0.000315) 
    98         self.assertEqual(self.data.dx[1], 0.008249) 
    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  
    105  
    106 class igor_reader(unittest.TestCase): 
    107      
    108     def setUp(self): 
    109         # the IgorReader should be able to read this filetype 
    110         # if it can't, stop here. 
    111         reader = IgorReader() 
    112         self.data = reader.read("MAR07232_rest.ASC") 
    113  
    114     def test_igor_checkdata(self): 
    115         """ 
    116             Check the data content to see whether  
     76        reader = DANSEReader() 
     77        self.data = reader.read("MP_New.sans") 
     78 
     79    def test_checkdata(self): 
     80        """ 
     81            Check the data content to see whether 
    11782            it matches the specific file we loaded. 
    11883            Check the units too to see whether the 
    … …  
    12085            tests won't pass 
    12186        """ 
    122         self.assertEqual(self.data.filename, "MAR07232_rest.ASC") 
    123         self.assertEqual(self.data.meta_data['loader'], "IGOR 2D") 
    124          
    125         self.assertEqual(self.data.source.wavelength_unit, 'A') 
    126         self.assertEqual(self.data.source.wavelength, 8.4) 
    127          
    128         self.assertEqual(self.data.detector[0].distance_unit, 'mm') 
    129         self.assertEqual(self.data.detector[0].distance, 13705) 
    130          
    131         self.assertEqual(self.data.sample.transmission, 0.84357) 
    132          
    133         self.assertEqual(self.data.detector[0].beam_center_unit, 'mm') 
    134         center_x = (68.76 - 1)*5.0 
    135         center_y = (62.47 - 1)*5.0 
    136         self.assertEqual(self.data.detector[0].beam_center.x, center_x) 
    137         self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    138          
    139         self.assertEqual(self.data.I_unit, '1/cm') 
    140         # 3 points should be suffcient to check that the data is in column 
    141         # major order. 
    142         np.testing.assert_almost_equal(self.data.data[0:3], 
    143                                        [0.279783, 0.28951, 0.167634]) 
    144         np.testing.assert_almost_equal(self.data.qx_data[0:3], 
    145                                        [-0.01849072, -0.01821785, -0.01794498]) 
    146         np.testing.assert_almost_equal(self.data.qy_data[0:3], 
    147                                        [-0.01677435, -0.01677435, -0.01677435]) 
    148  
    149     def test_generic_loader(self): 
    150         # the generic loader should direct the file to IgorReader as well 
    151         data = Loader().load("MAR07232_rest.ASC") 
    152         self.assertEqual(data.meta_data['loader'], "IGOR 2D") 
    153  
    154  
    155 class danse_reader(unittest.TestCase): 
    156      
    157     def setUp(self): 
    158         reader = DANSEReader() 
    159         self.data = reader.read("MP_New.sans") 
    160  
    161     def test_checkdata(self): 
    162         """ 
    163             Check the data content to see whether  
    164             it matches the specific file we loaded. 
    165             Check the units too to see whether the 
    166             Data1D defaults changed. Otherwise the 
    167             tests won't pass 
    168         """ 
    16987        self.assertEqual(self.data.filename, "MP_New.sans") 
    17088        self.assertEqual(self.data.meta_data['loader'], "DANSE") 
    171          
     89 
    17290        self.assertEqual(self.data.source.wavelength_unit, 'A') 
    17391        self.assertEqual(self.data.source.wavelength, 7.5) 
    174          
     92 
    17593        self.assertEqual(self.data.detector[0].distance_unit, 'mm') 
    17694        self.assertAlmostEqual(self.data.detector[0].distance, 5414.99, 3) 
    177          
     95 
    17896        self.assertEqual(self.data.detector[0].beam_center_unit, 'mm') 
    17997        center_x = 68.74*5.0 
    … …  
    18199        self.assertEqual(self.data.detector[0].beam_center.x, center_x) 
    182100        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    183          
     101 
    184102        self.assertEqual(self.data.I_unit, '1/cm') 
    185103        self.assertEqual(self.data.data[0], 1.57831) 
    … …  
    196114        self.assertEqual(data.meta_data['loader'], "DANSE") 
    197115 
    198   
     116 
    199117class cansas_reader(unittest.TestCase): 
    200      
     118 
    201119    def setUp(self): 
    202120        reader = CANSASReader() 
    … …  
    212130        self.assertEqual(self.data.filename, "cansas1d.xml") 
    213131        self._checkdata() 
    214          
     132 
    215133    def _checkdata(self): 
    216134        """ 
    217             Check the data content to see whether  
     135            Check the data content to see whether 
    218136            it matches the specific file we loaded. 
    219137            Check the units too to see whether the 
    … …  
    223141        self.assertEqual(self.data.run[0], "1234") 
    224142        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    225          
     143 
    226144        # Data 
    227145        self.assertEqual(len(self.data.x), 2) 
    … …  
    238156        self.assertEqual(self.data.run_name['1234'], 'run name') 
    239157        self.assertEqual(self.data.title, "Test title") 
    240          
     158 
    241159        # Sample info 
    242160        self.assertEqual(self.data.sample.ID, "SI600-new-long") 
    … …  
    244162        self.assertEqual(self.data.sample.thickness_unit, 'mm') 
    245163        self.assertAlmostEqual(self.data.sample.thickness, 1.03) 
    246          
     164 
    247165        self.assertAlmostEqual(self.data.sample.transmission, 0.327) 
    248          
     166 
    249167        self.assertEqual(self.data.sample.temperature_unit, 'C') 
    250168        self.assertEqual(self.data.sample.temperature, 0) 
    … …  
    258176        self.assertAlmostEqual(self.data.sample.orientation.y, 0.02, 6) 
    259177 
    260         self.assertEqual(self.data.sample.details[0], "http://chemtools.chem.soton.ac.uk/projects/blog/blogs.php/bit_id/2720")  
    261         self.assertEqual(self.data.sample.details[1], "Some text here")  
    262          
     178        self.assertEqual(self.data.sample.details[0], "http://chemtools.chem.soton.ac.uk/projects/blog/blogs.php/bit_id/2720") 
     179        self.assertEqual(self.data.sample.details[1], "Some text here") 
     180 
    263181        # Instrument info 
    264182        self.assertEqual(self.data.instrument, "canSAS instrument") 
    265          
     183 
    266184        # Source 
    267185        self.assertEqual(self.data.source.radiation, "neutron") 
    268          
     186 
    269187        self.assertEqual(self.data.source.beam_size_unit, "mm") 
    270188        self.assertEqual(self.data.source.beam_size_name, "bm") 
    271189        self.assertEqual(self.data.source.beam_size.x, 12) 
    272190        self.assertEqual(self.data.source.beam_size.y, 13) 
    273          
     191 
    274192        self.assertEqual(self.data.source.beam_shape, "disc") 
    275          
     193 
    276194        self.assertEqual(self.data.source.wavelength_unit, "A") 
    277195        self.assertEqual(self.data.source.wavelength, 6) 
    278          
     196 
    279197        self.assertEqual(self.data.source.wavelength_max_unit, "nm") 
    280198        self.assertAlmostEqual(self.data.source.wavelength_max, 1.0) 
    … …  
    283201        self.assertEqual(self.data.source.wavelength_spread_unit, "percent") 
    284202        self.assertEqual(self.data.source.wavelength_spread, 14.3) 
    285          
     203 
    286204        # Collimation 
    287205        _found1 = False 
    … …  
    289207        self.assertEqual(self.data.collimation[0].length, 123.) 
    290208        self.assertEqual(self.data.collimation[0].name, 'test coll name') 
    291          
     209 
    292210        for item in self.data.collimation[0].aperture: 
    293211            self.assertEqual(item.size_unit,'mm') 
    … …  
    303221                and item.type == 'radius': 
    304222                _found2 = True 
    305                  
     223 
    306224        if _found1 == False or _found2 == False: 
    307             raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2)  
    308              
     225            raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2) 
     226 
    309227        # Detector 
    310228        self.assertEqual(self.data.detector[0].name, "fictional hybrid") 
    311229        self.assertEqual(self.data.detector[0].distance_unit, "mm") 
    312230        self.assertEqual(self.data.detector[0].distance, 4150) 
    313          
     231 
    314232        self.assertEqual(self.data.detector[0].orientation_unit, "degree") 
    315233        self.assertAlmostEqual(self.data.detector[0].orientation.x, 1.0, 6) 
    316234        self.assertEqual(self.data.detector[0].orientation.y, 0.0) 
    317235        self.assertEqual(self.data.detector[0].orientation.z, 0.0) 
    318          
     236 
    319237        self.assertEqual(self.data.detector[0].offset_unit, "m") 
    320238        self.assertEqual(self.data.detector[0].offset.x, .001) 
    321239        self.assertEqual(self.data.detector[0].offset.y, .002) 
    322240        self.assertEqual(self.data.detector[0].offset.z, None) 
    323          
     241 
    324242        self.assertEqual(self.data.detector[0].beam_center_unit, "mm") 
    325243        self.assertEqual(self.data.detector[0].beam_center.x, 322.64) 
    326244        self.assertEqual(self.data.detector[0].beam_center.y, 327.68) 
    327245        self.assertEqual(self.data.detector[0].beam_center.z, None) 
    328          
     246 
    329247        self.assertEqual(self.data.detector[0].pixel_size_unit, "mm") 
    330248        self.assertEqual(self.data.detector[0].pixel_size.x, 5) 
    331249        self.assertEqual(self.data.detector[0].pixel_size.y, 5) 
    332250        self.assertEqual(self.data.detector[0].pixel_size.z, None) 
    333          
     251 
    334252        # Process 
    335253        _found_term1 = False 
    … …  
    349267                      and float(t['value']) == 10.0): 
    350268                    _found_term1 = True 
    351                      
     269 
    352270        if _found_term1 == False or _found_term2 == False: 
    353271            raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2) 
    354          
     272 
    355273    def test_writer(self): 
    356274        r = CANSASReader() 
    … …  
    364282        if os.path.isfile(filename): 
    365283            os.remove(filename) 
    366          
     284 
    367285    def test_units(self): 
    368286        """ 
    … …  
    375293        self.assertEqual(self.data.filename, filename) 
    376294        self._checkdata() 
    377          
     295 
    378296    def test_badunits(self): 
    379297        """ 
    … …  
    389307        # This one should 
    390308        self.assertAlmostEqual(self.data.sample.transmission, 0.327) 
    391          
     309 
    392310        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    393311        print(self.data.errors) 
    … …  
    403321        self.assertEqual(self.data.filename, filename) 
    404322        self.assertEqual(self.data.run[0], "1234") 
    405          
     323 
    406324        # Data 
    407325        self.assertEqual(len(self.data.x), 2) 

  • test/sasdataloader/test/utest_ascii.py

    r959eb01 rad92c5a  
    66 
    77import unittest 
    8 from sas.sascalc.dataloader.loader import  Loader 
    9   
    10 import os.path 
     8from sas.sascalc.dataloader.loader import Loader 
    119 
    12 class abs_reader(unittest.TestCase): 
     10 
     11class ABSReaderTests(unittest.TestCase): 
    1312     
    1413    def setUp(self): 
    1514        self.loader = Loader() 
    16          
     15        self.f1_list = self.loader.load("ascii_test_1.txt") 
     16        self.f1 = self.f1_list[0] 
     17        self.f2_list = self.loader.load("ascii_test_2.txt") 
     18        self.f2 = self.f2_list[0] 
     19        self.f3_list = self.loader.load("ascii_test_3.txt") 
     20        self.f3 = self.f3_list[0] 
     21        self.f4_list = self.loader.load("ascii_test_4.abs") 
     22        self.f4 = self.f4_list[0] 
     23        self.f5_list = self.loader.load("ascii_test_5.txt") 
     24        self.f5 = self.f5_list[0] 
     25 
    1726    def test_checkdata(self): 
    1827        """ 
    1928            Test .ABS file loaded as ascii 
    2029        """ 
    21         f = self.loader.load("ascii_test_1.txt") 
    2230        # The length of the data is 10 
    23         self.assertEqual(len(f.x), 10) 
    24         self.assertEqual(f.x[0],0.002618) 
    25         self.assertEqual(f.x[9],0.0497) 
    26         self.assertEqual(f.x_unit, '1/A') 
    27         self.assertEqual(f.y_unit, '1/cm') 
     31        self.assertEqual(len(self.f1.x), 10) 
     32        self.assertEqual(self.f1.x[0],0.002618) 
     33        self.assertEqual(self.f1.x[9],0.0497) 
     34        self.assertEqual(self.f1.x_unit, '1/A') 
     35        self.assertEqual(self.f1.y_unit, '1/cm') 
    2836         
    29         self.assertEqual(f.meta_data['loader'],"ASCII") 
    30          
     37        self.assertEqual(self.f1.meta_data['loader'],"ASCII") 
     38 
    3139    def test_truncated_1(self): 
    3240        """ 
    … …  
    3846            as though it were the start of a footer). 
    3947        """ 
    40         # Test .ABS file loaded as ascii 
    41         f = self.loader.load("ascii_test_2.txt") 
    42         # The length of the data is 10 
    43         self.assertEqual(len(f.x), 5) 
    44         self.assertEqual(f.x[0],0.002618) 
    45         self.assertEqual(f.x[4],0.02356) 
    46          
     48        # The length of the data is 5 
     49        self.assertEqual(len(self.f2.x), 5) 
     50        self.assertEqual(self.f2.x[0],0.002618) 
     51        self.assertEqual(self.f2.x[4],0.02356) 
     52 
    4753    def test_truncated_2(self): 
    4854        """ 
    … …  
    5258            reading at the first inconsitent line. 
    5359        """ 
    54         # Test .ABS file loaded as ascii 
    55         f = self.loader.load("ascii_test_3.txt") 
    5660        # The length of the data is 5 
    57         self.assertEqual(len(f.x), 5) 
    58         self.assertEqual(f.x[0],0.002618) 
    59         self.assertEqual(f.x[4],0.02356) 
    60          
     61        self.assertEqual(len(self.f3.x), 5) 
     62        self.assertEqual(self.f3.x[0],0.002618) 
     63        self.assertEqual(self.f3.x[4],0.02356) 
     64 
    6165    def test_truncated_3(self): 
    6266        """ 
    … …  
    6670            reading at the last line of header. 
    6771        """ 
    68         # Test .ABS file loaded as ascii 
    69         f = self.loader.load("ascii_test_4.abs") 
    7072        # The length of the data is 5 
    71         self.assertEqual(len(f.x), 5) 
    72         self.assertEqual(f.x[0],0.012654) 
    73         self.assertEqual(f.x[4],0.02654) 
    74          
     73        self.assertEqual(len(self.f4.x), 5) 
     74        self.assertEqual(self.f4.x[0],0.012654) 
     75        self.assertEqual(self.f4.x[4],0.02654) 
     76 
    7577    def test_truncated_4(self): 
    7678        """ 
    … …  
    7880            Only the last 5 2-col lines should be read. 
    7981        """ 
    80         # Test .ABS file loaded as ascii 
    81         f = self.loader.load("ascii_test_5.txt") 
    8282        # The length of the data is 5 
    83         self.assertEqual(len(f.x), 5) 
    84         self.assertEqual(f.x[0],0.02879) 
    85         self.assertEqual(f.x[4],0.0497) 
    86          
     83        self.assertEqual(len(self.f5.x), 5) 
     84        self.assertEqual(self.f5.x[0],0.02879) 
     85        self.assertEqual(self.f5.x[4],0.0497) 
     86 
    8787    def test_truncated_5(self): 
    8888        """ 
    89             Test a 6-col ascii file with complex header where one of them has a letter and  
    90             many lines with 2 or 2 columns in the middle of the data section. 
    91             Only last four lines should be read. 
     89            Test a 6-col ascii file with complex header where one of them has a 
     90            letter and many lines with 2 or 2 columns in the middle of the data 
     91            section. Will be rejected because fewer than 5 lines. 
    9292        """ 
    9393        # Test .ABS file loaded as ascii 
    … …  
    9898        except: 
    9999            self.assertEqual(f, None) 
    100          
     100 
    101101if __name__ == '__main__': 
    102102    unittest.main() 

  • test/sasdataloader/test/utest_averaging.py

    re123eb9 r2a52b0e  
    4646        # respectively. 
    4747        self.qmin = get_q(1.0, 1.0, detector.distance, source.wavelength) 
    48  
    4948        self.qmax = get_q(49.5, 49.5, detector.distance, source.wavelength) 
    5049 
    … …  
    104103    def setUp(self): 
    105104        filepath = os.path.join(os.path.dirname( 
    106             os.path.realpath(__file__)), 'MAR07232_rest.ASC') 
    107         self.data = Loader().load(filepath) 
     105            os.path.realpath(__file__)), 'MAR07232_rest.h5') 
     106        self.data = Loader().load(filepath)[0] 
    108107 
    109108    def test_ring(self): 
    … …  
    120119        filepath = os.path.join(os.path.dirname( 
    121120            os.path.realpath(__file__)), 'ring_testdata.txt') 
    122         answer = Loader().load(filepath) 
     121        answer = Loader().load(filepath)[0] 
    123122 
    124123        for i in range(r.nbins_phi - 1): 
    … …  
    140139        filepath = os.path.join(os.path.dirname( 
    141140            os.path.realpath(__file__)), 'avg_testdata.txt') 
    142         answer = Loader().load(filepath) 
     141        answer = Loader().load(filepath)[0] 
    143142        for i in range(r.nbins_phi): 
    144143            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    176175        filepath = os.path.join(os.path.dirname( 
    177176            os.path.realpath(__file__)), 'slabx_testdata.txt') 
    178         answer = Loader().load(filepath) 
     177        answer = Loader().load(filepath)[0] 
    179178        for i in range(len(o.x)): 
    180179            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    195194        filepath = os.path.join(os.path.dirname( 
    196195            os.path.realpath(__file__)), 'slaby_testdata.txt') 
    197         answer = Loader().load(filepath) 
     196        answer = Loader().load(filepath)[0] 
    198197        for i in range(len(o.x)): 
    199198            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    204203        """ 
    205204            Test sector averaging I(phi) 
    206             When considering the whole azimuthal range (2pi),  
     205            When considering the whole azimuthal range (2pi), 
    207206            the answer should be the same as ring averaging. 
    208207            The test data was not generated by IGOR. 
    … …  
    222221        filepath = os.path.join(os.path.dirname( 
    223222            os.path.realpath(__file__)), 'ring_testdata.txt') 
    224         answer = Loader().load(filepath) 
     223        answer = Loader().load(filepath)[0] 
    225224        for i in range(len(o.x)): 
    226225            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    240239        filepath = os.path.join(os.path.dirname( 
    241240            os.path.realpath(__file__)), 'sectorphi_testdata.txt') 
    242         answer = Loader().load(filepath) 
     241        answer = Loader().load(filepath)[0] 
    243242        for i in range(len(o.x)): 
    244243            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    258257        filepath = os.path.join(os.path.dirname( 
    259258            os.path.realpath(__file__)), 'sectorq_testdata.txt') 
    260         answer = Loader().load(filepath) 
     259        answer = Loader().load(filepath)[0] 
    261260        for i in range(len(o.x)): 
    262261            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    277276        for i in range(len(o.x)): 
    278277            self.assertAlmostEqual(o.x[i], expected_binning[i], 3) 
    279          
     278 
    280279        # TODO: Test for Y values (o.y) 
    281280        # print len(self.data.x_bins) 
    … …  
    288287        # xedges_width = (xedges[1] - xedges[0]) 
    289288        # xedges_center = xedges[1:] - xedges_width / 2 
    290          
     289 
    291290        # yedges_width = (yedges[1] - yedges[0]) 
    292291        # yedges_center = yedges[1:] - yedges_width / 2 
    293          
     292 
    294293        # print H.flatten().shape 
    295294        # print o.y.shape 
    296          
     295 
    297296 
    298297if __name__ == '__main__': 

  • test/sasdataloader/test/utest_red2d_reader.py

    r959eb01 r248ff73  
    77import unittest 
    88from sas.sascalc.dataloader.loader import  Loader 
    9   
     9 
    1010import os.path 
    1111 
    1212class abs_reader(unittest.TestCase): 
    13      
     13 
    1414    def setUp(self): 
    1515        self.loader = Loader() 
    16          
     16 
    1717    def test_checkdata(self): 
    1818        """ 
    1919            Test .DAT file loaded as IGOR/DAT 2D Q_map 
    2020        """ 
    21         f = self.loader.load("exp18_14_igor_2dqxqy.dat") 
     21        f = self.loader.load("exp18_14_igor_2dqxqy.dat")[0] 
    2222        # The length of the data is 10 
    2323        self.assertEqual(len(f.qx_data),  36864) 
    … …  
    2626        self.assertEqual(f.Q_unit, '1/A') 
    2727        self.assertEqual(f.I_unit, '1/cm') 
    28          
     28 
    2929        self.assertEqual(f.meta_data['loader'],"IGOR/DAT 2D Q_map") 
    30          
    31          
     30 
     31 
    3232if __name__ == '__main__': 
    3333    unittest.main() 
    34     
Note: See TracChangeset for help on using the changeset viewer.