Changeset 2ca5d57b in sasview


Ignore:
Timestamp:
Sep 13, 2018 11:33:22 AM (5 days ago)
Author:
krzywon
Branches:
ticket-1111
Children:
feec1cb
Parents:
4fdcc65
Message:

Code cleanup and additional unit tests.

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    r4fdcc65 r2ca5d57b  
    131131            value = data.get(key) 
    132132            class_name = h5attr(value, u'canSAS_class') 
     133            if isinstance(class_name, (list, tuple, np.ndarray)): 
     134                class_name = class_name[0] 
    133135            if class_name is None: 
    134136                class_name = h5attr(value, u'NX_class') 
     
    538540            if dataset.data.ndim == 2: 
    539541                (n_rows, n_cols) = dataset.data.shape 
    540                 print(n_rows) 
    541                 print(n_cols) 
    542542                flat_qy = dataset.qy_data[0::n_cols].flatten() 
    543543                if flat_qy[0] == flat_qy[1]: 
     
    548548                    flat_qx = np.transpose(dataset.qx_data)[0::n_rows].flatten() 
    549549                dataset.x_bins = np.unique(flat_qx) 
    550                 print(dataset.x_bins) 
    551                 print(len(dataset.x_bins)) 
    552                 print(dataset.y_bins) 
    553                 print(len(dataset.y_bins)) 
    554550                dataset.data = dataset.data.flatten() 
    555551                dataset.qx_data = dataset.qx_data.flatten() 
  • src/sas/sascalc/file_converter/nxcansas_writer.py

    r4fdcc65 r2ca5d57b  
    88import os 
    99 
    10 from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader as Cansas2Reader 
     10from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader 
    1111from sas.sascalc.dataloader.data_info import Data1D, Data2D 
    1212 
    13 class NXcanSASWriter(Cansas2Reader): 
     13class NXcanSASWriter(Reader): 
    1414    """ 
    1515    A class for writing in NXcanSAS data files. Any number of data sets may be 
     
    8787                    entry[names[2]].attrs['units'] = units 
    8888 
    89         valid_data = all([issubclass(d.__class__, (Data1D, Data2D)) for d in dataset]) 
     89        valid_data = all([issubclass(d.__class__, (Data1D, Data2D)) for d in 
     90                          dataset]) 
    9091        if not valid_data: 
    91             raise ValueError("All entries of dataset must be Data1D or Data2D objects") 
     92            raise ValueError("All entries of dataset must be Data1D or Data2D" 
     93                             "objects") 
    9294 
    9395        # Get run name and number from first Data object 
     
    145147                sample_entry.create_dataset('details', data=details) 
    146148 
    147         # Instrumment metadata 
     149        # Instrument metadata 
    148150        instrument_entry = sasentry.create_group('sasinstrument') 
    149151        instrument_entry.attrs['canSAS_class'] = 'SASinstrument' 
     
    175177        # Collimation metadata 
    176178        if len(data_info.collimation) > 0: 
    177             i = 1 
    178             for coll_info in data_info.collimation: 
     179            for i, coll_info in enumerate(data_info.collimation): 
    179180                collimation_entry = instrument_entry.create_group( 
    180                     'sascollimation{0:0=2d}'.format(i)) 
     181                    'sascollimation{0:0=2d}'.format(i + 1)) 
    181182                collimation_entry.attrs['canSAS_class'] = 'SAScollimation' 
    182183                if coll_info.length is not None: 
    183184                    _write_h5_float(collimation_entry, coll_info.length, 'SDD') 
    184                     collimation_entry['SDD'].attrs['units'] = coll_info.length_unit 
     185                    collimation_entry['SDD'].attrs['units'] =\ 
     186                        coll_info.length_unit 
    185187                if coll_info.name is not None: 
    186188                    collimation_entry['name'] = _h5_string(coll_info.name) 
    187189        else: 
    188             # Create a blank one - at least 1 set of collimation metadata 
    189             # required by format 
    190             collimation_entry = instrument_entry.create_group('sascollimation01') 
     190            # Create a blank one - at least 1 collimation required by format 
     191            instrument_entry.create_group('sascollimation01') 
    191192 
    192193        # Detector metadata 
    193194        if len(data_info.detector) > 0: 
    194195            i = 1 
    195             for det_info in data_info.detector: 
     196            for i, det_info in enumerate(data_info.detector): 
    196197                detector_entry = instrument_entry.create_group( 
    197                     'sasdetector{0:0=2d}'.format(i)) 
     198                    'sasdetector{0:0=2d}'.format(i + 1)) 
    198199                detector_entry.attrs['canSAS_class'] = 'SASdetector' 
    199200                if det_info.distance is not None: 
    200201                    _write_h5_float(detector_entry, det_info.distance, 'SDD') 
    201                     detector_entry['SDD'].attrs['units'] = det_info.distance_unit 
     202                    detector_entry['SDD'].attrs['units'] =\ 
     203                        det_info.distance_unit 
    202204                if det_info.name is not None: 
    203205                    detector_entry['name'] = _h5_string(det_info.name) 
     
    205207                    detector_entry['name'] = _h5_string('') 
    206208                if det_info.slit_length is not None: 
    207                     _write_h5_float(detector_entry, det_info.slit_length, 'slit_length') 
    208                     detector_entry['slit_length'].attrs['units'] = det_info.slit_length_unit 
     209                    _write_h5_float(detector_entry, det_info.slit_length, 
     210                                    'slit_length') 
     211                    detector_entry['slit_length'].attrs['units'] =\ 
     212                        det_info.slit_length_unit 
    209213                _write_h5_vector(detector_entry, det_info.offset) 
    210214                # NXcanSAS doesn't save information about pitch, only roll 
     
    220224                    names=['x_pixel_size', 'y_pixel_size'], 
    221225                    write_fn=_write_h5_float, units=det_info.pixel_size_unit) 
    222  
    223                 i += 1 
    224226        else: 
    225227            # Create a blank one - at least 1 detector required by format 
     
    229231 
    230232        # Process meta data 
    231         if len(data_info.process) > 0 and not data_info.process[0].is_empty(): 
    232             i = 1 
    233             for process in data_info.process: 
    234                 process_entry = sasentry.create_group( 
    235                     'sasprocess{0:0=2d}'.format(i)) 
    236                 process_entry.attrs['canSAS_class'] = 'SASprocess' 
    237                 if process.name: 
    238                     name = _h5_string(process.name) 
    239                     process_entry.create_dataset('name', data=name) 
    240                 if process.date: 
    241                     date = _h5_string(process.date) 
    242                     process_entry.create_dataset('date', data=date) 
    243                 if process.description: 
    244                     desc = _h5_string(process.description) 
    245                     process_entry.create_dataset('description', data=desc) 
    246                 j = 1 
    247                 for term in process.term: 
    248                     if term: 
    249                         h5_term = _h5_string(term) 
    250                         process_entry.create_dataset('term{0:0=2d}'.format(j), 
    251                                                      data=h5_term) 
    252                     j += 1 
    253                 j = 1 
    254                 for note in process.notes: 
    255                     if note: 
    256                         h5_note = _h5_string(note) 
    257                         process_entry.create_dataset('note{0:0=2d}'.format(j), 
    258                                                      data=h5_note) 
    259                     j += 1 
    260                 i += 1 
     233        for i, process in enumerate(data_info.process): 
     234            process_entry = sasentry.create_group('sasprocess{0:0=2d}'.format( 
     235                i + 1)) 
     236            process_entry.attrs['canSAS_class'] = 'SASprocess' 
     237            if process.name: 
     238                name = _h5_string(process.name) 
     239                process_entry.create_dataset('name', data=name) 
     240            if process.date: 
     241                date = _h5_string(process.date) 
     242                process_entry.create_dataset('date', data=date) 
     243            if process.description: 
     244                desc = _h5_string(process.description) 
     245                process_entry.create_dataset('description', data=desc) 
     246            for j, term in enumerate(process.term): 
     247                # Don't save empty terms 
     248                if term: 
     249                    h5_term = _h5_string(term) 
     250                    process_entry.create_dataset('term{0:0=2d}'.format( 
     251                        j + 1), data=h5_term) 
     252            for j, note in enumerate(process.notes): 
     253                # Don't save empty notes 
     254                if note: 
     255                    h5_note = _h5_string(note) 
     256                    process_entry.create_dataset('note{0:0=2d}'.format( 
     257                        j + 1), data=h5_note) 
    261258 
    262259        # Transmission Spectrum 
    263         if len(data_info.trans_spectrum) > 0: 
    264             i = 1 
    265             for trans in data_info.trans_spectrum: 
    266                 trans_entry = sasentry.create_group( 
    267                     'sastransmission_spectrum{0:0=2d}'.format(i)) 
    268                 trans_entry.attrs['canSAS_class'] = 'SAStransmission_spectrum' 
    269                 trans_entry.attrs['signal'] = 'T' 
    270                 trans_entry.attrs['T_axes'] = 'T' 
    271                 trans_entry.attrs['name'] = trans.name 
    272                 if trans.timestamp is not '': 
    273                     trans_entry.attrs['timestamp'] = trans.timestamp 
    274                 transmission = trans_entry.create_dataset( 
    275                     'T', data=trans.transmission) 
    276                 transmission.attrs['unertainties'] = 'Tdev' 
    277                 trans_entry.create_dataset('Tdev', 
    278                                            data = trans.transmission_deviation) 
    279                 trans_entry.create_dataset('lambda', data=trans.wavelength) 
     260        for i, trans in enumerate(data_info.trans_spectrum): 
     261            trans_entry = sasentry.create_group( 
     262                'sastransmission_spectrum{0:0=2d}'.format(i + 1)) 
     263            trans_entry.attrs['canSAS_class'] = 'SAStransmission_spectrum' 
     264            trans_entry.attrs['signal'] = 'T' 
     265            trans_entry.attrs['T_axes'] = 'T' 
     266            trans_entry.attrs['name'] = trans.name 
     267            if trans.timestamp is not '': 
     268                trans_entry.attrs['timestamp'] = trans.timestamp 
     269            transmission = trans_entry.create_dataset('T', 
     270                                                      data=trans.transmission) 
     271            transmission.attrs['unertainties'] = 'Tdev' 
     272            trans_entry.create_dataset('Tdev', 
     273                                       data=trans.transmission_deviation) 
     274            trans_entry.create_dataset('lambda', data=trans.wavelength) 
    280275 
    281276        note_entry = sasentry.create_group('sasnote'.format(i)) 
  • test/sasdataloader/test/utest_cansas.py

    r7fd5e2a r2ca5d57b  
    256256        self.datafile_basic = find("simpleexamplefile.h5") 
    257257        self.datafile_multiplesasentry = find( 
     258            "test_data//nxcansas_1Dand2D_multisasentry.h5") 
     259        self.datafile_multiplesasdata = find( 
    258260            "test_data//nxcansas_1Dand2D_multisasdata.h5") 
    259         self.datafile_multiplesasdata = find( 
    260             "test_data//nxcansas_1Dand2D_multisasentry.h5") 
    261261        self.datafile_multiplesasdata_multiplesasentry = find( 
    262262            "test_data//nxcansas_1Dand2D_multisasentry_multisasdata.h5") 
     
    277277            self._check_1d_data(self.data[1]) 
    278278            self._check_2d_data(self.data[0]) 
     279 
     280    def test_multiple_sasdatas(self): 
     281        self.data = self.loader.load(self.datafile_multiplesasdata) 
     282        self.assertTrue(len(self.data) == 2) 
     283        self._check_multiple_data(self.data[0]) 
     284        self._check_multiple_data(self.data[1]) 
     285        if isinstance(self.data[0], Data1D): 
     286            self._check_1d_data(self.data[0]) 
     287            self._check_2d_data(self.data[1]) 
     288        else: 
     289            self._check_1d_data(self.data[1]) 
     290            self._check_2d_data(self.data[0]) 
     291 
     292    def test_multiple_sasentries_multiplesasdatas(self): 
     293        self.data = self.loader.load( 
     294            self.datafile_multiplesasdata_multiplesasentry) 
     295        self.assertTrue(len(self.data) == 4) 
     296        self._check_multiple_data(self.data[0]) 
     297        self._check_multiple_data(self.data[1]) 
     298        self._check_multiple_data(self.data[2]) 
     299        self._check_multiple_data(self.data[3]) 
     300        for data in self.data: 
     301            if isinstance(data, Data1D): 
     302                self._check_1d_data(data) 
     303            else: 
     304                self._check_2d_data(data) 
    279305 
    280306    def _check_multiple_data(self, data): 
     
    305331        self.assertTrue(len(data.q_data) == 150*150) 
    306332        self.assertTrue(len(data.q_data) == len(data.data)) 
    307         print(data.err_data[10]) 
    308333        self.assertAlmostEqual(data.err_data[10], 0.186723989418) 
    309         self.assertAlmostEqual(data.data[10], 0.465181425808) 
     334        self.assertAlmostEqual(data.data[10], 0.465181) 
    310335        self.assertAlmostEqual(data.qx_data[10], -0.129) 
    311336        self.assertAlmostEqual(data.qy_data[10], -0.149) 
Note: See TracChangeset for help on using the changeset viewer.