Changeset 35ac8df in sasview for src/sas

Timestamp:

Aug 21, 2018 9:20:27 AM (6 years ago)

Author:

krzywon

Branches:

master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, unittest-saveload

Children:

c2525bf

Parents:

96d06a4 (diff), ec52ea1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into ticket-1111

Location:

src/sas

Files:

• sascalc/dataloader/readers/abs_reader.py (modified) (1 diff)
• sascalc/fit/pagestate.py (modified) (2 diffs)
• sasgui/guiframe/local_perspectives/plotting/parameters_panel_slicer.py (modified) (2 diffs)
• sasgui/guiframe/media/graph_help.rst (modified) (3 diffs)
• sasgui/perspectives/calculator/pyconsole.py (modified) (2 diffs)
• sasgui/perspectives/calculator/slit_length_calculator_panel.py (modified) (1 diff)
• sasgui/perspectives/fitting/basepage.py (modified) (1 diff)
• sasgui/perspectives/fitting/fitpage.py (modified) (3 diffs)
• sasview/__init__.py (modified) (1 diff)
• sascalc/data_util/nxsunit.py (modified) (2 diffs)
• sascalc/dataloader/file_reader_base_class.py (modified) (6 diffs)
• sascalc/dataloader/readers/ascii_reader.py (modified) (1 diff)
• sascalc/dataloader/readers/cansas_reader.py (modified) (1 diff)
• sascalc/dataloader/readers/cansas_reader_HDF5.py (modified) (15 diffs)
• sascalc/dataloader/readers/danse_reader.py (modified) (1 diff)
• sascalc/dataloader/readers/red2d_reader.py (modified) (1 diff)
• sascalc/file_converter/nxcansas_writer.py (modified) (5 diffs)
• sasgui/guiframe/gui_manager.py (modified) (6 diffs)
• sasgui/guiframe/local_perspectives/data_loader/data_loader.py (modified) (1 diff)
• sasview/test/1d_data/33837rear_1D_1.75_16.5_NXcanSAS.h5 (deleted)
• sasview/test/2d_data/33837rear_2D_1.75_16.5_NXcanSAS.h5 (deleted)

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

@@ -171 +171 @@
 
                 try:
-                    _x = float(toks[0])
+                    _x = float(toks[4])
                     _y = float(toks[1])
                     _dy = float(toks[2])

src/sas/sascalc/fit/pagestate.py

@@ -13 +13 @@
 ################################################################################
 import time
+import re
 import os
 import sys
@@ -962 +963 @@
         if node.get('version'):
             # Get the version for model conversion purposes
-            self.version = tuple(int(e) for e in
-                                 str.split(node.get('version'), "."))
+            x = re.sub('[^\d.]', '', node.get('version'))
+            self.version = tuple(int(e) for e in str.split(x, "."))
             # The tuple must be at least 3 items long
             while len(self.version) < 3:

src/sas/sasgui/guiframe/local_perspectives/plotting/parameters_panel_slicer.py

@@ -251 +251 @@
             self.bck.Add(self.batch_slicer_button, (iy, ix), (1, 1),
                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
+            # Help button
+
+            self.bt_help = wx.Button(self, wx.NewId(), "HELP")
+            self.bt_help.SetToolTipString(
+                "Help for the slicer parameters and batch slicing.")
+            self.bck.Add(self.bt_help, (iy, 1), (1, 1),
+                         wx.ALIGN_RIGHT | wx.ADJUST_MINSIZE, 15)
+            wx.EVT_BUTTON(self, self.bt_help.GetId(), self.on_help)
+
             iy += 1
             self.bck.Add((5, 5), (iy, ix), (1, 1),
                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5)
+
         self.bck.Layout()
         self.bck.Fit(self)
@@ -535 +545 @@
             self.default_value += "_{0}".format(key).split(" [")[0]
             self.default_value += "-{:.2f}".format(params[key])
+
+    def on_help(self, event=None):
+        """
+        Opens a help window for the slicer parameters/batch slicing window
+        :param event:
+        :return:
+        """
+        from sas.sasgui.guiframe.documentation_window import DocumentationWindow
+
+        _TreeLocation = "user/sasgui/guiframe/graph_help.html"
+        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
+                                          "#d-data-averaging",
+                                          "Data Explorer Help")

