Changeset 845144e for src/sas – SasView

src/sas/sascalc/fit/pagestate.py

-                      r59873e1
+                      r863ac2c
                 if len(value.strip()) == 0:
                     continue
+                title = value + " [" + repo_time + "]"
+                title = (value + " [" + repo_time + "] [SasView v" +
+                         SASVIEW_VERSION + "]")
                 title_name = HEADER % title
             elif name == "data":

src/sas/sasgui/guiframe/aboutbox.py

-                      rb963b20
+                      r1b4cb41
         self.bitmap_button_tudelft = wx.BitmapButton(self, -1, wx.NullBitmap)
         self.bitmap_button_dls = wx.BitmapButton(self, -1, wx.NullBitmap)
+        self.bitmap_button_bam = wx.BitmapButton(self, -1, wx.NullBitmap)
         self.static_line_3 = wx.StaticLine(self, -1)
 …
         self.Bind(wx.EVT_BUTTON, self.onTudelftLogo, self.bitmap_button_tudelft)
         self.Bind(wx.EVT_BUTTON, self.onDlsLogo, self.bitmap_button_dls)
+        self.Bind(wx.EVT_BUTTON, self.onBamLogo, self.bitmap_button_bam)
         # end wxGlade
         # fill in acknowledgements
 …
         logo = wx.Bitmap(image)
         self.bitmap_button_dls.SetBitmapLabel(logo)
+        image = file_dir + "/images/bam_logo.png"
+        if os.path.isfile(config._bam_logo):
+            image = config._bam_logo
+        logo = wx.Bitmap(image)
+        self.bitmap_button_bam.SetBitmapLabel(logo)
         # resize dialog window to fit version number nicely
 …
         self.bitmap_button_tudelft.SetSize(self.bitmap_button_tudelft.GetBestSize())
         self.bitmap_button_dls.SetSize(self.bitmap_button_dls.GetBestSize())
