Index: src/sas/sascalc/data_util/nxsunit.py
===================================================================
--- src/sas/sascalc/data_util/nxsunit.py	(revision 574adc767a9e86744546f8edd6a23dc4f81914ad)
+++ src/sas/sascalc/data_util/nxsunit.py	(revision b011ecbdc80ebea6a89f794bb503745e7f6e5785)
@@ -136,6 +136,7 @@
     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)
@@ -157,5 +158,5 @@
     # 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):
Index: src/sas/sascalc/dataloader/file_reader_base_class.py
===================================================================
--- src/sas/sascalc/dataloader/file_reader_base_class.py	(revision 4a8d55c05d1355e27bf5afa880633879b6178acc)
+++ src/sas/sascalc/dataloader/file_reader_base_class.py	(revision 8f882fecc993c2aea9372b888a43497808abe2d7)
@@ -16,4 +16,5 @@
 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__)
@@ -98,6 +99,6 @@
                     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)
@@ -166,5 +167,5 @@
         self.output.append(data_obj)
 
-    def sort_one_d_data(self):
+    def sort_data(self):
         """
         Sort 1D data along the X axis for consistency
@@ -174,5 +175,7 @@
                 # 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))
@@ -203,4 +206,40 @@
                     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.qx_data)
 
     @staticmethod
@@ -242,39 +281,95 @@
         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.qx_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("\\rm{Q}", '1/A')
+        data.yaxis("\\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", default_i_unit="1/cm"):
+        """
+        Converts al; data to the sasview default of units of A^{-1} for Q and
+        cm^{-1} for I.
+        :param default_x_unit: The default x unit used by Sasview
+        :param default_y_unit: The default y unit used by Sasview
+        """
+        new_output = []
+        for data in self.output:
+            if data.isSesans:
+                new_output.append(data)
+                continue
+            file_x_unit = data._xunit
+            data_conv_x = Converter(file_x_unit)
+            file_y_unit = data._yunit
+            data_conv_y = Converter(file_y_unit)
+            if isinstance(data, Data1D):
+                try:
+                    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)
+                except KeyError:
+                    message = "Unable to convert Q units from {0} to 1/A."
+                    message.format(default_q_unit)
+                    data.errors.append(message)
+                try:
+                    data.y = data_conv_y(data.y, units=default_i_unit)
+                    data._yunit = default_i_unit
+                    data.y_unit = default_i_unit
+                    if data.dy is not None:
+                        data.dy = data_conv_y(data.dy, units=default_i_unit)
+                except KeyError:
+                    message = "Unable to convert I units from {0} to 1/cm."
+                    message.format(default_q_unit)
+                    data.errors.append(message)
+            elif isinstance(data, Data2D):
+                try:
+                    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)
+                    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:
+                    message = "Unable to convert Q units from {0} to 1/A."
+                    message.format(default_q_unit)
+                    data.errors.append(message)
+                try:
+                    file_z_unit = data._zunit
+                    data_conv_z = Converter(file_z_unit)
+                    data.data = data_conv_z(data.data, units=default_i_unit)
+                    if data.err_data is not None:
+                        data.err_data = data_conv_z(data.err_data, units=default_i_unit)
+                except KeyError:
+                    message = "Unable to convert I units from {0} to 1/cm."
+                    message.format(default_q_unit)
+                    data.errors.append(message)
+            else:
+                # TODO: Throw error of some sort...
+                pass
+            new_output.append(data)
+        self.output = new_output
 
     def format_unit(self, unit=None):
Index: src/sas/sascalc/dataloader/readers/abs_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/abs_reader.py	(revision bd5c3b11a604dfd75fa3d6424e1ea40bcafd3727)
+++ src/sas/sascalc/dataloader/readers/abs_reader.py	(revision bd5c3b11a604dfd75fa3d6424e1ea40bcafd3727)
@@ -225,12 +225,9 @@
             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
Index: src/sas/sascalc/dataloader/readers/ascii_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/ascii_reader.py	(revision 7b07fbe306fb8a4fe61838f12a869394e2e47c0a)
+++ src/sas/sascalc/dataloader/readers/ascii_reader.py	(revision 3bab401d91e365ff93f8efbf5368655767ff2e5f)
@@ -157,6 +157,5 @@
 
         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
Index: src/sas/sascalc/dataloader/readers/cansas_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/cansas_reader.py	(revision 2469df7fc9ffa047115c5bffe589ed307b12c363)
+++ src/sas/sascalc/dataloader/readers/cansas_reader.py	(revision 058f6c331803fd9d3a8627da92364a3b0c0c29b5)
@@ -812,20 +812,20 @@
             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,
Index: src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py
===================================================================
--- src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py	(revision 61f329f00cdb8b300656d1c1feb4e78f35e59745)
+++ src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py	(revision 96d06a4a3a79d0f6bc53476600059adeb433ac8a)
@@ -38,18 +38,8 @@
     # 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']
@@ -81,5 +71,5 @@
                 except Exception as e:
                     if extension not in self.ext:
-                        msg = "CanSAS2.0 HDF5 Reader could not load file {}".format(basename + extension)
+                        msg = "NXcanSAS HDF5 Reader could not load file {}".format(basename + extension)
                         raise DefaultReaderException(msg)
                     raise FileContentsException(e.message)
@@ -111,4 +101,11 @@
         self.errors = set()
         self.logging = []
+        self.q_name = []
+        self.mask_name = u''
+        self.i_name = u''
+        self.i_node = u''
+        self.q_uncertainties = []
+        self.q_resolutions = []
+        self.i_uncertainties = u''
         self.parent_class = u''
         self.detector = Detector()
@@ -140,4 +137,5 @@
             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)
@@ -147,10 +145,11 @@
                     self.add_data_set(key)
                 elif class_prog.match(u'SASdata'):
-                    self._initialize_new_data_set(parent_list)
+                    self._initialize_new_data_set(value)
+                    self._find_data_attributes(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)
 
@@ -159,67 +158,4 @@
                 data_set = data[key][:]
                 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:
@@ -232,4 +168,5 @@
                     if key == u'definition':
                         self.current_datainfo.meta_data['reader'] = data_point
+                    # Run
                     elif key == u'run':
                         self.current_datainfo.run.append(data_point)
@@ -240,167 +177,43 @@
                         except Exception:
                             pass
+                    # Title
                     elif key == u'title':
                         self.current_datainfo.title = data_point
+                    # Note
                     elif key == u'SASnote':
                         self.current_datainfo.notes.append(data_point)
-
                     # 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(
@@ -411,4 +224,226 @@
                 # I don't know if this reachable code
                 self.errors.add("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:
+            self.current_dataset.y = data_set.flatten()
+            self.current_dataset.yaxis("Intensity", unit)
+        elif key == self.i_uncertainties:
+            self.current_dataset.dy = data_set.flatten()
+        elif key in self.q_name:
+            self.current_dataset.xaxis("Q", unit)
+            self.current_dataset.x = data_set.flatten()
+        elif key in self.q_uncertainties or key in self.q_resolutions:
+            if (len(self.q_resolutions) > 1
+                    and np.where(self.q_resolutions == key)[0] == 0):
+                self.current_dataset.dxw = data_set.flatten()
+            elif (len(self.q_resolutions) > 1
+                  and np.where(self.q_resolutions == 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:
+            self.current_dataset.err_data = data_set.flatten()
+        elif key in self.q_name:
+            self.current_dataset.xaxis("Q", unit)
+            self.current_dataset.yaxis("Q", unit)
+            #FIXME: This is broken - need to properly handle 2D data
+            # TODO: Check shape of array (2d - cash money, homey!)
+            # TODO: 3D - check dims, etc.
+            # TODO: Put data where it belongs
+            pass
+        elif key in self.q_uncertainties or key in self.q_resolutions:
+            # FIXME: This isn't right either.
+            # TODO: find resolution/uncertainty specific to q_name
+            pass
+        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):
@@ -452,11 +487,7 @@
             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:
@@ -491,5 +522,5 @@
                 (n_rows, n_cols) = dataset.data.shape
                 dataset.y_bins = dataset.qy_data[0::n_cols]
-                dataset.x_bins = dataset.qx_data[:n_cols]
+                dataset.x_bins = dataset.qx_data[0::n_rows]
                 dataset.data = dataset.data.flatten()
             self.current_dataset = dataset
@@ -515,6 +546,5 @@
         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
@@ -524,8 +554,5 @@
         :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:
@@ -534,25 +561,72 @@
             self.current_dataset = plottable_1D(x, y)
         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.
+        self.mask_name = ""
+        self.i_name = ""
+        self.i_node = ""
+        self.q_name = []
+        self.q_uncertainties = []
+        self.q_resolutions = []
+        self.i_uncertainties = ""
+
+    @staticmethod
+    def check_is_list_or_array(iterable):
+        try:
+            iter(iterable)
+            if (not isinstance(iterable, np.ndarray)) or (isinstance(iterable, str)
+                    or isinstance(iterable, unicode)):
+                raise TypeError
+        except TypeError:
+            iterable = iterable.split(",")
+        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
+        """
+        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()
+        self.mask_name = attrs.get("mask")
+        for val in q_indices:
+            self.q_name.append(i_axes[val])
+        self.i_name = signal
+        self.i_node = value.get(self.i_name)
+        for item in self.q_name:
+            if item in keys:
+                q_vals = value.get(item)
+                if q_vals.attrs.get("uncertainties") is not None:
+                    self.q_uncertainties = q_vals.attrs.get("uncertainties")
+                elif q_vals.attrs.get("uncertainty") is not None:
+                    self.q_uncertainties = q_vals.attrs.get("uncertainty")
+                if isinstance(self.q_uncertainties, str) is not None:
+                    self.q_uncertainties = [self.q_uncertainties]
+                if q_vals.attrs.get("resolutions") is not None:
+                    self.q_resolutions = q_vals.attrs.get("resolutions")
+                if isinstance(self.q_resolutions, str):
+                    self.q_resolutions = self.q_resolutions.split(",")
+        if self.i_name in keys:
+            i_vals = value.get(self.i_name)
+            self.i_uncertainties = i_vals.attrs.get("uncertainties")
+            if self.i_uncertainties is None:
+                self.i_uncertainties = i_vals.attrs.get("uncertainty")
+
+    def _is2d(self, value, basename="I"):
+        """
+        A private class to determine if the data set is 1d or 2d.
 
         :param parent_list: List of parents nodes in the HDF5 file
         :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
+        """
+
+        vals = value.get(basename)
+        return (vals is not None and vals.shape is not None
+                and len(vals.shape) != 1)
 
     def _create_unique_key(self, dictionary, name, numb=0):
