Diff [f560e23a467d864fa03a239fb4fe644e66bc5c59:c222c2703e7b61b91b4372539b1f54944ec11c45] for / – SasView

src/sas/sascalc/data_util/nxsunit.py

-                      r574adc7
+                      rb011ecb
     sld = { '10^-6 Angstrom^-2': 1e-6, 'Angstrom^-2': 1 }
     Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1,
+          '1/Angstrom': 1, '1/angstrom': 1, 'A^{-1}': 1, 'cm^{-1}': 1e-8,
           '10^-3 Angstrom^-1': 1e-3, '1/cm': 1e-8, '1/m': 1e-10,
           'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 }
+          'nm^{-1}': 1, 'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 }
     _caret_optional(sld)
 …
     # units for that particular dimension.
     # Note: don't have support for dimensionless units.
     unknown = {None:1, '???':1, '': 1, 'a.u.': 1}
+    unknown = {None:1, '???':1, '': 1, 'a.u.': 1, 'Counts': 1, 'counts': 1}
     def __init__(self, name):

src/sas/sascalc/dataloader/data_info.py

-                      rdeaa0c6
+                      r4fdcc65
         _str += "Data:\n"
         _str += "   Type:         %s\n" % self.__class__.__name__
+        _str += "   X- & Y-axis:  %s\t[%s]\n" % (self._yaxis, self._yunit)
+        _str += "   X-axis:       %s\t[%s]\n" % (self._xaxis, self._xunit)
+        _str += "   Y-axis:       %s\t[%s]\n" % (self._yaxis, self._yunit)
         _str += "   Z-axis:       %s\t[%s]\n" % (self._zaxis, self._zunit)
         _str += "   Length:       %g \n" % (len(self.data))
 …
                            qx_data=qx_data, qy_data=qy_data,
                            q_data=q_data, mask=mask)
+        clone._xaxis = self._xaxis
+        clone._yaxis = self._yaxis
+        clone._zaxis = self._zaxis
+        clone._xunit = self._xunit
+        clone._yunit = self._yunit
+        clone._zunit = self._zunit
+        clone.x_bins = self.x_bins
+        clone.y_bins = self.y_bins
         clone.title = self.title
 …
 def combine_data_info_with_plottable(data, datainfo):
     """
+    A function that combines the DataInfo data in self.current_datainto with a plottable_1D or 2D data object.
+    A function that combines the DataInfo data in self.current_datainto with a
+    plottable_1D or 2D data object.
     :param data: A plottable_1D or plottable_2D data object
 …
         final_dataset.yaxis(data._yaxis, data._yunit)
     elif isinstance(data, plottable_2D):
+        final_dataset = Data2D(data.data, data.err_data, data.qx_data, data.qy_data, data.q_data,
+                               data.mask, data.dqx_data, data.dqy_data)
+        final_dataset = Data2D(data.data, data.err_data, data.qx_data,
+                               data.qy_data, data.q_data, data.mask,
+                               data.dqx_data, data.dqy_data)
         final_dataset.xaxis(data._xaxis, data._xunit)
         final_dataset.yaxis(data._yaxis, data._yunit)
         final_dataset.zaxis(data._zaxis, data._zunit)
+        if len(data.data.shape) == 2:
+            n_rows, n_cols = data.data.shape
+            final_dataset.y_bins = data.qy_data[0::int(n_cols)]
+            final_dataset.x_bins = data.qx_data[:int(n_cols)]
+        final_dataset.y_bins = data.y_bins
+        final_dataset.x_bins = data.x_bins
     else:
+        return_string = "Should Never Happen: _combine_data_info_with_plottable input is not a plottable1d or " + \
+                        "plottable2d data object"
+        return_string = ("Should Never Happen: _combine_data_info_with_plottabl"
+                         "e input is not a plottable1d or plottable2d data "
+                         "object")
         return return_string

src/sas/sascalc/dataloader/file_reader_base_class.py

                       rfee520ec
 from .data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\
     combine_data_info_with_plottable
+from sas.sascalc.data_util.nxsunit import Converter
 logger = logging.getLogger(__name__)
 …
                        "SasView cannot guarantee the accuracy of the data.")
 class FileReader(object):
     # String to describe the type of data this reader can load
 …
     ext = ['.txt']
     # Deprecated extensions
     deprecated_extensions = ['.asc', '.nxs']
+    deprecated_extensions = ['.asc']
     # Bypass extension check and try to load anyway
     allow_all = False
 …
                     if len(self.output) > 0:
                         # Sort the data that's been loaded
                         self.sort_one_d_data()
                         self.sort_two_d_data()
+                        self.convert_data_units()
+                        self.sort_data()
         else:
             msg = "Unable to find file at: {}\n".format(filepath)
 …
         Returns the entire file as a string.
         """
-        #return self.f_open.read()
         return decode(self.f_open.read())
 …
         self.output.append(data_obj)
     def sort_one_d_data(self):
+    def sort_data(self):
         """
         Sort 1D data along the X axis for consistency
 …
                 # Normalize the units for
                 data.x_unit = self.format_unit(data.x_unit)
+                data._xunit = data.x_unit
                 data.y_unit = self.format_unit(data.y_unit)
+                data._yunit = data.y_unit
                 # Sort data by increasing x and remove 1st point
                 ind = np.lexsort((data.y, data.x))
 …
                     data.ymin = np.min(data.y)
                     data.ymax = np.max(data.y)
+            elif isinstance(data, Data2D):
+                # Normalize the units for
+                data.Q_unit = self.format_unit(data.Q_unit)
+                data.I_unit = self.format_unit(data.I_unit)
+                data._xunit = data.Q_unit
+                data._yunit = data.Q_unit
+                data._zunit = data.I_unit
+                data.data = data.data.astype(np.float64)
+                data.qx_data = data.qx_data.astype(np.float64)
+                data.xmin = np.min(data.qx_data)
+                data.xmax = np.max(data.qx_data)
+                data.qy_data = data.qy_data.astype(np.float64)
+                data.ymin = np.min(data.qy_data)
+                data.ymax = np.max(data.qy_data)
+                data.q_data = np.sqrt(data.qx_data * data.qx_data
+                                         + data.qy_data * data.qy_data)
+                if data.err_data is not None:
+                    data.err_data = data.err_data.astype(np.float64)
+                if data.dqx_data is not None:
+                    data.dqx_data = data.dqx_data.astype(np.float64)
+                if data.dqy_data is not None:
+                    data.dqy_data = data.dqy_data.astype(np.float64)
+                if data.mask is not None:
+                    data.mask = data.mask.astype(dtype=bool)
+                if len(data.data.shape) == 2:
+                    n_rows, n_cols = data.data.shape
+                    data.y_bins = data.qy_data[0::int(n_cols)]
+                    data.x_bins = data.qx_data[:int(n_cols)]
+                    data.data = data.data.flatten()
+                data = self._remove_nans_in_data(data)
+                if len(data.data) > 0:
+                    data.xmin = np.min(data.qx_data)
+                    data.xmax = np.max(data.qx_data)
+                    data.ymin = np.min(data.qy_data)
+                    data.ymax = np.max(data.qy_data)
     @staticmethod
 …
         return data
+    def sort_two_d_data(self):
+        for dataset in self.output:
+            if isinstance(dataset, Data2D):
+                # Normalize the units for
+                dataset.x_unit = self.format_unit(dataset.Q_unit)
+                dataset.y_unit = self.format_unit(dataset.I_unit)
+                dataset.data = dataset.data.astype(np.float64)
+                dataset.qx_data = dataset.qx_data.astype(np.float64)
+                dataset.xmin = np.min(dataset.qx_data)
+                dataset.xmax = np.max(dataset.qx_data)
+                dataset.qy_data = dataset.qy_data.astype(np.float64)
+                dataset.ymin = np.min(dataset.qy_data)
+                dataset.ymax = np.max(dataset.qy_data)
+                dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data
+                                         + dataset.qy_data * dataset.qy_data)
+                if dataset.err_data is not None:
+                    dataset.err_data = dataset.err_data.astype(np.float64)
+                if dataset.dqx_data is not None:
+                    dataset.dqx_data = dataset.dqx_data.astype(np.float64)
+                if dataset.dqy_data is not None:
+                    dataset.dqy_data = dataset.dqy_data.astype(np.float64)
+                if dataset.mask is not None:
+                    dataset.mask = dataset.mask.astype(dtype=bool)
+                if len(dataset.data.shape) == 2:
+                    n_rows, n_cols = dataset.data.shape
+                    dataset.y_bins = dataset.qy_data[0::int(n_cols)]
+                    dataset.x_bins = dataset.qx_data[:int(n_cols)]
+                dataset.data = dataset.data.flatten()
+                dataset = self._remove_nans_in_data(dataset)
+                if len(dataset.data) > 0:
+                    dataset.xmin = np.min(dataset.qx_data)
+                    dataset.xmax = np.max(dataset.qx_data)
+                    dataset.ymin = np.min(dataset.qy_data)
+                    dataset.ymax = np.max(dataset.qy_data)
+    @staticmethod
+    def set_default_1d_units(data):
+        """
+        Set the x and y axes to the default 1D units
+        :param data: 1D data set
+        :return:
+        """
+        data.xaxis(r"\rm{Q}", '1/A')
+        data.yaxis(r"\rm{Intensity}", "1/cm")
+        return data
+    @staticmethod
+    def set_default_2d_units(data):
+        """
+        Set the x and y axes to the default 2D units
+        :param data: 2D data set
+        :return:
+        """
+        data.xaxis("\\rm{Q_{x}}", '1/A')
+        data.yaxis("\\rm{Q_{y}}", '1/A')
+        data.zaxis("\\rm{Intensity}", "1/cm")
+        return data
+    def convert_data_units(self, default_q_unit="1/A"):
+        """
+        Converts al; data to the sasview default of units of A^{-1} for Q and
+        cm^{-1} for I.
+        :param default_q_unit: The default Q unit used by Sasview
+        """
+        convert_q = True
+        new_output = []
+        for data in self.output:
+            if data.isSesans:
+                new_output.append(data)
+                continue
+            try:
+                file_x_unit = data._xunit
+                data_conv_x = Converter(file_x_unit)
+            except KeyError:
+                logger.info("Unrecognized Q units in data file. No data "
+                            "conversion attempted")
+                convert_q = False
+            try:
+                if isinstance(data, Data1D):
+                        if convert_q:
+                            data.x = data_conv_x(data.x, units=default_q_unit)
+                            data._xunit = default_q_unit
+                            data.x_unit = default_q_unit
+                            if data.dx is not None:
+                                data.dx = data_conv_x(data.dx,
+                                                      units=default_q_unit)
+                            if data.dxl is not None:
+                                data.dxl = data_conv_x(data.dxl,
+                                                       units=default_q_unit)
+                            if data.dxw is not None:
+                                data.dxw = data_conv_x(data.dxw,
+                                                       units=default_q_unit)
+                elif isinstance(data, Data2D):
+                    if convert_q:
+                        data.qx_data = data_conv_x(data.qx_data,
+                                                   units=default_q_unit)
+                        if data.dqx_data is not None:
+                            data.dqx_data = data_conv_x(data.dqx_data,
+                                                        units=default_q_unit)
+                        try:
+                            file_y_unit = data._yunit
+                            data_conv_y = Converter(file_y_unit)
+                            data.qy_data = data_conv_y(data.qy_data,
+                                                       units=default_q_unit)
+                            if data.dqy_data is not None:
+                                data.dqy_data = data_conv_y(data.dqy_data,
+                                                            units=default_q_unit)
+                        except KeyError:
+                            logger.info("Unrecognized Qy units in data file. No"
+                                        " data conversion attempted")
+            except KeyError:
+                message = "Unable to convert Q units from {0} to 1/A."
+                message.format(default_q_unit)
+                data.errors.append(message)
+            new_output.append(data)
+        self.output = new_output
     def format_unit(self, unit=None):
 …
                     self.current_dataset.qy_data))
             if has_error_dy:
+                self.current_dataset.err_data = self.current_dataset.err_data[x != 0]
+                self.current_dataset.err_data = self.current_dataset.err_data[
+                    x != 0]
             if has_error_dqx:
+                self.current_dataset.dqx_data = self.current_dataset.dqx_data[x != 0]
+                self.current_dataset.dqx_data = self.current_dataset.dqx_data[
+                    x != 0]
             if has_error_dqy:
+                self.current_dataset.dqy_data = self.current_dataset.dqy_data[x != 0]
+                self.current_dataset.dqy_data = self.current_dataset.dqy_data[
+                    x != 0]
             if has_mask:
                 self.current_dataset.mask = self.current_dataset.mask[x != 0]

src/sas/sascalc/dataloader/loader.py

-                      r4a8d55c
+                      rb1ec23d
             try:
                 return fn(path, data)
+            except Exception:
+                pass  # give other loaders a chance to succeed
+        # If we get here it is because all loaders failed
+        raise  # reraises last exception
+            except Exception as exc:
+                msg = "Saving file {} using the {} writer failed.\n".format(
+                    path, type(fn).__name__)
+                msg += str(exc)
+                logger.exception(msg)  # give other loaders a chance to succeed

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

                       rbd5c3b1
             raise ValueError("ascii_reader: could not load file")
+        self.current_dataset = self.set_default_1d_units(self.current_dataset)
         if data_conv_q is not None:
             self.current_dataset.xaxis("\\rm{Q}", base_q_unit)
-        else:
-            self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}')
         if data_conv_i is not None:
             self.current_dataset.yaxis("\\rm{Intensity}", base_i_unit)
-        else:
-            self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}")
         # Store loading process information

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

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

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

-                      r2469df7
+                      r058f6c3
             node.append(point)
             self.write_node(point, "Q", datainfo.x[i],
                             {'unit': datainfo.x_unit})
+                            {'unit': datainfo._xunit})
             if len(datainfo.y) >= i:
                 self.write_node(point, "I", datainfo.y[i],
                                 {'unit': datainfo.y_unit})
+                                {'unit': datainfo._yunit})
             if datainfo.dy is not None and len(datainfo.dy) > i:
                 self.write_node(point, "Idev", datainfo.dy[i],
                                 {'unit': datainfo.y_unit})
+                                {'unit': datainfo._yunit})
             if datainfo.dx is not None and len(datainfo.dx) > i:
                 self.write_node(point, "Qdev", datainfo.dx[i],
                                 {'unit': datainfo.x_unit})
+                                {'unit': datainfo._xunit})
             if datainfo.dxw is not None and len(datainfo.dxw) > i:
                 self.write_node(point, "dQw", datainfo.dxw[i],
                                 {'unit': datainfo.x_unit})
+                                {'unit': datainfo._xunit})
             if datainfo.dxl is not None and len(datainfo.dxl) > i:
                 self.write_node(point, "dQl", datainfo.dxl[i],
                                 {'unit': datainfo.x_unit})
+                                {'unit': datainfo._xunit})
         if datainfo.isSesans:
             sesans_attrib = {'x_axis': datainfo._xaxis,

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

-                      r61f329f0
+                      ra165bee
 """
     CanSAS 2D data reader for reading HDF5 formatted CanSAS files.