+        self.bitmap_button_bam.SetSize(self.bitmap_button_bam.GetBestSize())
         # end wxGlade
 …
         sizer_logos.Add(self.bitmap_button_dls, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_bam, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add((10, 50), 0, wx.ADJUST_MINSIZE, 0)
 …
         event.Skip()
+    def onBamLogo(self, event):
+        """
+        """
+        # wxGlade: DialogAbout.<event_handler>
+        launchBrowser(config._bam_url)
+        event.Skip()
 # end of class DialogAbout

src/sas/sasgui/guiframe/config.py

-                      r1efbc190
+                      r1b4cb41
 _do_aboutbox = True
 _do_acknowledge = True
+_do_release = True
 _do_tutorial = True
 _acknowledgement_preamble =\
 …
 _acknowledgement_citation = \
 '''M. Doucet et al. SasView Version 4.1.2, Zenodo, 10.5281/zenodo.825675'''
 _acknowledgement =  \
 '''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: http://www.sasview.org/contact.html
+'''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, BAM and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: http://www.sasview.org/contact.html
 '''
 …
 _tudelft_url = "http://www.tnw.tudelft.nl/en/cooperation/facilities/reactor-instituut-delft/"
 _dls_url = "http://www.diamond.ac.uk/"
+_bam_url = "http://www.bam.de/"
 _danse_url = "http://www.cacr.caltech.edu/projects/danse/release/index.html"
 _inst_url = "http://www.utk.edu"
 _corner_image = os.path.join(icon_path, "angles_flat.png")
 _welcome_image = os.path.join(icon_path, "SVwelcome.png")
 _copyright = "(c) 2009 - 2017, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, and DLS"
+_copyright = "(c) 2009 - 2018, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS and BAM"
 marketplace_url = "http://marketplace.sasview.org/"

src/sas/sasgui/guiframe/gui_manager.py

-                      rb1ec23d
+                      r845144e
         wx_id = wx.NewId()
         self._help_menu.Append(wx_id, '&Documentation', '')
+        self._help_menu.Append(wx_id, '&Documentation', 'Help documentation for SasView')
         wx.EVT_MENU(self, wx_id, self._onSphinxDocs)
         if config._do_tutorial and (IS_WIN or sys.platform == 'darwin'):
             wx_id = wx.NewId()
+            self._help_menu.Append(wx_id, '&Tutorial', 'Software tutorial')
+            # Pluralised both occurences of 'Tutorial' in the line below
+            # S King, Sep 2018
+            self._help_menu.Append(wx_id, '&Tutorials', 'Tutorials on how to use SasView')
             wx.EVT_MENU(self, wx_id, self._onTutorial)
+        if config.marketplace_url:
+            wx_id = wx.NewId()
+            self._help_menu.Append(wx_id, '&Model marketplace', 'Plug-in fitting models for SasView')
+            wx.EVT_MENU(self, wx_id, self._on_marketplace_click)
+        if config._do_release:
+            wx_id = wx.NewId()
+            self._help_menu.Append(wx_id, '&Release notes',
+                                   'SasView release notes and known issues')
+            wx.EVT_MENU(self, wx_id, self._onRelease)
         if config._do_acknowledge:
 …
             logger.info("Doing help menu")
             wx_id = wx.NewId()
             self._help_menu.Append(wx_id, '&About', 'Software information')
+            self._help_menu.Append(wx_id, '&About', 'Information about SasView')
             wx.EVT_MENU(self, wx_id, self._onAbout)
-        if config.marketplace_url:
-            wx_id = wx.NewId()
-            self._help_menu.Append(wx_id, '&Model marketplace', '')
-            wx.EVT_MENU(self, wx_id, self._on_marketplace_click)
         # Checking for updates
 …
             dialog.ShowModal()
+    def _onRelease(self, evt):
+        """
+        Pop up the release notes
+        :param evt: menu event
+        """
+        # S King, Sep 2018
+        from documentation_window import DocumentationWindow
+        _TreeLocation = "user/release.html"
+        DocumentationWindow(self, -1, _TreeLocation, "",
+                            "SasView Documentation")
     def _onTutorial(self, evt):
         """
 …
         """
+        if config._do_tutorial:
+            path = config.TUTORIAL_PATH
+            if IS_WIN:
+                try:
+                    from sas.sasgui.guiframe.pdfview import PDFFrame
+                    dialog = PDFFrame(None, -1, "Tutorial", path)
+                    # put icon
+                    self.put_icon(dialog)
+                    dialog.Show(True)
+                except:
+                    logger.error("Error in _onTutorial: %s" % sys.exc_value)
+                    try:
+                        # Try an alternate method
+                        logger.error(
+                            "Could not open the tutorial pdf, trying xhtml2pdf")
+                        from xhtml2pdf import pisa
+                        pisa.startViewer(path)
+                    except:
+                        logger.error(
+                            "Could not open the tutorial pdf with xhtml2pdf")
+                        msg = "This feature requires 'PDF Viewer'\n"
+                        wx.MessageBox(msg, 'Error')
+            else:
+                try:
+                    command = "open '%s'" % path
+                    os.system(command)
+                except:
+                    try:
+                        # Try an alternate method
+                        logger.error(
+                            "Could not open the tutorial pdf, trying xhtml2pdf")
+                        from xhtml2pdf import pisa
+                        pisa.startViewer(path)
+                    except:
+                        logger.error(
+                            "Could not open the tutorial pdf with xhtml2pdf")
+                        msg = "This feature requires the Preview application\n"
+                        wx.MessageBox(msg, 'Error')
+        # Action changed from that in 2.x/3.x/4.0.x/4.1.x
+        # Help >> Tutorial used to bring up a pdf of the
+        # original 2.x tutorial.
+        # Code below, implemented from 4.2.0, redirects
+        # action to the Tutorials page of the help
+        # documentation to give access to all available
+        # tutorials
+        # S King, Sep 2018
+        from documentation_window import DocumentationWindow
+        _TreeLocation = "user/tutorial.html"
+        DocumentationWindow(self, -1, _TreeLocation, "",
+                            "SasView Documentation")
     def _onSphinxDocs(self, evt):

src/sas/sasgui/perspectives/corfunc/corfunc_panel.py

r2a399ca	r5652efc
20	20
21	21	OUTPUT_STRINGS = {
22		'max': "Long Period ~~/ 2~~ (A): ",
	22	'max': "Long Period (A): ",
23	23	'Lc': "Average Hard Block Thickness (A): ",
24	24	'dtr': "Average Interface Thickness (A): ",

src/sas/sasgui/perspectives/corfunc/corfunc_state.py

r1fa4f736	r5652efc
28	28	# List of output parameters, used by __str__
29	29	output_list = [
30		['max', "Long Period ~~/ 2~~ (A): "],
	30	['max', "Long Period (A): "],
31	31	['Lc', "Average Hard Block Thickness (A): "],
32	32	['dtr', "Average Interface Thickness (A): "],

src/sas/sasgui/perspectives/corfunc/media/corfunc_help.rst

-                      r501712f
+                      r490f790
 Both analyses are performed in 3 stages:
 *  Extrapolation of the scattering curve to :math:`Q = 0` and toward
    :math:`Q = \infty`
+*  Extrapolation of the scattering curve to :math:`q = 0` and toward
+   :math:`q = \infty`
 *  Smoothed merging of the two extrapolations into the original data
 *  Fourier / Hilbert Transform of the smoothed data to give the correlation
 …
 -------------
 To :math:`Q = 0`
+To :math:`q = 0`
 ................
 …
 the impact on any extrapolated parameters will be least significant.
 To :math:`Q = \infty`
+To :math:`q = \infty`
 .....................
 …
         - do they smoothly curve onto the ordinate at x = 0? (if not check the value
           of :math:`\sigma` is sensible)
         - are there ripples at x values corresponding to (2 :math:`pi` over) the two
+        - are there ripples at x values corresponding to (2 :math:`\pi` over) the two
           q values at which the extrapolated and experimental data are merged?
         - are there any artefacts at x values corresponding to 2 :math:`pi` / q\ :sub:`max` in
+        - are there any artefacts at x values corresponding to 2 :math:`\pi` / q\ :sub:`max` in
           the experimental data?
         - and lastly, do the significant features/peaks in the correlation functions
 …
     -q^{4} I(q)
+The IDF is proportional to the second derivative of Î\ :sub:`1`\ (x).
+The IDF is proportional to the second derivative of Î\ :sub:`1`\ (x) and represents a
+superposition of thickness distributions from all the contributing lamellae.
 Hilbert
 …
 *   Local Crystallinity :math:`= L_c/L_p`
+.. warning:: If the sample does not possess lamellar morphology then "Compute
+    Parameters" will return garbage!
 Volume Fraction Profile
 .......................
 …
 The reader is directed to the references for information on these parameters.
 References
 …
 Once the Q ranges have been set, click the "Calculate Bg" button to determine the
 background level. Alternatively, enter your own value into the box. If the box turns
+yellow this indicates that background subtraction has created some negative intensities.
+yellow this indicates that background subtraction has created some negative intensities.
+This may still be fine provided the peak intensity is very much greater than the
+background level. The important point is that the extrapolated dataset must approach
+zero at high-q.
 Now click the "Extrapolate" button to extrapolate the data. The graph window will update
 …
 .. note::
     This help document was last changed by Steve King, 26Sep2017
+    This help document was last changed by Steve King, 28Sep2017

src/sas/sasgui/perspectives/corfunc/media/fdr-pdfs.rst

r959eb01	r577460c
7	7
8	8	:download:`Fibre_Diffraction_Review_1994_3_25-29.pdf <Fibre_Diffraction_Review_1994_3_25-29.pdf>`
	9
9	10	:download:`Fibre_Diffraction_Review_2004_12_24.pdf <Fibre_Diffraction_Review_2004_12_24.pdf>`
	11
10	12	:download:`Fibre_Diffraction_Review_2005_13_19-22.pdf <Fibre_Diffraction_Review_2005_13_19-22.pdf>`

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

-                      ra4a1ac9
+                      r5323490
             self.magnetic_on = True
             button.SetLabel("Magnetic OFF")
             m_value = 1.0e-06
+            m_value = 1
             for key in self.model.magnetic_params:
                 if key.count('M0') > 0:
                     self.model.setParam(key, m_value)
                     m_value += 0.5e-06
+                    m_value += 0.5
         else:
             self.magnetic_on = False

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

-                      rdabcaf7
+                      rba1c145
     fitting  a model and one data
 """
+from __future__ import print_function
 import sys
 import wx
 …
         if saved_pars:
             self.get_paste_params(saved_pars)
+        # Make sure the model parameters correspond to the fit parameters
+        self._update_paramv_on_fit()
         if event is not None:

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

-                      raf7d2e5
+                      raba4559
         Update custom model list in the fitpage combo box
         """
-        custom_model = 'Plugin Models'
         try:
             # Update edit menus
 …
             if not new_pmodel_list:
                 return
+            # Set the new plugin model list for all fit pages
+            # Redraws to a page not in focus are showing up as if they are
+            # in the current page tab.
+            current_page_index = self.fit_panel.GetSelection()
+            current_page = self.fit_panel.GetCurrentPage()
+            last_drawn_page = current_page
+            # Set the new plugin model list for all fit pages; anticipating
+            # categories, the updated plugin may be in either the form factor
+            # or the structure factor combo boxes
             for uid, page in self.fit_panel.opened_pages.iteritems():
+                if hasattr(page, "formfactorbox"):
+                    page.model_list_box = new_pmodel_list
+                    mod_cat = page.categorybox.GetStringSelection()
+                    if mod_cat == custom_model:
+                        box = page.formfactorbox
+                        model_name = box.GetValue()
+                        model = (box.GetClientData(box.GetCurrentSelection())
+                                 if model_name else None)
+                        page._show_combox_helper()
+                        new_index = box.FindString(model_name)
+                        new_model = (box.GetClientData(new_index)
+                                     if new_index >= 0 else None)
+                        if new_index >= 0:
+                            box.SetStringSelection(model_name)
+                        else:
+                            box.SetStringSelection('')
+                        if model and new_model != model:
+                            page._on_select_model(keep_pars=True)
+                    if hasattr(page, "structurebox"):
+                        selected_name = page.structurebox.GetStringSelection()
+                        page.structurebox.Clear()
+                        page.initialize_combox()
+                        index = page.structurebox.FindString(selected_name)
+                        if index == -1:
+                            index = 0
+                        page.structurebox.SetSelection(index)
+                        page._on_select_model()
+                pbox = getattr(page, "formfactorbox", None)
+                sbox = getattr(page, "structurebox", None)
+                if pbox is None:
+                    continue
+                # Set the new model list for the page
+                page.model_list_box = new_pmodel_list
+                # Grab names of the P and S models from the page.  Need to do
+                # this before resetting the form factor box since that clears
+                # the structure factor box.
+                old_struct = old_form = None
+                form_name = pbox.GetValue()
+                struct_name = sbox.GetStringSelection()
+                if form_name:
+                    old_form = pbox.GetClientData(pbox.GetCurrentSelection())
+                if struct_name:
+                    old_struct = sbox.GetClientData(sbox.GetCurrentSelection())
+                # Reset form factor combo box.  We are doing this for all
+                # categories not just plugins since eventually the category
+                # manager will allow plugin models to be anywhere.
+                page._show_combox_helper()
+                form_index = pbox.FindString(form_name)
+                pbox.SetSelection(form_index)
+                new_form = (pbox.GetClientData(form_index)
+                            if form_index != wx.NOT_FOUND else None)
+                #print("form: %r"%form_name, old_form, new_form)
+                # Reset structure factor combo box; even if the model list
+                # hasn't changed, the model may have.  Show the structure
+                # factor combobox if the selected model is a form factor.
+                sbox.Clear()
+                page.initialize_combox()
+                if new_form is not None and getattr(new_form, 'is_form_factor', False):
+                    sbox.Show()
+                    sbox.Enable()
+                    page.text2.Show()
+                    page.text2.Enable()
+                struct_index = sbox.FindString(struct_name)
+                sbox.SetSelection(struct_index)
+                new_struct = (sbox.GetClientData(struct_index)
+                              if struct_index != wx.NOT_FOUND else None)
+                #print("struct: %r"%struct_name, old_struct, new_struct)
+                # Update the page if P or S has changed
+                if old_form != new_form or old_struct != new_struct:
+                    #print("triggering model update")
+                    page._on_select_model(keep_pars=True)
+                    last_drawn_page = page
+            # If last drawn is not the current, then switch the current to the
+            # last drawn then switch back.  Very ugly.
+            if last_drawn_page != current_page:
+                for page_index in range(self.fit_panel.PageCount):
+                    if self.fit_panel.GetPage(page_index) == last_drawn_page:
+                        self.fit_panel.SetSelection(page_index)
+                        break
+                self.fit_panel.SetSelection(current_page_index)
         except Exception:
             logger.error("update_custom_combo: %s", sys.exc_value)

src/sas/sasgui/perspectives/invariant/invariant_state.py

-                      rfa412df
+                      re9920cd
         my_time, date = self.timestamp
         file_name = self.file
+        from sas.sasview.__init__ import __version__ as sasview_version
         state_num = int(self.saved_state['state_num'])
         state = "\n[Invariant computation for %s: " % file_name
+        state += "performed at %s on %s] \n" % (my_time, date)
+        state += "performed at %s on %s] " % (my_time, date)
+        state += "[SasView v%s]\n" % (sasview_version)
         state += "State No.: %d \n" % state_num
         state += "\n=== Inputs ===\n"

src/sas/sasview/local_config.py

-                      rb229a3b
+                      r1b4cb41
 _do_aboutbox = True
 _do_acknowledge = True
+_do_release = True
 _do_tutorial = True
 _acknowledgement_preamble =\
 …
 _acknowledgement_citation = \
 '''M. Doucet et al. SasView Version 4.2, Zenodo, 10.5281/zenodo.1412041'''
 _acknowledgement =  \
 '''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: http://www.sasview.org/contact.html
+'''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, BAM and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: http://www.sasview.org/contact.html
 '''
 …
 _tudelft_logo = os.path.join(icon_path, "tudelft_logo.png")
 _dls_logo = os.path.join(icon_path, "dls_logo.png")
+_bam_logo = os.path.join(icon_path, "bam_logo.png")
 _nsf_logo = os.path.join(icon_path, "nsf_logo.png")
 _danse_logo = os.path.join(icon_path, "danse_logo.png")
 …
 _corner_image = os.path.join(icon_path, "angles_flat.png")
 _welcome_image = os.path.join(icon_path, "SVwelcome.png")
 _copyright = "(c) 2009 - 2017, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, and DLS"
+_copyright = "(c) 2009 - 2018, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS and BAM"
 marketplace_url = "http://marketplace.sasview.org/"

src/sas/sascalc/data_util/nxsunit.py

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

src/sas/sascalc/dataloader/data_info.py

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

src/sas/sascalc/dataloader/file_reader_base_class.py

-                      r4a8d55c
+                      rb1ec23d
 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__)
 …
                        "load the file was made, but, should it be successful, "
                        "SasView cannot guarantee the accuracy of the data.")
 class FileReader(object):
 …
                     if len(self.output) > 0:
                         # Sort the data that's been loaded
                         self.sort_one_d_data()
                         self.sort_two_d_data()