@@ -583,8 +657,3 @@
         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
Index: src/sas/sascalc/dataloader/readers/danse_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/danse_reader.py	(revision 2469df7fc9ffa047115c5bffe589ed307b12c363)
+++ src/sas/sascalc/dataloader/readers/danse_reader.py	(revision fc51d06ca61c96f09100f834da5f2bd421f461f7)
@@ -180,9 +180,5 @@
         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
Index: src/sas/sascalc/dataloader/readers/red2d_reader.py
===================================================================
--- src/sas/sascalc/dataloader/readers/red2d_reader.py	(revision c8321cfca1fe64cbabb0c8b781cf5aecc57c211b)
+++ src/sas/sascalc/dataloader/readers/red2d_reader.py	(revision 058f6c331803fd9d3a8627da92364a3b0c0c29b5)
@@ -317,7 +317,5 @@
 
         # 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
Index: src/sas/sascalc/file_converter/nxcansas_writer.py
===================================================================
--- src/sas/sascalc/file_converter/nxcansas_writer.py	(revision 574adc767a9e86744546f8edd6a23dc4f81914ad)
+++ src/sas/sascalc/file_converter/nxcansas_writer.py	(revision cf291877a6c230f60a2f5f658bc8f0fe952c2a26)
@@ -175,5 +175,4 @@
             names=['beam_size_x', 'beam_size_y'],
             units=data_info.source.beam_size_unit, write_fn=_write_h5_float)