src/sas/sasgui/guiframe/media/graph_help.rst

@@ -266 +266 @@
 
 .. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
+.. _d_data_averaging:
 
 2D data averaging
@@ -301 +302 @@
 Alternatively, once a 'slicer' is active you can also select the region to
 average by bringing back the *Dataset Menu* and selecting *Edit Slicer
-Parameters*. A dialog window will appear in which you can enter values to
-define a region or select the number of points to plot (*nbins*).
+Parameters and Batch Fitting*. A dialog window will appear in which you can
+enter values to define a region, select the number of points to plot (*nbins*),
+or apply the slicer to any or all other 2D data plots.
 
 A separate plot window will also have appeared, displaying the requested
@@ -315 +317 @@
 
 To remove a 'slicer', bring back the *Dataset menu* and select *Clear Slicer*.
+
+Batch Slicing
+^^^^^^^^^^^^^
+
+A slicer can be applied to any or all existing 2D data plots using the 'Slicer
+Parameters' window. To open the window, select *Edit Slicer Parameters and Batch
+Fitting* in the *Dataset Menu* (see Invoking_the_dataset_menu_). Batch slicing
+options are available at the bottom of the window.
+
+Select the 2D plots you want to apply the slicer to. All 2D plots are selected
+by default. The resulting 1D data for all slicers can be saved as a text file
+and then sent to fitting by selecting the *Auto save generated 1D* check box.
+Sending data to the fitting perspective requires the data be saved.
+
+Once the auto save check box is selected, you can select where the files are
+saved. The file name for the saved data is the slicer name plus the file name
+of the original data set, plus what is in the *Append to file name* field. The
+default value in the append to field includes the names and values for all of
+the slicer parameters.
+
+The batch of slices can be sent to fitting if desired, with three options
+available. The first is to not fit the data, the second is to send the
+slices to individual fit pages, and the third is to send all sliced data to a
+single batch fit window.
+
+Clicking *Apply Slicer to Selected Plots* will create a slicer for each selected
+plot with the parameters entered in the 'Slicer Parameters' window. Depending on
+the options selected the data may then be saved, loaded as separate data sets in
+the data manager panel, and finally sent to fitting.
 
 Unmasked circular average

src/sas/sasgui/perspectives/calculator/pyconsole.py

@@ -28 +28 @@
     Check that the model on the path can run.
     """
+    # TODO: fix model caching
+    # model_test.run_one() is directly forcing a reload of the module, but
+    # sasview_model is caching models that have already been loaded.
+    # If the sasview load happens before the test, then the module is
+    # reloaded out from under it, which causes the global variables in
+    # the model function definitions to be cleared (at least in python 2.7).
+    # To fix the proximal problem of models failing on test, perform the
+    # run_one() tests first.  To fix the deeper problem we should either
+    # remove caching from sasmodels.sasview_model.load_custom_model() or
+    # add caching to sasmodels.custom.load_custom_kernel_module().  Another
+    # option is to add a runTests method to SasviewModel which runs the
+    # test suite directly from the model info structure.  Probably some
+    # combination of options:
+    #    (1) have this function (check_model) operate on a loaded model
+    #    so that caching isn't needed in sasview_models.load_custom_model
+    #    (2) add the runTests method to SasviewModel so that tests can
+    #    be run on a loaded module.
+    #
+    # Also, note that the model test suite runs the equivalent of the
+    # "try running the model" block below, and doesn't need to be run
+    # twice.  The reason for duplicating the block here is to generate
+    # an exception that show_model_output can catch.  Need to write the
+    # runTests method so that it returns success flag as well as output
+    # string so that the extra test is not necessary.
+
+    # check the model's unit tests run
+    from sasmodels.model_test import run_one
+    result = run_one(path)
+
+    # remove cached version of the model, if any
+    from sasmodels import sasview_model
+    sasview_model.MODEL_BY_PATH.pop(path, None)
+
     # try running the model
-    from sasmodels.sasview_model import load_custom_model
-    Model = load_custom_model(path)
+    Model = sasview_model.load_custom_model(path)
     model = Model()
     q =  np.array([0.01, 0.1])
@@ -36 +68 @@
     qx, qy =  np.array([0.01, 0.01]), np.array([0.1, 0.1])
     Iqxy = model.evalDistribution([qx, qy])
-
-    # check the model's unit tests run
-    from sasmodels.model_test import run_one
-    result = run_one(path)
 
     return result

src/sas/sasgui/perspectives/calculator/slit_length_calculator_panel.py

@@ -248 +248 @@
             Complete the loading and compute the slit size
         """
