Changes in / [e2b2473:f9ba422] in sasview


Ignore:
Files:
7 added
9 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/dataloader/data_info.py

    r17e257b5 ra1b8fee  
    11611161    final_dataset = None 
    11621162    if isinstance(data, plottable_1D): 
    1163         final_dataset = Data1D(data.x, data.y, isSesans=datainfo.isSesans) 
     1163        final_dataset = Data1D(data.x, data.y) 
    11641164        final_dataset.dx = data.dx 
    11651165        final_dataset.dy = data.dy 
    11661166        final_dataset.dxl = data.dxl 
    11671167        final_dataset.dxw = data.dxw 
    1168         final_dataset.x_unit = data._xunit 
    1169         final_dataset.y_unit = data._yunit 
    11701168        final_dataset.xaxis(data._xaxis, data._xunit) 
    11711169        final_dataset.yaxis(data._yaxis, data._yunit) 

  • src/sas/sascalc/dataloader/file_reader_base_class.py

    ra78a02f rdcb91cf  
    66 
    77import os 
    8 import re 
    98import logging 
    109import numpy as np 
    … …  
    107106        for data in self.output: 
    108107            if isinstance(data, Data1D): 
    109                 # Normalize the units for 
    110                 data.x_unit = self.format_unit(data.x_unit) 
    111                 data.y_unit = self.format_unit(data.y_unit) 
    112108                # Sort data by increasing x and remove 1st point 
    113109                ind = np.lexsort((data.y, data.x)) 
    … …  
    135131        for dataset in self.output: 
    136132            if isinstance(dataset, Data2D): 
    137                 # Normalize the units for 
    138                 dataset.x_unit = self.format_unit(dataset.Q_unit) 
    139                 dataset.y_unit = self.format_unit(dataset.I_unit) 
    140133                dataset.data = dataset.data.astype(np.float64) 
    141134                dataset.qx_data = dataset.qx_data.astype(np.float64) 
    … …  
    162155                dataset.data = dataset.data.flatten() 
    163156 
    164     def format_unit(self, unit=None): 
    165         """ 
    166         Format units a common way 
    167         :param unit: 
    168         :return: 
    169         """ 
    170         if unit: 
    171             split = unit.split("/") 
    172             if len(split) == 1: 
    173                 return unit 
    174             elif split[0] == '1': 
    175                 return "{0}^".format(split[1]) + "{-1}" 
    176             else: 
    177                 return "{0}*{1}^".format(split[0], split[1]) + "{-1}" 
    178  
    179157    def set_all_to_none(self): 
    180158        """ 

  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    ra78a02f rdcb91cf  
    299299                    self.current_dataset.dx = np.append(self.current_dataset.dx, data_point) 
    300300                elif tagname == 'dQw': 
    301                     if self.current_dataset.dxw is None: 
    302                         self.current_dataset.dxw = np.empty(0) 
     301                    if self.current_dataset.dqw is None: self.current_dataset.dqw = np.empty(0) 
    303302                    self.current_dataset.dxw = np.append(self.current_dataset.dxw, data_point) 
    304303                elif tagname == 'dQl': 
    305                     if self.current_dataset.dxl is None: 
    306                         self.current_dataset.dxl = np.empty(0) 
     304                    if self.current_dataset.dxl is None: self.current_dataset.dxl = np.empty(0) 
    307305                    self.current_dataset.dxl = np.append(self.current_dataset.dxl, data_point) 
    308306                elif tagname == 'Qmean': 

  • src/sas/sascalc/dataloader/readers/danse_reader.py

    ra78a02f r713a047  
    189189        x_vals = np.tile(x_vals, (size_y, 1)).flatten() 
    190190        y_vals = np.tile(y_vals, (size_x, 1)).T.flatten() 
    191         if (np.all(self.current_dataset.err_data == None) 
    192                 or np.any(self.current_dataset.err_data <= 0)): 
     191        if self.current_dataset.err_data == np.all(np.array(None)) or np.any(self.current_dataset.err_data <= 0): 
    193192            new_err_data = np.sqrt(np.abs(self.current_dataset.data)) 
    194193        else: 

  • test/sasdataloader/test/utest_abs_reader.py

    ra78a02f rce8c7bd  
    2020    def setUp(self): 
    2121        reader = AbsReader() 
    22         data = reader.read("jan08002.ABS") 
    23         self.data= data[0] 
     22        self.data = reader.read("jan08002.ABS") 
    2423 
    2524    def test_abs_checkdata(self): 
    … …  
    4847        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    4948 
    50         self.assertEqual(self.data.y_unit, 'cm^{-1}') 
     49        self.assertEqual(self.data.y_unit, '1/cm') 
    5150        self.assertEqual(self.data.x[0], 0.002618) 
    5251        self.assertEqual(self.data.x[1], 0.007854) 
    … …  
    7069        # the generic loader should work as well 
    7170        data = Loader().load("jan08002.ABS") 
    72         self.assertEqual(data[0].meta_data['loader'], "IGOR 1D") 
     71        self.assertEqual(data.meta_data['loader'], "IGOR 1D") 
    7372 
    7473class DanseReaderTests(unittest.TestCase): 
    … …  
    7675    def setUp(self): 
    7776        reader = DANSEReader() 
    78         data = reader.read("MP_New.sans") 
    79         self.data = data[0] 
     77        self.data = reader.read("MP_New.sans") 
    8078 
    8179    def test_checkdata(self): 
    … …  
    114112        # the generic loader should work as well 
    115113        data = Loader().load("MP_New.sans") 
    116         self.assertEqual(data[0].meta_data['loader'], "DANSE") 
     114        self.assertEqual(data.meta_data['loader'], "DANSE") 
    117115 
    118116 
    … …  
    146144        # Data 
    147145        self.assertEqual(len(self.data.x), 2) 
    148         self.assertEqual(self.data.x_unit, 'A^{-1}') 
    149         self.assertEqual(self.data.y_unit, 'cm^{-1}') 
     146        self.assertEqual(self.data.x_unit, '1/A') 
     147        self.assertEqual(self.data.y_unit, '1/cm') 
    150148        self.assertAlmostEqual(self.data.x[0], 0.02, 6) 
    151149        self.assertAlmostEqual(self.data.y[0], 1000, 6) 
    … …  
    259257            self.assertTrue(item.date in ['04-Sep-2007 18:35:02', 
    260258                                          '03-SEP-2006 11:42:47']) 
     259            print(item.term) 
    261260            for t in item.term: 
    262261                if (t['name'] == "ABS:DSTAND" 
    … …  
    310309 
    311310        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    312         self.assertEqual(len(self.data.errors), 0) 
     311        print(self.data.errors) 
     312        self.assertEqual(len(self.data.errors), 1) 
    313313 
    314314    def test_slits(self): 
    … …  
    324324        # Data 
    325325        self.assertEqual(len(self.data.x), 2) 
    326         self.assertEqual(self.data.x_unit, 'A^{-1}') 
    327         self.assertEqual(self.data.y_unit, 'cm^{-1}') 
     326        self.assertEqual(self.data.x_unit, '1/A') 
     327        self.assertEqual(self.data.y_unit, '1/cm') 
    328328        self.assertEqual(self.data.x[0], 0.02) 
    329329        self.assertEqual(self.data.y[0], 1000) 
    … …  
    333333        self.assertEqual(self.data.x[1], 0.03) 
    334334        self.assertAlmostEquals(self.data.y[1], 1001.0) 
    335         self.assertEqual(self.data.dx[0], 0.0) 
     335        self.assertEqual(self.data.dx, None) 
    336336        self.assertEqual(self.data.dxl[1], 0.005) 
    337337        self.assertEqual(self.data.dxw[1], 0.001) 

  • test/sasdataloader/test/utest_ascii.py

    ra78a02f rad92c5a  
    3232        self.assertEqual(self.f1.x[0],0.002618) 
    3333        self.assertEqual(self.f1.x[9],0.0497) 
    34         self.assertTrue(self.f1.x_unit == 'A^{-1}') 
    35         self.assertTrue(self.f1.y_unit == 'cm^{-1}') 
     34        self.assertEqual(self.f1.x_unit, '1/A') 
     35        self.assertEqual(self.f1.y_unit, '1/cm') 
    3636         
    3737        self.assertEqual(self.f1.meta_data['loader'],"ASCII") 

  • test/sasdataloader/test/utest_cansas.py

    r17e257b5 r1fc50fb2  
    2020 
    2121from lxml import etree 
    22 from lxml.etree import XMLSyntaxError 
    2322from xml.dom import minidom 
    2423 
    … …  
    6362        """ 
    6463        invalid = StringIO.StringIO('<a><c></b></a>') 
    65         self.assertRaises(XMLSyntaxError, lambda: XMLreader(invalid)) 
     64        XMLreader(invalid) 
    6665 
    6766    def test_xml_validate(self): 
    … …  
    303302        self.assertTrue(data._yunit == "cm^{-1}") 
    304303        self.assertTrue(data.y.size == 100) 
    305         self.assertAlmostEqual(data.y[40], 0.952749011516985) 
    306         self.assertAlmostEqual(data.x[40], 0.3834415188257777) 
     304        self.assertAlmostEqual(data.y[9], 0.952749011516985) 
     305        self.assertAlmostEqual(data.x[9], 0.3834415188257777) 
    307306        self.assertAlmostEqual(len(data.meta_data), 0) 
    308307 

  • test/sasdataloader/test/utest_sesans.py

    ra78a02f ra67c494  
    44 
    55import unittest 
    6 from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\ 
    7     DefaultReaderException 
    86from sas.sascalc.dataloader.readers.sesans_reader import Reader 
    97from sas.sascalc.dataloader.loader import  Loader 
    … …  
    1917            Test .SES in the full loader to make sure that the file type is correctly accepted 
    2018        """ 
    21         file = Loader().load("sesans_examples/sphere2micron.ses") 
    22         f = file[0] 
     19        f = Loader().load("sesans_examples/sphere2micron.ses") 
    2320        # self.assertEqual(f, 5) 
    2421        self.assertEqual(len(f.x), 40) 
    … …  
    3734            Test .SES loading on a TOF dataset 
    3835        """ 
    39         file = self.loader("sesans_examples/sphere_isis.ses") 
    40         f = file[0] 
     36        f = self.loader("sesans_examples/sphere_isis.ses") 
    4137        self.assertEqual(len(f.x), 57) 
    4238        self.assertEqual(f.x[-1], 19303.4) 
    … …  
    5248        """ 
    5349        self.assertRaises( 
    54             FileContentsException, 
     50            RuntimeError, 
    5551            self.loader, 
    5652            "sesans_examples/sesans_no_data.ses") 
    … …  
    6157        """ 
    6258        self.assertRaises( 
    63             FileContentsException, 
     59            RuntimeError, 
    6460            self.loader, 
    6561            "sesans_examples/no_spin_echo_unit.ses") 
     62 
     63    def test_sesans_no_version(self): 
     64        """ 
     65            Confirm that sesans files with no file format version raise an appropriate error 
     66        """ 
     67        self.assertRaises( 
     68            RuntimeError, 
     69            self.loader, 
     70            "sesans_examples/no_version.ses") 
    6671 
    6772    def test_sesans_future_version(self): 
    … …  
    7075        """ 
    7176        self.assertRaises( 
    72             FileContentsException, 
     77            RuntimeError, 
    7378            self.loader, 
    7479            "sesans_examples/next_gen.ses") 
    … …  
    7984        """ 
    8085        self.assertRaises( 
    81             FileContentsException, 
     86            RuntimeError, 
    8287            self.loader, 
    8388            "sesans_examples/no_wavelength.ses") 
    … …  
    8893        """ 
    8994        self.assertRaises( 
    90             FileContentsException, 
     95            RuntimeError, 
    9196            self.loader, 
    9297            "sesans_examples/too_many_headers.ses") 

  • test/utest_sasview.py

    rb54440d raaf5e49  
    4444    n_errors = 0 
    4545    n_failures = 0 
    46  
     46     
    4747    for d in (dirs if dirs else os.listdir(test_root)): 
    48  
     48         
    4949        # Check for modules to be skipped 
    5050        if d in SKIPPED_DIRS: 
    5151            continue 
    52  
     52         
    5353 
    5454        # Go through modules looking for unit tests 
    … …  
    6464                    #print std_out 
    6565                    #sys.exit() 
     66                    has_failed = True 
    6667                    m = re.search("Ran ([0-9]+) test", std_out) 
    6768                    if m is not None: 
     69                        has_failed = False 
    6870                        n_tests += int(m.group(1)) 
    69                         has_tests = True 
    70                     else: 
    71                         has_tests = False 
    7271 
    73                     has_failed = "FAILED (" in std_out 
    74                     m = re.search("FAILED \(.*errors=([0-9]+)", std_out) 
     72                    m = re.search("FAILED \(errors=([0-9]+)\)", std_out) 
    7573                    if m is not None: 
     74                        has_failed = True 
    7675                        n_errors += int(m.group(1)) 
    77                     m = re.search("FAILED \(.*failures=([0-9]+)", std_out) 
     76                     
     77                    m = re.search("FAILED \(failures=([0-9]+)\)", std_out) 
    7878                    if m is not None: 
     79                        has_failed = True 
    7980                        n_failures += int(m.group(1)) 
    80  
    81                     if has_failed or not has_tests: 
     81                     
     82                    if has_failed: 
    8283                        failed += 1 
    8384                        print("Result for %s (%s): FAILED" % (module_name, module_dir)) 
    … …  
    101102        print("    Test errors:  %d" % n_errors) 
    102103    print("----------------------------------------------") 
    103  
     104     
    104105    return failed 
    105106 
    … …  
    109110    if run_tests(dirs=dirs, all=all)>0: 
    110111        sys.exit(1) 
    111  
     112     
Note: See TracChangeset for help on using the changeset viewer.