-
 
         # Collimation metadata
@@ -232,4 +231,55 @@
             detector_entry.attrs['name'] = ''
 
+        # Process meta data
+        if len(data_info.process) > 0 and not data_info.process[0].is_empty():
+            i = 1
+            for process in data_info.process:
+                process_entry = sasentry.create_group(
+                    'sasprocess{0:0=2d}'.format(i))
+                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)
+                j = 1
+                for term in process.term:
+                    if term:
+                        h5_term = _h5_string(term)
+                        process_entry.create_dataset('term{0:0=2d}'.format(j),
+                                                     data=h5_term)
+                    j += 1
+                j = 1
+                for note in process.notes:
+                    if note:
+                        h5_note = _h5_string(note)
+                        process_entry.create_dataset('note{0:0=2d}'.format(j),
+                                                     data=h5_note)
+                    j += 1
+                i += 1
+
+        # Transmission Spectrum
+        if len(data_info.trans_spectrum) > 0:
+            i = 1
+            for trans in data_info.trans_spectrum:
+                trans_entry = sasentry.create_group(
+                    'sastransmission_spectrum{0:0=2d}'.format(i))
+                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))
         note_entry.attrs['canSAS_class'] = 'SASnote'
@@ -254,14 +304,23 @@
         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):
@@ -273,7 +332,6 @@
         """
         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))
@@ -288,17 +346,25 @@
                 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
Index: src/sas/sasgui/guiframe/gui_manager.py
===================================================================
--- src/sas/sasgui/guiframe/gui_manager.py	(revision b963b2066d6a76fe5073000c5a596a6fd0130ac4)
+++ src/sas/sasgui/guiframe/gui_manager.py	(revision b799f09f2c99f77bd3191b769c1b488a0fe7124a)
@@ -46,4 +46,5 @@
 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
 
@@ -2422,6 +2423,9 @@
         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 = {0: ".txt",
+                   1: ".xml",
+                   2: ".h5"}
         dlg = wx.FileDialog(self, "Choose a file",
                             self._default_save_location,
@@ -2433,25 +2437,23 @@
             # 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)
@@ -2565,5 +2567,6 @@
         """
         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,
@@ -2577,4 +2580,6 @@
             if ext_num == 0:
                 ext_format = '.dat'
+            elif ext_num == 1:
+                ext_format = '.h5'
             else:
                 ext_format = ''
@@ -2584,11 +2589,15 @@
             # 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)
Index: src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py	(revision 2924532bedb06633b9888eb37ac4bd1a31dbbeff)
+++ src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py	(revision 02c1608e6546bb8b1a0df37db94d096ef657c016)
@@ -239,6 +239,4 @@
             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"):
