Changeset c416a17 in sasview for src/sas/sasgui/perspectives/fitting

Timestamp:

May 26, 2017 7:41:44 AM (8 years ago)

Author:

Piotr Rozyczko <rozyczko@…>

Branches:

ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

c1e380e

Parents:

6964d44 (diff), 7132e49 (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 ESS_GUI

Location:

src/sas/sasgui/perspectives/fitting

Files:

• basepage.py (modified) (45 diffs)
• batchfitpage.py (modified) (5 diffs)
• fit_thread.py (modified) (3 diffs)
• fitpage.py (modified) (41 diffs)
• fitting.py (modified) (50 diffs)
• media/plugin.rst (modified) (1 diff)
• model_thread.py (modified) (9 diffs)
• models.py (modified) (10 diffs)
• pagestate.py (modified) (24 diffs)
• report_dialog.py (modified) (1 diff)
• utils.py (modified) (2 diffs)

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

@@ -2 +2 @@
 Base Page for fitting
 """
+from __future__ import print_function
+
 import sys
 import os
 import wx
-import numpy
+import numpy as np
 import time
 import copy
@@ -34 +36 @@
 from sas.sasgui.guiframe.documentation_window import DocumentationWindow
 
+logger = logging.getLogger(__name__)
 
 (PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
@@ -53 +56 @@
     ON_MAC = True
 
+CUSTOM_MODEL = 'Plugin Models'
+
 class BasicPage(ScrolledPanel, PanelBase):
     """
-    This class provide general structure of  fitpanel page
+    This class provide general structure of the fitpanel page
     """
     # Internal name for the AUI manager
@@ -98 +103 @@
         self.graph_id = None
         # Q range for data set
-        self.qmin_data_set = numpy.inf
+        self.qmin_data_set = np.inf
         self.qmax_data_set = None
         self.npts_data_set = 0
@@ -118 +123 @@
         self.dxw = None
         # pinhole smear
-        self.dx_min = None
-        self.dx_max = None
+        self.dx_percent = None
         # smear attrbs
         self.enable_smearer = None
@@ -277 +281 @@
 
         """
-        x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x,
+        x = np.linspace(start=self.qmin_x, stop=self.qmax_x,
                            num=self.npts_x, endpoint=True)
         self.data = Data1D(x=x)
@@ -294 +298 @@
         """
         if self.qmin_x >= 1.e-10:
-            qmin = numpy.log10(self.qmin_x)
+            qmin = np.log10(self.qmin_x)
         else:
             qmin = -10.
 
         if self.qmax_x <= 1.e10:
-            qmax = numpy.log10(self.qmax_x)
+            qmax = np.log10(self.qmax_x)
         else:
             qmax = 10.
 
-        x = numpy.logspace(start=qmin, stop=qmax,
+        x = np.logspace(start=qmin, stop=qmax,
                            num=self.npts_x, endpoint=True, base=10.0)
         self.data = Data1D(x=x)
@@ -340 +344 @@
         qstep = self.npts_x
 
-        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
-        y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
+        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
+        y = np.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
         # use data info instead
-        new_x = numpy.tile(x, (len(y), 1))
-        new_y = numpy.tile(y, (len(x), 1))
+        new_x = np.tile(x, (len(y), 1))
+        new_y = np.tile(y, (len(x), 1))
         new_y = new_y.swapaxes(0, 1)
         # all data reuire now in 1d array
         qx_data = new_x.flatten()
         qy_data = new_y.flatten()
-        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
+        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data)
         # set all True (standing for unmasked) as default
-        mask = numpy.ones(len(qx_data), dtype=bool)
+        mask = np.ones(len(qx_data), dtype=bool)
         # store x and y bin centers in q space
         x_bins = x
@@ -357 +361 @@
 
         self.data.source = Source()
-        self.data.data = numpy.ones(len(mask))
-        self.data.err_data = numpy.ones(len(mask))
+        self.data.data = np.ones(len(mask))
+        self.data.err_data = np.ones(len(mask))
         self.data.qx_data = qx_data
         self.data.qy_data = qy_data
@@ -655 +659 @@
         # It seems MAC needs wxCallAfter
         if event.GetId() == GUIFRAME_ID.COPYEX_ID:
-            print "copy excel"
+            print("copy excel")
             wx.CallAfter(self.get_copy_excel)
         elif event.GetId() == GUIFRAME_ID.COPYLAT_ID:
-            print "copy latex"
+            print("copy latex")
             wx.CallAfter(self.get_copy_latex)
         else:
@@ -677 +681 @@
     def _copy_info(self, flag):
         """
-        Send event dpemding on flag
-
-        : Param flag: flag that distinguish event
+        Send event depending on flag
+
+        : Param flag: flag that distinguishes the event
         """
         # messages depending on the flag
@@ -781 +785 @@
                 except Exception:
                     # Skip non-data lines
-                    logging.error(traceback.format_exc())
-            return numpy.array(angles), numpy.array(weights)
+                    logger.error(traceback.format_exc())
+            return np.array(angles), np.array(weights)
         except:
             raise
@@ -847 +851 @@
         self.state.pinhole_smearer = \
                                 copy.deepcopy(self.pinhole_smearer.GetValue())
-        self.state.dx_max = copy.deepcopy(self.dx_max)
-        self.state.dx_min = copy.deepcopy(self.dx_min)
+        self.state.dx_percent = copy.deepcopy(self.dx_percent)
         self.state.dxl = copy.deepcopy(self.dxl)
         self.state.dxw = copy.deepcopy(self.dxw)
@@ -1105 +1108 @@
         """
         for key, value in self.master_category_dict.iteritems():
+            formfactor = state.formfactorcombobox.split(":")
+            if isinstance(formfactor, list):
+                formfactor = formfactor[0]
             for list_item in value:
-                if state.formfactorcombobox in list_item:
+                if formfactor in list_item:
                     return self.categorybox.Items.index(key)
         return 0
@@ -1116 +1122 @@
         :precondition: the page is already drawn or created
 
-        :postcondition: the state of the underlying data change as well as the
+        :postcondition: the state of the underlying data changes as well as the
             state of the graphic interface
         """
@@ -1152 +1158 @@
         self._show_combox_helper()
         # select the current model
-        try:
-            # to support older version
-            category_pos = int(state.categorycombobox)
-        except:
-            state.formfactorcombobox = state.formfactorcombobox.lower()
-            state.formfactorcombobox = \
-                state.formfactorcombobox.replace('model', '')
-            state.formfactorcombobox = unicode(state.formfactorcombobox)
-            state.categorycombobox = unicode(state.categorycombobox)
-            if state.categorycombobox in self.categorybox.Items:
-                category_pos = self.categorybox.Items.index(
-                    state.categorycombobox)
-            else:
-                # Look in master list for model name (model.lower)
-                category_pos = self.get_cat_combo_box_pos(state)
+        state._convert_to_sasmodels()
+        state.categorycombobox = unicode(state.categorycombobox)
+        if state.categorycombobox in self.categorybox.Items:
+            category_pos = self.categorybox.Items.index(
+                state.categorycombobox)
+        else:
+            # Look in master list for model name (model.lower)
+            category_pos = self.get_cat_combo_box_pos(state)
 
         self.categorybox.Select(category_pos)
         self._show_combox(None)
-        try:
-            # to support older version
-            formfactor_pos = int(state.formfactorcombobox)
-        except:
-            formfactor_pos = 0
-            for ind_form in range(self.formfactorbox.GetCount()):
-                if self.formfactorbox.GetString(ind_form) == \
-                                                    (state.formfactorcombobox):
-                    formfactor_pos = int(ind_form)
+        from models import PLUGIN_NAME_BASE
+        if self.categorybox.GetValue() == CUSTOM_MODEL \
+                and PLUGIN_NAME_BASE not in state.formfactorcombobox:
+            state.formfactorcombobox = \
+                PLUGIN_NAME_BASE + state.formfactorcombobox
+        formfactor_pos = 0
+        for ind_form in range(self.formfactorbox.GetCount()):
+            if self.formfactorbox.GetString(ind_form) == \
+                                                (state.formfactorcombobox):
+                formfactor_pos = int(ind_form)
+                break
+
+        self.formfactorbox.Select(formfactor_pos)
+
+        structfactor_pos = 0
+        if state.structurecombobox is not None:
+            state.structurecombobox = unicode(state.structurecombobox)
+            for ind_struct in range(self.structurebox.GetCount()):
+                if self.structurebox.GetString(ind_struct) == \
+                                                (state.structurecombobox):
+                    structfactor_pos = int(ind_struct)
                     break
-
-        self.formfactorbox.Select(formfactor_pos)
-
-        structfactor_pos = 0
-        try:
-            # to support older version
-            structfactor_pos = int(state.structurecombobox)
-        except:
-            if state.structurecombobox is not None:
-                state.structurecombobox = unicode(state.structurecombobox)
-                for ind_struct in range(self.structurebox.GetCount()):
-                    if self.structurebox.GetString(ind_struct) == \
-                                                    (state.structurecombobox):
-                        structfactor_pos = int(ind_struct)
-                        break
 
         self.structurebox.SetSelection(structfactor_pos)
@@ -1252 +1248 @@
         # we have two more options for smearing
         if self.pinhole_smearer.GetValue():
-            self.dx_min = state.dx_min
-            self.dx_max = state.dx_max
-            if self.dx_min is not None:
-                self.smear_pinhole_min.SetValue(str(self.dx_min))
-            if self.dx_max is not None:
-                self.smear_pinhole_max.SetValue(str(self.dx_max))
+            self.dx_percent = state.dx_percent
+            if self.dx_percent is not None:
+                if state.dx_old:
+                    self.dx_percent = 100 * (self.dx_percent / self.data.x[0])
+                self.smear_pinhole_percent.SetValue("%.2f" % self.dx_percent)
             self.onPinholeSmear(event=None)
         elif self.slit_smearer.GetValue():
@@ -1312 +1307 @@
                     [state.values, state.weights]
             except Exception:
-                logging.error(traceback.format_exc())
+                logger.error(traceback.format_exc())
             selection = self._find_polyfunc_selection(disp_model)
             for list in self.fittable_param:
@@ -1329 +1324 @@
                             list[6].Disable()
                         except Exception:
-                            logging.error(traceback.format_exc())
+                            logger.error(traceback.format_exc())
             # For array, disable all fixed params
             if selection == 1:
@@ -1338 +1333 @@
                             item[2].Disable()
                         except Exception:
-                            logging.error(traceback.format_exc())
+                            logger.error(traceback.format_exc())
 
     def _selectDlg(self):
         """
-        open a dialog file to selected the customized dispersity
+        open a dialog file to select the customized polydispersity function
         """
         if self.parent is not None:
@@ -1384 +1379 @@
         # self.state.struct_rbutton = self.struct_rbutton.GetValue()
         # self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
-        self.state.structurecombobox = self.structurebox.GetLabel()
-        self.state.formfactorcombobox = self.formfactorbox.GetLabel()
-        self.state.categorycombobox = self.categorybox.GetLabel()
+        self.state.structurecombobox = self.structurebox.GetValue()
+        self.state.formfactorcombobox = self.formfactorbox.GetValue()
+        self.state.categorycombobox = self.categorybox.GetValue()
 
         # post state to fit panel
@@ -1457 +1452 @@
                 self.state_change = True
                 self._draw_model()
-                # Time delay has been introduced to prevent _handle error
-                # on Windows
-                # This part of code is executed when model is selected and
-                # it's parameters are changed (with respect to previously
-                # selected model). There are two Iq evaluations occuring one
-                # after another and therefore there may be compilation error
-                # if model is calculated for the first time.
-                # This seems to be Windows only issue - haven't tested on Linux
-                # though.The proper solution (other than time delay) requires
-                # more fundemental code refatoring
-                # Wojtek P. Nov 7, 2016
-                if not ON_MAC:
-                    time.sleep(0.1)
                 self.Refresh()
 
-        # logging.info("is_modified flag set to %g",is_modified)
+        # logger.info("is_modified flag set to %g",is_modified)
         return is_modified
 
@@ -1576 +1558 @@
             self.save_current_state()
         except Exception:
-            logging.error(traceback.format_exc())
+            logger.error(traceback.format_exc())
 
         return flag, is_modified
@@ -1586 +1568 @@
         if len(statelist) == 0 or len(listtorestore) == 0:
             return
-        if len(statelist) != len(listtorestore):
-            return
 
         for j in range(len(listtorestore)):
-            item_page = listtorestore[j]
-            item_page_info = statelist[j]
-            # change the state of the check box for simple parameters
-            if item_page[0] is not None:
-                item_page[0].SetValue(item_page_info[0])
-            if item_page[2] is not None:
-                item_page[2].SetValue(item_page_info[2])
-                if item_page[2].__class__.__name__ == "ComboBox":
-                    if item_page_info[2] in self.model.fun_list:
-                        fun_val = self.model.fun_list[item_page_info[2]]
-                        self.model.setParam(item_page_info[1], fun_val)
-            if item_page[3] is not None:
-                # show or hide text +/-
-                if item_page_info[2]:
-                    item_page[3].Show(True)
-                else:
-                    item_page[3].Hide()
-            if item_page[4] is not None:
-                # show of hide the text crtl for fitting error
-                if item_page_info[4][0]:
-                    item_page[4].Show(True)
-                    item_page[4].SetValue(item_page_info[4][1])
-                else:
-                    item_page[3].Hide()
-            if item_page[5] is not None:
-                # show of hide the text crtl for fitting error
-                item_page[5].Show(item_page_info[5][0])
-                item_page[5].SetValue(item_page_info[5][1])
-
-            if item_page[6] is not None:
-                # show of hide the text crtl for fitting error
-                item_page[6].Show(item_page_info[6][0])
-                item_page[6].SetValue(item_page_info[6][1])
+            for param in statelist:
+                if param[1] == listtorestore[j][1]:
+                    item_page = listtorestore[j]
+                    item_page_info = param
+                    if (item_page_info[1] == "theta" or item_page_info[1] ==
+                            "phi") and not self._is_2D():
+                        break
+                    # change the state of the check box for simple parameters
+                    if item_page[0] is not None:
+                        item_page[0].SetValue(item_page_info[0])
+                    if item_page[2] is not None:
+                        item_page[2].SetValue(item_page_info[2])
+                        if item_page[2].__class__.__name__ == "ComboBox":
+                            if item_page_info[2] in self.model.fun_list:
+                                fun_val = self.model.fun_list[item_page_info[2]]
+                                self.model.setParam(item_page_info[1], fun_val)
+                    if item_page[3] is not None:
+                        # show or hide text +/-
+                        if item_page_info[2]:
+                            item_page[3].Show(True)
+                        else:
+                            item_page[3].Hide()
+                    if item_page[4] is not None:
+                        # show of hide the text crtl for fitting error
+                        if item_page_info[4][0]:
+                            item_page[4].Show(True)
+                            item_page[4].SetValue(str(item_page_info[4][1]))
+                        else:
+                            item_page[3].Hide()
+                    if item_page[5] is not None:
+                        # show of hide the text crtl for fitting error
+                        item_page[5].Show(True)
+                        item_page[5].SetValue(str(item_page_info[5][1]))
+                    if item_page[6] is not None:
+                        # show of hide the text crtl for fitting error
+                        item_page[6].Show(True)
+                        item_page[6].SetValue(str(item_page_info[6][1]))
+                    break
 
     def _reset_strparam_state(self, listtorestore, statelist):
@@ -1763 +1748 @@
     def _set_multfactor_combobox(self, multiplicity=10):
         """
-        Set comboBox for muitfactor of CoreMultiShellModel
+        Set comboBox for multitfactor of CoreMultiShellModel
         :param multiplicit: no. of multi-functionality
         """
@@ -1801 +1786 @@
         Fill panel's combo box according to the type of model selected
         """
-        custom_model = 'Customized Models'
+
         mod_cat = self.categorybox.GetStringSelection()
         self.structurebox.SetSelection(0)
@@ -1810 +1795 @@
         m_list = []
         try:
-            if mod_cat == custom_model:
+            if mod_cat == CUSTOM_MODEL:
                 for model in self.model_list_box[mod_cat]:
                     m_list.append(self.model_dict[model.name])
@@ -2125 +2110 @@
         for data in self.data_list:
             # q value from qx and qy
-            radius = numpy.sqrt(data.qx_data * data.qx_data +
+            radius = np.sqrt(data.qx_data * data.qx_data +
                                 data.qy_data * data.qy_data)
             # get unmasked index
@@ -2131 +2116 @@
                          (radius <= float(self.qmax.GetValue()))
             index_data = (index_data) & (data.mask)
-            index_data = (index_data) & (numpy.isfinite(data.data))
+            index_data = (index_data) & (np.isfinite(data.data))
 
             if len(index_data[index_data]) < 10:
@@ -2166 +2151 @@
             index_data = (float(self.qmin.GetValue()) <= radius) & \
                          (radius <= float(self.qmax.GetValue()))
-            index_data = (index_data) & (numpy.isfinite(data.y))
+            index_data = (index_data) & (np.isfinite(data.y))
 
             if len(index_data[index_data]) < 5:
@@ -2238 +2223 @@
 
                 # Check that min is less than max
-                low = -numpy.inf if min_str == "" else float(min_str)
-                high = numpy.inf if max_str == "" else float(max_str)
+                low = -np.inf if min_str == "" else float(min_str)
+                high = np.inf if max_str == "" else float(max_str)
                 if high < low:
                     min_ctrl.SetBackgroundColour("pink")
@@ -2389 +2374 @@
                     self.model.set_dispersion(p, disp_model)
                 except Exception:
-                    logging.error(traceback.format_exc())
+                    logger.error(traceback.format_exc())
 
         # save state into
@@ -2504 +2489 @@
             self.Refresh()
         except Exception:
-            logging.error(traceback.format_exc())
+            logger.error(traceback.format_exc())
             # Error msg
             msg = "Error occurred:"
@@ -2605 +2590 @@
                 del self.state.model._persistency_dict[name.split('.')[0]]
         except Exception:
-            logging.error(traceback.format_exc())
+            logger.error(traceback.format_exc())
 
     def _lay_out(self):
@@ -2614 +2599 @@
             Layout is called after fitting.
         """
-        self._sleep4sec()
         self.Layout()
         return
-
-    def _sleep4sec(self):
-        """
-            sleep for 1 sec only applied on Mac
-            Note: This 1sec helps for Mac not to crash on self.
-            Layout after self._draw_model
-        """
-        if ON_MAC:
-            time.sleep(1)
 
     def _find_polyfunc_selection(self, disp_func=None):
@@ -2659 +2634 @@
             self.qmin_x = data_min
             self.qmax_x = math.sqrt(x * x + y * y)
-            # self.data.mask = numpy.ones(len(self.data.data),dtype=bool)
+            # self.data.mask = np.ones(len(self.data.data),dtype=bool)
             # check smearing
             if not self.disable_smearer.GetValue():
@@ -2747 +2722 @@
             except Exception:
                 # Not for control panels
-                logging.error(traceback.format_exc())
+                logger.error(traceback.format_exc())
         # Make sure the resduals plot goes to the last
         if res_item is not None:
@@ -3080 +3055 @@
                     disfunc = str(item[7].GetValue())
             except Exception:
-                logging.error(traceback.format_exc())
+                logger.error(traceback.format_exc())
 
             # 2D
@@ -3123 +3098 @@
                         disfunc += ' ' + str(weight)
             except Exception:
-                logging.error(traceback.format_exc())
+                logger.error(traceback.format_exc())
             content += name + ',' + str(check) + ',' + value + disfunc + ',' + \
                        bound_lo + ',' + bound_hi + ':'
@@ -3371 +3346 @@
 
             if value[1] == 'array':
-                pd_vals = numpy.array(value[2])
-                pd_weights = numpy.array(value[3])
+                pd_vals = np.array(value[2])
+                pd_weights = np.array(value[3])
                 if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights):
                     msg = ("bad array distribution parameters for %s"
@@ -3394 +3369 @@
 
         except Exception:
-            logging.error(traceback.format_exc())
-            print "Error in BasePage._paste_poly_help: %s" % \
-                  sys.exc_info()[1]
+            logger.error(traceback.format_exc())
+            print("Error in BasePage._paste_poly_help: %s" % \
+                  sys.exc_info()[1])
 
     def _set_disp_cb(self, isarray, item):
@@ -3425 +3400 @@
             Moveit; This method doesn't belong here
         """
-        print "BasicPage.update_pinhole_smear was called: skipping"
+        print("BasicPage.update_pinhole_smear was called: skipping")
         return
 
@@ -3457 +3432 @@
         fills out the category list box
         """
-        uncat_str = 'Customized Models'
+        uncat_str = 'Plugin Models'
         self._read_category_info()
 
@@ -3486 +3461 @@
         self.model_box.Clear()
 
-        if category == 'Customized Models':
+        if category == 'Plugin Models':
             for model in self.model_list_box[category]:
                 str_m = str(model).split(".")[0]
@@ -3601 +3576 @@
         # check model type to show sizer
         if self.model is not None:
-            print "_set_model_sizer_selection: disabled."
+            print("_set_model_sizer_selection: disabled.")
             # self._set_model_sizer_selection(self.model)
 

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

@@ -200 +200 @@
 #         self.state.formfactorcombobox = self.formfactorbox.GetCurrentSelection()
 #       
-#         if self.model != None:
+#         if self.model is not None:
 #             self._set_copy_flag(True)
 #             self._set_paste_flag(True)
-#             if self.data != None:
+#             if self.data is not None:
 #                 self._set_bookmark_flag(False)
 #                 self._keep.Enable(False)
@@ -225 +225 @@
 # 
 #             
-#         if event != None:
+#         if event is not None:
 #             ## post state to fit panel
 #             new_event = PageInfoEvent(page = self)
@@ -254 +254 @@
 #         is_modified = False
 # 
-#         if self.model != None:           
+#         if self.model is not None:
 #             ##Check the values
 #             self._check_value_enter( self.fittable_param)
@@ -291 +291 @@
 #         else:
 #             #self.btFit.Enable(True)
-#             if self._is_2D() and  self.data != None:
+#             if self._is_2D() and  self.data is not None:
 #                 self.btEditMask.Enable(True)
 # 
@@ -335 +335 @@
 #             self._set_save_flag(False)
 #         else:
-#             if self.model != None:
+#             if self.model is not None:
 #                 self._set_bookmark_flag(False)
 #                 self._keep.Enable(False)

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

@@ -1 @@
-
 import sys
 import time
@@ -89 +88 @@
                           elapsed=time.time() - self.starttime)
 
-            return result[0], time.time()-self.starttime
-
         except KeyboardInterrupt, msg:
             # Thread was interrupted, just proceed and re-raise.
@@ -102 +99 @@
             if self.handler is not None:
                 self.handler.stop(msg=msg)
-        except Exception as ex:
-            #print "EXCEPTION: ", ex
+        except:
             import traceback
             if self.handler is not None:
                 self.handler.error(msg=traceback.format_exc())
-
-
-

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

@@ -6 +6 @@
 import wx
 import wx.lib.newevent
-import numpy
+import numpy as np
 import copy
 import math
@@ -29 +29 @@
 _BOX_WIDTH = 76
 _DATA_BOX_WIDTH = 300
-SMEAR_SIZE_L = 0.00
 SMEAR_SIZE_H = 0.00
-
+CUSTOM_MODEL = 'Plugin Models'
 
 class FitPage(BasicPage):
@@ -164 +163 @@
         On_select_data
         """
-        if event is None and self.dataSource.GetCount() > 0:
-            data = self.dataSource.GetClientData(0)
-            self.set_data(data)
-        elif self.dataSource.GetCount() > 0:
-            pos = self.dataSource.GetSelection()
+        if self.dataSource.GetCount() > 0:
+            pos = self.dataSource.GetSelection() if event is not None else 0
             data = self.dataSource.GetClientData(pos)
             self.set_data(data)
@@ -213 +209 @@
               "Please enter only the value of interest to customize smearing..."
         smear_message_new_psmear = \
-              "Please enter both; the dQ will be generated by interpolation..."
+              "Please enter a fixed percentage to be applied to all Q values..."
         smear_message_2d_x_title = "<dQp>[1/A]:"
         smear_message_2d_y_title = "<dQs>[1/A]:"
-        smear_message_pinhole_min_title = "dQ_low[1/A]:"
-        smear_message_pinhole_max_title = "dQ_high[1/A]:"
+        smear_message_pinhole_percent_title = "dQ[%]:"
         smear_message_slit_height_title = "Slit height[1/A]:"
         smear_message_slit_width_title = "Slit width[1/A]:"
@@ -256 +251 @@
         self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
                   id=self.dI_idata.GetId())
-        self.dI_didata.SetValue(True)
+        self.dI_noweight.SetValue(True)
         # add 4 types of weighting to the sizer
         sizer_weighting.Add(self.dI_noweight, 0, wx.LEFT, 10)
@@ -266 +261 @@
         sizer_weighting.Add(self.dI_idata)
         sizer_weighting.Add((10, 10))
-        self.dI_noweight.Enable(False)
+        self.dI_noweight.Enable(True)
         self.dI_didata.Enable(False)
         self.dI_sqrdata.Enable(False)
@@ -310 +305 @@
         
         # textcntrl for custom resolution
-        self.smear_pinhole_max = ModelTextCtrl(self, wx.ID_ANY,
-                            size=(_BOX_WIDTH - 25, 20),
-                            style=wx.TE_PROCESS_ENTER,
-                            text_enter_callback=self.onPinholeSmear)
-        self.smear_pinhole_min = ModelTextCtrl(self, wx.ID_ANY,
-                            size=(_BOX_WIDTH - 25, 20),
-                            style=wx.TE_PROCESS_ENTER,
-                            text_enter_callback=self.onPinholeSmear)
+        self.smear_pinhole_percent = ModelTextCtrl(self, wx.ID_ANY,
+                                                   size=(_BOX_WIDTH - 25, 20),
+                                                   style=wx.TE_PROCESS_ENTER,
+                                                   text_enter_callback=
+                                                   self.onPinholeSmear)
         self.smear_slit_height = ModelTextCtrl(self, wx.ID_ANY,
                             size=(_BOX_WIDTH - 25, 20),
@@ -336 +328 @@
 
         # set default values for smear
-        self.smear_pinhole_max.SetValue(str(self.dx_max))
-        self.smear_pinhole_min.SetValue(str(self.dx_min))
+        self.smear_pinhole_percent.SetValue(str(self.dx_percent))
         self.smear_slit_height.SetValue(str(self.dxl))
         self.smear_slit_width.SetValue(str(self.dxw))
@@ -362 +353 @@
         self.Bind(wx.EVT_RADIOBUTTON, self.onSlitSmear,
                   id=self.slit_smearer.GetId())
-        self.enable_smearer.SetValue(True)
+        self.disable_smearer.SetValue(True)
 
         sizer_smearer.Add(self.disable_smearer, 0, wx.LEFT, 10)
@@ -429 +420 @@
         self.smear_description_2d_y.SetToolTipString(
                                     " dQs(perpendicular) in q_phi direction.")
-        self.smear_description_pin_min = wx.StaticText(self, wx.ID_ANY,
-                        smear_message_pinhole_min_title, style=wx.ALIGN_LEFT)
-        self.smear_description_pin_max = wx.StaticText(self, wx.ID_ANY,
-                        smear_message_pinhole_max_title, style=wx.ALIGN_LEFT)
+        self.smear_description_pin_percent = wx.StaticText(self, wx.ID_ANY,
+                                            smear_message_pinhole_percent_title,
+                                            style=wx.ALIGN_LEFT)
         self.smear_description_slit_height = wx.StaticText(self, wx.ID_ANY,
                         smear_message_slit_height_title, style=wx.ALIGN_LEFT)
@@ -456 +446 @@
         self.sizer_new_smear.Add((15, -1))
         self.sizer_new_smear.Add(self.smear_description_2d_x, 0, wx.CENTER, 10)
-        self.sizer_new_smear.Add(self.smear_description_pin_min,
-                                 0, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_description_slit_height,
                                  0, wx.CENTER, 10)
 
-        self.sizer_new_smear.Add(self.smear_pinhole_min, 0, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_slit_height, 0, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_data_left, 0, wx.CENTER, 10)
@@ -467 +454 @@
         self.sizer_new_smear.Add(self.smear_description_2d_y,
                                  0, wx.CENTER, 10)
-        self.sizer_new_smear.Add(self.smear_description_pin_max,
+        self.sizer_new_smear.Add(self.smear_description_pin_percent,
                                  0, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_description_slit_width,
                                  0, wx.CENTER, 10)
 
-        self.sizer_new_smear.Add(self.smear_pinhole_max, 0, wx.CENTER, 10)
+        self.sizer_new_smear.Add(self.smear_pinhole_percent, 0, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_slit_width, 0, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_data_right, 0, wx.CENTER, 10)
@@ -1128 +1115 @@
             if item.GetValue():
                 if button_list.index(item) == 0:
-                    flag = 0  # dy = numpy.ones_like(dy_data)
+                    flag = 0  # dy = np.ones_like(dy_data)
                 elif button_list.index(item) == 1:
                     flag = 1  # dy = dy_data
                 elif button_list.index(item) == 2:
-                    flag = 2  # dy = numpy.sqrt(numpy.abs(data))
+                    flag = 2  # dy = np.sqrt(np.abs(data))
                 elif button_list.index(item) == 3:
-                    flag = 3  # dy = numpy.abs(data)
+                    flag = 3  # dy = np.abs(data)
                 break
         return flag
@@ -1190 +1177 @@
         self.state.slit_smearer = self.slit_smearer.GetValue()
 
-        self.state.structurecombobox = self.structurebox.GetLabel()
-        self.state.formfactorcombobox = self.formfactorbox.GetLabel()
+        self.state.structurecombobox = self.structurebox.GetValue()
+        self.state.formfactorcombobox = self.formfactorbox.GetValue()
+        self.state.categorycombobox = self.categorybox.GetValue()
         self.enable_fit_button()
         if self.model is not None:
@@ -1248 +1236 @@
             wx.PostEvent(self.parent, new_event)
             # update list of plugins if new plugin is available
-            custom_model = 'Customized Models'
+            custom_model = CUSTOM_MODEL
             mod_cat = self.categorybox.GetStringSelection()
             if mod_cat == custom_model:
@@ -1270 +1258 @@
             if copy_flag:
                 self.get_paste_params(copy_flag)
-                wx.CallAfter(self._onDraw, None)
+            wx.CallAfter(self._onDraw, None)
 
         else:
@@ -1434 +1422 @@
         key = event.GetKeyCode()
         length = len(self.data.x)
-        indx = (numpy.abs(self.data.x - x_data)).argmin()
+        indx = (np.abs(self.data.x - x_data)).argmin()
         # return array.flat[idx]
         if key == wx.WXK_PAGEUP or key == wx.WXK_NUMPAD_PAGEUP:
@@ -1489 +1477 @@
                     self.enable2D:
                 # set mask
-                radius = numpy.sqrt(self.data.qx_data * self.data.qx_data +
+                radius = np.sqrt(self.data.qx_data * self.data.qx_data +
                                     self.data.qy_data * self.data.qy_data)
                 index_data = ((self.qmin_x <= radius) & (radius <= self.qmax_x))
                 index_data = (index_data) & (self.data.mask)
-                index_data = (index_data) & (numpy.isfinite(self.data.data))
+                index_data = (index_data) & (np.isfinite(self.data.data))
                 if len(index_data[index_data]) < 10:
                     msg = "Cannot Plot :No or too little npts in"
@@ -1583 +1571 @@
         if self.dxw is None:
             self.dxw = ""
-        if self.dx_min is None:
-            self.dx_min = SMEAR_SIZE_L
-        if self.dx_max is None:
-            self.dx_max = SMEAR_SIZE_H
+        if self.dx_percent is None:
+            self.dx_percent = SMEAR_SIZE_H
 
     def _get_smear_info(self):
@@ -1612 +1598 @@
                 and data.dqx_data.any() != 0:
                 self.smear_type = "Pinhole2d"
-                self.dq_l = format_number(numpy.average(data.dqx_data))
-                self.dq_r = format_number(numpy.average(data.dqy_data))
+                self.dq_l = format_number(np.average(data.dqx_data))
+                self.dq_r = format_number(np.average(data.dqy_data))
                 return
             else:
                 return
         # check if it is pinhole smear and get min max if it is.
-        if data.dx is not None and numpy.any(data.dx):
+        if data.dx is not None and np.any(data.dx):
             self.smear_type = "Pinhole"
             self.dq_l = data.dx[0]
@@ -1626 +1612 @@
         elif data.dxl is not None or data.dxw is not None:
             self.smear_type = "Slit"
-            if data.dxl is not None and not numpy.all(data.dxl, 0):
+            if data.dxl is not None and np.all(data.dxl, 0):
                 self.dq_l = data.dxl[0]
-            if data.dxw is not None and not numpy.all(data.dxw, 0):
+            if data.dxw is not None and np.all(data.dxw, 0):
                 self.dq_r = data.dxw[0]
         # return self.smear_type,self.dq_l,self.dq_r
@@ -1648 +1634 @@
             self.smear_description_2d_y.Show(True)
             if self.pinhole_smearer.GetValue():
-                self.smear_pinhole_min.Show(True)
-                self.smear_pinhole_max.Show(True)
+                self.smear_pinhole_percent.Show(True)
         # smear from data
         elif self.enable_smearer.GetValue():
@@ -1660 +1645 @@
                     self.smear_description_slit_width.Show(True)
                 elif self.smear_type == 'Pinhole':
-                    self.smear_description_pin_min.Show(True)
-                    self.smear_description_pin_max.Show(True)
+                    self.smear_description_pin_percent.Show(True)
                 self.smear_description_smear_type.Show(True)
                 self.smear_description_type.Show(True)
@@ -1670 +1654 @@
             if self.smear_type == 'Pinhole':
                 self.smear_message_new_p.Show(True)
-                self.smear_description_pin_min.Show(True)
-                self.smear_description_pin_max.Show(True)
-
-            self.smear_pinhole_min.Show(True)
-            self.smear_pinhole_max.Show(True)
+                self.smear_description_pin_percent.Show(True)
+
+            self.smear_pinhole_percent.Show(True)
         # custom slit smear
         elif self.slit_smearer.GetValue():
@@ -1699 +1681 @@
         self.smear_data_left.Hide()
         self.smear_data_right.Hide()
-        self.smear_description_pin_min.Hide()
-        self.smear_pinhole_min.Hide()
-        self.smear_description_pin_max.Hide()
-        self.smear_pinhole_max.Hide()
+        self.smear_description_pin_percent.Hide()
+        self.smear_pinhole_percent.Hide()
         self.smear_description_slit_height.Hide()
         self.smear_slit_height.Hide()
@@ -1828 +1808 @@
         if not flag:
             self.onSmear(None)
-
-    def _mac_sleep(self, sec=0.2):
-        """
-        Give sleep to MAC
-        """
-        if self.is_mac:
-            time.sleep(sec)
 
     def get_view_mode(self):
@@ -1933 +1906 @@
 
             # more disables for 2D
+            di_flag = False
+            dq_flag = False
             if self.data.__class__.__name__ == "Data2D" or \
                         self.enable2D:
@@ -1938 +1913 @@
                 self.pinhole_smearer.Enable(True)
                 self.default_mask = copy.deepcopy(self.data.mask)
-                if self.data.err_data is None or\
-                        numpy.all(err == 1 for err in self.data.err_data) or \
-                        not numpy.any(self.data.err_data):
-                    self.dI_didata.Enable(False)
-                    self.dI_noweight.SetValue(True)
-                    self.weightbt_string = self.dI_noweight.GetLabelText()
-                else:
-                    self.dI_didata.Enable(True)
-                    self.dI_didata.SetValue(True)
-                    self.weightbt_string = self.dI_didata.GetLabelText()
+                if self.data.err_data is not None \
+                        and np.any(self.data.err_data):
+                    di_flag = True
+                if self.data.dqx_data is not None \
+                        and np.any(self.data.dqx_data):
+                    dq_flag = True
             else:
                 self.slit_smearer.Enable(True)
                 self.pinhole_smearer.Enable(True)
-
-                if self.data.dy is None or\
-                     numpy.all(self.data.dy == 1) or\
-                     not numpy.any(self.data.dy):
-                    self.dI_didata.Enable(False)
-                    self.dI_noweight.SetValue(True)
-                    self.weightbt_string = self.dI_noweight.GetLabelText()
-                else:
-                    self.dI_didata.Enable(True)
-                    self.dI_didata.SetValue(True)
-                    self.weightbt_string = self.dI_didata.GetLabelText()
+                if self.data.dy is not None and np.any(self.data.dy):
+                    di_flag = True
+                if self.data.dx is not None and np.any(self.data.dx):
+                    dq_flag = True
+                elif self.data.dxl is not None and np.any(self.data.dxl):
+                    dq_flag = True
+
+            if dq_flag:
+                self.enable_smearer.Enable(True)
+                self.enable_smearer.SetValue(True)
+                self.disable_smearer.SetValue(False)
+            else:
+                self.enable_smearer.Disable()
+                self.disable_smearer.Enable(True)
+                self.disable_smearer.SetValue(True)
+
+            if di_flag:
+                self.dI_didata.Enable(True)
+                self.dI_didata.SetValue(True)
+                self.weightbt_string = self.dI_didata.GetLabelText()
+            else:
+                self.dI_didata.Enable(False)
+                self.dI_noweight.SetValue(True)
+                self.weightbt_string = self.dI_noweight.GetLabelText()
+
             # Enable weighting radio buttons
             self.dI_noweight.Enable(True)
@@ -2003 +1988 @@
             self.EditMask_title.Disable()
 
+        self.on_smear_helper()
         self.on_set_focus(None)
         self.Refresh()
@@ -2074 +2060 @@
         if self.data.__class__.__name__ == "Data2D" or \
                         self.enable2D:
-            radius = numpy.sqrt(self.data.qx_data * self.data.qx_data +
+            radius = np.sqrt(self.data.qx_data * self.data.qx_data +
                                 self.data.qy_data * self.data.qy_data)
             index_data = (self.qmin_x <= radius) & (radius <= self.qmax_x)
             index_data = (index_data) & (self.data.mask)
-            index_data = (index_data) & (numpy.isfinite(self.data.data))
+            index_data = (index_data) & (np.isfinite(self.data.data))
             npts2fit = len(self.data.data[index_data])
         else:
@@ -2111 +2097 @@
         # make sure stop button to fit button all the time
         self._on_fit_complete()
-        if out is None or not numpy.isfinite(chisqr):
+        if out is None or not np.isfinite(chisqr):
             raise ValueError, "Fit error occured..."
 
@@ -2122 +2108 @@
 
         # Check if chi2 is finite
-        if chisqr is not None and numpy.isfinite(chisqr):
+        if chisqr is not None and np.isfinite(chisqr):
             # format chi2
             chi2 = format_number(chisqr, True)
@@ -2174 +2160 @@
 
                         if cov[ind] is not None:
-                            if numpy.isfinite(float(cov[ind])):
+                            if np.isfinite(float(cov[ind])):
                                 val_err = format_number(cov[ind], True)
                                 item[4].SetForegroundColour(wx.BLACK)
@@ -2195 +2181 @@
         self.save_current_state()
 
-        if not self.is_mac:
-            self.Layout()
-            self.Refresh()
-        self._mac_sleep(0.1)
         # plot model ( when drawing, do not update chisqr value again)
         self._draw_model(update_chisqr=False, source='fit')
@@ -2238 +2220 @@
             # event case of radio button
             if tcrtl.GetValue():
-                self.dx_min = 0.0
-                self.dx_max = 0.0
+                self.dx_percent = 0.0
                 is_new_pinhole = True
             else:
@@ -2276 +2257 @@
         """
         # get the values
-        pin_min = self.smear_pinhole_min.GetValue()
-        pin_max = self.smear_pinhole_max.GetValue()
-
-        # Check changes in slit width
+        pin_percent = self.smear_pinhole_percent.GetValue()
+
+        # Check changes in slit heigth
         try:
-            dx_min = float(pin_min)
+            dx_percent = float(pin_percent)
         except:
             return True
-        if self.dx_min != dx_min:
-            return True
-
-        # Check changes in slit heigth
-        try:
-            dx_max = float(pin_max)
-        except:
-            return True
-        if self.dx_max != dx_max:
+        if self.dx_percent != dx_percent:
             return True
         return False
@@ -2308 +2280 @@
             self.smear_type = 'Pinhole2d'
             len_data = len(data.data)
-            data.dqx_data = numpy.zeros(len_data)
-            data.dqy_data = numpy.zeros(len_data)
+            data.dqx_data = np.zeros(len_data)
+            data.dqy_data = np.zeros(len_data)
         else:
             self.smear_type = 'Pinhole'
             len_data = len(data.x)
-            data.dx = numpy.zeros(len_data)
+            data.dx = np.zeros(len_data)
             data.dxl = None
             data.dxw = None
         msg = None
 
-        get_pin_min = self.smear_pinhole_min
-        get_pin_max = self.smear_pinhole_max
-
-        if not check_float(get_pin_min):
-            get_pin_min.SetBackgroundColour("pink")
-            msg = "Model Error:wrong value entered!!!"
-        elif not check_float(get_pin_max):
-            get_pin_max.SetBackgroundColour("pink")
+        get_pin_percent = self.smear_pinhole_percent
+
+        if not check_float(get_pin_percent):
+            get_pin_percent.SetBackgroundColour("pink")
             msg = "Model Error:wrong value entered!!!"
         else:
             if len_data < 2:
                 len_data = 2
-            self.dx_min = float(get_pin_min.GetValue())
-            self.dx_max = float(get_pin_max.GetValue())
-            if self.dx_min < 0:
-                get_pin_min.SetBackgroundColour("pink")
+            self.dx_percent = float(get_pin_percent.GetValue())
+            if self.dx_percent < 0:
+                get_pin_percent.SetBackgroundColour("pink")
                 msg = "Model Error:This value can not be negative!!!"
-            elif self.dx_max < 0:
-                get_pin_max.SetBackgroundColour("pink")
-                msg = "Model Error:This value can not be negative!!!"
-            elif self.dx_min is not None and self.dx_max is not None:
+            elif self.dx_percent is not None:
+                percent = self.dx_percent/100
                 if self._is_2D():
-                    data.dqx_data[data.dqx_data == 0] = self.dx_min
-                    data.dqy_data[data.dqy_data == 0] = self.dx_max
-                elif self.dx_min == self.dx_max:
-                    data.dx[data.dx == 0] = self.dx_min
+                    data.dqx_data[data.dqx_data == 0] = percent * data.qx_data
+                    data.dqy_data[data.dqy_data == 0] = percent * data.qy_data
                 else:
-                    step = (self.dx_max - self.dx_min) / (len_data - 1)
-                    data.dx = numpy.arange(self.dx_min,
-                                           self.dx_max + step / 1.1,
-                                           step)
-            elif self.dx_min is not None:
-                if self._is_2D():
-                    data.dqx_data[data.dqx_data == 0] = self.dx_min
-                else:
-                    data.dx[data.dx == 0] = self.dx_min
-            elif self.dx_max is not None:
-                if self._is_2D():
-                    data.dqy_data[data.dqy_data == 0] = self.dx_max
-                else:
-                    data.dx[data.dx == 0] = self.dx_max
+                    data.dx = percent * data.x
             self.current_smearer = smear_selection(data, self.model)
             # 2D need to set accuracy
@@ -2368 +2318 @@
             wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
         else:
-            get_pin_min.SetBackgroundColour("white")
-            get_pin_max.SetBackgroundColour("white")
+            get_pin_percent.SetBackgroundColour("white")
         # set smearing value whether or not the data contain the smearing info
 
@@ -2509 +2458 @@
         try:
             self.dxl = float(self.smear_slit_height.GetValue())
-            data.dxl = self.dxl * numpy.ones(data_len)
+            data.dxl = self.dxl * np.ones(data_len)
             self.smear_slit_height.SetBackgroundColour(wx.WHITE)
         except:
             self.dxl = None
-            data.dxl = numpy.zeros(data_len)
+            data.dxl = np.zeros(data_len)
             if self.smear_slit_height.GetValue().lstrip().rstrip() != "":
                 self.smear_slit_height.SetBackgroundColour("pink")
@@ -2522 +2471 @@
             self.dxw = float(self.smear_slit_width.GetValue())
             self.smear_slit_width.SetBackgroundColour(wx.WHITE)
-            data.dxw = self.dxw * numpy.ones(data_len)
+            data.dxw = self.dxw * np.ones(data_len)
         except:
             self.dxw = None
-            data.dxw = numpy.zeros(data_len)
+            data.dxw = np.zeros(data_len)
             if self.smear_slit_width.GetValue().lstrip().rstrip() != "":
                 self.smear_slit_width.SetBackgroundColour("pink")
@@ -2652 +2601 @@
             if event is None:
                 output = "-"
-            elif not numpy.isfinite(event.output):
+            elif not np.isfinite(event.output):
                 output = "-"
             else:

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

@@ -11 +11 @@
 #copyright 2009, University of Tennessee
 ################################################################################
+from __future__ import print_function
+
 import re
 import sys
@@ -16 +18 @@
 import wx
 import logging
-import numpy
+import numpy as np
 import time
 from copy import deepcopy
@@ -48 +50 @@
 
 from . import models
+
+logger = logging.getLogger(__name__)
 
 MAX_NBR_DATA = 4
@@ -119 +123 @@
         self.page_finder = {}
         # Log startup
-        logging.info("Fitting plug-in started")
+        logger.info("Fitting plug-in started")
         self.batch_capable = self.get_batch_capable()
 
@@ -225 +229 @@
 
         self.id_edit = wx.NewId()
-        editmodel_help = "Edit customized model sample file"
         self.menu1.AppendMenu(self.id_edit, "Plugin Model Operations",
-                              self.edit_model_menu, editmodel_help)
+                              self.edit_model_menu)
         #create  menubar items
         return [(self.menu1, self.sub_menu)]
@@ -260 +263 @@
             self.update_custom_combo()
             if os.path.isfile(p_path):
-                msg = "Sorry! Could not be able to delete the default "
-                msg += "custom model... \n"
+                msg = "Sorry! unable to delete the default "
+                msg += "plugin model... \n"
                 msg += "Please manually remove the files (.py, .pyc) "
                 msg += "in the 'plugin_models' folder \n"
@@ -274 +277 @@
                     if item.GetLabel() == label:
                         self.edit_menu.DeleteItem(item)
-                        msg = "The custom model, %s, has been deleted." % label
+                        msg = "The plugin model, %s, has been deleted." % label
                         evt = StatusEvent(status=msg, type='stop', info='info')
                         wx.PostEvent(self.parent, evt)
@@ -301 +304 @@
         Make new model
         """
-        if self.new_model_frame != None:
+        if self.new_model_frame is not None:
             self.new_model_frame.Show(False)
             self.new_model_frame.Show(True)
@@ -331 +334 @@
             temp = self.fit_panel.reset_pmodel_list()
             if temp:
-                # Set the new custom model list for all fit pages
+                # Set the new plugin model list for all fit pages
                 for uid, page in self.fit_panel.opened_pages.iteritems():
                     if hasattr(page, "formfactorbox"):
@@ -347 +350 @@
                                 page.formfactorbox.SetLabel(current_val)
         except:
-            logging.error("update_custom_combo: %s", sys.exc_value)
+            logger.error("update_custom_combo: %s", sys.exc_value)
 
     def set_edit_menu(self, owner):
@@ -385 +388 @@
         help for setting list of the edit model menu labels
         """
-        if menu == None:
+        if menu is None:
             menu = self.edit_custom_model
         list_fnames = os.listdir(models.find_plugins_dir())
@@ -440 +443 @@
             wx.PostEvent(self.parent, StatusEvent(status=msg))
 
-        if page != None:
+        if page is not None:
             return set_focus_page(page)
         if caption == "Const & Simul Fit":
@@ -587 +590 @@
                 msg = "Fitting: cannot deal with the theory received"
                 evt = StatusEvent(status=msg, info="error")
-                logging.error("set_theory " + msg + "\n" + str(sys.exc_value))
+                logger.error("set_theory " + msg + "\n" + str(sys.exc_value))
                 wx.PostEvent(self.parent, evt)
 
@@ -633 +636 @@
             state = self.temp_state[self.state_index]
             #panel state should have model selection to set_state
-            if state.formfactorcombobox != None:
+            if state.formfactorcombobox is not None:
                 #set state
                 data = self.parent.create_gui_data(state.data)
@@ -876 +879 @@
                 enable1D=enable1D, enable2D=enable2D,
                 qmin=qmin, qmax=qmax, weight=weight)
-
-    def _mac_sleep(self, sec=0.2):
-        """
-        Give sleep to MAC
-        """
-        if ON_MAC:
-            time.sleep(sec)
 
     def draw_model(self, model, page_id, data=None, smearer=None,
@@ -1022 +1018 @@
                 return False
         ## If a thread is already started, stop it
-        #if self.calc_fit!= None and self.calc_fit.isrunning():
+        #if self.calc_fitis not None and self.calc_fit.isrunning():
         #    self.calc_fit.stop()
         msg = "Fitting is in progress..."
@@ -1031 +1027 @@
                                 manager=self,
                                 improvement_delta=0.1)
-        self._mac_sleep(0.2)
 
         # batch fit
@@ -1113 +1108 @@
             page = self.fit_panel.add_empty_page()
             # add data associated to the page created
-            if page != None:
+            if page is not None:
                 evt = StatusEvent(status="Page Created", info="info")
                 wx.PostEvent(self.parent, evt)
@@ -1132 +1127 @@
         page = self.fit_panel.set_data(data)
         # page could be None when loading state files
-        if page == None:
+        if page is None:
             return page
         #append Data1D to the panel containing its theory
@@ -1200 +1195 @@
         """
         # case that uid is not specified
-        if uid == None:
+        if uid is None:
             for page_id in self.page_finder.keys():
                 self.page_finder[page_id].schedule_tofit(value)
@@ -1223 +1218 @@
             for item in param:
                 ## check if constraint
-                if item[0] != None and item[1] != None:
+                if item[0] is not None and item[1] is not None:
                     listOfConstraint.append((item[0], item[1]))
         new_model = model
@@ -1238 +1233 @@
         """
         panel = self.plot_panel
-        if panel == None:
+        if panel is None:
             raise ValueError, "Fitting:_onSelect: NonType panel"
         Plugin.on_perspective(self, event=event)
@@ -1260 +1255 @@
         """
         """
-        print "update_fit result", result
+        print("update_fit result", result)
 
     def _batch_fit_complete(self, result, pars, page_id,
@@ -1271 +1266 @@
         :param elapsed: time spent at the fitting level
         """
-        self._mac_sleep(0.2)
         uid = page_id[0]
         if uid in self.fit_thread_list.keys():
@@ -1333 +1327 @@
                     new_theory = copy_data.data
                     new_theory[res.index] = res.theory
-                    new_theory[res.index == False] = numpy.nan
+                    new_theory[res.index == False] = np.nan
                     correct_result = True
                 #get all fittable parameters of the current model
@@ -1342 +1336 @@
                         param_list.remove(param)
                 if not correct_result or res.fitness is None or \
-                    not numpy.isfinite(res.fitness) or \
-                    numpy.any(res.pvec == None) or not \
-                    numpy.all(numpy.isfinite(res.pvec)):
+                    not np.isfinite(res.fitness) or \
+                        np.any(res.pvec is None) or not \
+                        np.all(np.isfinite(res.pvec)):
                     data_name = str(None)
                     if data is not None:
@@ -1353 +1347 @@
                     msg += "Data %s and Model %s did not fit.\n" % (data_name,
                                                                     model_name)
-                    ERROR = numpy.NAN
+                    ERROR = np.NAN
                     cell = BatchCell()
                     cell.label = res.fitness
@@ -1367 +1361 @@
                             batch_inputs["error on %s" % str(param)].append(ERROR)
                 else:
-                    # TODO: Why sometimes res.pvec comes with numpy.float64?
+                    # TODO: Why sometimes res.pvec comes with np.float64?
                     # probably from scipy lmfit
-                    if res.pvec.__class__ == numpy.float64:
+                    if res.pvec.__class__ == np.float64:
                         res.pvec = [res.pvec]
 
@@ -1465 +1459 @@
         cell.value = index
 
-        if theory_data != None:
+        if theory_data is not None:
             #Suucessful fit
             theory_data.id = wx.NewId()
@@ -1521 +1515 @@
             page_id = []
         ## fit more than 1 model at the same time
-        self._mac_sleep(0.2)
         try:
             index = 0
@@ -1534 +1527 @@
                 fit_msg = res.mesg
                 if res.fitness is None or \
-                    not numpy.isfinite(res.fitness) or \
-                    numpy.any(res.pvec == None) or \
-                    not numpy.all(numpy.isfinite(res.pvec)):
+                    not np.isfinite(res.fitness) or \
+                        np.any(res.pvec is None) or \
+                    not np.all(np.isfinite(res.pvec)):
                     fit_msg += "\nFitting did not converge!!!"
                     wx.CallAfter(self._update_fit_button, page_id)
                 else:
                     #set the panel when fit result are float not list
-                    if res.pvec.__class__ == numpy.float64:
+                    if res.pvec.__class__ == np.float64:
                         pvec = [res.pvec]
                     else:
                         pvec = res.pvec
-                    if res.stderr.__class__ == numpy.float64:
+                    if res.stderr.__class__ == np.float64:
                         stderr = [res.stderr]
                     else:
@@ -1553 +1546 @@
                     #(CallAfter is important to MAC)
                     try:
-                        #if res != None:
+                        #if res is not None:
                         wx.CallAfter(cpage.onsetValues, res.fitness,
                                      res.param_list,
@@ -1596 +1589 @@
         """
         event.Skip()
-        if self.menu1 == None:
+        if self.menu1 is None:
             return
         menu_item = self.menu1.FindItemById(self.id_reset_flag)
@@ -1655 +1648 @@
         caption = evt.caption
         enable_smearer = evt.enable_smearer
-        if model == None:
+        if model is None:
             return
         if uid not in self.page_finder.keys():
@@ -1693 +1686 @@
         if dy is None:
             new_plot.is_data = False
-            new_plot.dy = numpy.zeros(len(y))
+            new_plot.dy = np.zeros(len(y))
             # If this is a theory curve, pick the proper symbol to make it a curve
             new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
@@ -1707 +1700 @@
         new_plot.title = data.name
         new_plot.group_id = data.group_id
-        if new_plot.group_id == None:
+        if new_plot.group_id is None:
             new_plot.group_id = data.group_id
         new_plot.id = data_id
@@ -1742 +1735 @@
         """
         try:
-            numpy.nan_to_num(y)
+            np.nan_to_num(y)
             new_plot = self.create_theory_1D(x, y, page_id, model, data, state,
                                              data_description=model.name,
@@ -1756 +1749 @@
                                           data_id="Data  " + data.name + " unsmeared",
                                           dy=unsmeared_error)
-                
-            if sq_model is not None and pq_model is not None:
-                self.create_theory_1D(x, sq_model, page_id, model, data, state,
-                                      data_description=model.name + " S(q)",
-                                      data_id=str(page_id) + " " + data.name + " S(q)")
-                self.create_theory_1D(x, pq_model, page_id, model, data, state,
-                                      data_description=model.name + " P(q)",
-                                      data_id=str(page_id) + " " + data.name + " P(q)")
-
+            # Comment this out until we can get P*S models with correctly populated parameters
+            #if sq_model is not None and pq_model is not None:
+            #    self.create_theory_1D(x, sq_model, page_id, model, data, state,
+            #                          data_description=model.name + " S(q)",
+            #                          data_id=str(page_id) + " " + data.name + " S(q)")
+            #    self.create_theory_1D(x, pq_model, page_id, model, data, state,
+            #                          data_description=model.name + " P(q)",
+            #                          data_id=str(page_id) + " " + data.name + " P(q)")
 
             current_pg = self.fit_panel.get_page_by_id(page_id)
@@ -1808 +1800 @@
         Handle exception from calculator by posting it as an error.
         """
-        logging.error("".join(traceback.format_exception(etype, value, tb)))
+        logger.error("".join(traceback.format_exception(etype, value, tb)))
         msg = traceback.format_exception(etype, value, tb, limit=1)
         evt = StatusEvent(status="".join(msg), type="stop", info="error")
@@ -1827 +1819 @@
         that can be plot.
         """
-        numpy.nan_to_num(image)
+        np.nan_to_num(image)
         new_plot = Data2D(image=image, err_image=data.err_data)
         new_plot.name = model.name + '2d'
@@ -1965 +1957 @@
                 ## then kill itself but cannot.  Paul Kienzle came up with
                 ## this fix to prevent threads from stepping on each other
-                ## which was causing a simple custom model to crash Sasview.
+                ## which was causing a simple custom plugin model to crash
+                ##Sasview.
                 ## We still don't know why the fit sometimes lauched a second
                 ## thread -- something which should also be investigated.
@@ -2011 +2004 @@
         chisqr = None
         #to compute chisq make sure data has valid data
-        # return None if data == None
-        if not check_data_validity(data_copy) or data_copy == None:
+        # return None if data is None
+        if not check_data_validity(data_copy) or data_copy is None:
             return chisqr
 
         # Get data: data I, theory I, and data dI in order
         if data_copy.__class__.__name__ == "Data2D":
-            if index == None:
-                index = numpy.ones(len(data_copy.data), dtype=bool)
-            if weight != None:
+            if index is None:
+                index = np.ones(len(data_copy.data), dtype=bool)
+            if weight is not None:
                 data_copy.err_data = weight
             # get rid of zero error points
             index = index & (data_copy.err_data != 0)
-            index = index & (numpy.isfinite(data_copy.data))
+            index = index & (np.isfinite(data_copy.data))
             fn = data_copy.data[index]
             theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
-            if theory_data == None:
+            if theory_data is None:
                 return chisqr
             gn = theory_data.data[index]
@@ -2032 +2025 @@
         else:
             # 1 d theory from model_thread is only in the range of index
-            if index == None:
-                index = numpy.ones(len(data_copy.y), dtype=bool)
-            if weight != None:
+            if index is None:
+                index = np.ones(len(data_copy.y), dtype=bool)
+            if weight is not None:
                 data_copy.dy = weight
-            if data_copy.dy == None or data_copy.dy == []:
-                dy = numpy.ones(len(data_copy.y))
+            if data_copy.dy is None or data_copy.dy == []:
+                dy = np.ones(len(data_copy.y))
             else:
                 ## Set consistently w/AbstractFitengine:
@@ -2046 +2039 @@
 
             theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
-            if theory_data == None:
+            if theory_data is None:
                 return chisqr
             gn = theory_data.y
@@ -2055 +2048 @@
             res = (fn - gn) / en
         except ValueError:
-            print "Unmatch lengths %s, %s, %s" % (len(fn), len(gn), len(en))
+            print("Unmatch lengths %s, %s, %s" % (len(fn), len(gn), len(en)))
             return
 
-        residuals = res[numpy.isfinite(res)]
+        residuals = res[np.isfinite(res)]
         # get chisqr only w/finite
-        chisqr = numpy.average(residuals * residuals)
+        chisqr = np.average(residuals * residuals)
 
         self._plot_residuals(page_id=page_id, data=data_copy,
@@ -2089 +2082 @@
             theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
             gn = theory_data.data
-            if weight == None:
+            if weight is None:
                 en = data_copy.err_data
             else:
@@ -2097 +2090 @@
             residuals.qy_data = data_copy.qy_data
             residuals.q_data = data_copy.q_data
-            residuals.err_data = numpy.ones(len(residuals.data))
+            residuals.err_data = np.ones(len(residuals.data))
             residuals.xmin = min(residuals.qx_data)
             residuals.xmax = max(residuals.qx_data)
@@ -2110 +2103 @@
         else:
             # 1 d theory from model_thread is only in the range of index
-            if data_copy.dy == None or data_copy.dy == []:
-                dy = numpy.ones(len(data_copy.y))
+            if data_copy.dy is None or data_copy.dy == []:
+                dy = np.ones(len(data_copy.y))
             else:
-                if weight == None:
-                    dy = numpy.ones(len(data_copy.y))
+                if weight is None:
+                    dy = np.ones(len(data_copy.y))
                 ## Set consitently w/AbstractFitengine:
                 ## But this should be corrected later.
@@ -2133 +2126 @@
                 residuals.y = (fn - gn[index]) / en
             residuals.x = data_copy.x[index]
-            residuals.dy = numpy.ones(len(residuals.y))
+            residuals.dy = np.ones(len(residuals.y))
             residuals.dx = None
             residuals.dxl = None
@@ -2151 +2144 @@
         ##group_id specify on which panel to plot this data
         group_id = self.page_finder[page_id].get_graph_id()
-        if group_id == None:
+        if group_id is None:
             group_id = data.group_id
         new_plot.group_id = "res" + str(group_id)

src/sas/sasgui/perspectives/fitting/media/plugin.rst

@@ -538 +538 @@
     sin, cos, tan, asin, acos, atan:
         Trigonometry functions and inverses, operating on radians.
-    sinh, cos, tanh, asinh, acosh, atanh:
+    sinh, cosh, tanh, asinh, acosh, atanh:
         Hyperbolic trigonometry functions.
     atan2(y,x):

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

@@ -4 +4 @@
 
 import time
-import numpy
+import numpy as np
 import math
 from sas.sascalc.data_util.calcthread import CalcThread
@@ -53 +53 @@
         self.starttime = time.time()
         # Determine appropriate q range
-        if self.qmin == None:
+        if self.qmin is None:
             self.qmin = 0
-        if self.qmax == None:
-            if self.data != None:
+        if self.qmax is None:
+            if self.data is not None:
                 newx = math.pow(max(math.fabs(self.data.xmax),
                                    math.fabs(self.data.xmin)), 2)
@@ -68 +68 @@
 
         # Define matrix where data will be plotted
-        radius = numpy.sqrt((self.data.qx_data * self.data.qx_data) + \
+        radius = np.sqrt((self.data.qx_data * self.data.qx_data) + \
                     (self.data.qy_data * self.data.qy_data))
 
@@ -75 +75 @@
         index_model = (self.qmin <= radius) & (radius <= self.qmax)
         index_model = index_model & self.data.mask
-        index_model = index_model & numpy.isfinite(self.data.data)
+        index_model = index_model & np.isfinite(self.data.data)
 
         if self.smearer is not None:
@@ -91 +91 @@
                 self.data.qy_data[index_model]
             ])
-        output = numpy.zeros(len(self.data.qx_data))
+        output = np.zeros(len(self.data.qx_data))
         # output default is None
         # This method is to distinguish between masked
@@ -177 +177 @@
         """
         self.starttime = time.time()
-        output = numpy.zeros((len(self.data.x)))
+        output = np.zeros((len(self.data.x)))
         index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax)
 
@@ -189 +189 @@
                                                              self.qmax)
             mask = self.data.x[first_bin:last_bin+1]
-            unsmeared_output = numpy.zeros((len(self.data.x)))
+            unsmeared_output = np.zeros((len(self.data.x)))
             unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask)
+            self.smearer.model = self.model
             output = self.smearer(unsmeared_output, first_bin, last_bin)
 
@@ -196 +197 @@
             # Check that the arrays are compatible. If we only have a model but no data,
             # the length of data.y will be zero.
-            if isinstance(self.data.y, numpy.ndarray) and output.shape == self.data.y.shape:
-                unsmeared_data = numpy.zeros((len(self.data.x)))
-                unsmeared_error = numpy.zeros((len(self.data.x)))
+            if isinstance(self.data.y, np.ndarray) and output.shape == self.data.y.shape:
+                unsmeared_data = np.zeros((len(self.data.x)))
+                unsmeared_error = np.zeros((len(self.data.x)))
                 unsmeared_data[first_bin:last_bin+1] = self.data.y[first_bin:last_bin+1]\
                                                         * unsmeared_output[first_bin:last_bin+1]\
@@ -222 +223 @@
 
         if p_model is not None and s_model is not None:
-            sq_values = numpy.zeros((len(self.data.x)))
-            pq_values = numpy.zeros((len(self.data.x)))
+            sq_values = np.zeros((len(self.data.x)))
+            pq_values = np.zeros((len(self.data.x)))
             sq_values[index] = s_model.evalDistribution(self.data.x[index])
             pq_values[index] = p_model.evalDistribution(self.data.x[index])

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

@@ -2 +2 @@
     Utilities to manage models
 """
+from __future__ import print_function
+
 import traceback
 import os
@@ -19 +21 @@
 from sasmodels.sasview_model import load_custom_model, load_standard_models
 
+logger = logging.getLogger(__name__)
+
 
 PLUGIN_DIR = 'plugin_models'
 PLUGIN_LOG = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR,
                           "plugins.log")
+PLUGIN_NAME_BASE = '[plug-in] '
 
 def get_model_python_path():
@@ -138 +143 @@
         type, value, tb = sys.exc_info()
         if type is not None and issubclass(type, py_compile.PyCompileError):
-            print "Problem with", repr(value)
+            print("Problem with", repr(value))
             raise type, value, tb
         return 1
@@ -158 +163 @@
 
 
-def _findModels(dir):
+def _find_models():
     """
     Find custom models
     """
     # List of plugin objects
-    dir = find_plugins_dir()
+    directory = find_plugins_dir()
     # Go through files in plug-in directory
-    if not os.path.isdir(dir):
-        msg = "SasView couldn't locate Model plugin folder %r." % dir
-        logging.warning(msg)
+    if not os.path.isdir(directory):
+        msg = "SasView couldn't locate Model plugin folder %r." % directory
+        logger.warning(msg)
         return {}
 
-    plugin_log("looking for models in: %s" % str(dir))
-    #compile_file(dir)  #always recompile the folder plugin
-    logging.info("plugin model dir: %s" % str(dir))
+    plugin_log("looking for models in: %s" % str(directory))
+    # compile_file(directory)  #always recompile the folder plugin
+    logger.info("plugin model dir: %s" % str(directory))
 
     plugins = {}
-    for filename in os.listdir(dir):
+    for filename in os.listdir(directory):
         name, ext = os.path.splitext(filename)
         if ext == '.py' and not name == '__init__':
-            path = os.path.abspath(os.path.join(dir, filename))
+            path = os.path.abspath(os.path.join(directory, filename))
             try:
                 model = load_custom_model(path)
-                model.name = "[plug-in] "+model.name
+                model.name = PLUGIN_NAME_BASE + model.name
                 plugins[model.name] = model
             except Exception:
@@ -187 +192 @@
                 msg += "\nwhile accessing model in %r" % path
                 plugin_log(msg)
-                logging.warning("Failed to load plugin %r. See %s for details"
-                                % (path, PLUGIN_LOG))
-            
+                logger.warning("Failed to load plugin %r. See %s for details"
+                               % (path, PLUGIN_LOG))
+
     return plugins
 
@@ -259 +264 @@
         temp = {}
         if self.is_changed():
-            return  _findModels(dir)
-        logging.info("plugin model : %s" % str(temp))
+            return  _find_models()
+        logger.info("plugin model : %s" % str(temp))
         return temp
 
@@ -324 +329 @@
                     self.plugins.append(plug)
                     self.model_dictionary[name] = plug
-            self.model_combobox.set_list("Customized Models", self.plugins)
+            self.model_combobox.set_list("Plugin Models", self.plugins)
             return self.model_combobox.get_list()
         else:
@@ -334 +339 @@
         """
         self.plugins = []
-        new_plugins = _findModels(dir)
+        new_plugins = _find_models()
         for name, plug in  new_plugins.iteritems():
             for stored_name, stored_plug in self.stored_plugins.iteritems():
@@ -345 +350 @@
             self.model_dictionary[name] = plug
 
-        self.model_combobox.reset_list("Customized Models", self.plugins)
+        self.model_combobox.reset_list("Plugin Models", self.plugins)
         return self.model_combobox.get_list()
 
@@ -388 +393 @@
 #                                     self.shape_indep_list)
         self.model_combobox.set_list("Structure Factors", self.struct_list)
-        self.model_combobox.set_list("Customized Models", self.plugins)
+        self.model_combobox.set_list("Plugin Models", self.plugins)
         self.model_combobox.set_list("P(Q)*S(Q)", self.multiplication_factor)
         self.model_combobox.set_list("multiplication",

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

@@ -18 +18 @@
 import copy
 import logging
-import numpy
+import numpy as np
 import traceback
 
@@ -25 +25 @@
 from lxml import etree
 
+from sasmodels import convert
 import sasmodels.weights
 
@@ -32 +33 @@
 from sas.sascalc.dataloader.data_info import Data2D, Collimation, Detector
 from sas.sascalc.dataloader.data_info import Process, Aperture
+
+logger = logging.getLogger(__name__)
+
 # Information to read/write state as xml
 FITTING_NODE_NAME = 'fitting_plug_in'
 CANSAS_NS = "cansas1d/1.0"
+
+CUSTOM_MODEL = 'Plugin Models'
+CUSTOM_MODEL_OLD = 'Customized Models'
 
 LIST_OF_DATA_ATTRIBUTES = [["is_data", "is_data", "bool"],
@@ -69 +76 @@
                             ["dq_l", "dq_l", "float"],
                             ["dq_r", "dq_r", "float"],
-                            ["dx_max", "dx_max", "float"],
-                            ["dx_min", "dx_min", "float"],
+                            ["dx_percent", "dx_percent", "float"],
                             ["dxl", "dxl", "float"],
                             ["dxw", "dxw", "float"]]
@@ -210 +216 @@
         self.dq_l = None
         self.dq_r = None
-        self.dx_max = None
-        self.dx_min = None
+        self.dx_percent = None
+        self.dx_old = False
         self.dxl = None
         self.dxw = None
@@ -271 +277 @@
         # store value of chisqr
         self.tcChi = None
+        self.version = (1,0,0)
 
     def clone(self):
@@ -337 +344 @@
         obj.dq_l = copy.deepcopy(self.dq_l)
         obj.dq_r = copy.deepcopy(self.dq_r)
-        obj.dx_max = copy.deepcopy(self.dx_max)
-        obj.dx_min = copy.deepcopy(self.dx_min)
+        obj.dx_percent = copy.deepcopy(self.dx_percent)
+        obj.dx_old = copy.deepcopy(self.dx_old)
         obj.dxl = copy.deepcopy(self.dxl)
         obj.dxw = copy.deepcopy(self.dxw)
@@ -349 +356 @@
         obj.cb1 = copy.deepcopy(self.cb1)
         obj.smearer = copy.deepcopy(self.smearer)
+        obj.version = copy.deepcopy(self.version)
 
         for name, state in self.saved_states.iteritems():
@@ -355 +363 @@
             obj.saved_states[copy_name] = copy_state
         return obj
+
+    def _old_first_model(self):
+        """
+        Handle save states from 4.0.1 and before where the first item in the
+        selection boxes of category, formfactor and structurefactor were not
+        saved.
+        :return: None
+        """
+        if self.categorycombobox == CUSTOM_MODEL_OLD:
+            self.categorycombobox = CUSTOM_MODEL
+        if self.formfactorcombobox == '':
+            FIRST_FORM = {
+                'Shapes' : 'BCCrystalModel',
+                'Uncategorized' : 'LineModel',
+                'StructureFactor' : 'HardsphereStructure',
+                'Ellipsoid' : 'core_shell_ellipsoid',
+                'Lamellae' : 'lamellar',
+                'Paracrystal' : 'bcc_paracrystal',
+                'Parallelepiped' : 'core_shell_parallelepiped',
+                'Shape Independent' : 'be_polyelectrolyte',
+                'Sphere' : 'adsorbed_layer',
+                'Structure Factor' : 'hardsphere',
+                CUSTOM_MODEL : ''
+            }
+            if self.categorycombobox == '':
+                if len(self.parameters) == 3:
+                    self.categorycombobox = "Shape-Independent"
+                    self.formfactorcombobox = 'PowerLawAbsModel'
+                elif len(self.parameters) == 9:
+                    self.categorycombobox = 'Cylinder'
+                    self.formfactorcombobox = 'barbell'
+                else:
+                    msg = "Save state does not have enough information to load"
+                    msg += " the all of the data."
+                    logger.warning(msg=msg)
+            else:
+                self.formfactorcombobox = FIRST_FORM[self.categorycombobox]
+
+    @staticmethod
+    def param_remap_to_sasmodels_convert(params, is_string=False):
+        """
+        Remaps the parameters for sasmodels conversion
+
+        :param params: list of parameters (likely self.parameters)
+        :return: remapped dictionary of parameters
+        """
+        p = dict()
+        for fittable, name, value, _, uncert, lower, upper, units in params:
+            if not value:
+                value = np.nan
+            if not uncert or uncert[1] == '' or uncert[1] == 'None':
+                uncert[0] = False
+                uncert[1] = np.nan
+            if not upper or upper[1] == '' or upper[1] == 'None':
+                upper[0] = False
+                upper[1] = np.nan
+            if not lower or lower[1] == '' or lower[1] == 'None':
+                lower[0] = False
+                lower[1] = np.nan
+            if is_string:
+                p[name] = str(value)
+            else:
+                p[name] = float(value)
+            p[name + ".fittable"] = bool(fittable)
+            p[name + ".std"] = float(uncert[1])
+            p[name + ".upper"] = float(upper[1])
+            p[name + ".lower"] = float(lower[1])
+            p[name + ".units"] = units
+        return p
+
+    @staticmethod
+    def param_remap_from_sasmodels_convert(params):
+        """
+        Converts {name : value} map back to [] param list
+        :param params: parameter map returned from sasmodels
+        :return: None
+        """
+        p_map = []
+        for name, info in params.iteritems():
+            if ".fittable" in name or ".std" in name or ".upper" in name or \
+                            ".lower" in name or ".units" in name:
+                pass
+            else:
+                fittable = params.get(name + ".fittable", True)
+                std = params.get(name + ".std", '0.0')
+                upper = params.get(name + ".upper", 'inf')
+                lower = params.get(name + ".lower", '-inf')
+                units = params.get(name + ".units")
+                if std is not None and std is not np.nan:
+                    std = [True, str(std)]
+                else:
+                    std = [False, '']
+                if lower is not None and lower is not np.nan:
+                    lower = [True, str(lower)]
+                else:
+                    lower = [True, '-inf']
+                if upper is not None and upper is not np.nan:
+                    upper = [True, str(upper)]
+                else:
+                    upper = [True, 'inf']
+                param_list = [bool(fittable), str(name), str(info),
+                              "+/-", std, lower, upper, str(units)]
+                p_map.append(param_list)
+        return p_map
+
+    def _convert_to_sasmodels(self):
+        """
+        Convert parameters to a form usable by sasmodels converter
+
+        :return: None
+        """
+        # Create conversion dictionary to send to sasmodels
+        self._old_first_model()
+        p = self.param_remap_to_sasmodels_convert(self.parameters)
+        structurefactor, params = convert.convert_model(self.structurecombobox,
+                                                        p, False, self.version)
+        formfactor, params = convert.convert_model(self.formfactorcombobox,
+                                                   params, False, self.version)
+        if len(self.str_parameters) > 0:
+            str_pars = self.param_remap_to_sasmodels_convert(
+                self.str_parameters, True)
+            formfactor, str_params = convert.convert_model(
+                self.formfactorcombobox, str_pars, False, self.version)
+            for key, value in str_params.iteritems():
+                params[key] = value
+
+        if self.formfactorcombobox == 'SphericalSLDModel':
+            self.multi_factor += 1
+        self.formfactorcombobox = formfactor
+        self.structurecombobox = structurefactor
+        self.parameters = []
+        self.parameters = self.param_remap_from_sasmodels_convert(params)
 
     def _repr_helper(self, list, rep):
@@ -423 +563 @@
         rep += "dq_l  : %s\n" % self.dq_l
         rep += "dq_r  : %s\n" % self.dq_r
-        rep += "dx_max  : %s\n" % str(self.dx_max)
-        rep += "dx_min : %s\n" % str(self.dx_min)
+        rep += "dx_percent  : %s\n" % str(self.dx_percent)
         rep += "dxl  : %s\n" % str(self.dxl)
         rep += "dxw : %s\n" % str(self.dxw)
@@ -483 +622 @@
             except Exception:
                 msg = "Report string expected 'name: value' but got %r" % line
-                logging.error(msg)
+                logger.error(msg)
             if name.count("State created"):
                 repo_time = "" + value
@@ -525 +664 @@
                 except Exception:
                     msg = "While parsing 'data: ...'\n"
-                    logging.error(msg + traceback.format_exc())
+                    logger.error(msg + traceback.format_exc())
             if name == "model name ":
                 try:
@@ -541 +680 @@
                 except Exception:
                     msg = "While parsing 'Plotting Range: ...'\n"
-                    logging.error(msg + traceback.format_exc())
+                    logger.error(msg + traceback.format_exc())
         paramval = ""
         for lines in param_string.split(":"):
@@ -682 +821 @@
 
         attr = newdoc.createAttribute("version")
-        attr.nodeValue = '1.0'
+        from sas import sasview
+        attr.nodeValue = sasview.__version__
+        # attr.nodeValue = '1.0'
         top_element.setAttributeNode(attr)
 
@@ -875 +1016 @@
             raise RuntimeError, msg
 
-        if node.get('version') and node.get('version') == '1.0':
+        if node.get('version'):
+            # Get the version for model conversion purposes
+            self.version = tuple(int(e) for e in
+                                 str.split(node.get('version'), "."))
+            # The tuple must be at least 3 items long
+            while len(self.version) < 3:
+                ver_list = list(self.version)
+                ver_list.append(0)
+                self.version = tuple(ver_list)
 
             # Get file name
@@ -890 +1039 @@
                     msg = "PageState.fromXML: Could not"
                     msg += " read timestamp\n %s" % sys.exc_value
-                    logging.error(msg)
+                    logger.error(msg)
 
             if entry is not None:
@@ -899 +1048 @@
                     setattr(self, item[0], parse_entry_helper(node, item))
 
+                dx_old_node = get_content('ns:%s' % 'dx_min', entry)
                 for item in LIST_OF_STATE_ATTRIBUTES:
-                    node = get_content('ns:%s' % item[0], entry)
-                    setattr(self, item[0], parse_entry_helper(node, item))
+                    if item[0] == "dx_percent" and dx_old_node is not None:
+                        dxmin = ["dx_min", "dx_min", "float"]
+                        setattr(self, item[0], parse_entry_helper(dx_old_node,
+                                                                  dxmin))
+                        self.dx_old = True
+                    else:
+                        node = get_content('ns:%s' % item[0], entry)
+                        setattr(self, item[0], parse_entry_helper(node, item))
 
                 for item in LIST_OF_STATE_PARAMETERS:
@@ -923 +1079 @@
                             except Exception:
                                 base = "unable to load distribution %r for %s"
-                                logging.error(base % (value, parameter))
+                                logger.error(base % (value, parameter))
                                 continue
                         _disp_obj_dict = getattr(self, varname)
@@ -945 +1101 @@
                                 msg = ("Error reading %r from %s %s\n"
                                        % (line, tagname, name))
-                                logging.error(msg + traceback.format_exc())
-                        dic[name] = numpy.array(value_list)
+                                logger.error(msg + traceback.format_exc())
+                        dic[name] = np.array(value_list)
                     setattr(self, varname, dic)
 
@@ -1033 +1189 @@
         if self.cansas:
             return self._read_cansas(path)
-
-    def _data2d_to_xml_doc(self, datainfo):
-        """
-        Create an XML document to contain the content of a Data2D
-
-        :param datainfo: Data2D object
-
-        """
-        if not issubclass(datainfo.__class__, Data2D):
-            raise RuntimeError, "The cansas writer expects a Data2D instance"
-
-        title = "cansas1d/%s" % self.version
-        title += "http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd"
-        doc = xml.dom.minidom.Document()
-        main_node = doc.createElement("SASroot")
-        main_node.setAttribute("version", self.version)
-        main_node.setAttribute("xmlns", "cansas1d/%s" % self.version)
-        main_node.setAttribute("xmlns:xsi",
-                               "http://www.w3.org/2001/XMLSchema-instance")
-        main_node.setAttribute("xsi:schemaLocation", title)
-
-        doc.appendChild(main_node)
-
-        entry_node = doc.createElement("SASentry")
-        main_node.appendChild(entry_node)
-
-        write_node(doc, entry_node, "Title", datainfo.title)
-        if datainfo is not None:
-            write_node(doc, entry_node, "data_class",
-                       datainfo.__class__.__name__)
-        for item in datainfo.run:
-            runname = {}
-            if item in datainfo.run_name and \
-                            len(str(datainfo.run_name[item])) > 1:
-                runname = {'name': datainfo.run_name[item]}
-            write_node(doc, entry_node, "Run", item, runname)
-        # Data info
-        new_node = doc.createElement("SASdata")
-        entry_node.appendChild(new_node)
-        for item in LIST_OF_DATA_2D_ATTR:
-            element = doc.createElement(item[0])
-            element.setAttribute(item[0], str(getattr(datainfo, item[1])))
-            new_node.appendChild(element)
-
-        for item in LIST_OF_DATA_2D_VALUES:
-            root_node = doc.createElement(item[0])
-            new_node.appendChild(root_node)
-            temp_list = getattr(datainfo, item[1])
-
-            if temp_list is None or len(temp_list) == 0:
-                element = doc.createElement(item[0])
-                element.appendChild(doc.createTextNode(str(temp_list)))
-                root_node.appendChild(element)
-            else:
-                for value in temp_list:
-                    element = doc.createElement(item[0])
-                    element.setAttribute(item[0], str(value))
-                    root_node.appendChild(element)
-
-        # Sample info
-        sample = doc.createElement("SASsample")
-        if datainfo.sample.name is not None:
-            sample.setAttribute("name", str(datainfo.sample.name))
-        entry_node.appendChild(sample)
-        write_node(doc, sample, "ID", str(datainfo.sample.ID))
-        write_node(doc, sample, "thickness", datainfo.sample.thickness,
-                   {"unit": datainfo.sample.thickness_unit})
-        write_node(doc, sample, "transmission", datainfo.sample.transmission)
-        write_node(doc, sample, "temperature", datainfo.sample.temperature,
-                   {"unit": datainfo.sample.temperature_unit})
-
-        for item in datainfo.sample.details:
-            write_node(doc, sample, "details", item)
-
-        pos = doc.createElement("position")
-        written = write_node(doc, pos, "x", datainfo.sample.position.x,
-                             {"unit": datainfo.sample.position_unit})
-        written = written | write_node(doc, pos, "y",
-                                       datainfo.sample.position.y,
-                                       {"unit": datainfo.sample.position_unit})
-        written = written | write_node(doc, pos, "z",
-                                       datainfo.sample.position.z,
-                                       {"unit": datainfo.sample.position_unit})
-        if written:
-            sample.appendChild(pos)
-
-        ori = doc.createElement("orientation")
-        written = write_node(doc, ori, "roll", datainfo.sample.orientation.x,
-                             {"unit": datainfo.sample.orientation_unit})
-        written = written | write_node(doc, ori, "pitch",
-                                       datainfo.sample.orientation.y,
-                                       {"unit":
-                                            datainfo.sample.orientation_unit})
-        written = written | write_node(doc, ori, "yaw",
-                                       datainfo.sample.orientation.z,
-                                       {"unit":
-                                            datainfo.sample.orientation_unit})
-        if written:
-            sample.appendChild(ori)
-
-        # Instrument info
-        instr = doc.createElement("SASinstrument")
-        entry_node.appendChild(instr)
-
-        write_node(doc, instr, "name", datainfo.instrument)
-
-        #   Source
-        source = doc.createElement("SASsource")
-        if datainfo.source.name is not None:
-            source.setAttribute("name", str(datainfo.source.name))
-        instr.appendChild(source)
-
-        write_node(doc, source, "radiation", datainfo.source.radiation)
-        write_node(doc, source, "beam_shape", datainfo.source.beam_shape)
-        size = doc.createElement("beam_size")
-        if datainfo.source.beam_size_name is not None:
-            size.setAttribute("name", str(datainfo.source.beam_size_name))
-        written = write_node(doc, size, "x", datainfo.source.beam_size.x,
-                             {"unit": datainfo.source.beam_size_unit})
-        written = written | write_node(doc, size, "y",
-                                       datainfo.source.beam_size.y,
-                                       {"unit": datainfo.source.beam_size_unit})
-        written = written | write_node(doc, size, "z",
-                                       datainfo.source.beam_size.z,
-                                       {"unit": datainfo.source.beam_size_unit})
-        if written:
-            source.appendChild(size)
-
-        write_node(doc, source, "wavelength", datainfo.source.wavelength,
-                   {"unit": datainfo.source.wavelength_unit})
-        write_node(doc, source, "wavelength_min",
-                   datainfo.source.wavelength_min,
-                   {"unit": datainfo.source.wavelength_min_unit})
-        write_node(doc, source, "wavelength_max",
-                   datainfo.source.wavelength_max,
-                   {"unit": datainfo.source.wavelength_max_unit})
-        write_node(doc, source, "wavelength_spread",
-                   datainfo.source.wavelength_spread,
-                   {"unit": datainfo.source.wavelength_spread_unit})
-
-        #   Collimation
-        for item in datainfo.collimation:
-            coll = doc.createElement("SAScollimation")
-            if item.name is not None:
-                coll.setAttribute("name", str(item.name))
-            instr.appendChild(coll)
-
-            write_node(doc, coll, "length", item.length,
-                       {"unit": item.length_unit})
-
-            for apert in item.aperture:
-                ap = doc.createElement("aperture")
-                if apert.name is not None:
-                    ap.setAttribute("name", str(apert.name))
-                if apert.type is not None:
-                    ap.setAttribute("type", str(apert.type))
-                coll.appendChild(ap)
-
-                write_node(doc, ap, "distance", apert.distance,
-                           {"unit": apert.distance_unit})
-
-                size = doc.createElement("size")
-                if apert.size_name is not None:
-                    size.setAttribute("name", str(apert.size_name))
-                written = write_node(doc, size, "x", apert.size.x,
-                                     {"unit": apert.size_unit})
-                written = written | write_node(doc, size, "y", apert.size.y,
-                                               {"unit": apert.size_unit})
-                written = written | write_node(doc, size, "z", apert.size.z,
-                                               {"unit": apert.size_unit})
-                if written:
-                    ap.appendChild(size)
-
-        #   Detectors
-        for item in datainfo.detector:
-            det = doc.createElement("SASdetector")
-            written = write_node(doc, det, "name", item.name)
-            written = written | write_node(doc, det, "SDD", item.distance,
-                                           {"unit": item.distance_unit})
-            written = written | write_node(doc, det, "slit_length",
-                                           item.slit_length,
-                                           {"unit": item.slit_length_unit})
-            if written:
-                instr.appendChild(det)
-
-            off = doc.createElement("offset")
-            written = write_node(doc, off, "x", item.offset.x,
-                                 {"unit": item.offset_unit})
-            written = written | write_node(doc, off, "y", item.offset.y,
-                                           {"unit": item.offset_unit})
-            written = written | write_node(doc, off, "z", item.offset.z,
-                                           {"unit": item.offset_unit})
-            if written:
-                det.appendChild(off)
-
-            center = doc.createElement("beam_center")
-            written = write_node(doc, center, "x", item.beam_center.x,
-                                 {"unit": item.beam_center_unit})
-            written = written | write_node(doc, center, "y",
-                                           item.beam_center.y,
-                                           {"unit": item.beam_center_unit})
-            written = written | write_node(doc, center, "z",
-                                           item.beam_center.z,
-                                           {"unit": item.beam_center_unit})
-            if written:
-                det.appendChild(center)
-
-            pix = doc.createElement("pixel_size")
-            written = write_node(doc, pix, "x", item.pixel_size.x,
-                                 {"unit": item.pixel_size_unit})
-            written = written | write_node(doc, pix, "y", item.pixel_size.y,
-                                           {"unit": item.pixel_size_unit})
-            written = written | write_node(doc, pix, "z", item.pixel_size.z,
-                                           {"unit": item.pixel_size_unit})
-            if written:
-                det.appendChild(pix)
-
-            ori = doc.createElement("orientation")
-            written = write_node(doc, ori, "roll", item.orientation.x,
-                                 {"unit": item.orientation_unit})
-            written = written | write_node(doc, ori, "pitch",
-                                           item.orientation.y,
-                                           {"unit": item.orientation_unit})
-            written = written | write_node(doc, ori, "yaw", item.orientation.z,
-                                           {"unit": item.orientation_unit})
-            if written:
-                det.appendChild(ori)
-
-        # Processes info
-        for item in datainfo.process:
-            node = doc.createElement("SASprocess")
-            entry_node.appendChild(node)
-
-            write_node(doc, node, "name", item.name)
-            write_node(doc, node, "date", item.date)
-            write_node(doc, node, "description", item.description)
-            for term in item.term:
-                value = term['value']
-                del term['value']
-                write_node(doc, node, "term", value, term)
-            for note in item.notes:
-                write_node(doc, node, "SASprocessnote", note)
-        # Return the document, and the SASentry node associated with
-        # the data we just wrote
-        return doc, entry_node
 
     def _parse_state(self, entry):
@@ -1298 +1209 @@
 
         except:
-            logging.info("XML document does not contain fitting information.\n"
+            logger.info("XML document does not contain fitting information.\n"
                          + traceback.format_exc())
 
@@ -1354 +1265 @@
         """
         node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS})
-        if not node or node[0].text.lstrip().rstrip() != "Data2D":
-            return_value, _ = self._parse_entry(dom)
-            numpy.trim_zeros(return_value.x)
-            numpy.trim_zeros(return_value.y)
-            numpy.trim_zeros(return_value.dy)
-            size_dx = return_value.dx.size
-            size_dxl = return_value.dxl.size
-            size_dxw = return_value.dxw.size
-            if size_dxl == 0 and size_dxw == 0:
-                return_value.dxl = None
-                return_value.dxw = None
-                numpy.trim_zeros(return_value.dx)
-            elif size_dx == 0:
-                return_value.dx = None
-                size_dx = size_dxl
-                numpy.trim_zeros(return_value.dxl)
-                numpy.trim_zeros(return_value.dxw)
-
-            return return_value, _
-
-        # Parse 2D
-        data_info = Data2D()
-
-        # Look up title
-        self._store_content('ns:Title', dom, 'title', data_info)
-
-        # Look up run number
-        nodes = dom.xpath('ns:Run', namespaces={'ns': CANSAS_NS})
-        for item in nodes:
-            if item.text is not None:
-                value = item.text.strip()
-                if len(value) > 0:
-                    data_info.run.append(value)
-                    if item.get('name') is not None:
-                        data_info.run_name[value] = item.get('name')
-
-        # Look up instrument name
-        self._store_content('ns:SASinstrument/ns:name', dom,
-                            'instrument', data_info)
-
-        # Notes
-        note_list = dom.xpath('ns:SASnote', namespaces={'ns': CANSAS_NS})
-        for note in note_list:
-            try:
-                if note.text is not None:
-                    note_value = note.text.strip()
-                    if len(note_value) > 0:
-                        data_info.notes.append(note_value)
-            except Exception:
-                err_mess = "cansas_reader.read: error processing entry notes\n"
-                err_mess += "  %s" % sys.exc_value
-                self.errors.append(err_mess)
-                logging.error(err_mess)
-
-        # Sample info ###################
-        entry = get_content('ns:SASsample', dom)
-        if entry is not None:
-            data_info.sample.name = entry.get('name')
-
-        self._store_content('ns:SASsample/ns:ID', dom, 'ID', data_info.sample)
-        self._store_float('ns:SASsample/ns:thickness', dom, 'thickness',
-                          data_info.sample)
-        self._store_float('ns:SASsample/ns:transmission', dom, 'transmission',
-                          data_info.sample)
-        self._store_float('ns:SASsample/ns:temperature', dom, 'temperature',
-                          data_info.sample)
-
-        nodes = dom.xpath('ns:SASsample/ns:details',
-                          namespaces={'ns': CANSAS_NS})
-        for item in nodes:
-            try:
-                if item.text is not None:
-                    detail_value = item.text.strip()
-                    if len(detail_value) > 0:
-                        data_info.sample.details.append(detail_value)
-            except Exception:
-                err_mess = "cansas_reader.read: error processing entry notes\n"
-                err_mess += "  %s" % sys.exc_value
-                self.errors.append(err_mess)
-                logging.error(err_mess)
-
-        # Position (as a vector)
-        self._store_float('ns:SASsample/ns:position/ns:x', dom, 'position.x',
-                          data_info.sample)
-        self._store_float('ns:SASsample/ns:position/ns:y', dom, 'position.y',
-                          data_info.sample)
-        self._store_float('ns:SASsample/ns:position/ns:z', dom, 'position.z',
-                          data_info.sample)
-
-        # Orientation (as a vector)
-        self._store_float('ns:SASsample/ns:orientation/ns:roll',
-                          dom, 'orientation.x', data_info.sample)
-        self._store_float('ns:SASsample/ns:orientation/ns:pitch',
-                          dom, 'orientation.y', data_info.sample)
-        self._store_float('ns:SASsample/ns:orientation/ns:yaw',
-                          dom, 'orientation.z', data_info.sample)
-
-        # Source info ###################
-        entry = get_content('ns:SASinstrument/ns:SASsource', dom)
-        if entry is not None:
-            data_info.source.name = entry.get('name')
-
-        self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation',
-                            dom, 'radiation', data_info.source)
-        self._store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape',
-                            dom, 'beam_shape', data_info.source)
-        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength',
-                          dom, 'wavelength', data_info.source)
-        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min',
-                          dom, 'wavelength_min', data_info.source)
-        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max',
-                          dom, 'wavelength_max', data_info.source)
-        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread',
-                          dom, 'wavelength_spread', data_info.source)
-
-        # Beam size (as a vector)
-        entry = get_content('ns:SASinstrument/ns:SASsource/ns:beam_size', dom)
-        if entry is not None:
-            data_info.source.beam_size_name = entry.get('name')
-
-        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x',
-                          dom, 'beam_size.x', data_info.source)
-        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y',
-                          dom, 'beam_size.y', data_info.source)
-        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z',
-                          dom, 'beam_size.z', data_info.source)
-
-        # Collimation info ###################
-        nodes = dom.xpath('ns:SASinstrument/ns:SAScollimation',
-                          namespaces={'ns': CANSAS_NS})
-        for item in nodes:
-            collim = Collimation()
-            if item.get('name') is not None:
-                collim.name = item.get('name')
-            self._store_float('ns:length', item, 'length', collim)
-
-            # Look for apertures
-            apert_list = item.xpath('ns:aperture',
-                                    namespaces={'ns': CANSAS_NS})
-            for apert in apert_list:
-                aperture = Aperture()
-
-                # Get the name and type of the aperture
-                aperture.name = apert.get('name')
-                aperture.type = apert.get('type')
-
-                self._store_float('ns:distance', apert, 'distance', aperture)
-
-                entry = get_content('ns:size', apert)
-                if entry is not None:
-                    aperture.size_name = entry.get('name')
-
-                self._store_float('ns:size/ns:x', apert, 'size.x', aperture)
-                self._store_float('ns:size/ns:y', apert, 'size.y', aperture)
-                self._store_float('ns:size/ns:z', apert, 'size.z', aperture)
-
-                collim.aperture.append(aperture)
-
-            data_info.collimation.append(collim)
-
-        # Detector info ######################
-        nodes = dom.xpath('ns:SASinstrument/ns:SASdetector',
-                          namespaces={'ns': CANSAS_NS})
-        for item in nodes:
-
-            detector = Detector()
-
-            self._store_content('ns:name', item, 'name', detector)
-            self._store_float('ns:SDD', item, 'distance', detector)
-
-            # Detector offset (as a vector)
-            self._store_float('ns:offset/ns:x', item, 'offset.x', detector)
-            self._store_float('ns:offset/ns:y', item, 'offset.y', detector)
-            self._store_float('ns:offset/ns:z', item, 'offset.z', detector)
-
-            # Detector orientation (as a vector)
-            self._store_float('ns:orientation/ns:roll', item,
-                              'orientation.x', detector)
-            self._store_float('ns:orientation/ns:pitch', item,
-                              'orientation.y', detector)
-            self._store_float('ns:orientation/ns:yaw', item,
-                              'orientation.z', detector)
-
-            # Beam center (as a vector)
-            self._store_float('ns:beam_center/ns:x', item,
-                              'beam_center.x', detector)
-            self._store_float('ns:beam_center/ns:y', item,
-                              'beam_center.y', detector)
-            self._store_float('ns:beam_center/ns:z', item,
-                              'beam_center.z', detector)
-
-            # Pixel size (as a vector)
-            self._store_float('ns:pixel_size/ns:x', item,
-                              'pixel_size.x', detector)
-            self._store_float('ns:pixel_size/ns:y', item,
-                              'pixel_size.y', detector)
-            self._store_float('ns:pixel_size/ns:z', item,
-                              'pixel_size.z', detector)
-
-            self._store_float('ns:slit_length', item, 'slit_length', detector)
-
-            data_info.detector.append(detector)
-
-        # Processes info ######################
-        nodes = dom.xpath('ns:SASprocess', namespaces={'ns': CANSAS_NS})
-        for item in nodes:
-            process = Process()
-            self._store_content('ns:name', item, 'name', process)
-            self._store_content('ns:date', item, 'date', process)
-            self._store_content('ns:description', item, 'description', process)
-
-            term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS})
-            for term in term_list:
-                try:
-                    term_attr = {}
-                    for attr in term.keys():
-                        term_attr[attr] = term.get(attr).strip()
-                    if term.text is not None:
-                        term_attr['value'] = term.text.strip()
-                        process.term.append(term_attr)
-                except:
-                    err_mess = "cansas_reader.read: error processing "
-                    err_mess += "entry notes\n  %s" % sys.exc_value
-                    self.errors.append(err_mess)
-                    logging.error(err_mess)
-
-            note_list = item.xpath('ns:SASprocessnote',
-                                   namespaces={'ns': CANSAS_NS})
-            for note in note_list:
-                if note.text is not None:
-                    process.notes.append(note.text.strip())
-
-            data_info.process.append(process)
-
-        # Data info ######################
-        nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS})
-        if len(nodes) > 1:
-            raise RuntimeError, "CanSAS reader is not compatible with" + \
-                                " multiple SASdata entries"
-
-        for entry in nodes:
-            for item in LIST_OF_DATA_2D_ATTR:
-                # get node
-                node = get_content('ns:%s' % item[0], entry)
-                setattr(data_info, item[1], parse_entry_helper(node, item))
-
-            for item in LIST_OF_DATA_2D_VALUES:
-                field = get_content('ns:%s' % item[0], entry)
-                value_list = []
-                if field is not None:
-                    value_list = \
-                        [parse_entry_helper(node, item) for node in field]
-                if len(value_list) < 2:
-                    setattr(data_info, item[0], None)
-                else:
-                    setattr(data_info, item[0], numpy.array(value_list))
-
-        return data_info
+        return_value, _ = self._parse_entry(dom)
+        return return_value, _
 
     def _read_cansas(self, path):
