Ignore:
Timestamp:
Jan 21, 2019 6:15:40 AM (5 years ago)
Author:
Piotr Rozyczko <piotr.rozyczko@…>
Branches:
ESS_GUI, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_opencl, ESS_GUI_sync_sascalc
Children:
d541324e
Parents:
3ca645bb
git-author:
Piotr Rozyczko <piotr.rozyczko@…> (01/21/19 06:12:08)
git-committer:
Piotr Rozyczko <piotr.rozyczko@…> (01/21/19 06:15:40)
Message:

Updated cansas read (cherrypicked and fixed from master).
Fixes: hdf5 returns byte strings so these need to be recasted properly.
​https://github.com/h5py/h5py/issues/379

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/file_converter/nxcansas_writer.py

    r574adc7 r8db20a9  
    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([isinstance(d, (Data1D, Data2D)) for d in dataset]) 
    9090        if not valid_data: 
    91             raise ValueError("All entries of dataset must be Data1D or Data2D objects") 
     91            raise ValueError("All entries of dataset must be Data1D or Data2D" 
     92                             "objects") 
    9293 
    9394        # Get run name and number from first Data object 
    … …  
    109110        sasentry.attrs['version'] = '1.0' 
    110111 
    111         i = 1 
    112  
    113         for data_obj in dataset: 
    114             data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i)) 
     112        for i, data_obj in enumerate(dataset): 
     113            data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i+1)) 
    115114            data_entry.attrs['canSAS_class'] = 'SASdata' 
    116115            if isinstance(data_obj, Data1D): 
    … …  
    118117            elif isinstance(data_obj, Data2D): 
    119118                self._write_2d_data(data_obj, data_entry) 
    120             i += 1 
    121119 
    122120        data_info = dataset[0] 
    … …  
    148146                sample_entry.create_dataset('details', data=details) 
    149147 
    150         # Instrumment metadata 
     148        # Instrument metadata 
    151149        instrument_entry = sasentry.create_group('sasinstrument') 
    152150        instrument_entry.attrs['canSAS_class'] = 'SASinstrument' 
    … …  
    176174            units=data_info.source.beam_size_unit, write_fn=_write_h5_float) 
    177175 
    178  
    179176        # Collimation metadata 
    180177        if len(data_info.collimation) > 0: 
    181             i = 1 
    182             for coll_info in data_info.collimation: 
     178            for i, coll_info in enumerate(data_info.collimation): 
    183179                collimation_entry = instrument_entry.create_group( 
    184                     'sascollimation{0:0=2d}'.format(i)) 
     180                    'sascollimation{0:0=2d}'.format(i + 1)) 
    185181                collimation_entry.attrs['canSAS_class'] = 'SAScollimation' 
    186182                if coll_info.length is not None: 
    187183                    _write_h5_float(collimation_entry, coll_info.length, 'SDD') 
    188                     collimation_entry['SDD'].attrs['units'] = coll_info.length_unit 
     184                    collimation_entry['SDD'].attrs['units'] =\ 
     185                        coll_info.length_unit 
    189186                if coll_info.name is not None: 
    190187                    collimation_entry['name'] = _h5_string(coll_info.name) 
    191188        else: 
    192             # Create a blank one - at least 1 set of collimation metadata 
    193             # required by format 
    194             collimation_entry = instrument_entry.create_group('sascollimation01') 
     189            # Create a blank one - at least 1 collimation required by format 
     190            instrument_entry.create_group('sascollimation01') 
    195191 
    196192        # Detector metadata 
    197193        if len(data_info.detector) > 0: 
    198194            i = 1 
    199             for det_info in data_info.detector: 
     195            for i, det_info in enumerate(data_info.detector): 
    200196                detector_entry = instrument_entry.create_group( 
    201                     'sasdetector{0:0=2d}'.format(i)) 
     197                    'sasdetector{0:0=2d}'.format(i + 1)) 
    202198                detector_entry.attrs['canSAS_class'] = 'SASdetector' 
    203199                if det_info.distance is not None: 
    204200                    _write_h5_float(detector_entry, det_info.distance, 'SDD') 
    205                     detector_entry['SDD'].attrs['units'] = det_info.distance_unit 
     201                    detector_entry['SDD'].attrs['units'] =\ 
     202                        det_info.distance_unit 
    206203                if det_info.name is not None: 
    207204                    detector_entry['name'] = _h5_string(det_info.name) 
    … …  
    209206                    detector_entry['name'] = _h5_string('') 
    210207                if det_info.slit_length is not None: 
    211                     _write_h5_float(detector_entry, det_info.slit_length, 'slit_length') 
    212                     detector_entry['slit_length'].attrs['units'] = det_info.slit_length_unit 
     208                    _write_h5_float(detector_entry, det_info.slit_length, 
     209                                    'slit_length') 
     210                    detector_entry['slit_length'].attrs['units'] =\ 
     211                        det_info.slit_length_unit 
    213212                _write_h5_vector(detector_entry, det_info.offset) 
    214213                # NXcanSAS doesn't save information about pitch, only roll 
    … …  
    224223                    names=['x_pixel_size', 'y_pixel_size'], 
    225224                    write_fn=_write_h5_float, units=det_info.pixel_size_unit) 
    226  
    227                 i += 1 
    228225        else: 
    229226            # Create a blank one - at least 1 detector required by format 
    … …  
    231228            detector_entry.attrs['canSAS_class'] = 'SASdetector' 
    232229            detector_entry.attrs['name'] = '' 
     230 
     231        # Process meta data 
     232        for i, process in enumerate(data_info.process): 
     233            process_entry = sasentry.create_group('sasprocess{0:0=2d}'.format( 
     234                i + 1)) 
     235            process_entry.attrs['canSAS_class'] = 'SASprocess' 
     236            if process.name: 
     237                name = _h5_string(process.name) 
     238                process_entry.create_dataset('name', data=name) 
     239            if process.date: 
     240                date = _h5_string(process.date) 
     241                process_entry.create_dataset('date', data=date) 
     242            if process.description: 
     243                desc = _h5_string(process.description) 
     244                process_entry.create_dataset('description', data=desc) 
     245            for j, term in enumerate(process.term): 
     246                # Don't save empty terms 
     247                if term: 
     248                    h5_term = _h5_string(term) 
     249                    process_entry.create_dataset('term{0:0=2d}'.format( 
     250                        j + 1), data=h5_term) 
     251            for j, note in enumerate(process.notes): 
     252                # Don't save empty notes 
     253                if note: 
     254                    h5_note = _h5_string(note) 
     255                    process_entry.create_dataset('note{0:0=2d}'.format( 
     256                        j + 1), data=h5_note) 
     257 
     258        # Transmission Spectrum 
     259        for i, trans in enumerate(data_info.trans_spectrum): 
     260            trans_entry = sasentry.create_group( 
     261                'sastransmission_spectrum{0:0=2d}'.format(i + 1)) 
     262            trans_entry.attrs['canSAS_class'] = 'SAStransmission_spectrum' 
     263            trans_entry.attrs['signal'] = 'T' 
     264            trans_entry.attrs['T_axes'] = 'T' 
     265            trans_entry.attrs['name'] = trans.name 
     266            if trans.timestamp is not '': 
     267                trans_entry.attrs['timestamp'] = trans.timestamp 
     268            transmission = trans_entry.create_dataset('T', 
     269                                                      data=trans.transmission) 
     270            transmission.attrs['unertainties'] = 'Tdev' 
     271            trans_entry.create_dataset('Tdev', 
     272                                       data=trans.transmission_deviation) 
     273            trans_entry.create_dataset('lambda', data=trans.wavelength) 
    233274 
    234275        note_entry = sasentry.create_group('sasnote'.format(i)) 
    … …  
    254295        data_entry.attrs['signal'] = 'I' 
    255296        data_entry.attrs['I_axes'] = 'Q' 
    256         data_entry.attrs['I_uncertainties'] = 'Idev' 
    257         data_entry.attrs['Q_indicies'] = 0 
    258  
    259         dI = data_obj.dy 
    260         if dI is None: 
    261             dI = np.zeros((data_obj.y.shape)) 
    262  
    263         data_entry.create_dataset('Q', data=data_obj.x) 
    264         data_entry.create_dataset('I', data=data_obj.y) 
    265         data_entry.create_dataset('Idev', data=dI) 
     297        data_entry.attrs['Q_indices'] = [0] 
     298        q_entry = data_entry.create_dataset('Q', data=data_obj.x) 
     299        q_entry.attrs['units'] = data_obj.x_unit 
     300        i_entry = data_entry.create_dataset('I', data=data_obj.y) 
     301        i_entry.attrs['units'] = data_obj.y_unit 
     302        if data_obj.dy is not None: 
     303            i_entry.attrs['uncertainties'] = 'Idev' 
     304            i_dev_entry = data_entry.create_dataset('Idev', data=data_obj.dy) 
     305            i_dev_entry.attrs['units'] = data_obj.y_unit 
     306        if data_obj.dx is not None: 
     307            q_entry.attrs['resolutions'] = 'dQ' 
     308            dq_entry = data_entry.create_dataset('dQ', data=data_obj.dx) 
     309            dq_entry.attrs['units'] = data_obj.x_unit 
     310        elif data_obj.dxl is not None: 
     311            q_entry.attrs['resolutions'] = ['dQl','dQw'] 
     312            dql_entry = data_entry.create_dataset('dQl', data=data_obj.dxl) 
     313            dql_entry.attrs['units'] = data_obj.x_unit 
     314            dqw_entry = data_entry.create_dataset('dQw', data=data_obj.dxw) 
     315            dqw_entry.attrs['units'] = data_obj.x_unit 
    266316 
    267317    def _write_2d_data(self, data, data_entry): 
    … …  
    273323        """ 
    274324        data_entry.attrs['signal'] = 'I' 
    275         data_entry.attrs['I_axes'] = 'Q,Q' 
    276         data_entry.attrs['I_uncertainties'] = 'Idev' 
    277         data_entry.attrs['Q_indicies'] = [0,1] 
     325        data_entry.attrs['I_axes'] = 'Qx,Qy' 
     326        data_entry.attrs['Q_indices'] = [0,1] 
    278327 
    279328        (n_rows, n_cols) = (len(data.y_bins), len(data.x_bins)) 
    280329 
    281         if n_rows == 0 and n_cols == 0: 
     330        if (n_rows == 0 and n_cols == 0) or (n_cols*n_rows != data.data.size): 
    282331            # Calculate rows and columns, assuming detector is square 
    283332            # Same logic as used in PlotPanel.py _get_bins 
    … …  
    288337                raise ValueError("Unable to calculate dimensions of 2D data") 
    289338 
    290         I = np.reshape(data.data, (n_rows, n_cols)) 
    291         dI = np.zeros((n_rows, n_cols)) 
    292         if not all(data.err_data == [None]): 
    293             dI = np.reshape(data.err_data, (n_rows, n_cols)) 
    294         qx =  np.reshape(data.qx_data, (n_rows, n_cols)) 
     339        intensity = np.reshape(data.data, (n_rows, n_cols)) 
     340        qx = np.reshape(data.qx_data, (n_rows, n_cols)) 
    295341        qy = np.reshape(data.qy_data, (n_rows, n_cols)) 
    296342 
    297         I_entry = data_entry.create_dataset('I', data=I) 
    298         I_entry.attrs['units'] = data.I_unit 
    299         Qx_entry = data_entry.create_dataset('Qx', data=qx) 
    300         Qx_entry.attrs['units'] = data.Q_unit 
    301         Qy_entry = data_entry.create_dataset('Qy', data=qy) 
    302         Qy_entry.attrs['units'] = data.Q_unit 
    303         Idev_entry = data_entry.create_dataset('Idev', data=dI) 
    304         Idev_entry.attrs['units'] = data.I_unit 
     343        i_entry = data_entry.create_dataset('I', data=intensity) 
     344        i_entry.attrs['units'] = data.I_unit 
     345        qx_entry = data_entry.create_dataset('Qx', data=qx) 
     346        qx_entry.attrs['units'] = data.Q_unit 
     347        qy_entry = data_entry.create_dataset('Qy', data=qy) 
     348        qy_entry.attrs['units'] = data.Q_unit 
     349        if (data.err_data is not None 
     350                and not all(v is None for v in data.err_data)): 
     351            d_i = np.reshape(data.err_data, (n_rows, n_cols)) 
     352            i_entry.attrs['uncertainties'] = 'Idev' 
     353            i_dev_entry = data_entry.create_dataset('Idev', data=d_i) 
     354            i_dev_entry.attrs['units'] = data.I_unit 
     355        if (data.dqx_data is not None 
     356                and not all(v is None for v in data.dqx_data)): 
     357            qx_entry.attrs['resolutions'] = 'dQx' 
     358            dqx_entry = data_entry.create_dataset('dQx', data=data.dqx_data) 
     359            dqx_entry.attrs['units'] = data.Q_unit 
     360        if (data.dqy_data is not None 
     361                and not all(v is None for v in data.dqy_data)): 
     362            qy_entry.attrs['resolutions'] = 'dQy' 
     363            dqy_entry = data_entry.create_dataset('dQy', data=data.dqy_data) 
     364            dqy_entry.attrs['units'] = data.Q_unit 
     365        if data.mask is not None and not all(v is None for v in data.mask): 
     366            data_entry.attrs['mask'] = "mask" 
     367            mask = np.invert(np.asarray(data.mask, dtype=bool)) 
     368            data_entry.create_dataset('mask', data=mask) 
Note: See TracChangeset for help on using the changeset viewer.