Index: st/sasdataloader/test/avg_testdata.txt
===================================================================
--- test/sasdataloader/test/avg_testdata.txt	(revision 8c9ffde290eafed946f800881bf4901b48445d4c)
+++ 	(revision )
@@ -1,21 +1,0 @@
-0.00019987186878 -0.01196215 0.148605728355
-0.000453772721237 0.02091606 0.0680283029334
-0.000750492390439 -0.01337855 0.0444902910757
-0.00103996394336 0.03062 0.0580312894528
-0.0013420198959 0.0811008333333 0.0540469289108
-0.001652061869 0.167022288372 0.0651891320031
-0.00196086470492 27.5554711176 0.735053300957
-0.00226262401224 105.031578947 1.35744586624
-0.00256734439716 82.1791776119 1.10749938588
-0.0028637128388 54.714657971 0.890486416264
-0.00315257408712 36.8455584416 0.691746880003
-0.00344644126616 24.8938701149 0.534917225468
-0.00374248202229 16.5905619565 0.424655384023
-0.00404393067437 11.4714217925 0.328969543128
-0.004346317814 8.05405805556 0.273083524998
-0.00465162170627 5.5823291129 0.21217630209
-0.00495449803049 4.2574845082 0.186808495528
-0.00525641407066 3.30448963768 0.154743584955
-0.00555735057365 2.6995389781 0.140373302568
-0.00585577429002 2.03298512 0.116418358232
-
Index: st/sasdataloader/test/ring_testdata.txt
===================================================================
--- test/sasdataloader/test/ring_testdata.txt	(revision 400155bab01bdb35b3cf83069f57cf9f47005bca)
+++ 	(revision )
@@ -1,21 +1,0 @@
-<X>   <Y>   <dY>
-0.0 0.974491286452 0.0803843574327
-0.314159265359 0.9046853025 0.0768971192264
-0.628318530718 0.964040908176 0.0790933208542
-0.942477796077 0.922142905769 0.0781616076625
-1.25663706144 1.02710537736 0.080875897538
-1.57079632679 1.01448978075 0.0808313893873
-1.88495559215 1.04677136013 0.0828850195035
-2.19911485751 1.00067189877 0.0790510747578
-2.51327412287 1.06280533013 0.0830643956456
-2.82743338823 1.04313751703 0.0824585190353
-3.14159265359 0.993559460696 0.0803376331443
-3.45575191895 0.998101030127 0.0813124293449
-3.76991118431 1.04589910764 0.0821364674302
-4.08407044967 0.997201556522 0.0797466854806
-4.39822971503 1.07289797405 0.0830165798358
-4.71238898038 1.01212391625 0.0803021745794
-5.02654824574 0.995907123899 0.0804649435453
-5.3407075111 0.991431571613 0.0803765721376
-5.65486677646 0.959020086792 0.0787114622667
-5.96902604182 0.945705788519 0.0767669312314
Index: st/sasdataloader/test/sectorphi_testdata.txt
===================================================================
--- test/sasdataloader/test/sectorphi_testdata.txt	(revision 8c9ffde290eafed946f800881bf4901b48445d4c)
+++ 	(revision )
@@ -1,20 +1,0 @@
-0.0392699081699 1.1493915878 0.168324806231
-0.11780972451 0.782646832432 0.149121962919
-0.196349540849 0.706119607692 0.144012178287
-0.274889357189 0.911901097436 0.15555152836
-0.353429173529 0.974902392683 0.155253089415
-0.431968989869 1.01648397073 0.159026866657
-0.510508806208 1.00543825 0.162897198136
-0.589048622548 0.939649968421 0.160198723543
-0.667588438888 0.9170403625 0.154535441526
-0.746128255228 0.992733432558 0.155251042188
-0.824668071567 0.896487721622 0.158978849014
-0.903207887907 1.0337120475 0.161651279959
-0.981747704247 0.893411561538 0.151685984204
-1.06028752059 0.86231787 0.152618707077
-1.13882733693 1.0607364925 0.164276150316
-1.21736715327 1.0684421475 0.163649496829
-1.29590696961 1.09330437436 0.167871645263
-1.37444678595 0.88759347 0.150974201439
-1.45298660229 1.1352002 0.172191803977
-1.53152641863 0.940182580556 0.16499913089
Index: st/sasdataloader/test/sectorq_testdata.txt
===================================================================
--- test/sasdataloader/test/sectorq_testdata.txt	(revision 8c9ffde290eafed946f800881bf4901b48445d4c)
+++ 	(revision )
@@ -1,20 +1,0 @@
-0.00511441071783 3.62996057692 0.26421001906
-0.00536794842067 3.08426333333 0.226725360048
-0.00563163488481 2.60796274194 0.205094893141
-0.00588490295032 1.9348162623 0.178096320518
-0.00613345857943 1.7733072 0.16517157513
-0.00638164232075 1.47127022727 0.149304966898
-0.00662784449302 1.20943352174 0.132393436598
-0.00687996935062 1.09260586133 0.121129481208
-0.00713177859748 0.920554827027 0.112093900426
-0.0073754295467 0.722179797333 0.0994122997085
-0.00762120465356 0.806428308642 0.101199828878
-0.00787397172531 0.643935 0.0888805845221
-0.00811861136113 0.545498639506 0.0844090307303
-0.008367621478 0.540828518804 0.0775790478399
-0.00862439560875 0.506315036957 0.0759458433673
-0.00887906032589 0.435769230208 0.0692137718457
-0.00913119845523 0.405669568421 0.0705339106673
-0.00938052380065 0.331241946 0.061307573431
-0.00962825731078 0.237315993939 0.0578654769893
-0.00987552050718 0.296916590385 0.0592796733987
Index: st/sasdataloader/test/slabx_testdata.txt
===================================================================
--- test/sasdataloader/test/slabx_testdata.txt	(revision 8c9ffde290eafed946f800881bf4901b48445d4c)
+++ 	(revision )
@@ -1,50 +1,0 @@
--0.00975856539676 0.5172445 0.508549161832
--0.00934923500682 0.237763 0.243804737444
--0.00893990399468 0.12955415 0.254513408291
--0.0086670162536 0.9157545 0.676666276683
--0.00825768406971 0.65937975 0.406011006624
--0.00784835133627 0.8750275 0.661448221707
--0.00743901794994 1.02208225 0.519554195922
--0.00702968406854 1.079005 0.734508338959
--0.00662034960235 1.2496225 0.558932576435
--0.00621101469558 2.006035 1.00150761355
--0.00580167927212 2.4278325 0.779075172881
--0.00539234346255 3.455125 1.31436771871
--0.00498300720441 4.0214125 1.00267299006
--0.00457367061464 4.505215 1.500868915
--0.0041643336444 9.1015275 1.50843689792
--0.00375499639702 12.9323 2.54286256019
--0.00334565883727 24.9572 2.4978590833
--0.00293632105486 40.0841 4.47683481938
--0.00266342906662 60.4813 5.49914993431
--0.00225409091154 76.368475 4.36945291198
--0.00184475260646 2.40154 1.09579651396
--0.00143541414791 0.065281 0.198049867458
--0.00102607559383 -0.04767235 0.154389685536
--0.000616736954402 -0.0090503 0.0960105462957
--0.000207398273925 0.03109325 0.246629023029
-0.000201940423805 -0.027508775 0.082928847514
-0.000611279108096 0.03251315 0.246951260373
-0.00102061774154 -0.00987975 0.144233534589
-0.00142995630705 0.075937 0.19485507435
-0.00183929475361 10.60918375 1.62858709853
-0.00224863307777 106.2485 7.2886384188
-0.00265797121486 69.731775 4.17527768538
-0.00306730917507 37.64245 4.33834357791
-0.00334020101548 29.14025 3.81708331059
-0.00374953854926 16.858125 2.05293235398
-0.00415887583351 7.860455 1.98248013861
-0.00456821277179 4.8616775 1.1024606002
-0.00497754940605 4.619795 1.51983469496
-0.00538688562624 3.1591075 0.888693915249
-0.00579622148792 1.72058 0.927518193892
-0.00620555686743 1.913115 0.69157700222
-0.00661489183396 1.08108 0.735214254486
-0.0070242262502 1.0834955 0.520455449582
-0.00743356019898 0.4708995 0.485231645712
-0.00784289352938 0.774794 0.440111917585
-0.00825222633782 0.7830585 0.625722981838
-0.00866155845978 0.44196625 0.37397468163
-0.0090708900053 0.1305591 0.306123259489
-0.0093437773029 0.1961264 0.341325065004
-0.00975310762291 0.25845 0.280772594817
Index: st/sasdataloader/test/slaby_testdata.txt
===================================================================
--- test/sasdataloader/test/slaby_testdata.txt	(revision 8c9ffde290eafed946f800881bf4901b48445d4c)
+++ 	(revision )
@@ -1,50 +1,0 @@
--0.00981587154747 0.197046827778 0.0872226309261
--0.00940654133769 0.2466434 0.124972263589
--0.0089972103454 0.218745969444 0.0838510368061
--0.00858787875434 0.126093522222 0.107482002513
--0.00817854644886 0.310427366667 0.100945289852
--0.0077692135991 0.0843802722222 0.103942898914
--0.00735988010303 0.246036369444 0.0916479235889
--0.00695054611716 0.217840922222 0.128330031223
--0.00654121155308 0.379668444444 0.103424340152
--0.00613187655368 0.447654644444 0.166575873418
--0.00585898627901 0.419026583333 0.15428551475
--0.00544965048161 0.401599005556 0.107234964701
--0.00504031432153 0.552085055556 0.178458012837
--0.00463097774216 0.623354058333 0.134112874252
--0.0042216408546 0.653190877778 0.199963470429
--0.00381230361585 0.661400280556 0.136616295765
--0.00340296612338 0.714432968889 0.206518400818
--0.00299362834783 0.653196219444 0.137770239209
--0.00258429037305 0.823240055556 0.215465509543
--0.00217495218329 0.9738398 0.165854141631
--0.00176561384878 0.827869716667 0.217884056409
--0.00135627536739 1.01947547778 0.169285496487
--0.000946936795747 1.1655315 0.256453669437
--0.000537598145326 1.06619988306 0.174316381271
--0.000128259459128 1.03232983333 0.243681074459
-0.000144633007054 1.15035461111 0.254186641595
-0.000553971692162 1.14101948333 0.179426295522
-0.000963310340403 1.07222452222 0.244970006982
-0.00137264890851 1.16437213056 0.185866492018
-0.00178198738526 0.852203596111 0.219166988663
-0.00219132571378 0.901962183333 0.160186399428
-0.00260066389646 0.9240665 0.230158379447
-0.00301000186279 0.617907672222 0.137762238147
-0.00341933962881 0.650284455556 0.191734208711
-0.00382867711038 0.578899836111 0.127147693175
-0.00423801433715 0.507045738889 0.172630602733
-0.00464735121136 0.613949591667 0.131836392307
-0.00505668777629 0.593631783333 0.181602707905
-0.00532957859826 0.310741433333 0.143429472495
-0.00573891447198 0.422394166667 0.111503089837
-0.00614824996377 0.342731566667 0.148392724273
-0.0065575849441 0.286779447222 0.0946855610872
-0.00696691948801 0.223022966667 0.134800066857
-0.00737625345237 0.220648719444 0.0901314425104
-0.00778558692582 0.210920222222 0.13171959555
-0.00819491975161 0.206120872222 0.0877029867729
-0.00860425203202 0.26088625 0.127667879068
-0.00901358359666 0.156064891667 0.0817093355086
-0.00942291456144 0.177010094444 0.134301097823
-0.00983224474235 0.130891508333 0.0796420846741
Index: test/sasdataloader/test/test_data/avg_testdata.txt
===================================================================
--- test/sasdataloader/test/test_data/avg_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
+++ test/sasdataloader/test/test_data/avg_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
@@ -0,0 +1,21 @@
+0.00019987186878 -0.01196215 0.148605728355
+0.000453772721237 0.02091606 0.23372601
+0.000750492390439 -0.01337855 0.17169562
+0.00103996394336 0.03062 0.13136407
+0.0013420198959 0.0811008333333 0.10681163
+0.001652061869 0.167022288372 0.10098903
+0.00196086470492 27.5554711176 0.7350533
+0.00226262401224 105.031578947 1.35744586624
+0.00256734439716 82.1791776119 1.10749938588
+0.0028637128388 54.714657971 0.890486416264
+0.00315257408712 36.8455584416 0.691746880003
+0.00344644126616 24.8938701149 0.534917225468
+0.00374248202229 16.5905619565 0.424655384023
+0.00404393067437 11.4714217925 0.328969543128
+0.004346317814 8.05405805556 0.273083524998
+0.00465162170627 5.5823291129 0.21217630209
+0.00495449803049 4.2574845082 0.186808495528
+0.00525641407066 3.30448963768 0.154743584955
+0.00555735057365 2.6995389781 0.140373302568
+0.00585577429002 2.03298512 0.116418358232
+
Index: test/sasdataloader/test/test_data/ring_testdata.txt
===================================================================
--- test/sasdataloader/test/test_data/ring_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
+++ test/sasdataloader/test/test_data/ring_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
@@ -0,0 +1,21 @@
+<X>   <Y>   <dY>
+0.0 0.974491286452 0.0803843574327
+0.314159265359 0.9046853025 0.0768971192264
+0.628318530718 0.964040908176 0.0790933208542
+0.942477796077 0.922142905769 0.0781616076625
+1.25663706144 1.02710537736 0.08136351514804
+1.57079632679 1.01448978075 0.0808313893873
+1.88495559215 1.04677136013 0.0828850195035
+2.19911485751 1.00067189877 0.0790510747578
+2.51327412287 1.06280533013 0.0830643956456
+2.82743338823 1.04313751703 0.0824585190353
+3.14159265359 0.993559460696 0.0803376331443
+3.45575191895 0.998101030127 0.0813124293449
+3.76991118431 1.04589910764 0.0821364674302
+4.08407044967 0.997201556522 0.0797466854806
+4.39822971503 1.07289797405 0.0830165798358
+4.71238898038 1.01212391625 0.0803021745794
+5.02654824574 0.995907123899 0.0804649435453
+5.3407075111 0.991431571613 0.0803765721376
+5.65486677646 0.959020086792 0.0787114622667
+5.96902604182 0.945705788519 0.0767669312314
Index: test/sasdataloader/test/test_data/sectorphi_testdata.txt
===================================================================
--- test/sasdataloader/test/test_data/sectorphi_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
+++ test/sasdataloader/test/test_data/sectorphi_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
@@ -0,0 +1,20 @@
+0.0392699081699 1.1493915878 0.168324806231
+0.11780972451 0.782646832432 0.149121962919
+0.196349540849 0.706119607692 0.144012178287
+0.274889357189 0.911901097436 0.15555152836
+0.353429173529 0.974902392683 0.155253089415
+0.431968989869 1.01648397073 0.159026866657
+0.510508806208 1.00543825 0.162897198136
+0.589048622548 0.939649968421 0.160198723543
+0.667588438888 0.9170403625 0.154535441526
+0.746128255228 0.992733432558 0.155251042188
+0.824668071567 0.896487721622 0.158978849014
+0.903207887907 1.0337120475 0.161651279959
+0.981747704247 0.893411561538 0.151685984204
+1.06028752059 0.86231787 0.152618707077
+1.13882733693 1.0607364925 0.166167546658
+1.21736715327 1.0684421475 0.163649496829
+1.29590696961 1.09330437436 0.16981858402
+1.37444678595 0.88759347 0.150974201439
+1.45298660229 1.1352002 0.172191803977
+1.53152641863 0.940182580556 0.16499913089
Index: test/sasdataloader/test/test_data/sectorq_testdata.txt
===================================================================
--- test/sasdataloader/test/test_data/sectorq_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
+++ test/sasdataloader/test/test_data/sectorq_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
@@ -0,0 +1,20 @@
+0.00511441071783 3.62996057692 0.26421001906
+0.00536794842067 3.08426333333 0.226725360048
+0.00563163488481 2.60796274194 0.205094893141
+0.00588490295032 1.9348162623 0.178096320518
+0.00613345857943 1.7733072 0.16517157513
+0.00638164232075 1.47127022727 0.149304966898
+0.00662784449302 1.20943352174 0.132393436598
+0.00687996935062 1.09260586133 0.121129481208
+0.00713177859748 0.920554827027 0.112093900426
+0.0073754295467 0.722179797333 0.0994122997085
+0.00762120465356 0.806428308642 0.101199828878
+0.00787397172531 0.643935 0.0888805845221
+0.00811861136113 0.545498639506 0.0844090307303
+0.008367621478 0.540828518804 0.0775790478399
+0.00862439560875 0.506315036957 0.0759458433673
+0.00887906032589 0.435769230208 0.0692137718457
+0.00913119845523 0.405669568421 0.0705339106673
+0.00938052380065 0.331241946 0.061307573431
+0.00962825731078 0.237315993939 0.059602636160850493
+0.00987552050718 0.296916590385 0.0592796733987
Index: test/sasdataloader/test/test_data/slabx_testdata.txt
===================================================================
--- test/sasdataloader/test/test_data/slabx_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
+++ test/sasdataloader/test/test_data/slabx_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
@@ -0,0 +1,50 @@
+-0.00975856539676 0.5172445 0.508549161832
+-0.00934923500682 0.237763 0.243804737444
+-0.00893990399468 0.12955415 0.254513408291
+-0.0086670162536 0.9157545 0.676666276683
+-0.00825768406971 0.65937975 0.406011006624
+-0.00784835133627 0.8750275 0.661448221707
+-0.00743901794994 1.02208225 0.519554195922
+-0.00702968406854 1.079005 0.734508338959
+-0.00662034960235 1.2496225 0.558932576435
+-0.00621101469558 2.006035 1.00150761355
+-0.00580167927212 2.4278325 0.779075172881
+-0.00539234346255 3.455125 1.31436771871
+-0.00498300720441 4.0214125 1.00267299006
+-0.00457367061464 4.505215 1.500868915
+-0.0041643336444 9.1015275 1.50843689792
+-0.00375499639702 12.9323 2.54286256019
+-0.00334565883727 24.9572 2.4978590833
+-0.00293632105486 40.0841 4.47683481938
+-0.00266342906662 60.4813 5.49914993431
+-0.00225409091154 76.368475 4.36945291198
+-0.00184475260646 2.40154 1.09579651396
+-0.00143541414791 0.065281 0.198049867458
+-0.00102607559383 -0.04767235 0.52329358394690839
+-0.000616736954402 -0.0090503 0.36635778277525377
+-0.000207398273925 0.03109325 0.246629023029
+0.000201940423805 -0.027508775 0.36314899662535211
+0.000611279108096 0.03251315 0.246951260373
+0.00102061774154 -0.00987975 0.38184199939241886
+0.00142995630705 0.075937 0.53662696540520582
+0.00183929475361 10.60918375 1.62858709853
+0.00224863307777 106.2485 7.2886384188
+0.00265797121486 69.731775 4.17527768538
+0.00306730917507 37.64245 4.33834357791
+0.00334020101548 29.14025 3.81708331059
+0.00374953854926 16.858125 2.05293235398
+0.00415887583351 7.860455 1.98248013861
+0.00456821277179 4.8616775 1.1024606002
+0.00497754940605 4.619795 1.51983469496
+0.00538688562624 3.1591075 0.888693915249
+0.00579622148792 1.72058 0.927518193892
+0.00620555686743 1.913115 0.69157700222
+0.00661489183396 1.08108 0.735214254486
+0.0070242262502 1.0834955 0.520455449582
+0.00743356019898 0.4708995 0.485231645712
+0.00784289352938 0.774794 0.440111917585
+0.00825222633782 0.7830585 0.625722981838
+0.00866155845978 0.44196625 0.37397468163
+0.0090708900053 0.1305591 0.306123259489
+0.0093437773029 0.1961264 0.341325065004
+0.00975310762291 0.25845 0.280772594817
Index: test/sasdataloader/test/test_data/slaby_testdata.txt
===================================================================
--- test/sasdataloader/test/test_data/slaby_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
+++ test/sasdataloader/test/test_data/slaby_testdata.txt	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
@@ -0,0 +1,50 @@
+-0.00981587154747 0.197046827778 0.09153902
+-0.00940654133769 0.2466434 0.124972263589
+-0.0089972103454 0.218745969444 0.0838510368061
+-0.00858787875434 0.126093522222 0.107482002513
+-0.00817854644886 0.310427366667 0.10469745
+-0.0077692135991 0.0843802722222 0.103942898914
+-0.00735988010303 0.246036369444 0.0916479235889
+-0.00695054611716 0.217840922222 0.128330031223
+-0.00654121155308 0.379668444444 0.103424340152
+-0.00613187655368 0.447654644444 0.166575873418
+-0.00585898627901 0.419026583333 0.15428551475
+-0.00544965048161 0.401599005556 0.107234964701
+-0.00504031432153 0.552085055556 0.178458012837
+-0.00463097774216 0.623354058333 0.134112874252
+-0.0042216408546 0.653190877778 0.199963470429
+-0.00381230361585 0.661400280556 0.136616295765
+-0.00340296612338 0.714432968889 0.206518400818
+-0.00299362834783 0.653196219444 0.137770239209
+-0.00258429037305 0.823240055556 0.215465509543
+-0.00217495218329 0.9738398 0.165854141631
+-0.00176561384878 0.827869716667 0.217884056409
+-0.00135627536739 1.01947547778 0.169285496487
+-0.000946936795747 1.1655315 0.256453669437
+-0.000537598145326 1.06619988306 0.174316381271
+-0.000128259459128 1.03232983333 0.243681074459
+0.000144633007054 1.15035461111 0.254186641595
+0.000553971692162 1.14101948333 0.179426295522
+0.000963310340403 1.07222452222 0.244970006982
+0.00137264890851 1.16437213056 0.185866492018
+0.00178198738526 0.852203596111 0.219166988663
+0.00219132571378 0.901962183333 0.160186399428
+0.00260066389646 0.9240665 0.230158379447
+0.00301000186279 0.617907672222 0.137762238147
+0.00341933962881 0.650284455556 0.191734208711
+0.00382867711038 0.578899836111 0.127147693175
+0.00423801433715 0.507045738889 0.172630602733
+0.00464735121136 0.613949591667 0.131836392307
+0.00505668777629 0.593631783333 0.181602707905
+0.00532957859826 0.310741433333 0.143429472495
+0.00573891447198 0.422394166667 0.111503089837
+0.00614824996377 0.342731566667 0.148392724273
+0.0065575849441 0.286779447222 0.0946855610872
+0.00696691948801 0.223022966667 0.134800066857
+0.00737625345237 0.220648719444 0.0901314425104
+0.00778558692582 0.210920222222 0.13171959555
+0.00819491975161 0.206120872222 0.0877029867729
+0.00860425203202 0.26088625 0.127667879068
+0.00901358359666 0.156064891667 0.0817093355086
+0.00942291456144 0.177010094444 0.134301097823
+0.00983224474235 0.130891508333 0.0796420846741
Index: test/sasdataloader/test/utest_abs_reader.py
===================================================================
--- test/sasdataloader/test/utest_abs_reader.py	(revision bd5c3b11a604dfd75fa3d6424e1ea40bcafd3727)
+++ test/sasdataloader/test/utest_abs_reader.py	(revision bd5c3b11a604dfd75fa3d6424e1ea40bcafd3727)
@@ -118,5 +118,5 @@
         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)