+    NXcanSAS data reader for reading HDF5 formatted CanSAS files.
 """
 …
     Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \
     TransmissionSpectrum, Detector
-from ..data_info import combine_data_info_with_plottable
 from ..loader_exceptions import FileContentsException, DefaultReaderException
 from ..file_reader_base_class import FileReader, decode
 def h5attr(node, key, default=None):
     return decode(node.attrs.get(key, default))
 class Reader(FileReader):
     """
     A class for reading in CanSAS v2.0 data files. The existing iteration opens
     Mantid generated HDF5 formatted files with file extension .h5/.H5. Any
     number of data sets may be present within the file and any dimensionality
     of data may be used. Currently 1D and 2D SAS data sets are supported, but
     future implementations will include 1D and 2D SESANS data.
+    Any number of SASdata sets may be present in a SASentry and the data within
     can be either 1D I(Q) or 2D I(Qx, Qy).
     Also supports reading NXcanSAS formatted HDF5 files
+    A class for reading in NXcanSAS data files. The current implementation has
+    been tested to load data generated by multiple facilities, all of which are
+    known to produce NXcanSAS standards compliant data. Any number of data sets
+    may be present within the file and any dimensionality of data may be used.
+    Currently 1D and 2D SAS data sets are supported, but should be immediately
+    extensible to SESANS data.
+    Any number of SASdata groups  may be present in a SASentry and the data
+    within each SASdata group can be a single 1D I(Q), multi-framed 1D I(Q),
+D I(Qx, Qy) or multi-framed 2D I(Qx, Qy).
     :Dependencies:
         The CanSAS HDF5 reader requires h5py => v2.5.0 or later.