+        if isinstance(data, list):
+            data = data[0]
         if data is None or data.__class__.__name__ == 'Data2D':
             if self.parent.parent is None:

src/sas/sasgui/perspectives/fitting/basepage.py

@@ -2552 +2552 @@
             # draw
             self._draw_model()
+            self.Layout()
             self.Refresh()
         except Exception:

src/sas/sasgui/perspectives/fitting/fitpage.py

@@ -706 +706 @@
 
                         ix = 3
-                        ctl2 = wx.TextCtrl(self, wx.ID_ANY,
-                                           size=(_BOX_WIDTH / 1.3, 20),
-                                           style=0)
+                        ctl2 = BGTextCtrl(self, wx.ID_ANY,
+                                           size=(_BOX_WIDTH / 1.3, 20))
 
                         self.sizer4_4.Add(ctl2, (iy, ix), (1, 1),
@@ -1998 +1997 @@
         self.on_smear_helper()
         self.on_set_focus(None)
+        self.Layout()
         self.Refresh()
         # update model plot with new data information
@@ -2892 +2892 @@
                         text2.Hide()
                     ix += 1
-                    ctl2 = wx.TextCtrl(self, wx.ID_ANY,
-                                       size=(_BOX_WIDTH / 1.2, 20), style=0)
+                    ctl2 = BGTextCtrl(self, wx.ID_ANY,
+                                       size=(_BOX_WIDTH / 1.2, 20))
                     sizer.Add(ctl2, (iy, ix), (1, 1),
                               wx.EXPAND | wx.ADJUST_MINSIZE, 0)

src/sas/sasview/__init__.py

@@ -1 @@
-__version__ = "4.2.0"
+__version__ = "4.2.0-beta"
 __build__ = "GIT_COMMIT"

src/sas/sascalc/data_util/nxsunit.py

@@ -136 +136 @@
     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 +158 @@
     # 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/file_reader_base_class.py

@@ -16 +16 @@
 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 +99 @@
                     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 +167 @@
         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 +175 @@
                 # 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 +206 @@
                     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 +281 @@
         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):

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

@@ -157 +157 @@
 
         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

@@ -812 +812 @@
             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

@@ -38 +38 @@
     # 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 +71 @@
                 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 +101 @@
         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 +137 @@
             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 +145 @@
                     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 +158 @@
                 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 +168 @@
                     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 +177 @@
                         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 +224 @@
                 # 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 +487 @@
             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 +522 @@
                 (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 +546 @@
         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 +554 @@
         :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 +561 @@
             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 +657 @@
         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

@@ -180 +180 @@
         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

@@ -317 +317 @@
 
         # 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

@@ -175 +175 @@
             names=['beam_size_x', 'beam_size_y'],
             units=data_info.source.beam_size_unit, write_fn=_write_h5_float)
-
 
         # Collimation metadata
@@ -232 +231 @@
             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 +304 @@
         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 +332 @@
         """
         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 +346 @@
                 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

@@ -46 +46 @@
 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 +2423 @@
         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 +2437 @@
             # 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 +2567 @@
         """
         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 +2580 @@
             if ext_num == 0:
                 ext_format = '.dat'
+            elif ext_num == 1:
+                ext_format = '.h5'
             else:
                 ext_format = ''
@@ -2584 +2589 @@
             # 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

@@ -239 +239 @@
             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"):