Index: test/sasdataloader/test/utest_averaging.py
===================================================================
--- test/sasdataloader/test/utest_averaging.py	(revision f53d684ed4a54de3601e5f4bc601f78376d98e83)
+++ test/sasdataloader/test/utest_averaging.py	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
@@ -106,5 +106,5 @@
 
     def setUp(self):
-        filepath = find('MAR07232_rest.h5')
+        filepath = find('test_data//MAR07232_rest.h5')
         self.data_list = Loader().load(filepath)
         self.data = self.data_list[0]
@@ -121,5 +121,5 @@
 
         o = r(self.data)
-        filepath = find('ring_testdata.txt')
+        filepath = find('test_data//ring_testdata.txt')
         answer_list = Loader().load(filepath)
         answer = answer_list[0]
@@ -142,5 +142,5 @@
         o = r(self.data)
 
-        filepath = find('avg_testdata.txt')
+        filepath = find('test_data//avg_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(r.nbins_phi):
@@ -158,5 +158,5 @@
         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)
 
@@ -164,5 +164,5 @@
         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):
@@ -177,5 +177,5 @@
         o = r(self.data)
 
-        filepath = find('slabx_testdata.txt')
+        filepath = find('test_data//slabx_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
@@ -195,5 +195,5 @@
         o = r(self.data)
 
-        filepath = find('slaby_testdata.txt')
+        filepath = find('test_data//slaby_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
@@ -221,5 +221,5 @@
         o = r(self.data)
 
-        filepath = find('ring_testdata.txt')
+        filepath = find('test_data//ring_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
@@ -238,5 +238,5 @@
         o = r(self.data)
 
-        filepath = find('sectorphi_testdata.txt')
+        filepath = find('test_data//sectorphi_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
@@ -255,5 +255,5 @@
         o = r(self.data)
 
-        filepath = find('sectorq_testdata.txt')
+        filepath = find('test_data//sectorq_testdata.txt')
         answer = Loader().load(filepath)[0]
         for i in range(len(o.x)):
Index: test/sasdataloader/test/utest_cansas.py
===================================================================
--- test/sasdataloader/test/utest_cansas.py	(revision f53d684ed4a54de3601e5f4bc601f78376d98e83)
+++ test/sasdataloader/test/utest_cansas.py	(revision 7fd5e2abcc660d7481c92bbd68091179ecb0c4a8)
@@ -91,8 +91,5 @@
         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):
@@ -193,6 +190,5 @@
     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)
@@ -207,7 +203,6 @@
             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):
@@ -260,7 +255,10 @@
         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//nxcansas_1Dand2D_multisasdata.h5")
+        self.datafile_multiplesasdata = find(
+            "test_data//nxcansas_1Dand2D_multisasentry.h5")
+        self.datafile_multiplesasdata_multiplesasentry = find(
+            "test_data//nxcansas_1Dand2D_multisasentry_multisasdata.h5")
 
     def test_real_data(self):
@@ -273,5 +271,10 @@
         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 _check_multiple_data(self, data):
@@ -281,25 +284,30 @@
         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.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.assertTrue(data.detector[0].distance_unit == 'mm')
         self.assertTrue(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.assertTrue(data.dy[10] == 0.207214)
+        self.assertTrue(data.y[10] == 24.1939)
+        self.assertTrue(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.assertTrue(len(data.q_data) == 150*150)
+        self.assertTrue(len(data.q_data) == len(data.data))
+        print(data.err_data[10])
+        self.assertAlmostEqual(data.err_data[10], 0.186723989418)
+        self.assertAlmostEqual(data.data[10], 0.465181425808)
+        self.assertAlmostEqual(data.qx_data[10], -0.129)
+        self.assertAlmostEqual(data.qy_data[10], -0.149)
 
     def _check_example_data(self, data):
Index: test/sasdataloader/test/utest_red2d_reader.py
===================================================================
--- test/sasdataloader/test/utest_red2d_reader.py	(revision f53d684ed4a54de3601e5f4bc601f78376d98e83)
+++ test/sasdataloader/test/utest_red2d_reader.py	(revision fc51d06ca61c96f09100f834da5f2bd421f461f7)
@@ -31,6 +31,6 @@
         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")