+        The NXcanSAS HDF5 reader requires h5py => v2.5.0 or later.
     """
     # CanSAS version
     cansas_version = 2.0
-    # Logged warnings or messages
-    logging = None
-    # List of errors for the current data set
-    errors = None
-    # Raw file contents to be processed
-    raw_data = None
-    # List of plottable1D objects that should be linked to the current_datainfo
-    data1d = None
-    # List of plottable2D objects that should be linked to the current_datainfo
-    data2d = None
     # Data type name
     type_name = "CanSAS 2.0"
+    type_name = "NXcanSAS"
     # Wildcards
     type = ["CanSAS 2.0 HDF5 Files (*.h5)|*.h5"]
+    type = ["NXcanSAS HDF5 Files (*.h5)|*.h5|"]
     # List of allowed extensions
     ext = ['.h5', '.H5']
 …
                 except Exception as e:
                     if extension not in self.ext:
+                        msg = "CanSAS2.0 HDF5 Reader could not load file {}".format(basename + extension)
+                        msg = "NXcanSAS Reader could not load file {}".format(
+                            basename + extension)
                         raise DefaultReaderException(msg)
                     raise FileContentsException(e.message)
 …
                     self.raw_data.close()
+                for dataset in self.output:
+                    if isinstance(dataset, Data1D):
+                        if dataset.x.size < 5:
+                            self.output = []
+                            raise FileContentsException("Fewer than 5 data points found.")
+                for data_set in self.output:
+                    if isinstance(data_set, Data1D):
+                        if data_set.x.size < 5:
+                            exception = FileContentsException(
+                                "Fewer than 5 data points found.")
+                            data_set.errors.append(exception)
     def reset_state(self):
 …
         self.data2d = []
         self.raw_data = None
+        self.errors = set()
+        self.multi_frame = False
+        self.data_frames = []
+        self.data_uncertainty_frames = []
+        self.errors = []
         self.logging = []
+        self.q_names = []
+        self.mask_name = u''
+        self.i_name = u''
+        self.i_node = u''
+        self.i_uncertainties_name = u''
+        self.q_uncertainty_names = []
+        self.q_resolution_names = []
         self.parent_class = u''
         self.detector = Detector()
 …
             value = data.get(key)
             class_name = h5attr(value, u'canSAS_class')
+            if isinstance(class_name, (list, tuple, np.ndarray)):
+                class_name = class_name[0]
             if class_name is None:
                 class_name = h5attr(value, u'NX_class')
 …
             if isinstance(value, h5py.Group):
                 # Set parent class before recursion
+                last_parent_class = self.parent_class
                 self.parent_class = class_name
                 parent_list.append(key)
 …
                     self.add_data_set(key)
                 elif class_prog.match(u'SASdata'):
+                    self._initialize_new_data_set(parent_list)
+                    self._find_data_attributes(value)
+                    self._initialize_new_data_set(value)
                 # Recursion step to access data within the group
                 self.read_children(value, parent_list)
+                self.add_intermediate()
                 # Reset parent class when returning from recursive method
+                self.parent_class = class_name
+                self.add_intermediate()
+                self.parent_class = last_parent_class
                 parent_list.remove(key)
             elif isinstance(value, h5py.Dataset):
                 # If this is a dataset, store the data appropriately
                 data_set = data[key][:]
+                data_set = value.value
                 unit = self._get_unit(value)
-                # I and Q Data
-                if key == u'I':
-                    if isinstance(self.current_dataset, plottable_2D):
-                        self.current_dataset.data = data_set
-                        self.current_dataset.zaxis("Intensity", unit)
-                    else:
-                        self.current_dataset.y = data_set.flatten()
-                        self.current_dataset.yaxis("Intensity", unit)
-                    continue
-                elif key == u'Idev':
-                    if isinstance(self.current_dataset, plottable_2D):
-                        self.current_dataset.err_data = data_set.flatten()
-                    else:
-                        self.current_dataset.dy = data_set.flatten()
-                    continue
-                elif key == u'Q':
-                    self.current_dataset.xaxis("Q", unit)
-                    if isinstance(self.current_dataset, plottable_2D):
-                        self.current_dataset.q = data_set.flatten()
-                    else:
-                        self.current_dataset.x = data_set.flatten()
-                    continue
-                elif key == u'Qdev':
-                    self.current_dataset.dx = data_set.flatten()
-                    continue
-                elif key == u'dQw':
-                    self.current_dataset.dxw = data_set.flatten()
-                    continue
-                elif key == u'dQl':
-                    self.current_dataset.dxl = data_set.flatten()
-                    continue
-                elif key == u'Qy':
-                    self.current_dataset.yaxis("Q_y", unit)
-                    self.current_dataset.qy_data = data_set.flatten()
-                    continue
-                elif key == u'Qydev':
-                    self.current_dataset.dqy_data = data_set.flatten()
-                    continue
-                elif key == u'Qx':
-                    self.current_dataset.xaxis("Q_x", unit)
-                    self.current_dataset.qx_data = data_set.flatten()
-                    continue
-                elif key == u'Qxdev':
-                    self.current_dataset.dqx_data = data_set.flatten()
-                    continue
-                elif key == u'Mask':
-                    self.current_dataset.mask = data_set.flatten()
-                    continue
-                # Transmission Spectrum
-                elif (key == u'T'
-                      and self.parent_class == u'SAStransmission_spectrum'):
-                    self.trans_spectrum.transmission = data_set.flatten()
-                    continue
-                elif (key == u'Tdev'
-                      and self.parent_class == u'SAStransmission_spectrum'):
-                    self.trans_spectrum.transmission_deviation = \
-                        data_set.flatten()
-                    continue
-                elif (key == u'lambda'
-                      and self.parent_class == u'SAStransmission_spectrum'):
-                    self.trans_spectrum.wavelength = data_set.flatten()
-                    continue
                 for data_point in data_set:
 …
                     # Top Level Meta Data
                     if key == u'definition':
+                        self.current_datainfo.meta_data['reader'] = data_point
+                        if isinstance(data_set, basestring):
+                            self.current_datainfo.meta_data['reader'] = data_set
+                            break
+                        else:
+                            self.current_datainfo.meta_data[
+                                'reader'] = data_point
+                    # Run
                     elif key == u'run':
-                        self.current_datainfo.run.append(data_point)
                         try:
                             run_name = h5attr(value, 'name')
                             run_dict = {data_point: run_name}
+                            run_dict = {data_set: run_name}
                             self.current_datainfo.run_name = run_dict
                         except Exception:
                             pass
+                        if isinstance(data_set, basestring):
+                            self.current_datainfo.run.append(data_set)
+                            break
+                        else:
+                            self.current_datainfo.run.append(data_point)
+                    # Title
                     elif key == u'title':
+                        self.current_datainfo.title = data_point
+                        if isinstance(data_set, basestring):
+                            self.current_datainfo.title = data_set
+                            break
+                        else:
+                            self.current_datainfo.title = data_point
+                    # Note
                     elif key == u'SASnote':
                         self.current_datainfo.notes.append(data_point)
+                        self.current_datainfo.notes.append(data_set)
+                        break
                     # Sample Information
+                    # CanSAS 2.0 format
+                    elif key == u'Title' and self.parent_class == u'SASsample':
+                        self.current_datainfo.sample.name = data_point
+                    # NXcanSAS format
+                    elif key == u'name' and self.parent_class == u'SASsample':
+                        self.current_datainfo.sample.name = data_point
+                    # NXcanSAS format
+                    elif key == u'ID' and self.parent_class == u'SASsample':
+                        self.current_datainfo.sample.name = data_point
+                    elif (key == u'thickness'
+                          and self.parent_class == u'SASsample'):
+                        self.current_datainfo.sample.thickness = data_point
+                    elif (key == u'temperature'
+                          and self.parent_class == u'SASsample'):
+                        self.current_datainfo.sample.temperature = data_point
+                    elif (key == u'transmission'
+                          and self.parent_class == u'SASsample'):
+                        self.current_datainfo.sample.transmission = data_point
+                    elif (key == u'x_position'
+                          and self.parent_class == u'SASsample'):
+                        self.current_datainfo.sample.position.x = data_point
+                    elif (key == u'y_position'
+                          and self.parent_class == u'SASsample'):
+                        self.current_datainfo.sample.position.y = data_point
+                    elif key == u'pitch' and self.parent_class == u'SASsample':
+                        self.current_datainfo.sample.orientation.x = data_point
+                    elif key == u'yaw' and self.parent_class == u'SASsample':
+                        self.current_datainfo.sample.orientation.y = data_point
+                    elif key == u'roll' and self.parent_class == u'SASsample':
+                        self.current_datainfo.sample.orientation.z = data_point
+                    elif (key == u'details'
+                          and self.parent_class == u'SASsample'):
+                        self.current_datainfo.sample.details.append(data_point)
+                    elif self.parent_class == u'SASsample':
+                        self.process_sample(data_point, key)
                     # Instrumental Information
                     elif (key == u'name'
                           and self.parent_class == u'SASinstrument'):
                         self.current_datainfo.instrument = data_point
+                    elif key == u'name' and self.parent_class == u'SASdetector':
+                        self.detector.name = data_point
+                    elif key == u'SDD' and self.parent_class == u'SASdetector':
+                        self.detector.distance = float(data_point)
+                        self.detector.distance_unit = unit
+                    elif (key == u'slit_length'
+                          and self.parent_class == u'SASdetector'):
+                        self.detector.slit_length = float(data_point)
+                        self.detector.slit_length_unit = unit
+                    elif (key == u'x_position'
+                          and self.parent_class == u'SASdetector'):
+                        self.detector.offset.x = float(data_point)
+                        self.detector.offset_unit = unit
+                    elif (key == u'y_position'
+                          and self.parent_class == u'SASdetector'):
+                        self.detector.offset.y = float(data_point)
+                        self.detector.offset_unit = unit
+                    elif (key == u'pitch'
+                          and self.parent_class == u'SASdetector'):
+                        self.detector.orientation.x = float(data_point)
+                        self.detector.orientation_unit = unit
+                    elif key == u'roll' and self.parent_class == u'SASdetector':
+                        self.detector.orientation.z = float(data_point)
+                        self.detector.orientation_unit = unit
+                    elif key == u'yaw' and self.parent_class == u'SASdetector':
+                        self.detector.orientation.y = float(data_point)
+                        self.detector.orientation_unit = unit
+                    elif (key == u'beam_center_x'
+                          and self.parent_class == u'SASdetector'):
+                        self.detector.beam_center.x = float(data_point)
+                        self.detector.beam_center_unit = unit
+                    elif (key == u'beam_center_y'
+                          and self.parent_class == u'SASdetector'):
+                        self.detector.beam_center.y = float(data_point)
+                        self.detector.beam_center_unit = unit
+                    elif (key == u'x_pixel_size'
+                          and self.parent_class == u'SASdetector'):
+                        self.detector.pixel_size.x = float(data_point)
+                        self.detector.pixel_size_unit = unit
+                    elif (key == u'y_pixel_size'
+                          and self.parent_class == u'SASdetector'):
+                        self.detector.pixel_size.y = float(data_point)
+                        self.detector.pixel_size_unit = unit
+                    elif (key == u'distance'
+                          and self.parent_class == u'SAScollimation'):
+                        self.collimation.length = data_point
+                        self.collimation.length_unit = unit
+                    elif (key == u'name'
+                          and self.parent_class == u'SAScollimation'):
+                        self.collimation.name = data_point
+                    elif (key == u'shape'
+                          and self.parent_class == u'SASaperture'):
+                        self.aperture.shape = data_point
+                    elif (key == u'x_gap'
+                          and self.parent_class == u'SASaperture'):
+                        self.aperture.size.x = data_point
+                    elif (key == u'y_gap'
+                          and self.parent_class == u'SASaperture'):
+                        self.aperture.size.y = data_point
+                    # Detector
+                    elif self.parent_class == u'SASdetector':
+                        self.process_detector(data_point, key, unit)
+                    # Collimation
+                    elif self.parent_class == u'SAScollimation':
+                        self.process_collimation(data_point, key, unit)
+                    # Aperture
+                    elif self.parent_class == u'SASaperture':
+                        self.process_aperture(data_point, key)
                     # Process Information
+                    elif (key == u'Title'
+                          and self.parent_class == u'SASprocess'): # CanSAS 2.0
+                        self.process.name = data_point
+                    elif (key == u'name'
+                          and self.parent_class == u'SASprocess'): # NXcanSAS
+                        self.process.name = data_point
+                    elif (key == u'description'
+                          and self.parent_class == u'SASprocess'):
+                        self.process.description = data_point
+                    elif key == u'date' and self.parent_class == u'SASprocess':
+                        self.process.date = data_point
+                    elif key == u'term' and self.parent_class == u'SASprocess':
+                        self.process.term = data_point
+                    elif self.parent_class == u'SASprocess':
+                        self.process.notes.append(data_point)
+                    elif self.parent_class == u'SASprocess': # CanSAS 2.0
+                        self.process_process(data_point, key)
                     # Source
+                    elif (key == u'wavelength'
+                          and self.parent_class == u'SASdata'):
+                        self.current_datainfo.source.wavelength = data_point
+                        self.current_datainfo.source.wavelength_unit = unit
+                    elif (key == u'incident_wavelength'
+                          and self.parent_class == 'SASsource'):
+                        self.current_datainfo.source.wavelength = data_point
+                        self.current_datainfo.source.wavelength_unit = unit
+                    elif (key == u'wavelength_max'
+                          and self.parent_class == u'SASsource'):
+                        self.current_datainfo.source.wavelength_max = data_point
+                        self.current_datainfo.source.wavelength_max_unit = unit
+                    elif (key == u'wavelength_min'
+                          and self.parent_class == u'SASsource'):
+                        self.current_datainfo.source.wavelength_min = data_point
+                        self.current_datainfo.source.wavelength_min_unit = unit
+                    elif (key == u'incident_wavelength_spread'
+                          and self.parent_class == u'SASsource'):
+                        self.current_datainfo.source.wavelength_spread = \
+                            data_point
+                        self.current_datainfo.source.wavelength_spread_unit = \
+                            unit
+                    elif (key == u'beam_size_x'
+                          and self.parent_class == u'SASsource'):
+                        self.current_datainfo.source.beam_size.x = data_point
+                        self.current_datainfo.source.beam_size_unit = unit
+                    elif (key == u'beam_size_y'
+                          and self.parent_class == u'SASsource'):
+                        self.current_datainfo.source.beam_size.y = data_point
+                        self.current_datainfo.source.beam_size_unit = unit
+                    elif (key == u'beam_shape'
+                          and self.parent_class == u'SASsource'):
+                        self.current_datainfo.source.beam_shape = data_point
+                    elif (key == u'radiation'
+                          and self.parent_class == u'SASsource'):
+                        self.current_datainfo.source.radiation = data_point
+                    elif (key == u'transmission'
+                          and self.parent_class == u'SASdata'):
+                        self.current_datainfo.sample.transmission = data_point
+                    elif self.parent_class == u'SASsource':
+                        self.process_source(data_point, key, unit)
                     # Everything else goes in meta_data
+                    elif self.parent_class == u'SASdata':
+                        if isinstance(self.current_dataset, plottable_2D):
+                            self.process_2d_data_object(data_set, key, unit)
+                        else:
+                            self.process_1d_data_object(data_set, key, unit)
+                        break
+                    elif self.parent_class == u'SAStransmission_spectrum':
+                        self.process_trans_spectrum(data_set, key)
+                        break
                     else:
                         new_key = self._create_unique_key(
 …
             else:
                 # I don't know if this reachable code
+                self.errors.add("ShouldNeverHappenException")
+                self.errors.append("ShouldNeverHappenException")
+    def process_1d_data_object(self, data_set, key, unit):
+        """
+        SASdata processor method for 1d data items
+        :param data_set: data from HDF5 file
+        :param key: canSAS_class attribute
+        :param unit: unit attribute
+        """
+        if key == self.i_name:
+            if self.multi_frame:
+                for x in range(0, data_set.shape[0]):
+                    self.data_frames.append(data_set[x].flatten())
+            else:
+                self.current_dataset.y = data_set.flatten()
+                self.current_dataset.yaxis("Intensity", unit)
+        elif key == self.i_uncertainties_name:
+            if self.multi_frame:
+                for x in range(0, data_set.shape[0]):
+                    self.data_uncertainty_frames.append(data_set[x].flatten())
+            self.current_dataset.dy = data_set.flatten()
+        elif key in self.q_names:
+            self.current_dataset.xaxis("Q", unit)
+            self.current_dataset.x = data_set.flatten()
+        elif key in self.q_resolution_names:
+            if (len(self.q_resolution_names) > 1
+                    and np.where(self.q_resolution_names == key)[0] == 0):
+                self.current_dataset.dxw = data_set.flatten()
+            elif (len(self.q_resolution_names) > 1
+                  and np.where(self.q_resolution_names == key)[0] == 1):
+                self.current_dataset.dxl = data_set.flatten()
+            else:
+                self.current_dataset.dx = data_set.flatten()
+        elif key in self.q_uncertainty_names:
+            if (len(self.q_uncertainty_names) > 1
+                    and np.where(self.q_uncertainty_names == key)[0] == 0):
+                self.current_dataset.dxw = data_set.flatten()
+            elif (len(self.q_uncertainty_names) > 1
+                  and np.where(self.q_uncertainty_names == key)[0] == 1):
+                self.current_dataset.dxl = data_set.flatten()
+            else:
+                self.current_dataset.dx = data_set.flatten()
+        elif key == self.mask_name:
+            self.current_dataset.mask = data_set.flatten()
+        elif key == u'wavelength':
+            self.current_datainfo.source.wavelength = data_set[0]
+            self.current_datainfo.source.wavelength_unit = unit
+    def process_2d_data_object(self, data_set, key, unit):
+        if key == self.i_name:
+            self.current_dataset.data = data_set
+            self.current_dataset.zaxis("Intensity", unit)
+        elif key == self.i_uncertainties_name:
+            self.current_dataset.err_data = data_set.flatten()
+        elif key in self.q_names:
+            self.current_dataset.xaxis("Q_x", unit)
+            self.current_dataset.yaxis("Q_y", unit)
+            if self.q_names[0] == self.q_names[1]:
+                # All q data in a single array
+                self.current_dataset.qx_data = data_set[0]
+                self.current_dataset.qy_data = data_set[1]
+            elif self.q_names.index(key) == 0:
+                self.current_dataset.qx_data = data_set
+            elif self.q_names.index(key) == 1:
+                self.current_dataset.qy_data = data_set
+        elif key in self.q_uncertainty_names or key in self.q_resolution_names:
+            if ((self.q_uncertainty_names[0] == self.q_uncertainty_names[1]) or
+                    (self.q_resolution_names[0] == self.q_resolution_names[1])):
+                # All q data in a single array
+                self.current_dataset.dqx_data = data_set[0].flatten()
+                self.current_dataset.dqy_data = data_set[1].flatten()
+            elif (self.q_uncertainty_names.index(key) == 0 or
+                  self.q_resolution_names.index(key) == 0):
+                self.current_dataset.dqx_data = data_set.flatten()
+            elif (self.q_uncertainty_names.index(key) == 1 or
+                  self.q_resolution_names.index(key) == 1):
+                self.current_dataset.dqy_data = data_set.flatten()
+                self.current_dataset.yaxis("Q_y", unit)
+        elif key == self.mask_name:
+            self.current_dataset.mask = data_set.flatten()
+        elif key == u'Qy':
+            self.current_dataset.yaxis("Q_y", unit)
+            self.current_dataset.qy_data = data_set.flatten()
+        elif key == u'Qydev':
+            self.current_dataset.dqy_data = data_set.flatten()
+        elif key == u'Qx':
+            self.current_dataset.xaxis("Q_x", unit)
+            self.current_dataset.qx_data = data_set.flatten()
+        elif key == u'Qxdev':
+            self.current_dataset.dqx_data = data_set.flatten()
+    def process_trans_spectrum(self, data_set, key):
+        """
+        SAStransmission_spectrum processor
+        :param data_set: data from HDF5 file
+        :param key: canSAS_class attribute
+        """
+        if key == u'T':
+            self.trans_spectrum.transmission = data_set.flatten()
+        elif key == u'Tdev':
+            self.trans_spectrum.transmission_deviation = data_set.flatten()
+        elif key == u'lambda':
+            self.trans_spectrum.wavelength = data_set.flatten()
+    def process_sample(self, data_point, key):
+        """
+        SASsample processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        """
+        if key == u'Title':
+            self.current_datainfo.sample.name = data_point
+        elif key == u'name':
+            self.current_datainfo.sample.name = data_point
+        elif key == u'ID':
+            self.current_datainfo.sample.name = data_point
+        elif key == u'thickness':
+            self.current_datainfo.sample.thickness = data_point
+        elif key == u'temperature':
+            self.current_datainfo.sample.temperature = data_point
+        elif key == u'transmission':
+            self.current_datainfo.sample.transmission = data_point
+        elif key == u'x_position':
+            self.current_datainfo.sample.position.x = data_point
+        elif key == u'y_position':
+            self.current_datainfo.sample.position.y = data_point
+        elif key == u'pitch':
+            self.current_datainfo.sample.orientation.x = data_point
+        elif key == u'yaw':
+            self.current_datainfo.sample.orientation.y = data_point
+        elif key == u'roll':
+            self.current_datainfo.sample.orientation.z = data_point
+        elif key == u'details':
+            self.current_datainfo.sample.details.append(data_point)
+    def process_detector(self, data_point, key, unit):
+        """
+        SASdetector processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        :param unit: unit attribute from data set
+        """
+        if key == u'name':
+            self.detector.name = data_point
+        elif key == u'SDD':
+            self.detector.distance = float(data_point)
+            self.detector.distance_unit = unit
+        elif key == u'slit_length':
+            self.detector.slit_length = float(data_point)
+            self.detector.slit_length_unit = unit
+        elif key == u'x_position':
+            self.detector.offset.x = float(data_point)
+            self.detector.offset_unit = unit
+        elif key == u'y_position':
+            self.detector.offset.y = float(data_point)
+            self.detector.offset_unit = unit
+        elif key == u'pitch':
+            self.detector.orientation.x = float(data_point)
+            self.detector.orientation_unit = unit
+        elif key == u'roll':
+            self.detector.orientation.z = float(data_point)
+            self.detector.orientation_unit = unit
+        elif key == u'yaw':
+            self.detector.orientation.y = float(data_point)
+            self.detector.orientation_unit = unit
+        elif key == u'beam_center_x':
+            self.detector.beam_center.x = float(data_point)
+            self.detector.beam_center_unit = unit
+        elif key == u'beam_center_y':
+            self.detector.beam_center.y = float(data_point)
+            self.detector.beam_center_unit = unit
+        elif key == u'x_pixel_size':
+            self.detector.pixel_size.x = float(data_point)
+            self.detector.pixel_size_unit = unit
+        elif key == u'y_pixel_size':
+            self.detector.pixel_size.y = float(data_point)
+            self.detector.pixel_size_unit = unit
+    def process_collimation(self, data_point, key, unit):
+        """
+        SAScollimation processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        :param unit: unit attribute from data set
+        """
+        if key == u'distance':
+            self.collimation.length = data_point
+            self.collimation.length_unit = unit
+        elif key == u'name':
+            self.collimation.name = data_point
+    def process_aperture(self, data_point, key):
+        """
+        SASaperture processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        """
+        if key == u'shape':
+            self.aperture.shape = data_point
+        elif key == u'x_gap':
+            self.aperture.size.x = data_point
+        elif key == u'y_gap':
+            self.aperture.size.y = data_point
+    def process_source(self, data_point, key, unit):
+        """
+        SASsource processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        :param unit: unit attribute from data set
+        """
+        if key == u'incident_wavelength':
+            self.current_datainfo.source.wavelength = data_point
+            self.current_datainfo.source.wavelength_unit = unit
+        elif key == u'wavelength_max':
+            self.current_datainfo.source.wavelength_max = data_point
+            self.current_datainfo.source.wavelength_max_unit = unit
+        elif key == u'wavelength_min':
+            self.current_datainfo.source.wavelength_min = data_point
+            self.current_datainfo.source.wavelength_min_unit = unit
+        elif key == u'incident_wavelength_spread':
+            self.current_datainfo.source.wavelength_spread = data_point
+            self.current_datainfo.source.wavelength_spread_unit = unit
+        elif key == u'beam_size_x':
+            self.current_datainfo.source.beam_size.x = data_point
+            self.current_datainfo.source.beam_size_unit = unit
+        elif key == u'beam_size_y':
+            self.current_datainfo.source.beam_size.y = data_point
+            self.current_datainfo.source.beam_size_unit = unit
+        elif key == u'beam_shape':
+            self.current_datainfo.source.beam_shape = data_point
+        elif key == u'radiation':
+            self.current_datainfo.source.radiation = data_point
+    def process_process(self, data_point, key):
+        """
+        SASprocess processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        """
+        term_match = re.compile(u'^term[0-9]+$')
+        if key == u'Title':  # CanSAS 2.0
+            self.process.name = data_point
+        elif key == u'name':  # NXcanSAS
+            self.process.name = data_point
+        elif key == u'description':
+            self.process.description = data_point
+        elif key == u'date':
+            self.process.date = data_point
+        elif term_match.match(key):
+            self.process.term.append(data_point)
+        else:
+            self.process.notes.append(data_point)
     def add_intermediate(self):
 …
                 self.data2d.append(self.current_dataset)
             elif isinstance(self.current_dataset, plottable_1D):
+                self.data1d.append(self.current_dataset)
+                if self.multi_frame:
+                    for x in range(0, len(self.data_frames)):
+                        self.current_dataset.y = self.data_frames[x]
+                        if len(self.data_uncertainty_frames) > x:
+                            self.current_dataset.dy = \
+                                self.data_uncertainty_frames[x]
+                        self.data1d.append(self.current_dataset)
+                else:
+                    self.data1d.append(self.current_dataset)
     def final_data_cleanup(self):
 …
             spectrum_list = []
             for spectrum in self.current_datainfo.trans_spectrum:
-                spectrum.transmission = np.delete(spectrum.transmission, [0])
                 spectrum.transmission = spectrum.transmission.astype(np.float64)
-                spectrum.transmission_deviation = np.delete(
-                    spectrum.transmission_deviation, [0])
                 spectrum.transmission_deviation = \
                     spectrum.transmission_deviation.astype(np.float64)
-                spectrum.wavelength = np.delete(spectrum.wavelength, [0])
                 spectrum.wavelength = spectrum.wavelength.astype(np.float64)
                 if len(spectrum.transmission) > 0:
 …
         # Append errors to dataset and reset class errors
         self.current_datainfo.errors = self.errors
         self.errors.clear()
+        self.errors = []
         # Combine all plottables with datainfo and append each to output
 …
                     zeros[i] = dataset.mask[i]
             except:
                 self.errors.add(sys.exc_value)
+                self.errors.append(sys.exc_value)
             dataset.mask = zeros
             # Calculate the actual Q matrix
 …
             if dataset.data.ndim == 2:
                 (n_rows, n_cols) = dataset.data.shape
+                dataset.y_bins = dataset.qy_data[0::n_cols]
+                dataset.x_bins = dataset.qx_data[:n_cols]
+                flat_qy = dataset.qy_data[0::n_cols].flatten()
+                # For 2D arrays of Qx and Qy, the Q value should be constant
+                # along each row -OR- each column. The direction is not
+                # specified in the NXcanSAS standard.
+                if flat_qy[0] == flat_qy[1]:
+                    flat_qy = np.transpose(dataset.qy_data)[0::n_cols].flatten()
+                dataset.y_bins = np.unique(flat_qy)
+                flat_qx = dataset.qx_data[0::n_rows].flatten()
+                # For 2D arrays of Qx and Qy, the Q value should be constant
+                # along each row -OR- each column. The direction is not
+                # specified in the NXcanSAS standard.
+                if flat_qx[0] == flat_qx[1]:
+                    flat_qx = np.transpose(dataset.qx_data)[0::n_rows].flatten()
+                dataset.x_bins = np.unique(flat_qx)
                 dataset.data = dataset.data.flatten()
+                dataset.qx_data = dataset.qx_data.flatten()
+                dataset.qy_data = dataset.qy_data.flatten()
             self.current_dataset = dataset
             self.send_to_output()
 …
         if self.current_datainfo and self.current_dataset:
             self.final_data_cleanup()
+        self.data_frames = []
+        self.data_uncertainty_frames = []
         self.data1d = []
         self.data2d = []
         self.current_datainfo = DataInfo()
+    def _initialize_new_data_set(self, parent_list=None):
+    def _initialize_new_data_set(self, value=None):
         """
         A private class method to generate a new 1D or 2D data object based on
 …
         :param parent_list: List of names of parent elements
         """
+        if parent_list is None:
+            parent_list = []
+        if self._find_intermediate(parent_list, "Qx"):
+        if self._is2d(value):
             self.current_dataset = plottable_2D()
         else:
 …
         self.current_datainfo.filename = self.raw_data.filename
+    def _find_intermediate(self, parent_list, basename=""):
+        """
+        A private class used to find an entry by either using a direct key or
+        knowing the approximate basename.
+        :param parent_list: List of parents nodes in the HDF5 file
+    @staticmethod
+    def check_is_list_or_array(iterable):
+        try:
+            iter(iterable)
+            if (not isinstance(iterable, np.ndarray) and not isinstance(
+                    iterable, list)) or (isinstance(iterable, basestring)):
+                raise TypeError
+        except TypeError:
+            if isinstance(iterable, basestring):
+                iterable = iterable.split(",")
+            else:
+                iterable = [iterable]
+        return iterable
+    def _find_data_attributes(self, value):
+        """
+        A class to find the indices for Q, the name of the Qdev and Idev, and
+        the name of the mask.
+        :param value: SASdata/NXdata HDF5 Group
+        """
+        # Initialize values to base types
+        self.mask_name = u''
+        self.i_name = u''
+        self.i_node = u''
+        self.i_uncertainties_name = u''
+        self.q_names = []
+        self.q_uncertainty_names = []
+        self.q_resolution_names = []
+        # Get attributes
+        attrs = value.attrs
+        signal = attrs.get("signal", "I")
+        i_axes = attrs.get("I_axes", ["Q"])
+        q_indices = attrs.get("Q_indices", [0])
+        q_indices = map(int, self.check_is_list_or_array(q_indices))
+        i_axes = self.check_is_list_or_array(i_axes)
+        keys = value.keys()
+        # Assign attributes to appropriate class variables
+        self.mask_name = attrs.get("mask")
+        for val in q_indices:
+            self.q_names.append(i_axes[val])
+        self.i_name = signal
+        self.i_node = value.get(self.i_name)
+        for item in self.q_names:
+            if item in keys:
+                q_vals = value.get(item)
+                if q_vals.attrs.get("uncertainties") is not None:
+                    self.q_uncertainty_names = q_vals.attrs.get("uncertainties")
+                elif q_vals.attrs.get("uncertainty") is not None:
+                    self.q_uncertainty_names = q_vals.attrs.get("uncertainty")
+                if isinstance(self.q_uncertainty_names, basestring):
+                    self.q_uncertainty_names = self.q_uncertainty_names.split(",")
+                if q_vals.attrs.get("resolutions") is not None:
+                    self.q_resolution_names = q_vals.attrs.get("resolutions")
+                if isinstance(self.q_resolution_names, basestring):
+                    self.q_resolution_names = self.q_resolution_names.split(",")
+        if self.i_name in keys:
+            i_vals = value.get(self.i_name)
+            self.i_uncertainties_name = i_vals.attrs.get("uncertainties")
+            if self.i_uncertainties_name is None:
+                self.i_uncertainties_name = i_vals.attrs.get("uncertainty")
+    def _is2d(self, value, i_base="", q_base=[]):
+        """
+        A private class to determine if the data set is 1d or 2d.
+        :param value: Nexus/NXcanSAS data group
         :param basename: Approximate name of an entry to search for
+        :return:
+        """
+        entry = False
+        key_prog = re.compile(basename)
+        top = self.raw_data
+        for parent in parent_list:
+            top = top.get(parent)
+        for key in top.keys():
+            if key_prog.match(key):
+                entry = True
+                break
+        return entry
+        :return: True if 2D, otherwise false
+        """
+        i_basename = i_base if i_base != "" else self.i_name
+        i_vals = value.get(i_basename)
+        q_basename = q_base if q_base != [] else self.q_names
+        q_vals = value.get(q_basename[0])
+        self.multi_frame = True if (i_vals is not None and q_vals is not None
+                                    and len(i_vals.shape) != 1
+                                    and len(q_vals.shape) == 1) else False
+        return (i_vals is not None and i_vals.shape is not None
+                and len(i_vals.shape) != 1 and not self.multi_frame)
     def _create_unique_key(self, dictionary, name, numb=0):
 …
         if unit is None:
             unit = h5attr(value, u'unit')
-        # Convert the unit formats
-        if unit == "1/A":
-            unit = "A^{-1}"
-        elif unit == "1/cm":
-            unit = "cm^{-1}"
         return unit

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

-                      r2469df7
+                      rfc51d06
         detector.beam_center.y = center_y * pixel
+        self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}')
+        self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}')
+        self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}")
+        self.current_dataset = self.set_default_2d_units(self.current_dataset)
         self.current_dataset.x_bins = x_vals
         self.current_dataset.y_bins = y_vals

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

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

src/sas/sascalc/file_converter/nxcansas_writer.py

-                      r574adc7
+                      r2ca5d57b
 import os
 from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader as Cansas2Reader
+from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader
 from sas.sascalc.dataloader.data_info import Data1D, Data2D
 class NXcanSASWriter(Cansas2Reader):
+class NXcanSASWriter(Reader):
     """
     A class for writing in NXcanSAS data files. Any number of data sets may be
 …
                     entry[names[2]].attrs['units'] = units