+                        self.convert_data_units()
+                        self.sort_data()
         else:
             msg = "Unable to find file at: {}\n".format(filepath)
 …
         Returns the entire file as a string.
         """
-        #return self.f_open.read()
         return decode(self.f_open.read())
 …
         self.output.append(data_obj)
     def sort_one_d_data(self):
+    def sort_data(self):
         """
         Sort 1D data along the X axis for consistency
 …
                 # Normalize the units for
                 data.x_unit = self.format_unit(data.x_unit)
+                data._xunit = data.x_unit
                 data.y_unit = self.format_unit(data.y_unit)
+                data._yunit = data.y_unit
                 # Sort data by increasing x and remove 1st point
                 ind = np.lexsort((data.y, data.x))
 …
                     data.ymin = np.min(data.y)
                     data.ymax = np.max(data.y)
+            elif isinstance(data, Data2D):
+                # Normalize the units for
+                data.Q_unit = self.format_unit(data.Q_unit)
+                data.I_unit = self.format_unit(data.I_unit)
+                data._xunit = data.Q_unit
+                data._yunit = data.Q_unit
+                data._zunit = data.I_unit
+                data.data = data.data.astype(np.float64)
+                data.qx_data = data.qx_data.astype(np.float64)
+                data.xmin = np.min(data.qx_data)
+                data.xmax = np.max(data.qx_data)
+                data.qy_data = data.qy_data.astype(np.float64)
+                data.ymin = np.min(data.qy_data)
+                data.ymax = np.max(data.qy_data)
+                data.q_data = np.sqrt(data.qx_data * data.qx_data
+                                         + data.qy_data * data.qy_data)
+                if data.err_data is not None:
+                    data.err_data = data.err_data.astype(np.float64)
+                if data.dqx_data is not None:
+                    data.dqx_data = data.dqx_data.astype(np.float64)
+                if data.dqy_data is not None:
+                    data.dqy_data = data.dqy_data.astype(np.float64)
+                if data.mask is not None:
+                    data.mask = data.mask.astype(dtype=bool)
+                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
 …
         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(r"\rm{Q}", '1/A')
+        data.yaxis(r"\rm{Intensity}", "1/cm")
+        return data
+    @staticmethod
+    def set_default_2d_units(data):
+        """
+        Set the x and y axes to the default 2D units
+        :param data: 2D data set
+        :return:
+        """
+        data.xaxis("\\rm{Q_{x}}", '1/A')
+        data.yaxis("\\rm{Q_{y}}", '1/A')
+        data.zaxis("\\rm{Intensity}", "1/cm")
+        return data
+    def convert_data_units(self, default_q_unit="1/A", 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_q_unit: The default Q unit used by Sasview
+        :param default_i_unit: The default I 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):
 …
                     self.current_dataset.qy_data))
             if has_error_dy:
+                self.current_dataset.err_data = self.current_dataset.err_data[x != 0]
+                self.current_dataset.err_data = self.current_dataset.err_data[
+                    x != 0]
             if has_error_dqx:
+                self.current_dataset.dqx_data = self.current_dataset.dqx_data[x != 0]
+                self.current_dataset.dqx_data = self.current_dataset.dqx_data[
+                    x != 0]
             if has_error_dqy:
+                self.current_dataset.dqy_data = self.current_dataset.dqy_data[x != 0]
+                self.current_dataset.dqy_data = self.current_dataset.dqy_data[
+                    x != 0]
             if has_mask:
                 self.current_dataset.mask = self.current_dataset.mask[x != 0]

src/sas/sascalc/dataloader/loader.py

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

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

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

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

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

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

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

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

-                      r61f329f0
+                      rb204004
     Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \
     TransmissionSpectrum, Detector
-from ..data_info import combine_data_info_with_plottable
 from ..loader_exceptions import FileContentsException, DefaultReaderException
 from ..file_reader_base_class import FileReader, decode
 def h5attr(node, key, default=None):
     return decode(node.attrs.get(key, default))
 class Reader(FileReader):
 …
     # CanSAS version
     cansas_version = 2.0
-    # Logged warnings or messages
-    logging = None
-    # List of errors for the current data set
-    errors = None
-    # Raw file contents to be processed
-    raw_data = None
-    # List of plottable1D objects that should be linked to the current_datainfo
-    data1d = None
-    # List of plottable2D objects that should be linked to the current_datainfo
-    data2d = None
     # Data type name
     type_name = "CanSAS 2.0"
+    type_name = "NXcanSAS"
     # Wildcards
     type = ["CanSAS 2.0 HDF5 Files (*.h5)|*.h5"]
+    type = ["NXcanSAS HDF5 Files (*.h5)|*.h5|"]
     # List of allowed extensions
     ext = ['.h5', '.H5']
 …
                 except Exception as e:
                     if extension not in self.ext:
+                        msg = "CanSAS2.0 HDF5 Reader could not load file {}".format(basename + extension)
+                        msg = "NXcanSAS Reader could not load file {}".format(
+                            basename + extension)
                         raise DefaultReaderException(msg)
                     raise FileContentsException(e.message)
 …
                     self.raw_data.close()
+                for dataset in self.output:
+                    if isinstance(dataset, Data1D):
+                        if dataset.x.size < 5:
+                            self.output = []
+                            raise FileContentsException("Fewer than 5 data points found.")
+                for data_set in self.output:
+                    if isinstance(data_set, Data1D):
+                        if data_set.x.size < 5:
+                            exception = FileContentsException(
+                                "Fewer than 5 data points found.")
+                            data_set.errors.append(exception)
     def reset_state(self):
 …
         self.errors = set()
         self.logging = []
+        self.q_names = []
+        self.mask_name = u''
+        self.i_name = u''
+        self.i_node = u''
+        self.i_uncertainties_name = u''
+        self.q_uncertainty_names = []
+        self.q_resolution_names = []
         self.parent_class = u''
         self.detector = Detector()
 …
             value = data.get(key)
             class_name = h5attr(value, u'canSAS_class')
+            if isinstance(class_name, (list, tuple, np.ndarray)):
+                class_name = class_name[0]
             if class_name is None:
                 class_name = h5attr(value, u'NX_class')
 …
             if isinstance(value, h5py.Group):
                 # Set parent class before recursion
+                last_parent_class = self.parent_class
                 self.parent_class = class_name
                 parent_list.append(key)
 …
                     self.add_data_set(key)
                 elif class_prog.match(u'SASdata'):
+                    self._initialize_new_data_set(parent_list)
+                    self._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)
             elif isinstance(value, h5py.Dataset):
                 # If this is a dataset, store the data appropriately
                 data_set = data[key][:]
+                data_set = value.value
                 unit = self._get_unit(value)
-                # I and Q Data
-                if key == u'I':
-                    if isinstance(self.current_dataset, plottable_2D):
-                        self.current_dataset.data = data_set
-                        self.current_dataset.zaxis("Intensity", unit)
-                    else:
-                        self.current_dataset.y = data_set.flatten()
-                        self.current_dataset.yaxis("Intensity", unit)
-                    continue
-                elif key == u'Idev':
-                    if isinstance(self.current_dataset, plottable_2D):
-                        self.current_dataset.err_data = data_set.flatten()
-                    else:
-                        self.current_dataset.dy = data_set.flatten()
-                    continue
-                elif key == u'Q':
-                    self.current_dataset.xaxis("Q", unit)
-                    if isinstance(self.current_dataset, plottable_2D):
-                        self.current_dataset.q = data_set.flatten()
-                    else:
-                        self.current_dataset.x = data_set.flatten()
-                    continue
-                elif key == u'Qdev':
-                    self.current_dataset.dx = data_set.flatten()
-                    continue
-                elif key == u'dQw':
-                    self.current_dataset.dxw = data_set.flatten()
-                    continue
-                elif key == u'dQl':
-                    self.current_dataset.dxl = data_set.flatten()
-                    continue
-                elif key == u'Qy':
-                    self.current_dataset.yaxis("Q_y", unit)
-                    self.current_dataset.qy_data = data_set.flatten()
-                    continue
-                elif key == u'Qydev':
-                    self.current_dataset.dqy_data = data_set.flatten()
-                    continue
-                elif key == u'Qx':
-                    self.current_dataset.xaxis("Q_x", unit)
-                    self.current_dataset.qx_data = data_set.flatten()
-                    continue
-                elif key == u'Qxdev':
-                    self.current_dataset.dqx_data = data_set.flatten()
-                    continue
-                elif key == u'Mask':
-                    self.current_dataset.mask = data_set.flatten()
-                    continue
-                # Transmission Spectrum
-                elif (key == u'T'
-                      and self.parent_class == u'SAStransmission_spectrum'):
-                    self.trans_spectrum.transmission = data_set.flatten()
-                    continue
-                elif (key == u'Tdev'
-                      and self.parent_class == u'SAStransmission_spectrum'):
-                    self.trans_spectrum.transmission_deviation = \
-                        data_set.flatten()
-                    continue
-                elif (key == u'lambda'
-                      and self.parent_class == u'SAStransmission_spectrum'):
-                    self.trans_spectrum.wavelength = data_set.flatten()
-                    continue
                 for data_point in data_set:
 …
                     if key == u'definition':
                         self.current_datainfo.meta_data['reader'] = data_point
+                    # Run
                     elif key == u'run':
                         self.current_datainfo.run.append(data_point)
 …
                         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(
 …
                 # 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_name:
+            self.current_dataset.dy = data_set.flatten()
+        elif key in self.q_names:
+            self.current_dataset.xaxis("Q", unit)
+            self.current_dataset.x = data_set.flatten()
+        elif key in self.q_resolution_names:
+            if (len(self.q_resolution_names) > 1
+                    and np.where(self.q_resolution_names == key)[0] == 0):
+                self.current_dataset.dxw = data_set.flatten()
+            elif (len(self.q_resolution_names) > 1
+                  and np.where(self.q_resolution_names == key)[0] == 1):
+                self.current_dataset.dxl = data_set.flatten()
+            else:
+                self.current_dataset.dx = data_set.flatten()
+        elif key in self.q_uncertainty_names:
+            if (len(self.q_uncertainty_names) > 1
+                    and np.where(self.q_uncertainty_names == key)[0] == 0):
+                self.current_dataset.dxw = data_set.flatten()
+            elif (len(self.q_uncertainty_names) > 1
+                  and np.where(self.q_uncertainty_names == key)[0] == 1):
+                self.current_dataset.dxl = data_set.flatten()
+            else:
+                self.current_dataset.dx = data_set.flatten()
+        elif key == self.mask_name:
+            self.current_dataset.mask = data_set.flatten()
+        elif key == u'wavelength':
+            self.current_datainfo.source.wavelength = data_set[0]
+            self.current_datainfo.source.wavelength_unit = unit
+    def process_2d_data_object(self, data_set, key, unit):
+        if key == self.i_name:
+            self.current_dataset.data = data_set
+            self.current_dataset.zaxis("Intensity", unit)
+        elif key == self.i_uncertainties_name:
+            self.current_dataset.err_data = data_set.flatten()
+        elif key in self.q_names:
+            self.current_dataset.xaxis("Q_x", unit)
+            self.current_dataset.yaxis("Q_y", unit)
+            if self.q_names[0] == self.q_names[1]:
+                # All q data in a single array
+                self.current_dataset.qx_data = data_set[0]
+                self.current_dataset.qy_data = data_set[1]
+            elif self.q_names.index(key) == 0:
+                self.current_dataset.qx_data = data_set
+            elif self.q_names.index(key) == 1:
+                self.current_dataset.qy_data = data_set
+        elif key in self.q_uncertainty_names or key in self.q_resolution_names:
+            if ((self.q_uncertainty_names[0] == self.q_uncertainty_names[1]) or
+                    (self.q_resolution_names[0] == self.q_resolution_names[1])):
+                # All q data in a single array
+                self.current_dataset.dqx_data = data_set[0].flatten()
+                self.current_dataset.dqy_data = data_set[1].flatten()
+            elif (self.q_uncertainty_names.index(key) == 0 or
+                  self.q_resolution_names.index(key) == 0):
+                self.current_dataset.dqx_data = data_set.flatten()
+            elif (self.q_uncertainty_names.index(key) == 1 or
+                  self.q_resolution_names.index(key) == 1):
+                self.current_dataset.dqy_data = data_set.flatten()
+                self.current_dataset.yaxis("Q_y", unit)
+        elif key == self.mask_name:
+            self.current_dataset.mask = data_set.flatten()
+        elif key == u'Qy':
+            self.current_dataset.yaxis("Q_y", unit)
+            self.current_dataset.qy_data = data_set.flatten()
+        elif key == u'Qydev':
+            self.current_dataset.dqy_data = data_set.flatten()
+        elif key == u'Qx':
+            self.current_dataset.xaxis("Q_x", unit)
+            self.current_dataset.qx_data = data_set.flatten()
+        elif key == u'Qxdev':
+            self.current_dataset.dqx_data = data_set.flatten()
+    def process_trans_spectrum(self, data_set, key):
+        """
+        SAStransmission_spectrum processor
+        :param data_set: data from HDF5 file
+        :param key: canSAS_class attribute
+        """
+        if key == u'T':
+            self.trans_spectrum.transmission = data_set.flatten()
+        elif key == u'Tdev':
+            self.trans_spectrum.transmission_deviation = data_set.flatten()
+        elif key == u'lambda':
+            self.trans_spectrum.wavelength = data_set.flatten()
+    def process_sample(self, data_point, key):
+        """
+        SASsample processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        """
+        if key == u'Title':
+            self.current_datainfo.sample.name = data_point
+        elif key == u'name':
+            self.current_datainfo.sample.name = data_point
+        elif key == u'ID':
+            self.current_datainfo.sample.name = data_point
+        elif key == u'thickness':
+            self.current_datainfo.sample.thickness = data_point
+        elif key == u'temperature':
+            self.current_datainfo.sample.temperature = data_point
+        elif key == u'transmission':
+            self.current_datainfo.sample.transmission = data_point
+        elif key == u'x_position':
+            self.current_datainfo.sample.position.x = data_point
+        elif key == u'y_position':
+            self.current_datainfo.sample.position.y = data_point
+        elif key == u'pitch':
+            self.current_datainfo.sample.orientation.x = data_point
+        elif key == u'yaw':
+            self.current_datainfo.sample.orientation.y = data_point
+        elif key == u'roll':
+            self.current_datainfo.sample.orientation.z = data_point
+        elif key == u'details':
+            self.current_datainfo.sample.details.append(data_point)
+    def process_detector(self, data_point, key, unit):
+        """
+        SASdetector processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        :param unit: unit attribute from data set
+        """
+        if key == u'name':
+            self.detector.name = data_point
+        elif key == u'SDD':
+            self.detector.distance = float(data_point)
+            self.detector.distance_unit = unit
+        elif key == u'slit_length':
+            self.detector.slit_length = float(data_point)
+            self.detector.slit_length_unit = unit
+        elif key == u'x_position':
+            self.detector.offset.x = float(data_point)
+            self.detector.offset_unit = unit
+        elif key == u'y_position':
+            self.detector.offset.y = float(data_point)
+            self.detector.offset_unit = unit
+        elif key == u'pitch':
+            self.detector.orientation.x = float(data_point)
+            self.detector.orientation_unit = unit
+        elif key == u'roll':
+            self.detector.orientation.z = float(data_point)
+            self.detector.orientation_unit = unit
+        elif key == u'yaw':
+            self.detector.orientation.y = float(data_point)
+            self.detector.orientation_unit = unit
+        elif key == u'beam_center_x':
+            self.detector.beam_center.x = float(data_point)
+            self.detector.beam_center_unit = unit
+        elif key == u'beam_center_y':
+            self.detector.beam_center.y = float(data_point)
+            self.detector.beam_center_unit = unit
+        elif key == u'x_pixel_size':
+            self.detector.pixel_size.x = float(data_point)
+            self.detector.pixel_size_unit = unit
+        elif key == u'y_pixel_size':
+            self.detector.pixel_size.y = float(data_point)
+            self.detector.pixel_size_unit = unit
+    def process_collimation(self, data_point, key, unit):
+        """
+        SAScollimation processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        :param unit: unit attribute from data set
+        """
+        if key == u'distance':
+            self.collimation.length = data_point
+            self.collimation.length_unit = unit
+        elif key == u'name':
+            self.collimation.name = data_point
+    def process_aperture(self, data_point, key):
+        """
+        SASaperture processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        """
+        if key == u'shape':
+            self.aperture.shape = data_point
+        elif key == u'x_gap':
+            self.aperture.size.x = data_point
+        elif key == u'y_gap':
+            self.aperture.size.y = data_point
+    def process_source(self, data_point, key, unit):
+        """
+        SASsource processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        :param unit: unit attribute from data set
+        """
+        if key == u'incident_wavelength':
+            self.current_datainfo.source.wavelength = data_point
+            self.current_datainfo.source.wavelength_unit = unit
+        elif key == u'wavelength_max':
+            self.current_datainfo.source.wavelength_max = data_point
+            self.current_datainfo.source.wavelength_max_unit = unit
+        elif key == u'wavelength_min':
+            self.current_datainfo.source.wavelength_min = data_point
+            self.current_datainfo.source.wavelength_min_unit = unit
+        elif key == u'incident_wavelength_spread':
+            self.current_datainfo.source.wavelength_spread = data_point
+            self.current_datainfo.source.wavelength_spread_unit = unit
+        elif key == u'beam_size_x':
+            self.current_datainfo.source.beam_size.x = data_point
+            self.current_datainfo.source.beam_size_unit = unit
+        elif key == u'beam_size_y':
+            self.current_datainfo.source.beam_size.y = data_point
+            self.current_datainfo.source.beam_size_unit = unit
+        elif key == u'beam_shape':
+            self.current_datainfo.source.beam_shape = data_point
+        elif key == u'radiation':
+            self.current_datainfo.source.radiation = data_point
+    def process_process(self, data_point, key):
+        """
+        SASprocess processor
+        :param data_point: Single point from an HDF5 data file
+        :param key: class name data_point was taken from
+        """
+        term_match = re.compile(u'^term[0-9]+$')
+        if key == u'Title':  # CanSAS 2.0
+            self.process.name = data_point
+        elif key == u'name':  # NXcanSAS
+            self.process.name = data_point
+        elif key == u'description':
+            self.process.description = data_point
+        elif key == u'date':
+            self.process.date = data_point
+        elif term_match.match(key):
+            self.process.term.append(data_point)
+        else:
+            self.process.notes.append(data_point)
     def add_intermediate(self):
 …
             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:
 …
             if dataset.data.ndim == 2:
                 (n_rows, n_cols) = dataset.data.shape
+                dataset.y_bins = dataset.qy_data[0::n_cols]
+                dataset.x_bins = dataset.qx_data[:n_cols]
+                flat_qy = dataset.qy_data[0::n_cols].flatten()
+                # For 2D arrays of Qx and Qy, the Q value should be constant
+                # along each row -OR- each column. The direction is not
+                # specified in the NXcanSAS standard.
+                if flat_qy[0] == flat_qy[1]:
+                    flat_qy = np.transpose(dataset.qy_data)[0::n_cols].flatten()
+                dataset.y_bins = np.unique(flat_qy)
+                flat_qx = dataset.qx_data[0::n_rows].flatten()
+                # For 2D arrays of Qx and Qy, the Q value should be constant
+                # along each row -OR- each column. The direction is not
+                # specified in the NXcanSAS standard.
+                if flat_qx[0] == flat_qx[1]:
+                    flat_qx = np.transpose(dataset.qx_data)[0::n_rows].flatten()
+                dataset.x_bins = np.unique(flat_qx)
                 dataset.data = dataset.data.flatten()
+                dataset.qx_data = dataset.qx_data.flatten()
+                dataset.qy_data = dataset.qy_data.flatten()
             self.current_dataset = dataset
             self.send_to_output()
 …
         self.current_datainfo = DataInfo()
+    def _initialize_new_data_set(self, parent_list=None):
+    def _initialize_new_data_set(self, value=None):
         """
         A private class method to generate a new 1D or 2D data object based on
 …
         :param parent_list: List of names of parent elements
         """
+        if parent_list is None:
+            parent_list = []
+        if self._find_intermediate(parent_list, "Qx"):
+        if self._is2d(value):
             self.current_dataset = plottable_2D()
         else:
 …
             self.current_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 = u''
+        self.i_name = u''
+        self.i_node = u''
+        self.i_uncertainties_name = u''
+        self.q_names = []
+        self.q_uncertainty_names = []
+        self.q_resolution_names = []
+    @staticmethod
+    def check_is_list_or_array(iterable):
+        try:
+            iter(iterable)
+            if (not isinstance(iterable, np.ndarray) and not isinstance(
+                    iterable, list)) or (isinstance(iterable, basestring)):
+                raise TypeError
+        except TypeError:
+            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_names.append(i_axes[val])
+        self.i_name = signal
+        self.i_node = value.get(self.i_name)
+        for item in self.q_names:
+            if item in keys:
+                q_vals = value.get(item)
+                if q_vals.attrs.get("uncertainties") is not None:
+                    self.q_uncertainty_names = q_vals.attrs.get("uncertainties")
+                elif q_vals.attrs.get("uncertainty") is not None:
+                    self.q_uncertainty_names = q_vals.attrs.get("uncertainty")
+                if isinstance(self.q_uncertainty_names, basestring):
+                    self.q_uncertainty_names = self.q_uncertainty_names.split(",")
+                if q_vals.attrs.get("resolutions") is not None:
+                    self.q_resolution_names = q_vals.attrs.get("resolutions")
+                if isinstance(self.q_resolution_names, basestring):
+                    self.q_resolution_names = self.q_resolution_names.split(",")
+        if self.i_name in keys:
+            i_vals = value.get(self.i_name)
+            self.i_uncertainties_name = i_vals.attrs.get("uncertainties")
+            if self.i_uncertainties_name is None:
+                self.i_uncertainties_name = i_vals.attrs.get("uncertainty")
+    def _is2d(self, value, 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):
 …
         if unit is None:
             unit = h5attr(value, u'unit')
-        # Convert the unit formats
-        if unit == "1/A":
-            unit = "A^{-1}"
-        elif unit == "1/cm":
-            unit = "cm^{-1}"
         return unit

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

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

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

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

src/sas/sascalc/file_converter/nxcansas_writer.py

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

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

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

SasView

Changeset 845144e in sasview for src/sas

Legend:

src/sas/sascalc/fit/pagestate.py

src/sas/sasgui/guiframe/aboutbox.py

src/sas/sasgui/guiframe/config.py

src/sas/sasgui/guiframe/gui_manager.py

src/sas/sasgui/perspectives/corfunc/corfunc_panel.py

src/sas/sasgui/perspectives/corfunc/corfunc_state.py

src/sas/sasgui/perspectives/corfunc/media/corfunc_help.rst

src/sas/sasgui/perspectives/corfunc/media/fdr-pdfs.rst

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

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

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

src/sas/sasgui/perspectives/invariant/invariant_state.py

src/sas/sasview/local_config.py

src/sas/sascalc/data_util/nxsunit.py

src/sas/sascalc/dataloader/data_info.py

src/sas/sascalc/dataloader/file_reader_base_class.py

src/sas/sascalc/dataloader/loader.py

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

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

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

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

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

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

src/sas/sascalc/file_converter/nxcansas_writer.py

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

Download in other formats: