Changes in / [9a0fc50:356af60e] in sasview


Ignore:
Files:
12 added
10 deleted
17 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/data_util/nxsunit.py

    rb011ecb r574adc7  
    136136    sld = { '10^-6 Angstrom^-2': 1e-6, 'Angstrom^-2': 1 } 
    137137    Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1, 
    138           '1/Angstrom': 1, '1/angstrom': 1, 'A^{-1}': 1, 'cm^{-1}': 1e-8, 
    139138          '10^-3 Angstrom^-1': 1e-3, '1/cm': 1e-8, '1/m': 1e-10, 
    140           'nm^{-1}': 1, 'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 } 
     139          'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 } 
    141140 
    142141    _caret_optional(sld) 
    … …  
    158157    # units for that particular dimension. 
    159158    # Note: don't have support for dimensionless units. 
    160     unknown = {None:1, '???':1, '': 1, 'a.u.': 1, 'Counts': 1, 'counts': 1} 
     159    unknown = {None:1, '???':1, '': 1, 'a.u.': 1} 
    161160 
    162161    def __init__(self, name): 

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

    r4fdcc65 rdeaa0c6  
    954954        _str += "Data:\n" 
    955955        _str += "   Type:         %s\n" % self.__class__.__name__ 
    956         _str += "   X-axis:       %s\t[%s]\n" % (self._xaxis, self._xunit) 
    957         _str += "   Y-axis:       %s\t[%s]\n" % (self._yaxis, self._yunit) 
     956        _str += "   X- & Y-axis:  %s\t[%s]\n" % (self._yaxis, self._yunit) 
    958957        _str += "   Z-axis:       %s\t[%s]\n" % (self._zaxis, self._zunit) 
    959958        _str += "   Length:       %g \n" % (len(self.data)) 
    … …  
    984983                           qx_data=qx_data, qy_data=qy_data, 
    985984                           q_data=q_data, mask=mask) 
    986  
    987         clone._xaxis = self._xaxis 
    988         clone._yaxis = self._yaxis 
    989         clone._zaxis = self._zaxis 
    990         clone._xunit = self._xunit 
    991         clone._yunit = self._yunit 
    992         clone._zunit = self._zunit 
    993         clone.x_bins = self.x_bins 
    994         clone.y_bins = self.y_bins 
    995985 
    996986        clone.title = self.title 
    … …  
    11631153def combine_data_info_with_plottable(data, datainfo): 
    11641154    """ 
    1165     A function that combines the DataInfo data in self.current_datainto with a 
    1166     plottable_1D or 2D data object. 
     1155    A function that combines the DataInfo data in self.current_datainto with a plottable_1D or 2D data object. 
    11671156 
    11681157    :param data: A plottable_1D or plottable_2D data object 
    … …  
    11821171        final_dataset.yaxis(data._yaxis, data._yunit) 
    11831172    elif isinstance(data, plottable_2D): 
    1184         final_dataset = Data2D(data.data, data.err_data, data.qx_data, 
    1185                                data.qy_data, data.q_data, data.mask, 
    1186                                data.dqx_data, data.dqy_data) 
     1173        final_dataset = Data2D(data.data, data.err_data, data.qx_data, data.qy_data, data.q_data, 
     1174                               data.mask, data.dqx_data, data.dqy_data) 
    11871175        final_dataset.xaxis(data._xaxis, data._xunit) 
    11881176        final_dataset.yaxis(data._yaxis, data._yunit) 
    11891177        final_dataset.zaxis(data._zaxis, data._zunit) 
    1190         final_dataset.y_bins = data.y_bins 
    1191         final_dataset.x_bins = data.x_bins 
     1178        if len(data.data.shape) == 2: 
     1179            n_rows, n_cols = data.data.shape 
     1180            final_dataset.y_bins = data.qy_data[0::int(n_cols)] 
     1181            final_dataset.x_bins = data.qx_data[:int(n_cols)] 
    11921182    else: 
    1193         return_string = ("Should Never Happen: _combine_data_info_with_plottabl" 
    1194                          "e input is not a plottable1d or plottable2d data " 
    1195                          "object") 
     1183        return_string = "Should Never Happen: _combine_data_info_with_plottable input is not a plottable1d or " + \ 
     1184                        "plottable2d data object" 
    11961185        return return_string 
    11971186 

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

    r8d5e11c r4a8d55c  
    1616from .data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\ 
    1717    combine_data_info_with_plottable 
    18 from sas.sascalc.data_util.nxsunit import Converter 
    1918 
    2019logger = logging.getLogger(__name__) 
    … …  
    3736                       "load the file was made, but, should it be successful, " 
    3837                       "SasView cannot guarantee the accuracy of the data.") 
    39  
    4038 
    4139class FileReader(object): 
    … …  
    10098                    if len(self.output) > 0: 
    10199                        # Sort the data that's been loaded 
    102                         self.convert_data_units() 
    103                         self.sort_data() 
     100                        self.sort_one_d_data() 
     101                        self.sort_two_d_data() 
    104102        else: 
    105103            msg = "Unable to find file at: {}\n".format(filepath) 
    … …  
    142140        Returns the entire file as a string. 
    143141        """ 
     142        #return self.f_open.read() 
    144143        return decode(self.f_open.read()) 
    145144 
    … …  
    167166        self.output.append(data_obj) 
    168167 
    169     def sort_data(self): 
     168    def sort_one_d_data(self): 
    170169        """ 
    171170        Sort 1D data along the X axis for consistency 
    … …  
    175174                # Normalize the units for 
    176175                data.x_unit = self.format_unit(data.x_unit) 
    177                 data._xunit = data.x_unit 
    178176                data.y_unit = self.format_unit(data.y_unit) 
    179                 data._yunit = data.y_unit 
    180177                # Sort data by increasing x and remove 1st point 
    181178                ind = np.lexsort((data.y, data.x)) 
    … …  
    206203                    data.ymin = np.min(data.y) 
    207204                    data.ymax = np.max(data.y) 
    208             elif isinstance(data, Data2D): 
    209                 # Normalize the units for 
    210                 data.Q_unit = self.format_unit(data.Q_unit) 
    211                 data.I_unit = self.format_unit(data.I_unit) 
    212                 data._xunit = data.Q_unit 
    213                 data._yunit = data.Q_unit 
    214                 data._zunit = data.I_unit 
    215                 data.data = data.data.astype(np.float64) 
    216                 data.qx_data = data.qx_data.astype(np.float64) 
    217                 data.xmin = np.min(data.qx_data) 
    218                 data.xmax = np.max(data.qx_data) 
    219                 data.qy_data = data.qy_data.astype(np.float64) 
    220                 data.ymin = np.min(data.qy_data) 
    221                 data.ymax = np.max(data.qy_data) 
    222                 data.q_data = np.sqrt(data.qx_data * data.qx_data 
    223                                          + data.qy_data * data.qy_data) 
    224                 if data.err_data is not None: 
    225                     data.err_data = data.err_data.astype(np.float64) 
    226                 if data.dqx_data is not None: 
    227                     data.dqx_data = data.dqx_data.astype(np.float64) 
    228                 if data.dqy_data is not None: 
    229                     data.dqy_data = data.dqy_data.astype(np.float64) 
    230                 if data.mask is not None: 
    231                     data.mask = data.mask.astype(dtype=bool) 
    232  
    233                 if len(data.data.shape) == 2: 
    234                     n_rows, n_cols = data.data.shape 
    235                     data.y_bins = data.qy_data[0::int(n_cols)] 
    236                     data.x_bins = data.qx_data[:int(n_cols)] 
    237                     data.data = data.data.flatten() 
    238                     data = self._remove_nans_in_data(data) 
    239                 if len(data.data) > 0: 
    240                     data.xmin = np.min(data.qx_data) 
    241                     data.xmax = np.max(data.qx_data) 
    242                     data.ymin = np.min(data.qy_data) 
    243                     data.ymax = np.max(data.qx_data) 
    244205 
    245206    @staticmethod 
    … …  
    281242        return data 
    282243 
    283     @staticmethod 
    284     def set_default_1d_units(data): 
    285         """ 
    286         Set the x and y axes to the default 1D units 
    287         :param data: 1D data set 
    288         :return: 
    289         """ 
    290         data.xaxis("\\rm{Q}", '1/A') 
    291         data.yaxis("\\rm{Intensity}", "1/cm") 
    292         return data 
    293  
    294     @staticmethod 
    295     def set_default_2d_units(data): 
    296         """ 
    297         Set the x and y axes to the default 2D units 
    298         :param data: 2D data set 
    299         :return: 
    300         """ 
    301         data.xaxis("\\rm{Q_{x}}", '1/A') 
    302         data.yaxis("\\rm{Q_{y}}", '1/A') 
    303         data.zaxis("\\rm{Intensity}", "1/cm") 
    304         return data 
    305  
    306     def convert_data_units(self, default_q_unit="1/A", default_i_unit="1/cm"): 
    307         """ 
    308         Converts al; data to the sasview default of units of A^{-1} for Q and 
    309         cm^{-1} for I. 
    310         :param default_q_unit: The default Q unit used by Sasview 
    311         :param default_i_unit: The default I unit used by Sasview 
    312         """ 
    313         new_output = [] 
    314         for data in self.output: 
    315             if data.isSesans: 
    316                 new_output.append(data) 
    317                 continue 
    318             file_x_unit = data._xunit 
    319             data_conv_x = Converter(file_x_unit) 
    320             file_y_unit = data._yunit 
    321             data_conv_y = Converter(file_y_unit) 
    322             if isinstance(data, Data1D): 
    323                 try: 
    324                     data.x = data_conv_x(data.x, units=default_q_unit) 
    325                     data._xunit = default_q_unit 
    326                     data.x_unit = default_q_unit 
    327                     if data.dx is not None: 
    328                         data.dx = data_conv_x(data.dx, units=default_q_unit) 
    329                     if data.dxl is not None: 
    330                         data.dxl = data_conv_x(data.dxl, units=default_q_unit) 
    331                     if data.dxw is not None: 
    332                         data.dxw = data_conv_x(data.dxw, units=default_q_unit) 
    333                 except KeyError: 
    334                     message = "Unable to convert Q units from {0} to 1/A." 
    335                     message.format(default_q_unit) 
    336                     data.errors.append(message) 
    337                 try: 
    338                     data.y = data_conv_y(data.y, units=default_i_unit) 
    339                     data._yunit = default_i_unit 
    340                     data.y_unit = default_i_unit 
    341                     if data.dy is not None: 
    342                         data.dy = data_conv_y(data.dy, units=default_i_unit) 
    343                 except KeyError: 
    344                     message = "Unable to convert I units from {0} to 1/cm." 
    345                     message.format(default_q_unit) 
    346                     data.errors.append(message) 
    347             elif isinstance(data, Data2D): 
    348                 try: 
    349                     data.qx_data = data_conv_x(data.qx_data, 
    350                                                units=default_q_unit) 
    351                     if data.dqx_data is not None: 
    352                         data.dqx_data = data_conv_x(data.dqx_data, 
    353                                                     units=default_q_unit) 
    354                     data.qy_data = data_conv_y(data.qy_data, 
    355                                                units=default_q_unit) 
    356                     if data.dqy_data is not None: 
    357                         data.dqy_data = data_conv_y(data.dqy_data, 
    358                                                     units=default_q_unit) 
    359                 except KeyError: 
    360                     message = "Unable to convert Q units from {0} to 1/A." 
    361                     message.format(default_q_unit) 
    362                     data.errors.append(message) 
    363                 try: 
    364                     file_z_unit = data._zunit 
    365                     data_conv_z = Converter(file_z_unit) 
    366                     data.data = data_conv_z(data.data, units=default_i_unit) 
    367                     if data.err_data is not None: 
    368                         data.err_data = data_conv_z(data.err_data, 
    369                                                     units=default_i_unit) 
    370                 except KeyError: 
    371                     message = "Unable to convert I units from {0} to 1/cm." 
    372                     message.format(default_q_unit) 
    373                     data.errors.append(message) 
    374             else: 
    375                 # TODO: Throw error of some sort... 
    376                 pass 
    377             new_output.append(data) 
    378         self.output = new_output 
     244    def sort_two_d_data(self): 
     245        for dataset in self.output: 
     246            if isinstance(dataset, Data2D): 
     247                # Normalize the units for 
     248                dataset.x_unit = self.format_unit(dataset.Q_unit) 
     249                dataset.y_unit = self.format_unit(dataset.I_unit) 
     250                dataset.data = dataset.data.astype(np.float64) 
     251                dataset.qx_data = dataset.qx_data.astype(np.float64) 
     252                dataset.xmin = np.min(dataset.qx_data) 
     253                dataset.xmax = np.max(dataset.qx_data) 
     254                dataset.qy_data = dataset.qy_data.astype(np.float64) 
     255                dataset.ymin = np.min(dataset.qy_data) 
     256                dataset.ymax = np.max(dataset.qy_data) 
     257                dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data 
     258                                         + dataset.qy_data * dataset.qy_data) 
     259                if dataset.err_data is not None: 
     260                    dataset.err_data = dataset.err_data.astype(np.float64) 
     261                if dataset.dqx_data is not None: 
     262                    dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
     263                if dataset.dqy_data is not None: 
     264                    dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
     265                if dataset.mask is not None: 
     266                    dataset.mask = dataset.mask.astype(dtype=bool) 
     267 
     268                if len(dataset.data.shape) == 2: 
     269                    n_rows, n_cols = dataset.data.shape 
     270                    dataset.y_bins = dataset.qy_data[0::int(n_cols)] 
     271                    dataset.x_bins = dataset.qx_data[:int(n_cols)] 
     272                dataset.data = dataset.data.flatten() 
     273                dataset = self._remove_nans_in_data(dataset) 
     274                if len(dataset.data) > 0: 
     275                    dataset.xmin = np.min(dataset.qx_data) 
     276                    dataset.xmax = np.max(dataset.qx_data) 
     277                    dataset.ymin = np.min(dataset.qy_data) 
     278                    dataset.ymax = np.max(dataset.qx_data) 
    379279 
    380280    def format_unit(self, unit=None): 
    … …  
    467367                    self.current_dataset.qy_data)) 
    468368            if has_error_dy: 
    469                 self.current_dataset.err_data = self.current_dataset.err_data[ 
    470                     x != 0] 
     369                self.current_dataset.err_data = self.current_dataset.err_data[x != 0] 
    471370            if has_error_dqx: 
    472                 self.current_dataset.dqx_data = self.current_dataset.dqx_data[ 
    473                     x != 0] 
     371                self.current_dataset.dqx_data = self.current_dataset.dqx_data[x != 0] 
    474372            if has_error_dqy: 
    475                 self.current_dataset.dqy_data = self.current_dataset.dqy_data[ 
    476                     x != 0] 
     373                self.current_dataset.dqy_data = self.current_dataset.dqy_data[x != 0] 
    477374            if has_mask: 
    478375                self.current_dataset.mask = self.current_dataset.mask[x != 0] 

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

    r8d5e11c r4a8d55c  
    367367            try: 
    368368                return fn(path, data) 
    369             except Exception as exep: 
     369            except Exception: 
    370370                pass  # give other loaders a chance to succeed 
    371371        # If we get here it is because all loaders failed 
    372         raise exep # raises last exception 
     372        raise  # reraises last exception 
    373373 
    374374 

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

    rbd5c3b1 rbd5c3b1  
    225225            raise ValueError("ascii_reader: could not load file") 
    226226 
    227         self.current_dataset = self.set_default_1d_units(self.current_dataset) 
    228227        if data_conv_q is not None: 
    229228            self.current_dataset.xaxis("\\rm{Q}", base_q_unit) 
     229        else: 
     230            self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
    230231        if data_conv_i is not None: 
    231232            self.current_dataset.yaxis("\\rm{Intensity}", base_i_unit) 
     233        else: 
     234            self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 
    232235 
    233236        # Store loading process information 

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

    r3bab401 r7b07fbe  
    157157 
    158158        self.remove_empty_q_values() 
    159         self.current_dataset = self.set_default_1d_units(self.current_dataset) 
     159        self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
     160        self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 
    160161 
    161162        # Store loading process information 

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

    r058f6c3 r2469df7  
    812812            node.append(point) 
    813813            self.write_node(point, "Q", datainfo.x[i], 
    814                             {'unit': datainfo._xunit}) 
     814                            {'unit': datainfo.x_unit}) 
    815815            if len(datainfo.y) >= i: 
    816816                self.write_node(point, "I", datainfo.y[i], 
    817                                 {'unit': datainfo._yunit}) 
     817                                {'unit': datainfo.y_unit}) 
    818818            if datainfo.dy is not None and len(datainfo.dy) > i: 
    819819                self.write_node(point, "Idev", datainfo.dy[i], 
    820                                 {'unit': datainfo._yunit}) 
     820                                {'unit': datainfo.y_unit}) 
    821821            if datainfo.dx is not None and len(datainfo.dx) > i: 
    822822                self.write_node(point, "Qdev", datainfo.dx[i], 
    823                                 {'unit': datainfo._xunit}) 
     823                                {'unit': datainfo.x_unit}) 
    824824            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    825825                self.write_node(point, "dQw", datainfo.dxw[i], 
    826                                 {'unit': datainfo._xunit}) 
     826                                {'unit': datainfo.x_unit}) 
    827827            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    828828                self.write_node(point, "dQl", datainfo.dxl[i], 
    829                                 {'unit': datainfo._xunit}) 
     829                                {'unit': datainfo.x_unit}) 
    830830        if datainfo.isSesans: 
    831831            sesans_attrib = {'x_axis': datainfo._xaxis, 

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

    rfeec1cb r61f329f0  
    1212    Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \ 
    1313    TransmissionSpectrum, Detector 
     14from ..data_info import combine_data_info_with_plottable 
    1415from ..loader_exceptions import FileContentsException, DefaultReaderException 
    1516from ..file_reader_base_class import FileReader, decode 
    1617 
    17  
    1818def h5attr(node, key, default=None): 
    1919    return decode(node.attrs.get(key, default)) 
    20  
    2120 
    2221class Reader(FileReader): 
    … …  
    3938    # CanSAS version 
    4039    cansas_version = 2.0 
     40    # Logged warnings or messages 
     41    logging = None 
     42    # List of errors for the current data set 
     43    errors = None 
     44    # Raw file contents to be processed 
     45    raw_data = None 
     46    # List of plottable1D objects that should be linked to the current_datainfo 
     47    data1d = None 
     48    # List of plottable2D objects that should be linked to the current_datainfo 
     49    data2d = None 
    4150    # Data type name 
    42     type_name = "NXcanSAS" 
     51    type_name = "CanSAS 2.0" 
    4352    # Wildcards 
    44     type = ["NXcanSAS HDF5 Files (*.h5)|*.h5|"] 
     53    type = ["CanSAS 2.0 HDF5 Files (*.h5)|*.h5"] 
    4554    # List of allowed extensions 
    4655    ext = ['.h5', '.H5'] 
    … …  
    7281                except Exception as e: 
    7382                    if extension not in self.ext: 
    74                         msg = "NXcanSAS Reader could not load file {}".format( 
    75                             basename + extension) 
     83                        msg = "CanSAS2.0 HDF5 Reader could not load file {}".format(basename + extension) 
    7684                        raise DefaultReaderException(msg) 
    7785                    raise FileContentsException(e.message) 
    … …  
    8795                    self.raw_data.close() 
    8896 
    89                 for data_set in self.output: 
    90                     if isinstance(data_set, Data1D): 
    91                         if data_set.x.size < 5: 
    92                             exception = FileContentsException( 
    93                                 "Fewer than 5 data points found.") 
    94                             data_set.errors.append(exception) 
     97                for dataset in self.output: 
     98                    if isinstance(dataset, Data1D): 
     99                        if dataset.x.size < 5: 
     100                            self.output = [] 
     101                            raise FileContentsException("Fewer than 5 data points found.") 
    95102 
    96103    def reset_state(self): 
    … …  
    104111        self.errors = set() 
    105112        self.logging = [] 
    106         self.q_name = [] 
    107         self.mask_name = u'' 
    108         self.i_name = u'' 
    109         self.i_node = u'' 
    110         self.q_uncertainties = None 
    111         self.q_resolutions = None 
    112         self.i_uncertainties = u'' 
    113113        self.parent_class = u'' 
    114114        self.detector = Detector() 
    … …  
    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] 
    135133            if class_name is None: 
    136134                class_name = h5attr(value, u'NX_class') 
    … …  
    142140            if isinstance(value, h5py.Group): 
    143141                # Set parent class before recursion 
    144                 last_parent_class = self.parent_class 
    145142                self.parent_class = class_name 
    146143                parent_list.append(key) 
    … …  
    150147                    self.add_data_set(key) 
    151148                elif class_prog.match(u'SASdata'): 
    152                     self._initialize_new_data_set(value) 
    153                     self._find_data_attributes(value) 
     149                    self._initialize_new_data_set(parent_list) 
    154150                # Recursion step to access data within the group 
    155151                self.read_children(value, parent_list) 
     152                # Reset parent class when returning from recursive method 
     153                self.parent_class = class_name 
    156154                self.add_intermediate() 
    157                 # Reset parent class when returning from recursive method 
    158                 self.parent_class = last_parent_class 
    159155                parent_list.remove(key) 
    160156 
    161157            elif isinstance(value, h5py.Dataset): 
    162158                # If this is a dataset, store the data appropriately 
    163                 data_set = value.value 
     159                data_set = data[key][:] 
    164160                unit = self._get_unit(value) 
     161 
     162                # I and Q Data 
     163                if key == u'I': 
     164                    if isinstance(self.current_dataset, plottable_2D): 
     165                        self.current_dataset.data = data_set 
     166                        self.current_dataset.zaxis("Intensity", unit) 
     167                    else: 
     168                        self.current_dataset.y = data_set.flatten() 
     169                        self.current_dataset.yaxis("Intensity", unit) 
     170                    continue 
     171                elif key == u'Idev': 
     172                    if isinstance(self.current_dataset, plottable_2D): 
     173                        self.current_dataset.err_data = data_set.flatten() 
     174                    else: 
     175                        self.current_dataset.dy = data_set.flatten() 
     176                    continue 
     177                elif key == u'Q': 
     178                    self.current_dataset.xaxis("Q", unit) 
     179                    if isinstance(self.current_dataset, plottable_2D): 
     180                        self.current_dataset.q = data_set.flatten() 
     181                    else: 
     182                        self.current_dataset.x = data_set.flatten() 
     183                    continue 
     184                elif key == u'Qdev': 
     185                    self.current_dataset.dx = data_set.flatten() 
     186                    continue 
     187                elif key == u'dQw': 
     188                    self.current_dataset.dxw = data_set.flatten() 
     189                    continue 
     190                elif key == u'dQl': 
     191                    self.current_dataset.dxl = data_set.flatten() 
     192                    continue 
     193                elif key == u'Qy': 
     194                    self.current_dataset.yaxis("Q_y", unit) 
     195                    self.current_dataset.qy_data = data_set.flatten() 
     196                    continue 
     197                elif key == u'Qydev': 
     198                    self.current_dataset.dqy_data = data_set.flatten() 
     199                    continue 
     200                elif key == u'Qx': 
     201                    self.current_dataset.xaxis("Q_x", unit) 
     202                    self.current_dataset.qx_data = data_set.flatten() 
     203                    continue 
     204                elif key == u'Qxdev': 
     205                    self.current_dataset.dqx_data = data_set.flatten() 
     206                    continue 
     207                elif key == u'Mask': 
     208                    self.current_dataset.mask = data_set.flatten() 
     209                    continue 
     210                # Transmission Spectrum 
     211                elif (key == u'T' 
     212                      and self.parent_class == u'SAStransmission_spectrum'): 
     213                    self.trans_spectrum.transmission = data_set.flatten() 
     214                    continue 
     215                elif (key == u'Tdev' 
     216                      and self.parent_class == u'SAStransmission_spectrum'): 
     217                    self.trans_spectrum.transmission_deviation = \ 
     218                        data_set.flatten() 
     219                    continue 
     220                elif (key == u'lambda' 
     221                      and self.parent_class == u'SAStransmission_spectrum'): 
     222                    self.trans_spectrum.wavelength = data_set.flatten() 
     223                    continue 
    165224 
    166225                for data_point in data_set: 
    … …  
    173232                    if key == u'definition': 
    174233                        self.current_datainfo.meta_data['reader'] = data_point 
    175                     # Run 
    176234                    elif key == u'run': 
    177235                        self.current_datainfo.run.append(data_point) 
    … …  
    182240                        except Exception: 
    183241                            pass 
    184                     # Title 
    185242                    elif key == u'title': 
    186243                        self.current_datainfo.title = data_point 
    187                     # Note 
    188244                    elif key == u'SASnote': 
    189245                        self.current_datainfo.notes.append(data_point) 
     246 
    190247                    # Sample Information 
    191                     elif self.parent_class == u'SASsample': 
    192                         self.process_sample(data_point, key) 
     248                    # CanSAS 2.0 format 
     249                    elif key == u'Title' and self.parent_class == u'SASsample': 
     250                        self.current_datainfo.sample.name = data_point 
     251                    # NXcanSAS format 
     252                    elif key == u'name' and self.parent_class == u'SASsample': 
     253                        self.current_datainfo.sample.name = data_point 
     254                    # NXcanSAS format 
     255                    elif key == u'ID' and self.parent_class == u'SASsample': 
     256                        self.current_datainfo.sample.name = data_point 
     257                    elif (key == u'thickness' 
     258                          and self.parent_class == u'SASsample'): 
     259                        self.current_datainfo.sample.thickness = data_point 
     260                    elif (key == u'temperature' 
     261                          and self.parent_class == u'SASsample'): 
     262                        self.current_datainfo.sample.temperature = data_point 
     263                    elif (key == u'transmission' 
     264                          and self.parent_class == u'SASsample'): 
     265                        self.current_datainfo.sample.transmission = data_point 
     266                    elif (key == u'x_position' 
     267                          and self.parent_class == u'SASsample'): 
     268                        self.current_datainfo.sample.position.x = data_point 
     269                    elif (key == u'y_position' 
     270                          and self.parent_class == u'SASsample'): 
     271                        self.current_datainfo.sample.position.y = data_point 
     272                    elif key == u'pitch' and self.parent_class == u'SASsample': 
     273                        self.current_datainfo.sample.orientation.x = data_point 
     274                    elif key == u'yaw' and self.parent_class == u'SASsample': 
     275                        self.current_datainfo.sample.orientation.y = data_point 
     276                    elif key == u'roll' and self.parent_class == u'SASsample': 
     277                        self.current_datainfo.sample.orientation.z = data_point 
     278                    elif (key == u'details' 
     279                          and self.parent_class == u'SASsample'): 
     280                        self.current_datainfo.sample.details.append(data_point) 
     281 
    193282                    # Instrumental Information 
    194283                    elif (key == u'name' 
    195284                          and self.parent_class == u'SASinstrument'): 
    196285                        self.current_datainfo.instrument = data_point 
    197                     # Detector 
    198                     elif self.parent_class == u'SASdetector': 
    199                         self.process_detector(data_point, key, unit) 
    200                     # Collimation 
    201                     elif self.parent_class == u'SAScollimation': 
    202                         self.process_collimation(data_point, key, unit) 
    203                     # Aperture 
    204                     elif self.parent_class == u'SASaperture': 
    205                         self.process_aperture(data_point, key) 
     286                    elif key == u'name' and self.parent_class == u'SASdetector': 
     287                        self.detector.name = data_point 
     288                    elif key == u'SDD' and self.parent_class == u'SASdetector': 
     289                        self.detector.distance = float(data_point) 
     290                        self.detector.distance_unit = unit 
     291                    elif (key == u'slit_length' 
     292                          and self.parent_class == u'SASdetector'): 
     293                        self.detector.slit_length = float(data_point) 
     294                        self.detector.slit_length_unit = unit 
     295                    elif (key == u'x_position' 
     296                          and self.parent_class == u'SASdetector'): 
     297                        self.detector.offset.x = float(data_point) 
     298                        self.detector.offset_unit = unit 
     299                    elif (key == u'y_position' 
     300                          and self.parent_class == u'SASdetector'): 
     301                        self.detector.offset.y = float(data_point) 
     302                        self.detector.offset_unit = unit 
     303                    elif (key == u'pitch' 
     304                          and self.parent_class == u'SASdetector'): 
     305                        self.detector.orientation.x = float(data_point) 
     306                        self.detector.orientation_unit = unit 
     307                    elif key == u'roll' and self.parent_class == u'SASdetector': 
     308                        self.detector.orientation.z = float(data_point) 
     309                        self.detector.orientation_unit = unit 
     310                    elif key == u'yaw' and self.parent_class == u'SASdetector': 
     311                        self.detector.orientation.y = float(data_point) 
     312                        self.detector.orientation_unit = unit 
     313                    elif (key == u'beam_center_x' 
     314                          and self.parent_class == u'SASdetector'): 
     315                        self.detector.beam_center.x = float(data_point) 
     316                        self.detector.beam_center_unit = unit 
     317                    elif (key == u'beam_center_y' 
     318                          and self.parent_class == u'SASdetector'): 
     319                        self.detector.beam_center.y = float(data_point) 
     320                        self.detector.beam_center_unit = unit 
     321                    elif (key == u'x_pixel_size' 
     322                          and self.parent_class == u'SASdetector'): 
     323                        self.detector.pixel_size.x = float(data_point) 
     324                        self.detector.pixel_size_unit = unit 
     325                    elif (key == u'y_pixel_size' 
     326                          and self.parent_class == u'SASdetector'): 
     327                        self.detector.pixel_size.y = float(data_point) 
     328                        self.detector.pixel_size_unit = unit 
     329                    elif (key == u'distance' 
     330                          and self.parent_class == u'SAScollimation'): 
     331                        self.collimation.length = data_point 
     332                        self.collimation.length_unit = unit 
     333                    elif (key == u'name' 
     334                          and self.parent_class == u'SAScollimation'): 
     335                        self.collimation.name = data_point 
     336                    elif (key == u'shape' 
     337                          and self.parent_class == u'SASaperture'): 
     338                        self.aperture.shape = data_point 
     339                    elif (key == u'x_gap' 
     340                          and self.parent_class == u'SASaperture'): 
     341                        self.aperture.size.x = data_point 
     342                    elif (key == u'y_gap' 
     343                          and self.parent_class == u'SASaperture'): 
     344                        self.aperture.size.y = data_point 
     345 
    206346                    # Process Information 
    207                     elif self.parent_class == u'SASprocess': # CanSAS 2.0 
    208                         self.process_process(data_point, key) 
     347                    elif (key == u'Title' 
     348                          and self.parent_class == u'SASprocess'): # CanSAS 2.0 
     349                        self.process.name = data_point 
     350                    elif (key == u'name' 
     351                          and self.parent_class == u'SASprocess'): # NXcanSAS 
     352                        self.process.name = data_point 
     353                    elif (key == u'description' 
     354                          and self.parent_class == u'SASprocess'): 
     355                        self.process.description = data_point 
     356                    elif key == u'date' and self.parent_class == u'SASprocess': 
     357                        self.process.date = data_point 
     358                    elif key == u'term' and self.parent_class == u'SASprocess': 
     359                        self.process.term = data_point 
     360                    elif self.parent_class == u'SASprocess': 
     361                        self.process.notes.append(data_point) 
     362 
    209363                    # Source 
    210                     elif self.parent_class == u'SASsource': 
    211                         self.process_source(data_point, key, unit) 
     364                    elif (key == u'wavelength' 
     365                          and self.parent_class == u'SASdata'): 
     366                        self.current_datainfo.source.wavelength = data_point 
     367                        self.current_datainfo.source.wavelength_unit = unit 
     368                    elif (key == u'incident_wavelength' 
     369                          and self.parent_class == 'SASsource'): 
     370                        self.current_datainfo.source.wavelength = data_point 
     371                        self.current_datainfo.source.wavelength_unit = unit 
     372                    elif (key == u'wavelength_max' 
     373                          and self.parent_class == u'SASsource'): 
     374                        self.current_datainfo.source.wavelength_max = data_point 
     375                        self.current_datainfo.source.wavelength_max_unit = unit 
     376                    elif (key == u'wavelength_min' 
     377                          and self.parent_class == u'SASsource'): 
     378                        self.current_datainfo.source.wavelength_min = data_point 
     379                        self.current_datainfo.source.wavelength_min_unit = unit 
     380                    elif (key == u'incident_wavelength_spread' 
     381                          and self.parent_class == u'SASsource'): 
     382                        self.current_datainfo.source.wavelength_spread = \ 
     383                            data_point 
     384                        self.current_datainfo.source.wavelength_spread_unit = \ 
     385                            unit 
     386                    elif (key == u'beam_size_x' 
     387                          and self.parent_class == u'SASsource'): 
     388                        self.current_datainfo.source.beam_size.x = data_point 
     389                        self.current_datainfo.source.beam_size_unit = unit 
     390                    elif (key == u'beam_size_y' 
     391                          and self.parent_class == u'SASsource'): 
     392                        self.current_datainfo.source.beam_size.y = data_point 
     393                        self.current_datainfo.source.beam_size_unit = unit 
     394                    elif (key == u'beam_shape' 
     395                          and self.parent_class == u'SASsource'): 
     396                        self.current_datainfo.source.beam_shape = data_point 
     397                    elif (key == u'radiation' 
     398                          and self.parent_class == u'SASsource'): 
     399                        self.current_datainfo.source.radiation = data_point 
     400                    elif (key == u'transmission' 
     401                          and self.parent_class == u'SASdata'): 
     402                        self.current_datainfo.sample.transmission = data_point 
     403 
    212404                    # Everything else goes in meta_data 
    213                     elif self.parent_class == u'SASdata': 
    214                         if isinstance(self.current_dataset, plottable_2D): 
    215                             self.process_2d_data_object(data_set, key, unit) 
    216                         else: 
    217                             self.process_1d_data_object(data_set, key, unit) 
    218  
    219                         break 
    220                     elif self.parent_class == u'SAStransmission_spectrum': 
    221                         self.process_trans_spectrum(data_set, key) 
    222                         break 
    223405                    else: 
    224406                        new_key = self._create_unique_key( 
    … …  
    229411                # I don't know if this reachable code 
    230412                self.errors.add("ShouldNeverHappenException") 
    231  
    232     def process_1d_data_object(self, data_set, key, unit): 
    233         """ 
    234         SASdata processor method for 1d data items 
    235         :param data_set: data from HDF5 file 
    236         :param key: canSAS_class attribute 
    237         :param unit: unit attribute 
    238         """ 
    239         if key == self.i_name: 
    240             self.current_dataset.y = data_set.flatten() 
    241             self.current_dataset.yaxis("Intensity", unit) 
    242         elif key == self.i_uncertainties: 
    243             self.current_dataset.dy = data_set.flatten() 
    244         elif key in self.q_name: 
    245             self.current_dataset.xaxis("Q", unit) 
    246             self.current_dataset.x = data_set.flatten() 
    247         elif key in self.q_uncertainties or key in self.q_resolutions: 
    248             if (len(self.q_resolutions) > 1 
    249                     and np.where(self.q_resolutions == key)[0] == 0): 
    250                 self.current_dataset.dxw = data_set.flatten() 
    251             elif (len(self.q_resolutions) > 1 
    252                   and np.where(self.q_resolutions == key)[0] == 1): 
    253                 self.current_dataset.dxl = data_set.flatten() 
    254             else: 
    255                 self.current_dataset.dx = data_set.flatten() 
    256         elif key == self.mask_name: 
    257             self.current_dataset.mask = data_set.flatten() 
    258         elif key == u'wavelength': 
    259             self.current_datainfo.source.wavelength = data_set[0] 
    260             self.current_datainfo.source.wavelength_unit = unit 
    261  
    262     def process_2d_data_object(self, data_set, key, unit): 
    263         if key == self.i_name: 
    264             self.current_dataset.data = data_set 
    265             self.current_dataset.zaxis("Intensity", unit) 
    266         elif key == self.i_uncertainties: 
    267             self.current_dataset.err_data = data_set.flatten() 
    268         elif key in self.q_name: 
    269             self.current_dataset.xaxis("Q_x", unit) 
    270             self.current_dataset.yaxis("Q_y", unit) 
    271             if self.q_name[0] == self.q_name[1]: 
    272                 # All q data in a single array 
    273                 self.current_dataset.qx_data = data_set[0] 
    274                 self.current_dataset.qy_data = data_set[1] 
    275             elif self.q_name.index(key) == 0: 
    276                 self.current_dataset.qx_data = data_set 
    277             elif self.q_name.index(key) == 1: 
    278                 self.current_dataset.qy_data = data_set 
    279         elif key in self.q_uncertainties or key in self.q_resolutions: 
    280             if ((self.q_uncertainties[0] == self.q_uncertainties[1]) or 
    281                     (self.q_resolutions[0] == self.q_resolutions[1])): 
    282                 # All q data in a single array 
    283                 self.current_dataset.dqx_data = data_set[0].flatten() 
    284                 self.current_dataset.dqy_data = data_set[1].flatten() 
    285             elif (self.q_uncertainties.index(key) == 0 or 
    286                   self.q_resolutions.index(key) == 0): 
    287                 self.current_dataset.dqx_data = data_set.flatten() 
    288             elif (self.q_uncertainties.index(key) == 1 or 
    289                   self.q_resolutions.index(key) == 1): 
    290                 self.current_dataset.dqy_data = data_set.flatten() 
    291                 self.current_dataset.yaxis("Q_y", unit) 
    292         elif key == self.mask_name: 
    293             self.current_dataset.mask = data_set.flatten() 
    294         elif key == u'Qy': 
    295             self.current_dataset.yaxis("Q_y", unit) 
    296             self.current_dataset.qy_data = data_set.flatten() 
    297         elif key == u'Qydev': 
    298             self.current_dataset.dqy_data = data_set.flatten() 
    299         elif key == u'Qx': 
    300             self.current_dataset.xaxis("Q_x", unit) 
    301             self.current_dataset.qx_data = data_set.flatten() 
    302         elif key == u'Qxdev': 
    303             self.current_dataset.dqx_data = data_set.flatten() 
    304  
    305     def process_trans_spectrum(self, data_set, key): 
    306         """ 
    307         SAStransmission_spectrum processor 
    308         :param data_set: data from HDF5 file 
    309         :param key: canSAS_class attribute 
    310         """ 
    311         if key == u'T': 
    312             self.trans_spectrum.transmission = data_set.flatten() 
    313         elif key == u'Tdev': 
    314             self.trans_spectrum.transmission_deviation = data_set.flatten() 
    315         elif key == u'lambda': 
    316             self.trans_spectrum.wavelength = data_set.flatten() 
    317  
    318     def process_sample(self, data_point, key): 
    319         """ 
    320         SASsample processor 
    321         :param data_point: Single point from an HDF5 data file 
    322         :param key: class name data_point was taken from 
    323         """ 
    324         if key == u'Title': 
    325             self.current_datainfo.sample.name = data_point 
    326         elif key == u'name': 
    327             self.current_datainfo.sample.name = data_point 
    328         elif key == u'ID': 
    329             self.current_datainfo.sample.name = data_point 
    330         elif key == u'thickness': 
    331             self.current_datainfo.sample.thickness = data_point 
    332         elif key == u'temperature': 
    333             self.current_datainfo.sample.temperature = data_point 
    334         elif key == u'transmission': 
    335             self.current_datainfo.sample.transmission = data_point 
    336         elif key == u'x_position': 
    337             self.current_datainfo.sample.position.x = data_point 
    338         elif key == u'y_position': 
    339             self.current_datainfo.sample.position.y = data_point 
    340         elif key == u'pitch': 
    341             self.current_datainfo.sample.orientation.x = data_point 
    342         elif key == u'yaw': 
    343             self.current_datainfo.sample.orientation.y = data_point 
    344         elif key == u'roll': 
    345             self.current_datainfo.sample.orientation.z = data_point 
    346         elif key == u'details': 
    347             self.current_datainfo.sample.details.append(data_point) 
    348  
    349     def process_detector(self, data_point, key, unit): 
    350         """ 
    351         SASdetector processor 
    352         :param data_point: Single point from an HDF5 data file 
    353         :param key: class name data_point was taken from 
    354         :param unit: unit attribute from data set 
    355         """ 
    356         if key == u'name': 
    357             self.detector.name = data_point 
    358         elif key == u'SDD': 
    359             self.detector.distance = float(data_point) 
    360             self.detector.distance_unit = unit 
    361         elif key == u'slit_length': 
    362             self.detector.slit_length = float(data_point) 
    363             self.detector.slit_length_unit = unit 
    364         elif key == u'x_position': 
    365             self.detector.offset.x = float(data_point) 
    366             self.detector.offset_unit = unit 
    367         elif key == u'y_position': 
    368             self.detector.offset.y = float(data_point) 
    369             self.detector.offset_unit = unit 
    370         elif key == u'pitch': 
    371             self.detector.orientation.x = float(data_point) 
    372             self.detector.orientation_unit = unit 
    373         elif key == u'roll': 
    374             self.detector.orientation.z = float(data_point) 
    375             self.detector.orientation_unit = unit 
    376         elif key == u'yaw': 
    377             self.detector.orientation.y = float(data_point) 
    378             self.detector.orientation_unit = unit 
    379         elif key == u'beam_center_x': 
    380             self.detector.beam_center.x = float(data_point) 
    381             self.detector.beam_center_unit = unit 
    382         elif key == u'beam_center_y': 
    383             self.detector.beam_center.y = float(data_point) 
    384             self.detector.beam_center_unit = unit 
    385         elif key == u'x_pixel_size': 
    386             self.detector.pixel_size.x = float(data_point) 
    387             self.detector.pixel_size_unit = unit 
    388         elif key == u'y_pixel_size': 
    389             self.detector.pixel_size.y = float(data_point) 
    390             self.detector.pixel_size_unit = unit 
    391  
    392     def process_collimation(self, data_point, key, unit): 
    393         """ 
    394         SAScollimation processor 
    395         :param data_point: Single point from an HDF5 data file 
    396         :param key: class name data_point was taken from 
    397         :param unit: unit attribute from data set 
    398         """ 
    399         if key == u'distance': 
    400             self.collimation.length = data_point 
    401             self.collimation.length_unit = unit 
    402         elif key == u'name': 
    403             self.collimation.name = data_point 
    404  
    405     def process_aperture(self, data_point, key): 
    406         """ 
    407         SASaperture processor 
    408         :param data_point: Single point from an HDF5 data file 
    409         :param key: class name data_point was taken from 
    410         """ 
    411         if key == u'shape': 
    412             self.aperture.shape = data_point 
    413         elif key == u'x_gap': 
    414             self.aperture.size.x = data_point 
    415         elif key == u'y_gap': 
    416             self.aperture.size.y = data_point 
    417  
    418     def process_source(self, data_point, key, unit): 
    419         """ 
    420         SASsource processor 
    421         :param data_point: Single point from an HDF5 data file 
    422         :param key: class name data_point was taken from 
    423         :param unit: unit attribute from data set 
    424         """ 
    425         if key == u'incident_wavelength': 
    426             self.current_datainfo.source.wavelength = data_point 
    427             self.current_datainfo.source.wavelength_unit = unit 
    428         elif key == u'wavelength_max': 
    429             self.current_datainfo.source.wavelength_max = data_point 
    430             self.current_datainfo.source.wavelength_max_unit = unit 
    431         elif key == u'wavelength_min': 
    432             self.current_datainfo.source.wavelength_min = data_point 
    433             self.current_datainfo.source.wavelength_min_unit = unit 
    434         elif key == u'incident_wavelength_spread': 
    435             self.current_datainfo.source.wavelength_spread = data_point 
    436             self.current_datainfo.source.wavelength_spread_unit = unit 
    437         elif key == u'beam_size_x': 
    438             self.current_datainfo.source.beam_size.x = data_point 
    439             self.current_datainfo.source.beam_size_unit = unit 
    440         elif key == u'beam_size_y': 
    441             self.current_datainfo.source.beam_size.y = data_point 
    442             self.current_datainfo.source.beam_size_unit = unit 
    443         elif key == u'beam_shape': 
    444             self.current_datainfo.source.beam_shape = data_point 
    445         elif key == u'radiation': 
    446             self.current_datainfo.source.radiation = data_point 
    447  
    448     def process_process(self, data_point, key): 
    449         """ 
    450         SASprocess processor 
    451         :param data_point: Single point from an HDF5 data file 
    452         :param key: class name data_point was taken from 
    453         """ 
    454         term_match = re.compile(u'^term[0-9]+$') 
    455         if key == u'Title':  # CanSAS 2.0 
    456             self.process.name = data_point 
    457         elif key == u'name':  # NXcanSAS 
    458             self.process.name = data_point 
    459         elif key == u'description': 
    460             self.process.description = data_point 
    461         elif key == u'date': 
    462             self.process.date = data_point 
    463         elif term_match.match(key): 
    464             self.process.term.append(data_point) 
    465         else: 
    466             self.process.notes.append(data_point) 
    467413 
    468414    def add_intermediate(self): 
    … …  
    506452            spectrum_list = [] 
    507453            for spectrum in self.current_datainfo.trans_spectrum: 
     454                spectrum.transmission = np.delete(spectrum.transmission, [0]) 
    508455                spectrum.transmission = spectrum.transmission.astype(np.float64) 
     456                spectrum.transmission_deviation = np.delete( 
     457                    spectrum.transmission_deviation, [0]) 
    509458                spectrum.transmission_deviation = \ 
    510459                    spectrum.transmission_deviation.astype(np.float64) 
     460                spectrum.wavelength = np.delete(spectrum.wavelength, [0]) 
    511461                spectrum.wavelength = spectrum.wavelength.astype(np.float64) 
    512462                if len(spectrum.transmission) > 0: 
    … …  
    540490            if dataset.data.ndim == 2: 
    541491                (n_rows, n_cols) = dataset.data.shape 
    542                 flat_qy = dataset.qy_data[0::n_cols].flatten() 
    543                 if flat_qy[0] == flat_qy[1]: 
    544                     flat_qy = np.transpose(dataset.qy_data)[0::n_cols].flatten() 
    545                 dataset.y_bins = np.unique(flat_qy) 
    546                 flat_qx = dataset.qx_data[0::n_rows].flatten() 
    547                 if flat_qx[0] == flat_qx[1]: 
    548                     flat_qx = np.transpose(dataset.qx_data)[0::n_rows].flatten() 
    549                 dataset.x_bins = np.unique(flat_qx) 
     492                dataset.y_bins = dataset.qy_data[0::n_cols] 
     493                dataset.x_bins = dataset.qx_data[:n_cols] 
    550494                dataset.data = dataset.data.flatten() 
    551                 dataset.qx_data = dataset.qx_data.flatten() 
    552                 dataset.qy_data = dataset.qy_data.flatten() 
    553495            self.current_dataset = dataset 
    554496            self.send_to_output() 
    … …  
    573515        self.current_datainfo = DataInfo() 
    574516 
    575     def _initialize_new_data_set(self, value=None): 
     517 
     518    def _initialize_new_data_set(self, parent_list=None): 
    576519        """ 
    577520        A private class method to generate a new 1D or 2D data object based on 
    … …  
    581524        :param parent_list: List of names of parent elements 
    582525        """ 
    583         if self._is2d(value): 
     526 
     527        if parent_list is None: 
     528            parent_list = [] 
     529        if self._find_intermediate(parent_list, "Qx"): 
    584530            self.current_dataset = plottable_2D() 
    585531        else: 
    … …  
    588534            self.current_dataset = plottable_1D(x, y) 
    589535        self.current_datainfo.filename = self.raw_data.filename 
    590         self.mask_name = "" 
    591         self.i_name = "" 
    592         self.i_node = "" 
    593         self.q_name = [] 
    594         self.q_uncertainties = [] 
    595         self.q_resolutions = [] 
    596         self.i_uncertainties = "" 
    597  
    598     @staticmethod 
    599     def check_is_list_or_array(iterable): 
    600         try: 
    601             iter(iterable) 
    602             if (not isinstance(iterable, np.ndarray) and not isinstance( 
    603                     iterable, list)) or (isinstance(iterable, str) or 
    604                                          isinstance(iterable, unicode)): 
    605                 raise TypeError 
    606         except TypeError: 
    607             iterable = iterable.split(",") 
    608         return iterable 
    609  
    610     def _find_data_attributes(self, value): 
    611         """ 
    612         A class to find the indices for Q, the name of the Qdev and Idev, and 
    613         the name of the mask. 
    614         :param value: SASdata/NXdata HDF5 Group 
    615         """ 
    616         attrs = value.attrs 
    617         signal = attrs.get("signal", "I") 
    618         i_axes = attrs.get("I_axes", ["Q"]) 
    619         q_indices = attrs.get("Q_indices", [0]) 
    620         q_indices = map(int, self.check_is_list_or_array(q_indices)) 
    621         i_axes = self.check_is_list_or_array(i_axes) 
    622         keys = value.keys() 
    623         self.mask_name = attrs.get("mask") 
    624         for val in q_indices: 
    625             self.q_name.append(i_axes[val]) 
    626         self.i_name = signal 
    627         self.i_node = value.get(self.i_name) 
    628         for item in self.q_name: 
    629             if item in keys: 
    630                 q_vals = value.get(item) 
    631                 if q_vals.attrs.get("uncertainties") is not None: 
    632                     self.q_uncertainties = q_vals.attrs.get("uncertainties") 
    633                 elif q_vals.attrs.get("uncertainty") is not None: 
    634                     self.q_uncertainties = q_vals.attrs.get("uncertainty") 
    635                 if isinstance(self.q_uncertainties, str): 
    636                     self.q_uncertainties = self.q_uncertainties.split(",") 
    637                 if q_vals.attrs.get("resolutions") is not None: 
    638                     self.q_resolutions = q_vals.attrs.get("resolutions") 
    639                 if isinstance(self.q_resolutions, (str, unicode)): 
    640                     self.q_resolutions = self.q_resolutions.split(",") 
    641         if self.i_name in keys: 
    642             i_vals = value.get(self.i_name) 
    643             self.i_uncertainties = i_vals.attrs.get("uncertainties") 
    644             if self.i_uncertainties is None: 
    645                 self.i_uncertainties = i_vals.attrs.get("uncertainty") 
    646  
    647     def _is2d(self, value, basename="I"): 
    648         """ 
    649         A private class to determine if the data set is 1d or 2d. 
     536 
     537    def _find_intermediate(self, parent_list, basename=""): 
     538        """ 
     539        A private class used to find an entry by either using a direct key or 
     540        knowing the approximate basename. 
    650541 
    651542        :param parent_list: List of parents nodes in the HDF5 file 
    652543        :param basename: Approximate name of an entry to search for 
    653         :return: True if 2D, otherwise false 
    654         """ 
    655  
    656         vals = value.get(basename) 
    657         return (vals is not None and vals.shape is not None 
    658                 and len(vals.shape) != 1) 
     544        :return: 
     545        """ 
     546 
     547        entry = False 
     548        key_prog = re.compile(basename) 
     549        top = self.raw_data 
     550        for parent in parent_list: 
     551            top = top.get(parent) 
     552        for key in top.keys(): 
     553            if key_prog.match(key): 
     554                entry = True 
     555                break 
     556        return entry 
    659557 
    660558    def _create_unique_key(self, dictionary, name, numb=0): 
    … …  
    685583        if unit is None: 
    686584            unit = h5attr(value, u'unit') 
     585        # Convert the unit formats 
     586        if unit == "1/A": 
     587            unit = "A^{-1}" 
     588        elif unit == "1/cm": 
     589            unit = "cm^{-1}" 
    687590        return unit 

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

    rfc51d06 r2469df7  
    180180        detector.beam_center.y = center_y * pixel 
    181181 
    182         self.current_dataset = self.set_default_2d_units(self.current_dataset) 
     182 
     183        self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
     184        self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
     185        self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 
     186 
    183187        self.current_dataset.x_bins = x_vals 
    184188        self.current_dataset.y_bins = y_vals 

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

    r058f6c3 rc8321cfc  
    317317 
    318318        # Units of axes 
    319         self.current_dataset = self.set_default_2d_units(self.current_dataset) 
     319        self.current_dataset.xaxis(r"\rm{Q_{x}}", 'A^{-1}') 
     320        self.current_dataset.yaxis(r"\rm{Q_{y}}", 'A^{-1}') 
     321        self.current_dataset.zaxis(r"\rm{Intensity}", "cm^{-1}") 
    320322 
    321323        # Store loading process information 

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

    r2ca5d57b r574adc7  
    88import os 
    99 
    10 from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader 
     10from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader as Cansas2Reader 
    1111from sas.sascalc.dataloader.data_info import Data1D, Data2D 
    1212 
    13 class NXcanSASWriter(Reader): 
     13class NXcanSASWriter(Cansas2Reader): 
    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 
    90                           dataset]) 
     89        valid_data = all([issubclass(d.__class__, (Data1D, Data2D)) for d in dataset]) 
    9190        if not valid_data: 
    92             raise ValueError("All entries of dataset must be Data1D or Data2D" 
    93                              "objects") 
     91            raise ValueError("All entries of dataset must be Data1D or Data2D objects") 
    9492 
    9593        # Get run name and number from first Data object 
    … …  
    111109        sasentry.attrs['version'] = '1.0' 
    112110 
    113         for i, data_obj in enumerate(dataset): 
    114             data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i+1)) 
     111        i = 1 
     112 
     113        for data_obj in dataset: 
     114            data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i)) 
    115115            data_entry.attrs['canSAS_class'] = 'SASdata' 
    116116            if isinstance(data_obj, Data1D): 
    … …  
    118118            elif isinstance(data_obj, Data2D): 
    119119                self._write_2d_data(data_obj, data_entry) 
     120            i += 1 
    120121 
    121122        data_info = dataset[0] 
    … …  
    147148                sample_entry.create_dataset('details', data=details) 
    148149 
    149         # Instrument metadata 
     150        # Instrumment metadata 
    150151        instrument_entry = sasentry.create_group('sasinstrument') 
    151152        instrument_entry.attrs['canSAS_class'] = 'SASinstrument' 
    … …  
    175176            units=data_info.source.beam_size_unit, write_fn=_write_h5_float) 
    176177 
     178 
    177179        # Collimation metadata 
    178180        if len(data_info.collimation) > 0: 
    179             for i, coll_info in enumerate(data_info.collimation): 
     181            i = 1 
     182            for coll_info in data_info.collimation: 
    180183                collimation_entry = instrument_entry.create_group( 
    181                     'sascollimation{0:0=2d}'.format(i + 1)) 
     184                    'sascollimation{0:0=2d}'.format(i)) 
    182185                collimation_entry.attrs['canSAS_class'] = 'SAScollimation' 
    183186                if coll_info.length is not None: 
    184187                    _write_h5_float(collimation_entry, coll_info.length, 'SDD') 
    185                     collimation_entry['SDD'].attrs['units'] =\ 
    186                         coll_info.length_unit 
     188                    collimation_entry['SDD'].attrs['units'] = coll_info.length_unit 
    187189                if coll_info.name is not None: 
    188190                    collimation_entry['name'] = _h5_string(coll_info.name) 
    189191        else: 
    190             # Create a blank one - at least 1 collimation required by format 
    191             instrument_entry.create_group('sascollimation01') 
     192            # Create a blank one - at least 1 set of collimation metadata 
     193            # required by format 
     194            collimation_entry = instrument_entry.create_group('sascollimation01') 
    192195 
    193196        # Detector metadata 
    194197        if len(data_info.detector) > 0: 
    195198            i = 1 
    196             for i, det_info in enumerate(data_info.detector): 
     199            for det_info in data_info.detector: 
    197200                detector_entry = instrument_entry.create_group( 
    198                     'sasdetector{0:0=2d}'.format(i + 1)) 
     201                    'sasdetector{0:0=2d}'.format(i)) 
    199202                detector_entry.attrs['canSAS_class'] = 'SASdetector' 
    200203                if det_info.distance is not None: 
    201204                    _write_h5_float(detector_entry, det_info.distance, 'SDD') 
    202                     detector_entry['SDD'].attrs['units'] =\ 
    203                         det_info.distance_unit 
     205                    detector_entry['SDD'].attrs['units'] = det_info.distance_unit 
    204206                if det_info.name is not None: 
    205207                    detector_entry['name'] = _h5_string(det_info.name) 
    … …  
    207209                    detector_entry['name'] = _h5_string('') 
    208210                if det_info.slit_length is not None: 
    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 
     211                    _write_h5_float(detector_entry, det_info.slit_length, 'slit_length') 
     212                    detector_entry['slit_length'].attrs['units'] = det_info.slit_length_unit 
    213213                _write_h5_vector(detector_entry, det_info.offset) 
    214214                # NXcanSAS doesn't save information about pitch, only roll 
    … …  
    224224                    names=['x_pixel_size', 'y_pixel_size'], 
    225225                    write_fn=_write_h5_float, units=det_info.pixel_size_unit) 
     226 
     227                i += 1 
    226228        else: 
    227229            # Create a blank one - at least 1 detector required by format 
    … …  
    229231            detector_entry.attrs['canSAS_class'] = 'SASdetector' 
    230232            detector_entry.attrs['name'] = '' 
    231  
    232         # Process meta data 
    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) 
    258  
    259         # Transmission Spectrum 
    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) 
    275233 
    276234        note_entry = sasentry.create_group('sasnote'.format(i)) 
    … …  
    296254        data_entry.attrs['signal'] = 'I' 
    297255        data_entry.attrs['I_axes'] = 'Q' 
    298         data_entry.attrs['Q_indices'] = [0] 
    299         q_entry = data_entry.create_dataset('Q', data=data_obj.x) 
    300         q_entry.attrs['units'] = data_obj.x_unit 
    301         i_entry = data_entry.create_dataset('I', data=data_obj.y) 
    302         i_entry.attrs['units'] = data_obj.y_unit 
    303         if data_obj.dy is not None: 
    304             i_entry.attrs['uncertainties'] = 'Idev' 
    305             i_dev_entry = data_entry.create_dataset('Idev', data=data_obj.dy) 
    306             i_dev_entry.attrs['units'] = data_obj.y_unit 
    307         if data_obj.dx is not None: 
    308             q_entry.attrs['resolutions'] = 'dQ' 
    309             dq_entry = data_entry.create_dataset('dQ', data=data_obj.dx) 
    310             dq_entry.attrs['units'] = data_obj.x_unit 
    311         elif data_obj.dxl is not None: 
    312             q_entry.attrs['resolutions'] = ['dQl','dQw'] 
    313             dql_entry = data_entry.create_dataset('dQl', data=data_obj.dxl) 
    314             dql_entry.attrs['units'] = data_obj.x_unit 
    315             dqw_entry = data_entry.create_dataset('dQw', data=data_obj.dxw) 
    316             dqw_entry.attrs['units'] = data_obj.x_unit 
     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) 
    317266 
    318267    def _write_2d_data(self, data, data_entry): 
    … …  
    324273        """ 
    325274        data_entry.attrs['signal'] = 'I' 
    326         data_entry.attrs['I_axes'] = 'Qx,Qy' 
    327         data_entry.attrs['Q_indices'] = [0,1] 
     275        data_entry.attrs['I_axes'] = 'Q,Q' 
     276        data_entry.attrs['I_uncertainties'] = 'Idev' 
     277        data_entry.attrs['Q_indicies'] = [0,1] 
    328278 
    329279        (n_rows, n_cols) = (len(data.y_bins), len(data.x_bins)) 
    … …  
    338288                raise ValueError("Unable to calculate dimensions of 2D data") 
    339289 
    340         intensity = np.reshape(data.data, (n_rows, n_cols)) 
    341         qx = np.reshape(data.qx_data, (n_rows, n_cols)) 
     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)) 
    342295        qy = np.reshape(data.qy_data, (n_rows, n_cols)) 
    343296 
    344         i_entry = data_entry.create_dataset('I', data=intensity) 
    345         i_entry.attrs['units'] = data.I_unit 
    346         qx_entry = data_entry.create_dataset('Qx', data=qx) 
    347         qx_entry.attrs['units'] = data.Q_unit 
    348         qy_entry = data_entry.create_dataset('Qy', data=qy) 
    349         qy_entry.attrs['units'] = data.Q_unit 
    350         if data.err_data is not None and not all(data.err_data == [None]): 
    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 and not all(data.dqx_data == [None]): 
    356             qx_entry.attrs['resolutions'] = 'dQx' 
    357             dqx_entry = data_entry.create_dataset('dQx', data=data.dqx_data) 
    358             dqx_entry.attrs['units'] = data.Q_unit 
    359         if data.dqy_data is not None and not all(data.dqy_data == [None]): 
    360             qy_entry.attrs['resolutions'] = 'dQy' 
    361             dqy_entry = data_entry.create_dataset('dQy', data=data.dqy_data) 
    362             dqy_entry.attrs['units'] = data.Q_unit 
     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 

  • src/sas/sasgui/guiframe/gui_manager.py

    rfeec1cb rb963b20  
    4646from sas.sasgui.guiframe.CategoryManager import CategoryManager 
    4747from sas.sascalc.dataloader.loader import Loader 
    48 from sas.sascalc.file_converter.nxcansas_writer import NXcanSASWriter 
    4948from sas.sasgui.guiframe.proxy import Connection 
    5049 
    … …  
    24232422        default_name = fname 
    24242423        wildcard = "Text files (*.txt)|*.txt|"\ 
    2425                     "CanSAS 1D files (*.xml)|*.xml|"\ 
    2426                      "NXcanSAS files (*.h5)|*.h5|" 
    2427         options = {0: ".txt", 
    2428                    1: ".xml", 
    2429                    2: ".h5"} 
     2424                    "CanSAS 1D files(*.xml)|*.xml" 
     2425        path = None 
    24302426        dlg = wx.FileDialog(self, "Choose a file", 
    24312427                            self._default_save_location, 
    … …  
    24372433            # This is MAC Fix 
    24382434            ext_num = dlg.GetFilterIndex() 
    2439  
    2440             ext_format = options[ext_num] 
     2435            if ext_num == 0: 
     2436                ext_format = '.txt' 
     2437            else: 
     2438                ext_format = '.xml' 
    24412439            path = os.path.splitext(path)[0] + ext_format 
    24422440            mypath = os.path.basename(path) 
    2443             fName = os.path.splitext(path)[0] + ext_format 
    2444  
    2445             if os.path.splitext(mypath)[1].lower() == options[0]: 
     2441 
     2442            # Instantiate a loader 
     2443            loader = Loader() 
     2444            ext_format = ".txt" 
     2445            if os.path.splitext(mypath)[1].lower() == ext_format: 
    24462446                # Make sure the ext included in the file name 
    24472447                # especially on MAC 
     2448                fName = os.path.splitext(path)[0] + ext_format 
    24482449                self._onsaveTXT(data, fName) 
    2449             elif os.path.splitext(mypath)[1].lower() == options[1]: 
     2450            ext_format = ".xml" 
     2451            if os.path.splitext(mypath)[1].lower() == ext_format: 
    24502452                # Make sure the ext included in the file name 
    24512453                # especially on MAC 
    2452                 # Instantiate a loader 
    2453                 loader = Loader() 
     2454                fName = os.path.splitext(path)[0] + ext_format 
    24542455                loader.save(fName, data, ext_format) 
    2455             elif os.path.splitext(mypath)[1].lower() == options[2]: 
    2456                 nxcansaswriter = NXcanSASWriter() 
    2457                 nxcansaswriter.write([data], fName) 
    24582456            try: 
    24592457                self._default_save_location = os.path.dirname(path) 
    … …  
    25302528            text += 'dY_min = %s:  dY_max = %s\n' % (min(data.dy), max(data.dy)) 
    25312529        text += '\nData Points:\n' 
    2532         text += "<index> \t<X> \t<Y> \t<dY> \t<dX" 
    2533         if data.dxl is not None and data.dxw is not None: 
    2534                 text += "l> \t<dxw" 
    2535         text += ">\n" 
     2530        x_st = "X" 
    25362531        for index in range(len(data.x)): 
    25372532            if data.dy is not None and len(data.dy) > index: 
    … …  
    25442539                dx_val = 0.0 
    25452540            if data.dxl is not None and len(data.dxl) > index: 
     2541                if index == 0: 
     2542                    x_st = "Xl" 
    25462543                dx_val = data.dxl[index] 
    2547                 if data.dxw is not None and len(data.dxw) > index: 
    2548                     dx_val = "%s \t%s" % (data.dxl[index], data.dxw[index]) 
    2549  
     2544            elif data.dxw is not None and len(data.dxw) > index: 
     2545                if index == 0: 
     2546                    x_st = "Xw" 
     2547                dx_val = data.dxw[index] 
     2548 
     2549            if index == 0: 
     2550                text += "<index> \t<X> \t<Y> \t<dY> \t<d%s>\n" % x_st 
    25502551            text += "%s \t%s \t%s \t%s \t%s\n" % (index, 
    25512552                                                  data.x[index], 
    … …  
    25642565        """ 
    25652566        default_name = fname 
    2566         wildcard = "IGOR/DAT 2D file in Q_map (*.dat)|*.DAT|"\ 
    2567                    "NXcanSAS files (*.h5)|*.h5|" 
     2567        wildcard = "IGOR/DAT 2D file in Q_map (*.dat)|*.DAT" 
    25682568        dlg = wx.FileDialog(self, "Choose a file", 
    25692569                            self._default_save_location, 
    … …  
    25772577            if ext_num == 0: 
    25782578                ext_format = '.dat' 
    2579             elif ext_num == 1: 
    2580                 ext_format = '.h5' 
    25812579            else: 
    25822580                ext_format = '' 
    … …  
    25862584            # Instantiate a loader 
    25872585            loader = Loader() 
    2588             if os.path.splitext(mypath)[1].lower() == '.dat': 
     2586 
     2587            ext_format = ".dat" 
     2588            if os.path.splitext(mypath)[1].lower() == ext_format: 
    25892589                # Make sure the ext included in the file name 
    25902590                # especially on MAC 
    25912591                fileName = os.path.splitext(path)[0] + ext_format 
    25922592                loader.save(fileName, data, ext_format) 
    2593             elif os.path.splitext(mypath)[1].lower() == '.h5': 
    2594                 # Make sure the ext included in the file name 
    2595                 # especially on MAC 
    2596                 fileName = os.path.splitext(path)[0] + ext_format 
    2597                 nxcansaswriter = NXcanSASWriter() 
    2598                 nxcansaswriter.write([data], fileName) 
    25992593            try: 
    26002594                self._default_save_location = os.path.dirname(path) 

  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    r02c1608e r2924532  
    239239            self.load_complete(output=output, message="Loading data complete!", 
    240240                               info="info") 
     241        else: 
     242            self.load_complete(output=None, message=error_message, info="error") 
    241243 
    242244    def load_update(self, message="", info="warning"): 

  • test/sasdataloader/test/utest_abs_reader.py

    rbd5c3b1 rbd5c3b1  
    118118        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    119119 
    120         self.assertEqual(self.data.I_unit, 'cm^{-1}') 
     120        self.assertEqual(self.data.I_unit, '1/cm') 
    121121        self.assertEqual(self.data.data[0], 1.57831) 
    122122        self.assertEqual(self.data.data[1], 2.70983) 

  • test/sasdataloader/test/utest_averaging.py

    r7fd5e2a rf53d684  
    106106 
    107107    def setUp(self): 
    108         filepath = find('test_data//MAR07232_rest.h5') 
     108        filepath = find('MAR07232_rest.h5') 
    109109        self.data_list = Loader().load(filepath) 
    110110        self.data = self.data_list[0] 
    … …  
    121121 
    122122        o = r(self.data) 
    123         filepath = find('test_data//ring_testdata.txt') 
     123        filepath = find('ring_testdata.txt') 
    124124        answer_list = Loader().load(filepath) 
    125125        answer = answer_list[0] 
    … …  
    142142        o = r(self.data) 
    143143 
    144         filepath = find('test_data//avg_testdata.txt') 
     144        filepath = find('avg_testdata.txt') 
    145145        answer = Loader().load(filepath)[0] 
    146146        for i in range(r.nbins_phi): 
    … …  
    158158        s, ds, npoints = r(self.data) 
    159159        self.assertAlmostEqual(s, 34.278990899999997, 4) 
    160         self.assertAlmostEqual(ds, 8.237259999538685, 4) 
     160        self.assertAlmostEqual(ds, 7.8007981835194293, 4) 
    161161        self.assertAlmostEqual(npoints, 324.0000, 4) 
    162162 
    … …  
    164164        s, ds = r(self.data) 
    165165        self.assertAlmostEqual(s, 0.10579935462962962, 4) 
    166         self.assertAlmostEqual(ds, 0.02542364197388483, 4) 
     166        self.assertAlmostEqual(ds, 0.024076537603455028, 4) 
    167167 
    168168    def test_slabX(self): 
    … …  
    177177        o = r(self.data) 
    178178 
    179         filepath = find('test_data//slabx_testdata.txt') 
     179        filepath = find('slabx_testdata.txt') 
    180180        answer = Loader().load(filepath)[0] 
    181181        for i in range(len(o.x)): 
    … …  
    195195        o = r(self.data) 
    196196 
    197         filepath = find('test_data//slaby_testdata.txt') 
     197        filepath = find('slaby_testdata.txt') 
    198198        answer = Loader().load(filepath)[0] 
    199199        for i in range(len(o.x)): 
    … …  
    221221        o = r(self.data) 
    222222 
    223         filepath = find('test_data//ring_testdata.txt') 
     223        filepath = find('ring_testdata.txt') 
    224224        answer = Loader().load(filepath)[0] 
    225225        for i in range(len(o.x)): 
    … …  
    238238        o = r(self.data) 
    239239 
    240         filepath = find('test_data//sectorphi_testdata.txt') 
     240        filepath = find('sectorphi_testdata.txt') 
    241241        answer = Loader().load(filepath)[0] 
    242242        for i in range(len(o.x)): 
    … …  
    255255        o = r(self.data) 
    256256 
    257         filepath = find('test_data//sectorq_testdata.txt') 
     257        filepath = find('sectorq_testdata.txt') 
    258258        answer = Loader().load(filepath)[0] 
    259259        for i in range(len(o.x)): 

  • test/sasdataloader/test/utest_cansas.py

    r2ca5d57b rf53d684  
    9191        reader = XMLreader(self.xml_valid, self.schema_1_0) 
    9292        valid = reader.validate_xml() 
    93         self.assertTrue(valid) 
     93        if valid: 
     94            self.assertTrue(valid) 
     95        else: 
     96            self.assertFalse(valid) 
    9497 
    9598    def _check_data(self, data): 
    … …  
    190193    def test_save_cansas_v1_0(self): 
    191194        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0) 
    192         self.assertTrue(xmlreader.validate_xml()) 
     195        valid = xmlreader.validate_xml() 
     196        self.assertTrue(valid) 
    193197        reader_generic = Loader() 
    194198        dataloader = reader_generic.load(self.isis_1_0) 
    … …  
    203207            return_data = reader2.read(self.write_1_0_filename) 
    204208            written_data = return_data[0] 
    205             xmlreader = XMLreader(self.write_1_0_filename, self.schema_1_0) 
    206             self.assertTrue(xmlreader.validate_xml()) 
     209            XMLreader(self.write_1_0_filename, self.schema_1_0) 
     210            valid = xmlreader.validate_xml() 
     211            self.assertTrue(valid) 
    207212            self._check_data(written_data) 
    208213        if os.path.isfile(self.write_1_0_filename): 
    … …  
    255260        self.loader = Loader() 
    256261        self.datafile_basic = find("simpleexamplefile.h5") 
    257         self.datafile_multiplesasentry = find( 
    258             "test_data//nxcansas_1Dand2D_multisasentry.h5") 
    259         self.datafile_multiplesasdata = find( 
    260             "test_data//nxcansas_1Dand2D_multisasdata.h5") 
    261         self.datafile_multiplesasdata_multiplesasentry = find( 
    262             "test_data//nxcansas_1Dand2D_multisasentry_multisasdata.h5") 
     262        self.datafile_multiplesasentry = find("cansas_1Dand2D_samedatafile.h5") 
     263        self.datafile_multiplesasdata = find("cansas_1Dand2D_samesasentry.h5") 
     264        self.datafile_multiplesasdata_multiplesasentry = find("cansas_1Dand2D_multiplesasentry_multiplesasdata.h5") 
    263265 
    264266    def test_real_data(self): 
    … …  
    271273        self._check_multiple_data(self.data[0]) 
    272274        self._check_multiple_data(self.data[1]) 
    273         if isinstance(self.data[0], Data1D): 
    274             self._check_1d_data(self.data[0]) 
    275             self._check_2d_data(self.data[1]) 
    276         else: 
    277             self._check_1d_data(self.data[1]) 
    278             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) 
     275        self._check_1d_data(self.data[0]) 
    305276 
    306277    def _check_multiple_data(self, data): 
    … …  
    310281        self.assertTrue(data.instrument == "SANS2D") 
    311282        self.assertTrue(data.source.radiation == "Spallation Neutron Source") 
    312         self.assertTrue(len(data.detector) == 2) 
    313         self.assertTrue(data.detector[0].name == "rear-detector" 
    314                         or data.detector[1].name == "rear-detector") 
    315         self.assertTrue(data.detector[0].name == "front-detector" 
    316                         or data.detector[1].name == "front-detector") 
    317         self.assertAlmostEqual(data.detector[0].distance + 
    318                                data.detector[1].distance, 7230.54, 2) 
    319         self.assertTrue(data.detector[0].distance_unit == 'mm') 
     283        self.assertTrue(len(data.detector) == 1) 
     284        self.assertTrue(data.detector[0].name == "rear-detector") 
     285        self.assertTrue(data.detector[0].distance == 4.385281) 
     286        self.assertTrue(data.detector[0].distance_unit == 'm') 
    320287        self.assertTrue(len(data.trans_spectrum) == 1) 
    321288 
    322289    def _check_1d_data(self, data): 
     290        self.assertTrue(isinstance(data, Data1D)) 
    323291        self.assertTrue(len(data.x) == 66) 
    324292        self.assertTrue(len(data.x) == len(data.y)) 
    325         self.assertTrue(data.dy[10] == 0.207214) 
    326         self.assertTrue(data.y[10] == 24.1939) 
    327         self.assertTrue(data.x[10] == 0.00898113) 
     293        self.assertTrue(data.dy[10] == 0.20721350111248701) 
     294        self.assertTrue(data.y[10] == 24.193889608153476) 
     295        self.assertTrue(data.x[10] == 0.008981127988654792) 
    328296 
    329297    def _check_2d_data(self, data): 
    330298        self.assertTrue(isinstance(data, Data2D)) 
    331         self.assertTrue(len(data.q_data) == 150*150) 
    332         self.assertTrue(len(data.q_data) == len(data.data)) 
    333         self.assertAlmostEqual(data.err_data[10], 0.186723989418) 
    334         self.assertAlmostEqual(data.data[10], 0.465181) 
    335         self.assertAlmostEqual(data.qx_data[10], -0.129) 
    336         self.assertAlmostEqual(data.qy_data[10], -0.149) 
     299        self.assertTrue(len(data.x) == 66) 
     300        self.assertTrue(len(data.x) == len(data.y)) 
     301        self.assertTrue(data.dy[10] == 0.20721350111248701) 
     302        self.assertTrue(data.y[10] == 24.193889608153476) 
     303        self.assertTrue(data.x[10] == 0.008981127988654792) 
    337304 
    338305    def _check_example_data(self, data): 

  • test/sasdataloader/test/utest_red2d_reader.py

    rfc51d06 rf53d684  
    3131        self.assertEqual(f.qx_data[0],-0.03573497) 
    3232        self.assertEqual(f.qx_data[36863],0.2908819) 
    33         self.assertEqual(f.Q_unit, 'A^{-1}') 
    34         self.assertEqual(f.I_unit, 'cm^{-1}') 
     33        self.assertEqual(f.Q_unit, '1/A') 
     34        self.assertEqual(f.I_unit, '1/cm') 
    3535 
    3636        self.assertEqual(f.meta_data['loader'],"IGOR/DAT 2D Q_map") 
Note: See TracChangeset for help on using the changeset viewer.