@@ -1692 +1347 @@
                         name = original_fname
                     state.data.group_id = name
+                    state.version = fitstate.version
                     # store state in fitting
                     self.call_back(state=state,
@@ -1745 +1401 @@
             state.data.run_name[0] = state.data.name
 
-        if issubclass(state.data.__class__,
-                      sas.sascalc.dataloader.data_info.Data1D):
-            data = state.data
-            doc, sasentry = self._to_xml_doc(data)
-        else:
-            data = state.data
-            doc, sasentry = self._data2d_to_xml_doc(data)
+        data = state.data
+        doc, sasentry = self._to_xml_doc(data)
 
         if state is not None:

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

@@ -39 +39 @@
         self.nimages = len(self.report_list[2])
 
-        if self.report_list[2] != None:
+        if self.report_list[2] is not None:
             # put image path in the report string
             if len(self.report_list[2]) == 1:

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

@@ -2 +2 @@
 Module contains functions frequently used in this package
 """
-import numpy
+import numpy as np
 
 
@@ -19 +19 @@
         data = data.y
     if flag == 0:
-        weight = numpy.ones_like(data)
+        weight = np.ones_like(data)
     elif flag == 1:
         weight = dy_data
     elif flag == 2:
-        weight = numpy.sqrt(numpy.abs(data))
+        weight = np.sqrt(np.abs(data))
     elif flag == 3:
-        weight = numpy.abs(data)
+        weight = np.abs(data)
     return weight