+        valid_data = all([issubclass(d.__class__, (Data1D, Data2D)) for d in dataset])
+        valid_data = all([issubclass(d.__class__, (Data1D, Data2D)) for d in
+                          dataset])
         if not valid_data:
+            raise ValueError("All entries of dataset must be Data1D or Data2D objects")
+            raise ValueError("All entries of dataset must be Data1D or Data2D"
+                             "objects")
         # Get run name and number from first Data object
 …
         sasentry.attrs['version'] = '1.0'
+        i = 1
+        for data_obj in dataset:
+            data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i))
+        for i, data_obj in enumerate(dataset):
+            data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i+1))
             data_entry.attrs['canSAS_class'] = 'SASdata'
             if isinstance(data_obj, Data1D):
 …
             elif isinstance(data_obj, Data2D):
                 self._write_2d_data(data_obj, data_entry)
-            i += 1
         data_info = dataset[0]
 …
                 sample_entry.create_dataset('details', data=details)
         # Instrumment metadata
+        # Instrument metadata
         instrument_entry = sasentry.create_group('sasinstrument')
         instrument_entry.attrs['canSAS_class'] = 'SASinstrument'
 …
             units=data_info.source.beam_size_unit, write_fn=_write_h5_float)
         # Collimation metadata
         if len(data_info.collimation) > 0:
+            i = 1
+            for coll_info in data_info.collimation:
+            for i, coll_info in enumerate(data_info.collimation):
                 collimation_entry = instrument_entry.create_group(
                     'sascollimation{0:0=2d}'.format(i))
+                    'sascollimation{0:0=2d}'.format(i + 1))
                 collimation_entry.attrs['canSAS_class'] = 'SAScollimation'
                 if coll_info.length is not None:
                     _write_h5_float(collimation_entry, coll_info.length, 'SDD')
+                    collimation_entry['SDD'].attrs['units'] = coll_info.length_unit
+                    collimation_entry['SDD'].attrs['units'] =\
+                        coll_info.length_unit
                 if coll_info.name is not None:
                     collimation_entry['name'] = _h5_string(coll_info.name)
         else:
+            # Create a blank one - at least 1 set of collimation metadata
+            # required by format
+            collimation_entry = instrument_entry.create_group('sascollimation01')
+            # Create a blank one - at least 1 collimation required by format
+            instrument_entry.create_group('sascollimation01')
         # Detector metadata
         if len(data_info.detector) > 0:
             i = 1
             for det_info in data_info.detector:
+            for i, det_info in enumerate(data_info.detector):
                 detector_entry = instrument_entry.create_group(
                     'sasdetector{0:0=2d}'.format(i))
+                    'sasdetector{0:0=2d}'.format(i + 1))
                 detector_entry.attrs['canSAS_class'] = 'SASdetector'
                 if det_info.distance is not None:
                     _write_h5_float(detector_entry, det_info.distance, 'SDD')
+                    detector_entry['SDD'].attrs['units'] = det_info.distance_unit
+                    detector_entry['SDD'].attrs['units'] =\
+                        det_info.distance_unit
                 if det_info.name is not None:
                     detector_entry['name'] = _h5_string(det_info.name)
 …
                     detector_entry['name'] = _h5_string('')
                 if det_info.slit_length is not None:
+                    _write_h5_float(detector_entry, det_info.slit_length, 'slit_length')
+                    detector_entry['slit_length'].attrs['units'] = det_info.slit_length_unit
+                    _write_h5_float(detector_entry, det_info.slit_length,
+                                    'slit_length')
+                    detector_entry['slit_length'].attrs['units'] =\
+                        det_info.slit_length_unit
                 _write_h5_vector(detector_entry, det_info.offset)
                 # NXcanSAS doesn't save information about pitch, only roll
 …
                     names=['x_pixel_size', 'y_pixel_size'],
                     write_fn=_write_h5_float, units=det_info.pixel_size_unit)
-                i += 1
         else:
             # Create a blank one - at least 1 detector required by format
 …
             detector_entry.attrs['canSAS_class'] = 'SASdetector'
             detector_entry.attrs['name'] = ''
+        # Process meta data
+        for i, process in enumerate(data_info.process):
+            process_entry = sasentry.create_group('sasprocess{0:0=2d}'.format(
+                i + 1))
+            process_entry.attrs['canSAS_class'] = 'SASprocess'
+            if process.name:
+                name = _h5_string(process.name)
+                process_entry.create_dataset('name', data=name)
+            if process.date:
+                date = _h5_string(process.date)
+                process_entry.create_dataset('date', data=date)
+            if process.description:
+                desc = _h5_string(process.description)
+                process_entry.create_dataset('description', data=desc)
+            for j, term in enumerate(process.term):
+                # Don't save empty terms
+                if term:
+                    h5_term = _h5_string(term)
+                    process_entry.create_dataset('term{0:0=2d}'.format(
+                        j + 1), data=h5_term)
+            for j, note in enumerate(process.notes):
+                # Don't save empty notes
+                if note:
+                    h5_note = _h5_string(note)
+                    process_entry.create_dataset('note{0:0=2d}'.format(
+                        j + 1), data=h5_note)
+        # Transmission Spectrum
+        for i, trans in enumerate(data_info.trans_spectrum):
+            trans_entry = sasentry.create_group(
+                'sastransmission_spectrum{0:0=2d}'.format(i + 1))
+            trans_entry.attrs['canSAS_class'] = 'SAStransmission_spectrum'
+            trans_entry.attrs['signal'] = 'T'
+            trans_entry.attrs['T_axes'] = 'T'
+            trans_entry.attrs['name'] = trans.name
+            if trans.timestamp is not '':
+                trans_entry.attrs['timestamp'] = trans.timestamp
+            transmission = trans_entry.create_dataset('T',
+                                                      data=trans.transmission)
+            transmission.attrs['unertainties'] = 'Tdev'
+            trans_entry.create_dataset('Tdev',
+                                       data=trans.transmission_deviation)
+            trans_entry.create_dataset('lambda', data=trans.wavelength)
         note_entry = sasentry.create_group('sasnote'.format(i))
 …
         data_entry.attrs['signal'] = 'I'
         data_entry.attrs['I_axes'] = 'Q'
+        data_entry.attrs['I_uncertainties'] = 'Idev'
+        data_entry.attrs['Q_indicies'] = 0
+        dI = data_obj.dy
+        if dI is None:
+            dI = np.zeros((data_obj.y.shape))
+        data_entry.create_dataset('Q', data=data_obj.x)
+        data_entry.create_dataset('I', data=data_obj.y)
+        data_entry.create_dataset('Idev', data=dI)
+        data_entry.attrs['Q_indices'] = [0]
+        q_entry = data_entry.create_dataset('Q', data=data_obj.x)
+        q_entry.attrs['units'] = data_obj.x_unit
+        i_entry = data_entry.create_dataset('I', data=data_obj.y)
+        i_entry.attrs['units'] = data_obj.y_unit
+        if data_obj.dy is not None:
+            i_entry.attrs['uncertainties'] = 'Idev'
+            i_dev_entry = data_entry.create_dataset('Idev', data=data_obj.dy)
+            i_dev_entry.attrs['units'] = data_obj.y_unit
+        if data_obj.dx is not None:
+            q_entry.attrs['resolutions'] = 'dQ'
+            dq_entry = data_entry.create_dataset('dQ', data=data_obj.dx)
+            dq_entry.attrs['units'] = data_obj.x_unit
+        elif data_obj.dxl is not None:
+            q_entry.attrs['resolutions'] = ['dQl','dQw']
+            dql_entry = data_entry.create_dataset('dQl', data=data_obj.dxl)
+            dql_entry.attrs['units'] = data_obj.x_unit
+            dqw_entry = data_entry.create_dataset('dQw', data=data_obj.dxw)
+            dqw_entry.attrs['units'] = data_obj.x_unit
     def _write_2d_data(self, data, data_entry):
 …
         """
         data_entry.attrs['signal'] = 'I'
+        data_entry.attrs['I_axes'] = 'Q,Q'
+        data_entry.attrs['I_uncertainties'] = 'Idev'
+        data_entry.attrs['Q_indicies'] = [0,1]
+        data_entry.attrs['I_axes'] = 'Qx,Qy'
+        data_entry.attrs['Q_indices'] = [0,1]
         (n_rows, n_cols) = (len(data.y_bins), len(data.x_bins))
 …
                 raise ValueError("Unable to calculate dimensions of 2D data")
+        I = np.reshape(data.data, (n_rows, n_cols))
+        dI = np.zeros((n_rows, n_cols))
+        if not all(data.err_data == [None]):
+            dI = np.reshape(data.err_data, (n_rows, n_cols))
+        qx =  np.reshape(data.qx_data, (n_rows, n_cols))
+        intensity = np.reshape(data.data, (n_rows, n_cols))
+        qx = np.reshape(data.qx_data, (n_rows, n_cols))
         qy = np.reshape(data.qy_data, (n_rows, n_cols))
+        I_entry = data_entry.create_dataset('I', data=I)
+        I_entry.attrs['units'] = data.I_unit
+        Qx_entry = data_entry.create_dataset('Qx', data=qx)
+        Qx_entry.attrs['units'] = data.Q_unit
+        Qy_entry = data_entry.create_dataset('Qy', data=qy)
+        Qy_entry.attrs['units'] = data.Q_unit
+        Idev_entry = data_entry.create_dataset('Idev', data=dI)
+        Idev_entry.attrs['units'] = data.I_unit
+        i_entry = data_entry.create_dataset('I', data=intensity)
+        i_entry.attrs['units'] = data.I_unit
+        qx_entry = data_entry.create_dataset('Qx', data=qx)
+        qx_entry.attrs['units'] = data.Q_unit
+        qy_entry = data_entry.create_dataset('Qy', data=qy)
+        qy_entry.attrs['units'] = data.Q_unit
+        if data.err_data is not None and not all(data.err_data == [None]):
+            d_i = np.reshape(data.err_data, (n_rows, n_cols))
+            i_entry.attrs['uncertainties'] = 'Idev'
+            i_dev_entry = data_entry.create_dataset('Idev', data=d_i)
+            i_dev_entry.attrs['units'] = data.I_unit
+        if data.dqx_data is not None and not all(data.dqx_data == [None]):
+            qx_entry.attrs['resolutions'] = 'dQx'
+            dqx_entry = data_entry.create_dataset('dQx', data=data.dqx_data)
+            dqx_entry.attrs['units'] = data.Q_unit
+        if data.dqy_data is not None and not all(data.dqy_data == [None]):
+            qy_entry.attrs['resolutions'] = 'dQy'
+            dqy_entry = data_entry.create_dataset('dQy', data=data.dqy_data)
+            dqy_entry.attrs['units'] = data.Q_unit

src/sas/sasgui/guiframe/gui_manager.py

-                      r8ac05a5
+                      r9f45f83
 from sas.sasgui.guiframe.CategoryManager import CategoryManager
 from sas.sascalc.dataloader.loader import Loader
+from sas.sascalc.file_converter.nxcansas_writer import NXcanSASWriter
 from sas.sasgui.guiframe.proxy import Connection
 …
         default_name = fname
         wildcard = "Text files (*.txt)|*.txt|"\
+                    "CanSAS 1D files(*.xml)|*.xml"
+        path = None
+                    "CanSAS 1D files (*.xml)|*.xml|"\
+                     "NXcanSAS files (*.h5)|*.h5|"
+        options = [".txt", ".xml",".h5"]
         dlg = wx.FileDialog(self, "Choose a file",
                             self._default_save_location,
 …
             # This is MAC Fix
             ext_num = dlg.GetFilterIndex()
+            if ext_num == 0:
+                ext_format = '.txt'
+            else:
+                ext_format = '.xml'
+            ext_format = options[ext_num]
             path = os.path.splitext(path)[0] + ext_format
             mypath = os.path.basename(path)
+            # Instantiate a loader
+            loader = Loader()
+            ext_format = ".txt"
+            if os.path.splitext(mypath)[1].lower() == ext_format:
+            fName = os.path.splitext(path)[0] + ext_format
+            if os.path.splitext(mypath)[1].lower() == options[0]:
                 # Make sure the ext included in the file name
                 # especially on MAC
-                fName = os.path.splitext(path)[0] + ext_format
                 self._onsaveTXT(data, fName)
+            ext_format = ".xml"
+            if os.path.splitext(mypath)[1].lower() == ext_format:
+            elif os.path.splitext(mypath)[1].lower() == options[1]:
                 # Make sure the ext included in the file name
                 # especially on MAC
+                fName = os.path.splitext(path)[0] + ext_format
+                # Instantiate a loader
+                loader = Loader()
                 loader.save(fName, data, ext_format)
+            elif os.path.splitext(mypath)[1].lower() == options[2]:
+                nxcansaswriter = NXcanSASWriter()
+                nxcansaswriter.write([data], fName)
             try:
                 self._default_save_location = os.path.dirname(path)
 …
             if has_errors:
                 if data.dx is not None and data.dx != []:
                     out.write("<X>   <Y>   <dY>   <dX>\n")
+                    out.write("<X>\t<Y>\t<dY>\t<dX>\n")
                 else:
                     out.write("<X>   <Y>   <dY>\n")
+                    out.write("<X>\t<Y>\t<dY>\n")
             else:
                 out.write("<X>   <Y>\n")
+                out.write("<X>\t<Y>\n")
             for i in range(len(data.x)):
 …
             text += 'dY_min = %s:  dY_max = %s\n' % (min(data.dy), max(data.dy))
         text += '\nData Points:\n'
+        x_st = "X"
+        text += "<index> \t<X> \t<Y> \t<dY> "
+        text += "\t<dXl> \t<dXw>\n" if(data.dxl is not None and
+                                       data.dxw is not None) else "\t<dX>\n"
         for index in range(len(data.x)):
             if data.dy is not None and len(data.dy) > index:
 …
                 dx_val = 0.0
             if data.dxl is not None and len(data.dxl) > index:
-                if index == 0:
-                    x_st = "Xl"
                 dx_val = data.dxl[index]
+            elif data.dxw is not None and len(data.dxw) > index:
+                if index == 0:
+                    x_st = "Xw"
+                dx_val = data.dxw[index]
+            if index == 0:
+                text += "<index> \t<X> \t<Y> \t<dY> \t<d%s>\n" % x_st
+                if data.dxw is not None and len(data.dxw) > index:
+                    dx_val = "%s \t%s" % (data.dxl[index], data.dxw[index])
             text += "%s \t%s \t%s \t%s \t%s\n" % (index,
                                                   data.x[index],
 …
         """
         default_name = fname
+        wildcard = "IGOR/DAT 2D file in Q_map (*.dat)|*.DAT"
+        wildcard = "IGOR/DAT 2D file in Q_map (*.dat)|*.DAT|"\
+                   "NXcanSAS files (*.h5)|*.h5|"
         dlg = wx.FileDialog(self, "Choose a file",
                             self._default_save_location,
 …
             if ext_num == 0:
                 ext_format = '.dat'
+            elif ext_num == 1:
+                ext_format = '.h5'
             else:
                 ext_format = ''
 …
             # Instantiate a loader
             loader = Loader()
+            ext_format = ".dat"
+            if os.path.splitext(mypath)[1].lower() == ext_format:
+            if os.path.splitext(mypath)[1].lower() == '.dat':
                 # Make sure the ext included in the file name
                 # especially on MAC
                 fileName = os.path.splitext(path)[0] + ext_format
                 loader.save(fileName, data, ext_format)
+            elif os.path.splitext(mypath)[1].lower() == '.h5':
+                # Make sure the ext included in the file name
+                # especially on MAC
+                fileName = os.path.splitext(path)[0] + ext_format
+                nxcansaswriter = NXcanSASWriter()
+                nxcansaswriter.write([data], fileName)
             try:
                 self._default_save_location = os.path.dirname(path)

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

                       r9c7e2b8
             except NoKnownLoaderException as e:
                 exception_occurred = True
                 error_message = "Loading data failed!" + e.message
+                error_message = "Loading data failed!\n" + e.message
                 file_errors[basename] = [error_message]
             except Exception as e:
 …
                 for message in error_array:
                     error_message += message + "\n"
+                error_message = error_message[:-1]
             self.load_complete(output=output,
                                message=error_message,
 …
             self.load_complete(output=output, message="Loading data complete!",
                                info="info")
-        else:
-            self.load_complete(output=None, message=error_message, info="error")
     def load_update(self, message="", info="warning"):

test/sasdataloader/test/utest_abs_reader.py

-                      rbd5c3b1
+                      rf4e2f22
         data_cor = Loader().load(find("sam14_cor.cor"))
         for i in range(0, len(data_abs) - 1):
             self.assertEquals(data_abs.x[i], data_cor.x[i])
             self.assertEquals(data_abs.y[i], data_cor.y[i])
             self.assertEquals(data_abs.dxl[i], data_cor.dxl[i])
             self.assertEquals(data_abs.dxw[i], data_cor.dxw[i])
+            self.assertEqual(data_abs.x[i], data_cor.x[i])
+            self.assertEqual(data_abs.y[i], data_cor.y[i])
+            self.assertEqual(data_abs.dxl[i], data_cor.dxl[i])
+            self.assertEqual(data_abs.dxw[i], data_cor.dxw[i])
             self.assertTrue(data_abs.dxl > 0)
 …
         self.assertEqual(self.data.detector[0].beam_center.y, center_y)
         self.assertEqual(self.data.I_unit, '1/cm')
+        self.assertEqual(self.data.I_unit, 'cm^{-1}')
         self.assertEqual(self.data.data[0], 1.57831)
         self.assertEqual(self.data.data[1], 2.70983)

test/sasdataloader/test/utest_ascii.py

-                      rdb5196d
+                      r9fb4572
 import unittest
 from sas.sascalc.dataloader.loader import Loader
+from sas.sascalc.dataloader.data_info import Data2D
 …
             self.assertFalse(math.isnan(f_1d.y[i]))
             self.assertFalse(math.isnan(f_1d.dy[i]))
+        self.assertTrue(isinstance(f_2d, Data2D))
         f_2d.data = f_2d.data.flatten()
         f_2d.qx_data = f_2d.qx_data.flatten()

test/sasdataloader/test/utest_averaging.py

-                      rf53d684
+                      rf4e2f22
     def setUp(self):
         filepath = find('MAR07232_rest.h5')
+        filepath = find('test_data' + os.sep + 'MAR07232_rest.h5')
         self.data_list = Loader().load(filepath)
         self.data = self.data_list[0]
 …
         o = r(self.data)
         filepath = find('ring_testdata.txt')
+        filepath = find('test_data' + os.sep + 'ring_testdata.txt')
         answer_list = Loader().load(filepath)
         answer = answer_list[0]
 …
         o = r(self.data)
         filepath = find('avg_testdata.txt')
+        filepath = find('test_data' + os.sep + 'avg_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(r.nbins_phi):
 …
         s, ds, npoints = r(self.data)
         self.assertAlmostEqual(s, 34.278990899999997, 4)
         self.assertAlmostEqual(ds, 7.8007981835194293, 4)
+        self.assertAlmostEqual(ds, 8.237259999538685, 4)
         self.assertAlmostEqual(npoints, 324.0000, 4)
 …
         s, ds = r(self.data)
         self.assertAlmostEqual(s, 0.10579935462962962, 4)
         self.assertAlmostEqual(ds, 0.024076537603455028, 4)
+        self.assertAlmostEqual(ds, 0.02542364197388483, 4)
     def test_slabX(self):
 …
         o = r(self.data)
         filepath = find('slabx_testdata.txt')
+        filepath = find('test_data' + os.sep + 'slabx_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
 …
         o = r(self.data)
         filepath = find('slaby_testdata.txt')
+        filepath = find('test_data' + os.sep + 'slaby_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
 …
         o = r(self.data)
         filepath = find('ring_testdata.txt')
+        filepath = find('test_data' + os.sep + 'ring_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
 …
         o = r(self.data)
         filepath = find('sectorphi_testdata.txt')
+        filepath = find('test_data' + os.sep + 'sectorphi_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
 …
         o = r(self.data)
         filepath = find('sectorq_testdata.txt')
+        filepath = find('test_data' + os.sep + 'sectorq_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):

test/sasdataloader/test/utest_cansas.py

-                      rf53d684
+                      rf4e2f22
         reader = XMLreader(self.xml_valid, self.schema_1_0)
         valid = reader.validate_xml()
+        if valid:
+            self.assertTrue(valid)
+        else:
+            self.assertFalse(valid)
+        self.assertTrue(valid)
     def _check_data(self, data):
 …
     def test_save_cansas_v1_0(self):
         xmlreader = XMLreader(self.isis_1_0, self.schema_1_0)
+        valid = xmlreader.validate_xml()
+        self.assertTrue(valid)
+        self.assertTrue(xmlreader.validate_xml())
         reader_generic = Loader()
         dataloader = reader_generic.load(self.isis_1_0)
 …
             return_data = reader2.read(self.write_1_0_filename)
             written_data = return_data[0]
+            XMLreader(self.write_1_0_filename, self.schema_1_0)
+            valid = xmlreader.validate_xml()
+            self.assertTrue(valid)
+            xmlreader = XMLreader(self.write_1_0_filename, self.schema_1_0)
+            self.assertTrue(xmlreader.validate_xml())
             self._check_data(written_data)
         if os.path.isfile(self.write_1_0_filename):
 …
         self.loader = Loader()
         self.datafile_basic = find("simpleexamplefile.h5")
+        self.datafile_multiplesasentry = find("cansas_1Dand2D_samedatafile.h5")
+        self.datafile_multiplesasdata = find("cansas_1Dand2D_samesasentry.h5")
+        self.datafile_multiplesasdata_multiplesasentry = find("cansas_1Dand2D_multiplesasentry_multiplesasdata.h5")
+        self.datafile_multiplesasentry = find(
+            "test_data" + os.sep + "nxcansas_1Dand2D_multisasentry.h5")
+        self.datafile_multiplesasdata = find(
+            "test_data" + os.sep + "nxcansas_1Dand2D_multisasdata.h5")
+        self.datafile_multiplesasdata_multiplesasentry = find(
+            "test_data" + os.sep + "nxcansas_1Dand2D_multisasentry_multisasdata.h5")
     def test_real_data(self):
 …
         self._check_multiple_data(self.data[0])
         self._check_multiple_data(self.data[1])
+        self._check_1d_data(self.data[0])
+        if isinstance(self.data[0], Data1D):
+            self._check_1d_data(self.data[0])
+            self._check_2d_data(self.data[1])
+        else:
+            self._check_1d_data(self.data[1])
+            self._check_2d_data(self.data[0])
+    def test_multiple_sasdatas(self):
+        self.data = self.loader.load(self.datafile_multiplesasdata)
+        self.assertTrue(len(self.data) == 2)
+        self._check_multiple_data(self.data[0])
+        self._check_multiple_data(self.data[1])
+        if isinstance(self.data[0], Data1D):
+            self._check_1d_data(self.data[0])
+            self._check_2d_data(self.data[1])
+        else:
+            self._check_1d_data(self.data[1])
+            self._check_2d_data(self.data[0])
+    def test_multiple_sasentries_multiplesasdatas(self):
+        self.data = self.loader.load(
+            self.datafile_multiplesasdata_multiplesasentry)
+        self.assertTrue(len(self.data) == 4)
+        self._check_multiple_data(self.data[0])
+        self._check_multiple_data(self.data[1])
+        self._check_multiple_data(self.data[2])
+        self._check_multiple_data(self.data[3])
+        for data in self.data:
+            if isinstance(data, Data1D):
+                self._check_1d_data(data)
+            else:
+                self._check_2d_data(data)
     def _check_multiple_data(self, data):
+        self.assertTrue(data.title == "MH4_5deg_16T_SLOW")
+        self.assertTrue(data.run[0] == '33837')
+        self.assertTrue(len(data.run) == 1)
+        self.assertTrue(data.instrument == "SANS2D")
+        self.assertTrue(data.source.radiation == "Spallation Neutron Source")
+        self.assertTrue(len(data.detector) == 1)
+        self.assertTrue(data.detector[0].name == "rear-detector")
+        self.assertTrue(data.detector[0].distance == 4.385281)
+        self.assertTrue(data.detector[0].distance_unit == 'm')
+        self.assertTrue(len(data.trans_spectrum) == 1)
+        self.assertEqual(data.title, "MH4_5deg_16T_SLOW")
+        self.assertEqual(data.run[0], '33837')
+        self.assertEqual(len(data.run), 1)
+        self.assertEqual(data.instrument, "SANS2D")
+        self.assertEqual(data.source.radiation, "Spallation Neutron Source")
+        self.assertEqual(len(data.detector), 2)
+        self.assertTrue(data.detector[0].name == "rear-detector"
+                        or data.detector[1].name == "rear-detector")
+        self.assertTrue(data.detector[0].name == "front-detector"
+                        or data.detector[1].name == "front-detector")
+        self.assertAlmostEqual(data.detector[0].distance +
+                               data.detector[1].distance, 7230.54, 2)
+        self.assertEqual(data.detector[0].distance_unit, 'mm')
+        self.assertEqual(len(data.trans_spectrum), 1)
     def _check_1d_data(self, data):
+        self.assertTrue(isinstance(data, Data1D))
+        self.assertTrue(len(data.x) == 66)
+        self.assertTrue(len(data.x) == len(data.y))
+        self.assertTrue(data.dy[10] == 0.20721350111248701)
+        self.assertTrue(data.y[10] == 24.193889608153476)
+        self.assertTrue(data.x[10] == 0.008981127988654792)
+        self.assertEqual(len(data.x), 66)
+        self.assertEqual(len(data.x), len(data.y))
+        self.assertAlmostEqual(data.dy[10], 0.207214)
+        self.assertAlmostEqual(data.y[10], 24.1939)
+        self.assertAlmostEqual(data.x[10], 0.00898113)
     def _check_2d_data(self, data):
         self.assertTrue(isinstance(data, Data2D))
+        self.assertTrue(len(data.x) == 66)
+        self.assertTrue(len(data.x) == len(data.y))
+        self.assertTrue(data.dy[10] == 0.20721350111248701)
+        self.assertTrue(data.y[10] == 24.193889608153476)
+        self.assertTrue(data.x[10] == 0.008981127988654792)
+        self.assertEqual(len(data.q_data), 150*150)
+        self.assertEqual(len(data.q_data), len(data.data))
+        self.assertAlmostEqual(data.err_data[10], 0.186723989418)
+        self.assertAlmostEqual(data.data[10], 0.465181)
+        self.assertAlmostEqual(data.qx_data[10], -0.129)
+        self.assertAlmostEqual(data.qy_data[10], -0.149)
     def _check_example_data(self, data):
         self.assertTrue(data.title == "")
         self.assertTrue(data.x.size == 100)
         self.assertTrue(data._xunit == "A^{-1}")
         self.assertTrue(data._yunit == "cm^{-1}")
         self.assertTrue(data.y.size == 100)
+        self.assertEqual(data.title, "")
+        self.assertEqual(data.x.size, 100)
+        self.assertEqual(data._xunit, "A^{-1}")
+        self.assertEqual(data._yunit, "cm^{-1}")
+        self.assertEqual(data.y.size, 100)
         self.assertAlmostEqual(data.y[40], 0.952749011516985)
         self.assertAlmostEqual(data.x[40], 0.3834415188257777)

test/sasdataloader/test/utest_generic_file_reader_class.py

-                      r4a8d55c
+                      r282bc3f
         last_f = f[0]
         if hasattr(last_f, "errors"):
             self.assertEquals(len(last_f.errors), 1)
+            self.assertEqual(len(last_f.errors), 1)
         else:
             self.fail("Errors did not propogate to the file properly.")
 …
     def test_same_file_unknown_extensions(self):
         # Five files, all with the same content, but different file extensions
         no_ext = find("test_data//TestExtensions")
         not_xml = find("test_data//TestExtensions.notxml")
+        no_ext = find("test_data" + os.sep + "TestExtensions")
+        not_xml = find("test_data" + os.sep + "TestExtensions.notxml")
         # Deprecated extensions
         asc_dep = find("test_data//TestExtensions.asc")
         nxs_dep = find("test_data//TestExtensions.nxs")
+        asc_dep = find("test_data" + os.sep + "TestExtensions.asc")
+        nxs_dep = find("test_data" + os.sep + "TestExtensions.nxs")
         # Native extension as a baseline
         xml_native = find("test_data//TestExtensions.xml")
+        xml_native = find("test_data" + os.sep + "TestExtensions.xml")
         # Load the files and check contents
         no_ext_load = self.generic_reader.load(no_ext)
 …
         self.check_unknown_extension(xml_load[0])
         # Be sure the deprecation warning is passed with the file
         self.assertEquals(len(asc_load[0].errors), 1)
         self.assertEquals(len(nxs_load[0].errors), 1)
+        self.assertEqual(len(asc_load[0].errors), 1)
+        self.assertEqual(len(nxs_load[0].errors), 0)
     def check_unknown_extension(self, data):
         self.assertTrue(isinstance(data, Data1D))
         self.assertEquals(len(data.x), 138)
         self.assertEquals(data.sample.ID, "TK49 c10_SANS")
         self.assertEquals(data.meta_data["loader"], "CanSAS XML 1D")
+        self.assertEqual(len(data.x), 138)
+        self.assertEqual(data.sample.ID, "TK49 c10_SANS")
+        self.assertEqual(data.meta_data["loader"], "CanSAS XML 1D")
     def tearDown(self):

test/sasdataloader/test/utest_red2d_reader.py

-                      rf53d684
+                      rfc51d06
         self.assertEqual(f.qx_data[0],-0.03573497)
         self.assertEqual(f.qx_data[36863],0.2908819)
         self.assertEqual(f.Q_unit, '1/A')
         self.assertEqual(f.I_unit, '1/cm')
+        self.assertEqual(f.Q_unit, 'A^{-1}')
+        self.assertEqual(f.I_unit, 'cm^{-1}')
         self.assertEqual(f.meta_data['loader'],"IGOR/DAT 2D Q_map")

test/sasdataloader/test/utest_sesans.py

-                      rf53d684
+                      rf4e2f22
             Test .SES in the full loader to make sure that the file type is correctly accepted
         """
+        file = Loader().load(find("sesans_examples/sphere2micron.ses"))
+        file = Loader().load(find("sesans_examples" + os.sep +
+                                  "sphere2micron.ses"))
         f = file[0]
         # self.assertEqual(f, 5)
 …
             Test .SES loading on a TOF dataset
         """
         file = self.loader(find("sesans_examples/sphere_isis.ses"))
+        file = self.loader(find("sesans_examples" + os.sep + "sphere_isis.ses"))
         f = file[0]
         self.assertEqual(len(file), 1)
 …
             FileContentsException,
             self.loader,
             find("sesans_examples/sesans_no_data.ses"))
+            find("sesans_examples" + os.sep + "sesans_no_data.ses"))
     def test_sesans_no_spin_echo_unit(self):
 …
             FileContentsException,
             self.loader,
             find("sesans_examples/no_spin_echo_unit.ses"))
+            find("sesans_examples" + os.sep + "no_spin_echo_unit.ses"))
     def test_sesans_future_version(self):
 …
             FileContentsException,
             self.loader,
             find("sesans_examples/next_gen.ses"))
+            find("sesans_examples" + os.sep + "next_gen.ses"))
     def test_sesans_mandatory_headers(self):
 …
             FileContentsException,
             self.loader,
             find("sesans_examples/no_wavelength.ses"))
+            find("sesans_examples" + os.sep + "no_wavelength.ses"))
     def test_sesans_columns_match_headers(self):
 …
             FileContentsException,
             self.loader,
             find("sesans_examples/too_many_headers.ses"))
+            find("sesans_examples" + os.sep + "too_many_headers.ses"))
 if __name__ == "__main__":

SasView

Changes in / [f560e23:c222c27] in sasview

Legend:

src/sas/sascalc/data_util/nxsunit.py

src/sas/sascalc/dataloader/data_info.py

src/sas/sascalc/dataloader/file_reader_base_class.py

src/sas/sascalc/dataloader/loader.py

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

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

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

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

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

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

src/sas/sascalc/file_converter/nxcansas_writer.py

src/sas/sasgui/guiframe/gui_manager.py

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

test/sasdataloader/test/utest_abs_reader.py

test/sasdataloader/test/utest_ascii.py

test/sasdataloader/test/utest_averaging.py

test/sasdataloader/test/utest_cansas.py

test/sasdataloader/test/utest_generic_file_reader_class.py

test/sasdataloader/test/utest_red2d_reader.py

test/sasdataloader/test/utest_sesans.py

Download in other formats: