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

Timestamp:

Sep 23, 2017 4:24:27 PM (7 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, 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, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

b963b20, fca1f50

Parents:

9706d88 (diff), dba8557 (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 'ticket-887-reorg' into ticket-853-fit-gui-to-calc

Location:

src/sas/sasgui/perspectives/fitting

Files:

• __init__.py (modified) (4 diffs)
• basepage.py (modified) (4 diffs)
• batchfitpage.py (modified) (18 diffs)
• fit_thread.py (modified) (3 diffs)
• fitpage.py (modified) (6 diffs)
• fitpanel.py (modified) (10 diffs)
• fitproblem.py (modified) (40 diffs)
• fitting.py (modified) (36 diffs)
• model_thread.py (modified) (10 diffs)
• models.py (deleted)
• report_dialog.py (modified) (3 diffs)
• simfitpage.py (modified) (6 diffs)

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

@@ -13 +13 @@
     # Check for data path next to exe/zip file.
     # If we are inside a py2exe zip file, we need to go up
-    # to get to the directory containing 
+    # to get to the directory containing
     # the media for this module
     path = os.path.dirname(__file__)
@@ -26 +26 @@
                 return module_media_path
             return media_path
-   
+
     raise RuntimeError('Could not find models media files')
 
@@ -32 +32 @@
     """
     Return the data files associated with media.
-    
+
     The format is a list of (directory, [files...]) pairs which can be
     used directly in setup(...,data_files=...) for setup.py.
@@ -38 +38 @@
     """
     data_files = []
-    path = os.path.dirname(__file__)
-    p_path = os.path.join(path, 'plugin_models')
-    for f in findall(p_path):
-        data_files.append(('plugin_models', [f]))
-    # path = get_data_path(media="media")
-    for f in findall(path):
-        data_files.append(('media/fitting_media', [f]))
-    
+    # Note: windows installer requires the plugin_models directory
+    plugin_models = os.path.join(os.path.dirname(__file__), "plugin_models")
+    data_files.append(('plugin_models', findall(plugin_models)))
+    data_files.append(('media/fitting_media', findall(get_data_path("media"))))
+
     return data_files

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

@@ -12 +12 @@
 import logging
 import traceback
+from Queue import Queue
+from threading import Thread
 from collections import defaultdict
 
@@ -248 +250 @@
         self.set_layout()
 
+        # Setting up a thread for the fitting
+        self.threaded_draw_queue = Queue()
+
+        self.draw_worker_thread = Thread(target = self._threaded_draw_worker,
+                                         args = (self.threaded_draw_queue,))
+        self.draw_worker_thread.setDaemon(True)
+        self.draw_worker_thread.start()
+
+        # And a home for the thread submission times
+        self.last_time_fit_submitted = 0.00
+
     def set_index_model(self, index):
         """
@@ -1735 +1748 @@
         :param chisqr: update chisqr value [bool]
         """
-        wx.CallAfter(self._draw_model_after, update_chisqr, source)
+        self.threaded_draw_queue.put([copy.copy(update_chisqr), copy.copy(source)])
+
+    def _threaded_draw_worker(self, threaded_draw_queue):
+        while True:
+            # sit and wait for the next task
+            next_task = threaded_draw_queue.get()
+
+            # sleep for 1/10th second in case some other tasks accumulate
+            time.sleep(0.1)
+
+            # skip all intermediate tasks
+            while self.threaded_draw_queue.qsize() > 0:
+                self.threaded_draw_queue.task_done()
+                next_task = self.threaded_draw_queue.get()
+
+            # and finally, do the task
+            self._draw_model_after(*next_task)
+            threaded_draw_queue.task_done()
 
     def _draw_model_after(self, update_chisqr=True, source='model'):
@@ -1757 +1787 @@
             toggle_mode_on = self.model_view.IsEnabled()
             is_2d = self._is_2D()
+
             self._manager.draw_model(self.model,
                                      data=self.data,

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

@@ -5 +5 @@
 import wx.lib.newevent
 import math
+
+from sas.sascalc.fit.qsmearing import smear_selection
+
 from sas.sasgui.guiframe.events import StatusEvent
 from sas.sasgui.guiframe.events import NewPlotEvent
+from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent
+from sas.sasgui.perspectives.fitting.fitpage import FitPage
+from sas.sasgui.perspectives.fitting.fitpage import check_data_validity
 
 (Chi2UpdateEvent, EVT_CHI2_UPDATE) = wx.lib.newevent.NewEvent()
@@ -13 +19 @@
 SMEAR_SIZE_L = 0.00
 SMEAR_SIZE_H = 0.00
-
-from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent
-from sas.sascalc.data_util.qsmearing import smear_selection
-from sas.sasgui.perspectives.fitting.fitpage import FitPage
-from sas.sasgui.perspectives.fitting.fitpage import check_data_validity
 
 class BatchFitPage(FitPage):
@@ -76 +77 @@
 #         """
 #         is_2Ddata = False
-#         
+#
 #         # Check if data is 2D
 #         if self.data.__class__.__name__ ==  "Data2D" or \
 #                         self.enable2D:
 #             is_2Ddata = True
-#             
-#         title = "Fitting"     
+#
+#         title = "Fitting"
 #         self._get_smear_info()
-#         
+#
 #         #Sizers
 #         box_description_range = wx.StaticBox(self, wx.ID_ANY, str(title))
-#         boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)      
+#         boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)
 #         self.sizer_set_smearer = wx.BoxSizer(wx.VERTICAL)
 #         #sizer_smearer = wx.BoxSizer(wx.HORIZONTAL)
@@ -93 +94 @@
 #         self.sizer_set_masking = wx.BoxSizer(wx.HORIZONTAL)
 #         sizer_chi2 = wx.BoxSizer(wx.VERTICAL)
-# 
+#
 #         sizer_fit = wx.GridSizer(2, 4, 2, 6)
 #         #Fit button
@@ -100 +101 @@
 #         self.btFit.Bind(wx.EVT_BUTTON, self._onFit, id= self.btFit.GetId())
 #         self.btFit.SetToolTipString("Start fitting.")
-# 
+#
 #         # Update and Draw button
 #         self.draw_button = wx.Button(self, self._ids.next(), 'Compute', size=(88, 24))
 #         self.draw_button.Bind(wx.EVT_BUTTON, \
 #                               self._onDraw,id=self.draw_button.GetId())
-#         self.draw_button.SetToolTipString("Compute and Draw.")  
+#         self.draw_button.SetToolTipString("Compute and Draw.")
 #         sizer_fit.Add(self.draw_button, 0, 0)
-#         sizer_fit.Add(self.btFit, 0, 0) 
+#         sizer_fit.Add(self.btFit, 0, 0)
 #         sizer_chi2.Add((-1, 5))
 #         # get smear_selection
@@ -114 +115 @@
 #          #2D data? default
 #         is_2Ddata = False
-#         
+#
 #         #check if it is 2D data
 #         if self.data.__class__.__name__ ==  "Data2D" or \
 #                         self.enable2D:
 #             is_2Ddata = True
-#             
+#
 #         self.sizer5.Clear(True)
-#      
+#
 #         self.qmin  = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
-#                                           style=wx.TE_PROCESS_ENTER, 
+#                                           style=wx.TE_PROCESS_ENTER,
 #                                     text_enter_callback = self._onQrangeEnter)
 #         self.qmin.SetValue(str(self.qmin_x))
 #         self.qmin.SetToolTipString("Minimun value of Q in linear scale.")
-#      
+#
 #         self.qmax  = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
-#                                           style=wx.TE_PROCESS_ENTER, 
+#                                           style=wx.TE_PROCESS_ENTER,
 #                                         text_enter_callback=self._onQrangeEnter)
 #         self.qmax.SetValue(str(self.qmax_x))
 #         self.qmax.SetToolTipString("Maximum value of Q in linear scale.")
-#         
+#
 #         id = self._ids.next()
 #         self.reset_qrange =wx.Button(self, id, 'Reset', size=(77, 20))
-#       
+#
 #         self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked, id=id)
 #         self.reset_qrange.SetToolTipString(\
 #                                     "Reset Q range to the default values")
-#      
+#
 #         sizer_horizontal = wx.BoxSizer(wx.HORIZONTAL)
 #         sizer = wx.GridSizer(2, 4, 2, 6)
-# 
+#
 #         self.btEditMask = wx.Button(self, self._ids.next(),'Editor', size=(88, 23))
-#         self.btEditMask.Bind(wx.EVT_BUTTON, 
+#         self.btEditMask.Bind(wx.EVT_BUTTON,
 #                              self._onMask,id=self.btEditMask.GetId())
 #         self.btEditMask.SetToolTipString("Edit Mask.")
 #         self.EditMask_title = wx.StaticText(self, wx.ID_ANY, ' Masking(2D)')
-# 
+#
 #         sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Q range'))
 #         sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Min[1/A]'))
 #         sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Max[1/A]'))
 #         sizer.Add(self.EditMask_title)
-#  
-#         sizer.Add(self.reset_qrange)   
+#
+#         sizer.Add(self.reset_qrange)
 #         sizer.Add(self.qmin)
 #         sizer.Add(self.qmax)
-# 
+#
 #         sizer.Add(self.btEditMask)
-#         boxsizer_range.Add(sizer_chi2) 
+#         boxsizer_range.Add(sizer_chi2)
 #         boxsizer_range.Add((10, 10))
 #         boxsizer_range.Add(sizer)
-#         
+#
 #         boxsizer_range.Add((10, 15))
 #         boxsizer_range.Add(sizer_fit)
 #         if is_2Ddata:
-#             self.btEditMask.Enable()  
-#             self.EditMask_title.Enable() 
+#             self.btEditMask.Enable()
+#             self.EditMask_title.Enable()
 #         else:
-#             self.btEditMask.Disable()  
+#             self.btEditMask.Disable()
 #             self.EditMask_title.Disable()
-# 
+#
 #         ## save state
 #         #self.save_current_state()
-# 
+#
 #         self.sizer5.Add(boxsizer_range, 0, wx.EXPAND | wx.ALL, 10)
 #         self.sizer5.Layout()
-#        
-#     def _on_select_model(self, event=None): 
+#
+#     def _on_select_model(self, event=None):
 #         """
 #         call back for model selection
-#         """  
-#         
-#         self.Show(False)    
-#         self._on_select_model_helper() 
-#         self.set_model_param_sizer(self.model)                   
+#         """
+#
+#         self.Show(False)
+#         self._on_select_model_helper()
+#         self.set_model_param_sizer(self.model)
 #         if self.model is None:
 #             self._set_bookmark_flag(False)
@@ -199 +200 @@
 #         self.state.structurecombobox = self.structurebox.GetCurrentSelection()
 #         self.state.formfactorcombobox = self.formfactorbox.GetCurrentSelection()
-#       
+#
 #         if self.model is not None:
 #             self._set_copy_flag(True)
@@ -206 +207 @@
 #                 self._set_bookmark_flag(False)
 #                 self._keep.Enable(False)
-#                 
+#
 #             temp_smear = None
 #             ## event to post model to fit to fitting plugins
 #             (ModelEventbox, _) = wx.lib.newevent.NewEvent()
-#          
-#             ## set smearing value whether or not 
+#
+#             ## set smearing value whether or not
 #             #    the data contain the smearing info
-#             evt = ModelEventbox(model=self.model, 
-#                                         smearer=temp_smear, 
+#             evt = ModelEventbox(model=self.model,
+#                                         smearer=temp_smear,
 #                                         qmin=float(self.qmin_x),
 #                                         uid=self.uid,
-#                                      qmax=float(self.qmax_x)) 
-#    
+#                                      qmax=float(self.qmax_x))
+#
 #             self._manager._on_model_panel(evt=evt)
 #             self.mbox_description.SetLabel("Model [%s]" % str(self.model.name))
 #             self.state.model = self.model.clone()
 #             self.state.model.name = self.model.name
-# 
-#             
+#
+#
 #         if event is not None:
 #             ## post state to fit panel
 #             new_event = PageInfoEvent(page = self)
-#             wx.PostEvent(self.parent, new_event) 
+#             wx.PostEvent(self.parent, new_event)
 #             #update list of plugins if new plugin is available
 #             if self.plugin_rbutton.GetValue():
@@ -243 +244 @@
 #             self._draw_model()
 #         self.SetupScrolling()
-#         self.Show(True)   
-#         
+#         self.Show(True)
+#
 #     def _update_paramv_on_fit(self):
 #         """
@@ -253 +254 @@
 #         self.fitrange = True
 #         is_modified = False
-# 
+#
 #         if self.model is not None:
 #             ##Check the values
@@ -259 +260 @@
 #             self._check_value_enter( self.fixed_param)
 #             self._check_value_enter( self.parameters)
-# 
-#             # If qmin and qmax have been modified, update qmin and qmax and 
+#
+#             # If qmin and qmax have been modified, update qmin and qmax and
 #              # Here we should check whether the boundaries have been modified.
-#             # If qmin and qmax have been modified, update qmin and qmax and 
+#             # If qmin and qmax have been modified, update qmin and qmax and
 #             # set the is_modified flag to True
 #             self.fitrange = self._validate_qrange(self.qmin, self.qmax)
@@ -273 +274 @@
 #                     self.qmax_x = tempmax
 #                 if tempmax == tempmin:
-#                     flag = False    
+#                     flag = False
 #                 #temp_smearer = None
 #                 if self._is_2D():
-#                     # only 2D case set mask  
+#                     # only 2D case set mask
 #                     flag = self._validate_Npts()
 #                     if not flag:
 #                         return flag
 #             else: flag = False
-#         else: 
+#         else:
 #             flag = False
-# 
-#         #For invalid q range, disable the mask editor and fit button, vs.    
+#
+#         #For invalid q range, disable the mask editor and fit button, vs.
 #         if not self.fitrange:
 #             #self.btFit.Disable()
@@ -293 +294 @@
 #             if self._is_2D() and  self.data is not None:
 #                 self.btEditMask.Enable(True)
-# 
+#
 #         if not flag:
 #             msg = "Cannot Plot or Fit :Must select a "
 #             msg += " model or Fitting range is not valid!!!  "
 #             wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
-#         
+#
 #         self.save_current_state()
-#    
-#         return flag  
+#
+#         return flag
 #     def save_current_state(self):
 #         """
 #         Currently no save option implemented for batch page
 #         """
-#         pass 
+#         pass
 #     def save_current_state_fit(self):
 #         """
@@ -314 +315 @@
 #     def set_data(self, data):
 #         """
-#         reset the current data 
+#         reset the current data
 #         """
 #         #id = None
@@ -340 +341 @@
 #             self._set_save_flag(False)
 #             self._set_preview_flag(True)
-#   
+#
 #             self.formfactorbox.Enable()
 #             self.structurebox.Enable()
@@ -346 +347 @@
 #             #set maximum range for x in linear scale
 #             if not hasattr(self.data,"data"): #Display only for 1D data fit
-#                 # Minimum value of data   
+#                 # Minimum value of data
 #                 data_min = min(self.data.x)
-#                 # Maximum value of data  
+#                 # Maximum value of data
 #                 data_max = max(self.data.x)
-#                 self.btEditMask.Disable()  
+#                 self.btEditMask.Disable()
 #                 self.EditMask_title.Disable()
 #             else:
-#                 
-#                 ## Minimum value of data 
+#
+#                 ## Minimum value of data
 #                 data_min = 0
-#                 x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax)) 
+#                 x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
 #                 y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
-#                 ## Maximum value of data  
+#                 ## Maximum value of data
 #                 data_max = math.sqrt(x*x + y*y)
-#                 self.btEditMask.Enable()  
-#                 self.EditMask_title.Enable() 
-# 
+#                 self.btEditMask.Enable()
+#                 self.EditMask_title.Enable()
+#
 #         self.dataSource.SetValue(data_name)
 #         self.qmin_x = data_min
@@ -375 +376 @@
 #         self.state.qmin = self.qmin_x
 #         self.state.qmax = self.qmax_x
-#         
+#
 #         #update model plot with new data information
 #         if flag:
@@ -385 +386 @@
 #                 self.enable2D = False
 #                 self.model_view.SetLabel("1D Mode")
-#                 
+#
 #             self.model_view.Disable()
-#             
-#             wx.PostEvent(self._manager.parent, 
+#
+#             wx.PostEvent(self._manager.parent,
 #                              NewPlotEvent(group_id=group_id,
 #                                                action="delete"))
 #             #plot the current selected data
-#             wx.PostEvent(self._manager.parent, NewPlotEvent(plot=self.data, 
+#             wx.PostEvent(self._manager.parent, NewPlotEvent(plot=self.data,
 #                                                     title=str(self.data.title)))
 #             self._manager.store_data(uid=self.uid, data=data,

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

@@ -29 +29 @@
                  worktime=0.03,
                  reset_flag=False):
-        CalcThread.__init__(self,
-                 completefn,
-                 updatefn,
-                 yieldtime,
-                 worktime)
+        CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime)
         self.handler = handler
         self.fitter = fn
@@ -93 +89 @@
             # Real code should not print, but this is an example...
             #print "keyboard exception"
-            #Stop on exception during fitting. Todo: need to put 
+            #Stop on exception during fitting. Todo: need to put
             #some mssg and reset progress bar.
 
@@ -100 +96 @@
             if self.handler is not None:
                 self.handler.stop(msg=msg)
-        except:
+        except:  # catch-all: show every exception which stops the thread
             import traceback
             if self.handler is not None:

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

@@ -14 +14 @@
 from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
 
+from sas.sascalc.fit.qsmearing import smear_selection
+
 from sas.sasgui.guiframe.events import StatusEvent, NewPlotEvent, \
     PlotQrangeEvent
@@ -23 +25 @@
 from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent as \
     PageInfoEvent
-from sas.sascalc.data_util.qsmearing import smear_selection
 from .basepage import ModelTextCtrl
 
@@ -1142 +1143 @@
             self.model.name = "M" + str(self.index_model)
 
-    def _on_select_model(self, event=None):
+    def _on_select_model(self, event=None, keep_pars=False):
         """
         call back for model selection
         """
         self.Show(False)
-        copy_flag = False
-        is_poly_enabled = None
         if event is not None:
-            if (event.GetEventObject() == self.formfactorbox
-                    and self.structurebox.GetLabel() != 'None')\
-                    or event.GetEventObject() == self.structurebox\
-                    or event.GetEventObject() == self.multifactorbox:
-                copy_flag = self.get_copy_params()
-                is_poly_enabled = self.enable_disp.GetValue()
+            control = event.GetEventObject()
+            if ((control == self.formfactorbox
+                 and self.structurebox.GetLabel() != 'None')
+                    or control == self.structurebox
+                    or control == self.multifactorbox):
+                keep_pars = True
+
+        if keep_pars:
+            saved_pars = self.get_copy_params()
+            is_poly_enabled = self.enable_disp.GetValue()
+        else:
+            saved_pars = None
+            is_poly_enabled = None
+
         try:
             self._on_select_model_helper()
@@ -1177 +1184 @@
         try:
             self.set_dispers_sizer()
-        except:
+        except Exception:
             pass
         self.state.enable_disp = self.enable_disp.GetValue()
@@ -1238 +1245 @@
             self.state.model.name = self.model.name
 
+        # when select a model only from guictr/button
+        if is_poly_enabled is not None:
+            self.enable_disp.SetValue(is_poly_enabled)
+            self.disable_disp.SetValue(not is_poly_enabled)
+            self._set_dipers_Param(event=None)
+            self.state.enable_disp = self.enable_disp.GetValue()
+            self.state.disable_disp = self.disable_disp.GetValue()
+
+        # Keep the previous param values
+        if saved_pars:
+            self.get_paste_params(saved_pars)
+
         if event is not None:
+            # update list of plugins if new plugin is available
+            # mod_cat = self.categorybox.GetStringSelection()
+            # if mod_cat == CUSTOM_MODEL:
+            #     temp = self.parent.update_model_list()
+            #     for v in self.parent.model_dictionary.values():
+            #         if v.id == self.model.id:
+            #             self.model = v()
+            #             break
+            #     if temp:
+            #         self.model_list_box = temp
+            #         current_val = self.formfactorbox.GetLabel()
+            #         pos = self.formfactorbox.GetSelection()
+            #         self._show_combox_helper()
+            #         self.formfactorbox.SetStringSelection(current_val)
+            #         self.formfactorbox.SetValue(current_val)
             # post state to fit panel
             new_event = PageInfoEvent(page=self)
             wx.PostEvent(self.parent, new_event)
-            # update list of plugins if new plugin is available
-            mod_cat = self.categorybox.GetStringSelection()
-            if mod_cat == CUSTOM_MODEL:
-                temp_id = self.model.id
-                temp = self.parent.update_model_list()
-                for v in self.parent.model_dictionary.values():
-                    if v.id == temp_id:
-                        self.model = v()
-                        break
-                if temp:
-                    self.model_list_box = temp
-                    current_val = self.formfactorbox.GetLabel()
-                    pos = self.formfactorbox.GetSelection()
-                    self._show_combox_helper()
-                    self.formfactorbox.SetSelection(pos)
-                    self.formfactorbox.SetValue(current_val)
-            # when select a model only from guictr/button
-            if is_poly_enabled is not None:
-                self.enable_disp.SetValue(is_poly_enabled)
-                self.disable_disp.SetValue(not is_poly_enabled)
-                self._set_dipers_Param(event=None)
-                self.state.enable_disp = self.enable_disp.GetValue()
-                self.state.disable_disp = self.disable_disp.GetValue()
-
-            # Keep the previous param values
-            if copy_flag:
-                self.get_paste_params(copy_flag)
             wx.CallAfter(self._onDraw, None)
 
@@ -1726 +1733 @@
         ind = 0
         while(ind < len(list)):
-            for key, val in list.iteritems():
-                if (val == ind):
+            for key, val in list.items():
+                if val == ind:
                     fun_box.Append(key, val)
                     break

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

@@ -9 +9 @@
 from wx.aui import AuiNotebook as nb
 
+from sas.sascalc.fit.models import ModelManager
+
 from sas.sasgui.guiframe.panel_base import PanelBase
 from sas.sasgui.guiframe.events import PanelOnFocusEvent, StatusEvent
 from sas.sasgui.guiframe.dataFitting import check_data_validity
-from sas.sasgui.perspectives.fitting.simfitpage import SimultaneousFitPage
-
-import basepage
-import models
+
+
+from . import basepage
+from .fitpage import FitPage
+from .simfitpage import SimultaneousFitPage
+from .batchfitpage import BatchFitPage
+from .fitting_widgets import BatchDataDialog
+
 _BOX_WIDTH = 80
 
@@ -46 +52 @@
         self.event_owner = None
         # dictionary of miodel {model class name, model class}
-        self.menu_mng = models.ModelManager()
+        self.menu_mng = ModelManager()
         self.model_list_box = self.menu_mng.get_model_list()
         # pageClosedEvent = nb.EVT_FLATNOTEBOOK_PAGE_CLOSING
@@ -114 +120 @@
         """
         temp = self.menu_mng.update()
-        if len(temp):
+        if temp:
             self.model_list_box = temp
         return temp
@@ -121 +127 @@
         """
         """
-        temp = self.menu_mng.plugins_reset()
-        if len(temp):
-            self.model_list_box = temp
-        return temp
+        self.model_list_box = self.menu_mng.plugins_reset()
+        return self.model_list_box
 
     def get_page_by_id(self, uid):
@@ -298 +302 @@
         self.model_list_box = dict
 
-    def set_model_dict(self, m_dict):
+    def set_model_dictionary(self, model_dictionary):
         """
         copy a dictionary of model name -> model object
 
-        :param m_dict: dictionary linking model name -> model object
+        :param model_dictionary: dictionary linking model name -> model object
         """
 
@@ -316 +320 @@
         Add the simultaneous fit page
         """
-        from simfitpage import SimultaneousFitPage
         page_finder = self._manager.get_page_finder()
         if caption == "Const & Simul Fit":
@@ -344 +347 @@
         """
         if self.batch_on:
-            from batchfitpage import BatchFitPage
             panel = BatchFitPage(parent=self)
             self.batch_page_index += 1
@@ -351 +353 @@
         else:
             # Increment index of fit page
-            from fitpage import FitPage
             panel = FitPage(parent=self)
             self.fit_page_index += 1
@@ -359 +360 @@
         panel._set_save_flag(not panel.batch_on)
         panel.set_model_dictionary(self.model_dictionary)
-        panel.populate_box(model_dict=self.model_list_box)
+        panel.populate_box(model_list_box=self.model_list_box)
         panel.formfactor_combo_init()
         panel.set_manager(self._manager)
@@ -445 +446 @@
         if data_1d_list and data_2d_list:
             # need to warning the user that this batch is a special case
-            from sas.sasgui.perspectives.fitting.fitting_widgets import \
-                BatchDataDialog
             dlg = BatchDataDialog(self)
             if dlg.ShowModal() == wx.ID_OK:

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

@@ -14 +14 @@
 ################################################################################
 import copy
-from sas.sascalc.data_util.qsmearing import smear_selection
-
-class FitProblemComponent(object):
+
+from sas.sascalc.fit.qsmearing import smear_selection
+
+class FitProblem(object):
     """
-    Inferface containing information to store data, model, range of data, etc...
-    and retreive this information. This is an inferface
-    for a fitProblem i.e relationship between data and model.
+    Define the relationship between data and model, including range, weights,
+    etc.
     """
+    def __init__(self):
+        """
+        contains information about data and model to fit
+        """
+        ## data used for fitting
+        self.fit_data = None
+        self.theory_data = None
+        self.residuals = None
+        # original data: should not be modified
+        self.original_data = None
+        ## the current model
+        self.model = None
+        ## if 1 this fit problem will be selected to fit , if 0
+        ## it will not be selected for fit
+        self.schedule = 0
+        ##list containing parameter name and value
+        self.list_param = []
+        self.list_param2fit = []
+        ## smear object to smear or not data1D
+        self.smearer_computed = False
+        self.smearer_enable = False
+        self.smearer_computer_value = None
+        ## fitting range
+        self.qmin = None
+        self.qmax = None
+        # fit weight
+        self.weight = None
+        self.result = None
+        self.fit_tab_caption = None
+        self.name_per_page = None
+
     def enable_smearing(self, flag=False):
         """
@@ -27 +58 @@
             flag is 0 ingore smear value.
         """
+        self.smearer_enable = flag
+
+    def set_smearer(self, smearer):
+        """
+        save reference of  smear object on fitdata
+
+        :param smear: smear object from DataLoader
+
+        """
+        self.smearer_computer_value = smearer
 
     def get_smearer(self):
@@ -32 +73 @@
         return smear object
         """
+        if not self.smearer_enable:
+            return None
+        if not self.smearer_computed:
+            #smeari_selection should be call only once per fitproblem
+            self.smearer_computer_value = smear_selection(self.fit_data,
+                                                          self.model)
+            self.smearer_computed = True
+        return self.smearer_computer_value
+
     def save_model_name(self, name):
         """
         """
+        self.name_per_page = name
 
     def get_name(self):
         """
         """
+        return self.name_per_page
 
     def set_model(self, model):
@@ -46 +98 @@
         :param name: name created for model
         """
+        self.model = model
+        self.smearer_computer_value = smear_selection(self.fit_data,
+                                                      self.model)
+        self.smearer_computed = True
 
     def get_model(self):
@@ -51 +107 @@
         :return: saved model
         """
+        return self.model
 
     def set_residuals(self, residuals):
@@ -57 +114 @@
         :param data: data selected
         """
+        self.residuals = residuals
 
     def get_residuals(self):
@@ -62 +120 @@
         :return: residuals
         """
+        return self.residuals
 
     def set_theory_data(self, data):
         """
         save a copy of the data select to fit
+
         :param data: data selected
-        """
+
+        """
+        self.theory_data = copy.deepcopy(data)
 
     def get_theory_data(self):
         """
-        :return: list of data dList
-        """
+        :return: theory generated with the current model and data of this class
+        """
+        return self.theory_data
 
     def set_fit_data(self, data):
         """
-        Store of list of data and create  by create new fitproblem of each data
-        id, if there was existing information about model, this information
-        get copy to the new fitproblem
+        Store data associated with this class
         :param data: list of data selected
         """
+        self.original_data = None
+        self.fit_data = None
+        # original data: should not be modified
+        self.original_data = data
+        # fit data: used for fit and can be modified for convenience
+        self.fit_data = copy.deepcopy(data)
+        self.smearer_computer_value = smear_selection(self.fit_data, self.model)
+        self.smearer_computed = True
+        self.result = None
 
     def get_fit_data(self):
         """
-        """
+        :return: data associate with this class
+        """
+        return self.fit_data
+
+    def get_origin_data(self):
+        """
+        """
+        return self.original_data
+
+    def set_weight(self, is2d, flag=None):
+        """
+        Received flag and compute error on data.
+        :param flag: flag to transform error of data.
+        :param is2d: flag to distinguish 1D to 2D Data
+        """
+        from sas.sasgui.perspectives.fitting.utils import get_weight
+        # send original data for weighting
+        self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag)
+        if is2d:
+            self.fit_data.err_data = self.weight
+        else:
+            self.fit_data.dy = self.weight
+
+    def get_weight(self):
+        """
+        returns weight array
+        """
+        return self.weight
+
+    def set_param2fit(self, list):
+        """
+        Store param names to fit (checked)
+        :param list: list of the param names
+        """
+        self.list_param2fit = list
+
+    def get_param2fit(self):
+        """
+        return the list param names to fit
+        """
+        return self.list_param2fit
 
     def set_model_param(self, name, value=None):
@@ -92 +202 @@
         :param value: value of that parameter
         """
-
-    def set_param2fit(self, list):
-        """
-        Store param names to fit (checked)
-        :param list: list of the param names
-        """
-
-    def get_param2fit(self):
-        """
-        return the list param names to fit
-        """
+        self.list_param.append([name, value])
 
     def get_model_param(self):
@@ -108 +208 @@
         return list of couple of parameter name and value
         """
+        return self.list_param
 
     def schedule_tofit(self, schedule=0):
@@ -113 +214 @@
         set schedule to true to decide if this fit  must be performed
         """
+        self.schedule = schedule
 
     def get_scheduled(self):
@@ -118 +220 @@
         return true or false if a problem as being schedule for fitting
         """
+        return self.schedule
 
     def set_range(self, qmin=None, qmax=None):
         """
         set fitting range
-        """
+        :param qmin: minimum value to consider for the fit range
+        :param qmax: maximum value to consider for the fit range
+        """
+        self.qmin = qmin
+        self.qmax = qmax
 
     def get_range(self):
         """
         :return: fitting range
-        """
-
-    def set_weight(self, flag=None):
-        """
-        set fitting range
-        """
-
-    def get_weight(self):
-        """
-        get fitting weight
-        """
+
+        """
+        return self.qmin, self.qmax
 
     def clear_model_param(self):
@@ -143 +242 @@
         clear constraint info
         """
+        self.list_param = []
 
     def set_fit_tab_caption(self, caption):
         """
-        store the caption of the page associated with object
-        """
+        """
+        self.fit_tab_caption = str(caption)
 
     def get_fit_tab_caption(self):
         """
-        Return the caption of the page associated with object
-        """
+        """
+        return self.fit_tab_caption
 
     def set_graph_id(self, id):
@@ -158 +258 @@
         Set graph id (from data_group_id at the time the graph produced)
         """
+        self.graph_id = id
 
     def get_graph_id(self):
@@ -163 +264 @@
         Get graph_id
         """
+        return self.graph_id
 
     def set_result(self, result):
         """
         """
+        self.result = result
 
     def get_result(self):
@@ -172 +275 @@
         get result
         """
-
-
-class FitProblemDictionary(FitProblemComponent, dict):
+        return self.result
+
+
+class FitProblemDictionary(dict):
     """
     This module implements a dictionary of fitproblem objects
     """
     def __init__(self):
-        FitProblemComponent.__init__(self)
         dict.__init__(self)
         ## the current model
@@ -206 +309 @@
         self._smear_on = flag
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.enable_smearing(flag)
-        else:
-            if fid in self.iterkeys():
-                self[fid].enable_smearing(flag)
+        elif fid in self:
+            self[fid].enable_smearing(flag)
 
     def set_smearer(self, smearer, fid=None):
@@ -218 +320 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_smearer(smearer)
-        else:
-            if fid in self.iterkeys():
-                self[fid].set_smearer(smearer)
+        elif fid in self:
+            self[fid].set_smearer(smearer)
 
     def get_smearer(self, fid=None):
@@ -228 +329 @@
         return smear object
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_smearer()
 
@@ -235 +336 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.save_model_name(name)
-        else:
-            if fid in self.iterkeys():
-                self[fid].save_model_name(name)
+        elif fid in self:
+            self[fid].save_model_name(name)
 
     def get_name(self, fid=None):
@@ -246 +346 @@
         result = []
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 result.append(value.get_name())
-        else:
-            if fid in self.iterkeys():
-                result.append(self[fid].get_name())
+        elif fid in self:
+            result.append(self[fid].get_name())
         return result
 
@@ -261 +360 @@
         self.model = model
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_model(self.model)
-        else:
-            if fid in self.iterkeys():
-                self[fid].set_model(self.model)
+        elif fid in self:
+            self[fid].set_model(self.model)
 
     def get_model(self, fid):
@@ -271 +369 @@
         :return: saved model
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_model()
 
@@ -291 +389 @@
         :param data: data selected
         """
-        if fid in self.iterkeys():
+        if fid in self:
             self[fid].set_residuals(residuals)
 
@@ -298 +396 @@
         :return: residuals
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_residuals()
 
@@ -306 +404 @@
         :param data: data selected
         """
-        if fid in self.iterkeys():
+        if fid in self:
             self[fid].set_theory_data(data)
 
@@ -313 +411 @@
         :return: list of data dList
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_theory_data()
 
@@ -322 +420 @@
         :note: only data changes in the fit problem
         """
-        if data.id not in self.iterkeys():
+        if data.id not in self:
             self[data.id] = FitProblem()
         self[data.id].set_fit_data(data)
@@ -336 +434 @@
             data = []
         for d in data:
-            if (d is not None):
-                if (d.id not in self.iterkeys()):
+            if d is not None:
+                if d.id not in self:
                     self[d.id] = FitProblem()
                 self[d.id].set_fit_data(d)
@@ -348 +446 @@
         :param fid: key representing a fitproblem, usually extract from data id
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_fit_data()
 
@@ -358 +456 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_model_param(name, value)
-        else:
-            if fid in self.iterkeys():
-                self[fid].set_model_param(name, value)
+        elif fid in self:
+            self[fid].set_model_param(name, value)
 
     def get_model_param(self, fid):
@@ -368 +465 @@
         return list of couple of parameter name and value
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_model_param()
 
@@ -389 +486 @@
         """
         self.scheduled = schedule
-        for value in self.itervalues():
+        for value in self.values():
             value.schedule_tofit(schedule)
 
@@ -405 +502 @@
         self.qmax = qmax
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_range(self.qmin, self.qmax)
-        else:
-            if fid in self.iterkeys():
-                self[fid].value.set_range(self.qmin, self.qmax)
+        elif fid in self:
+            self[fid].value.set_range(self.qmin, self.qmax)
 
     def get_range(self, fid):
@@ -415 +511 @@
         :return: fitting range
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_range()
 
@@ -423 +519 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_weight(flag=flag, is2d=is2d)
-        else:
-            if fid in self.iterkeys():
-                self[fid].set_weight(flag=flag, is2d=is2d)
+        elif fid in self:
+            self[fid].set_weight(flag=flag, is2d=is2d)
 
     def get_weight(self, fid=None):
@@ -433 +528 @@
         return fit weight
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_weight()
 
@@ -441 +536 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.clear_model_param()
-        else:
-            if fid in self.iterkeys():
-                self[fid].clear_model_param()
+        elif fid in self:
+            self[fid].clear_model_param()
 
     def get_fit_problem(self):
@@ -451 +545 @@
         return fitproblem contained in this dictionary
         """
-        return self.itervalues()
+        return self.values()
 
     def set_result(self, result, fid):
         """
         """
-        if fid in self.iterkeys():
+        if fid in self:
             self[fid].set_result(result)
 
@@ -470 +564 @@
         get result
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_result()
 
@@ -490 +584 @@
         """
         return self.graph_id
-
-
-class FitProblem(FitProblemComponent):
-    """
-    FitProblem class allows to link a model with the new name created in _on_model,
-    a name theory created with that model  and the data fitted with the model.
-    FitProblem is mostly used  as value of the dictionary by fitting module.
-    """
-    def __init__(self):
-        FitProblemComponent.__init__(self)
-        """
-        contains information about data and model to fit
-        """
-        ## data used for fitting
-        self.fit_data = None
-        self.theory_data = None
-        self.residuals = None
-        # original data: should not be modified
-        self.original_data = None
-        ## the current model
-        self.model = None
-        ## if 1 this fit problem will be selected to fit , if 0
-        ## it will not be selected for fit
-        self.schedule = 0
-        ##list containing parameter name and value
-        self.list_param = []
-        ## smear object to smear or not data1D
-        self.smearer_computed = False
-        self.smearer_enable = False
-        self.smearer_computer_value = None
-        ## fitting range
-        self.qmin = None
-        self.qmax = None
-        # fit weight
-        self.weight = None
-        self.result = None
-
-    def enable_smearing(self, flag=False):
-        """
-        :param flag: bool.When flag is 1 get the computer smear value. When
-            flag is 0 ingore smear value.
-        """
-        self.smearer_enable = flag
-
-    def set_smearer(self, smearer):
-        """
-        save reference of  smear object on fitdata
-
-        :param smear: smear object from DataLoader
-
-        """
-        self.smearer_computer_value = smearer
-
-    def get_smearer(self):
-        """
-        return smear object
-        """
-        if not self.smearer_enable:
-            return None
-        if not self.smearer_computed:
-            #smeari_selection should be call only once per fitproblem
-            self.smearer_computer_value = smear_selection(self.fit_data,
-                                                           self.model)
-            self.smearer_computed = True
-        return self.smearer_computer_value
-
-    def save_model_name(self, name):
-        """
-        """
-        self.name_per_page = name
-
-    def get_name(self):
-        """
-        """
-        return self.name_per_page
-
-    def set_model(self, model):
-        """
-        associates each model with its new created name
-        :param model: model selected
-        :param name: name created for model
-        """
-        self.model = model
-        self.smearer_computer_value = smear_selection(self.fit_data,
-                                                           self.model)
-        self.smearer_computed = True
-
-    def get_model(self):
-        """
-        :return: saved model
-        """
-        return self.model
-
-    def set_residuals(self, residuals):
-        """
-        save a copy of residual
-        :param data: data selected
-        """
-        self.residuals = residuals
-
-    def get_residuals(self):
-        """
-        :return: residuals
-        """
-        return self.residuals
-
-    def set_theory_data(self, data):
-        """
-        save a copy of the data select to fit
-
-        :param data: data selected
-
-        """
-        self.theory_data = copy.deepcopy(data)
-
-    def get_theory_data(self):
-        """
-        :return: theory generated with the current model and data of this class
-        """
-        return self.theory_data
-
-    def set_fit_data(self, data):
-        """
-        Store data associated with this class
-        :param data: list of data selected
-        """
-        self.original_data = None
-        self.fit_data = None
-        # original data: should not be modified
-        self.original_data = data
-        # fit data: used for fit and can be modified for convenience
-        self.fit_data = copy.deepcopy(data)
-        self.smearer_computer_value = smear_selection(self.fit_data,
-                                                           self.model)
-        self.smearer_computed = True
-        self.result = None
-
-    def get_fit_data(self):
-        """
-        :return: data associate with this class
-        """
-        return self.fit_data
-
-    def get_origin_data(self):
-        """
-        """
-        return self.original_data
-
-    def set_weight(self, is2d, flag=None):
-        """
-        Received flag and compute error on data.
-        :param flag: flag to transform error of data.
-        :param is2d: flag to distinguish 1D to 2D Data
-        """
-        from sas.sasgui.perspectives.fitting.utils import get_weight
-        # send original data for weighting
-        self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag)
-        if is2d:
-            self.fit_data.err_data = self.weight
-        else:
-            self.fit_data.dy = self.weight
-
-    def get_weight(self):
-        """
-        returns weight array
-        """
-        return self.weight
-
-    def set_param2fit(self, list):
-        """
-        Store param names to fit (checked)
-        :param list: list of the param names
-        """
-        self.list_param2fit = list
-
-    def get_param2fit(self):
-        """
-        return the list param names to fit
-        """
-        return self.list_param2fit
-
-    def set_model_param(self, name, value=None):
-        """
-        Store the name and value of a parameter of this fitproblem's model
-        :param name: name of the given parameter
-        :param value: value of that parameter
-        """
-        self.list_param.append([name, value])
-
-    def get_model_param(self):
-        """
-        return list of couple of parameter name and value
-        """
-        return self.list_param
-
-    def schedule_tofit(self, schedule=0):
-        """
-        set schedule to true to decide if this fit  must be performed
-        """
-        self.schedule = schedule
-
-    def get_scheduled(self):
-        """
-        return true or false if a problem as being schedule for fitting
-        """
-        return self.schedule
-
-    def set_range(self, qmin=None, qmax=None):
-        """
-        set fitting range
-        :param qmin: minimum value to consider for the fit range
-        :param qmax: maximum value to consider for the fit range
-        """
-        self.qmin = qmin
-        self.qmax = qmax
-
-    def get_range(self):
-        """
-        :return: fitting range
-
-        """
-        return self.qmin, self.qmax
-
-    def clear_model_param(self):
-        """
-        clear constraint info
-        """
-        self.list_param = []
-
-    def set_fit_tab_caption(self, caption):
-        """
-        """
-        self.fit_tab_caption = str(caption)
-
-    def get_fit_tab_caption(self):
-        """
-        """
-        return self.fit_tab_caption
-
-    def set_graph_id(self, id):
-        """
-        Set graph id (from data_group_id at the time the graph produced)
-        """
-        self.graph_id = id
-
-    def get_graph_id(self):
-        """
-        Get graph_id
-        """
-        return self.graph_id
-
-    def set_result(self, result):
-        """
-        """
-        self.result = result
-
-    def get_result(self):
-        """
-        get result
-        """
-        return self.result

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

@@ -23 +23 @@
 import traceback
 
+import bumps.options
+from bumps.gui.fit_dialog import show_fit_config
+try:
+    from bumps.gui.fit_dialog import EVT_FITTER_CHANGED
+except ImportError:
+    # CRUFT: bumps 0.7.5.8 and below
+    EVT_FITTER_CHANGED = None  # type: wx.PyCommandEvent
+
 from sas.sascalc.dataloader.loader import Loader
+from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit
+from sas.sascalc.fit.pagestate import Reader, PageState, SimFitPageState
+from sas.sascalc.fit import models
+
 from sas.sasgui.guiframe.dataFitting import Data2D
 from sas.sasgui.guiframe.dataFitting import Data1D
@@ -34 +46 @@
 from sas.sasgui.guiframe.plugin_base import PluginBase
 from sas.sasgui.guiframe.data_processor import BatchCell
-from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit
-from sas.sasgui.perspectives.fitting.console import ConsoleUpdate
-from sas.sasgui.perspectives.fitting.fitproblem import FitProblemDictionary
-from sas.sasgui.perspectives.fitting.fitpanel import FitPanel
-from sas.sasgui.perspectives.fitting.resultpanel import ResultPanel, PlotResultEvent
-
-from sas.sasgui.perspectives.fitting.fit_thread import FitThread
-from sas.sasgui.perspectives.fitting.pagestate import Reader
-from sas.sasgui.perspectives.fitting.fitpage import Chi2UpdateEvent
+from sas.sasgui.guiframe.gui_manager import MDIFrame
+from sas.sasgui.guiframe.documentation_window import DocumentationWindow
+
 from sas.sasgui.perspectives.calculator.model_editor import TextDialog
 from sas.sasgui.perspectives.calculator.model_editor import EditorWindow
-from sas.sasgui.guiframe.gui_manager import MDIFrame
-from sas.sasgui.guiframe.documentation_window import DocumentationWindow
-from sas.sasgui.perspectives.fitting.gpu_options import GpuOptions
-
-from . import models
+from sas.sasgui.perspectives.calculator.pyconsole import PyConsole
+
+from .fitting_widgets import DataDialog
+from .fit_thread import FitThread
+from .fitpage import Chi2UpdateEvent
+from .console import ConsoleUpdate
+from .fitproblem import FitProblemDictionary
+from .fitpanel import FitPanel
+from .model_thread import Calc1D, Calc2D
+from .resultpanel import ResultPanel, PlotResultEvent
+from .gpu_options import GpuOptions
 
 logger = logging.getLogger(__name__)
@@ -63 +75 @@
     ON_MAC = True
 
-import bumps.options
-from bumps.gui.fit_dialog import show_fit_config
-try:
-    from bumps.gui.fit_dialog import EVT_FITTER_CHANGED
-except ImportError:
-    # CRUFT: bumps 0.7.5.8 and below
-    EVT_FITTER_CHANGED = None  # type: wx.PyCommandEvent
 
 class Plugin(PluginBase):
@@ -240 +245 @@
         event_id = event.GetId()
         label = self.edit_menu.GetLabel(event_id)
-        from sas.sasgui.perspectives.calculator.pyconsole import PyConsole
         filename = os.path.join(models.find_plugins_dir(), label)
         frame = PyConsole(parent=self.parent, manager=self,
@@ -290 +294 @@
                         break
         except Exception:
-            import traceback; traceback.print_exc()
+            traceback.print_exc()
             msg = 'Delete Error: \nCould not delete the file; Check if in use.'
             wx.MessageBox(msg, 'Error')
@@ -300 +304 @@
         event_id = event.GetId()
         model_manager = models.ModelManager()
-        model_list = model_manager.get_model_name_list()
+        model_list = model_manager.composable_models()
         plug_dir = models.find_plugins_dir()
         textdial = TextDialog(None, self, wx.ID_ANY, 'Easy Sum/Multi(p1, p2) Editor',
@@ -340 +344 @@
             self.set_edit_menu_helper(self.parent, self.edit_custom_model)
             self.set_edit_menu_helper(self.parent, self.delete_custom_model)
-            temp = self.fit_panel.reset_pmodel_list()
-            if temp:
-                # Set the new plugin model list for all fit pages
-                for uid, page in self.fit_panel.opened_pages.iteritems():
-                    if hasattr(page, "formfactorbox"):
-                        page.model_list_box = temp
-                        current_val = page.formfactorbox.GetLabel()
-                        #if page.plugin_rbutton.GetValue():
-                        mod_cat = page.categorybox.GetStringSelection()
-                        if mod_cat == custom_model:
-                            #pos = page.formfactorbox.GetSelection()
-                            page._show_combox_helper()
-                            new_val = page.formfactorbox.GetLabel()
-                            if current_val != new_val and new_val != '':
-                                page.formfactorbox.SetLabel(new_val)
-                            else:
-                                page.formfactorbox.SetLabel(current_val)
-                        if hasattr(page, 'structurebox'):
-                            selected_name = page.structurebox.GetStringSelection()
-
-                            page.structurebox.Clear()
-                            page.initialize_combox()
-
-                            index = page.structurebox.FindString(selected_name)
-                            if index == -1:
-                                index = 0
-                            page.structurebox.SetSelection(index)
-                            page._on_select_model()
-        except:
+            new_pmodel_list = self.fit_panel.reset_pmodel_list()
+            if not new_pmodel_list:
+                return
+            # Set the new plugin model list for all fit pages
+            for uid, page in self.fit_panel.opened_pages.iteritems():
+                if hasattr(page, "formfactorbox"):
+                    page.model_list_box = new_pmodel_list
+                    mod_cat = page.categorybox.GetStringSelection()
+                    if mod_cat == custom_model:
+                        box = page.formfactorbox
+                        model_name = box.GetValue()
+                        model = (box.GetClientData(box.GetCurrentSelection())
+                                 if model_name else None)
+                        page._show_combox_helper()
+                        new_index = box.FindString(model_name)
+                        new_model = (box.GetClientData(new_index)
+                                     if new_index >= 0 else None)
+                        if new_index >= 0:
+                            box.SetStringSelection(model_name)
+                        else:
+                            box.SetStringSelection('')
+                        if model and new_model != model:
+                            page._on_select_model(keep_pars=True)
+                    if hasattr(page, "structurebox"):
+                        selected_name = page.structurebox.GetStringSelection()
+
+                        page.structurebox.Clear()
+                        page.initialize_combox()
+
+                        index = page.structurebox.FindString(selected_name)
+                        if index == -1:
+                            index = 0
+                        page.structurebox.SetSelection(index)
+                        page._on_select_model()
+        except Exception:
             logger.error("update_custom_combo: %s", sys.exc_value)
 
@@ -378 +388 @@
         #new_model_menu = wx.Menu()
         self.edit_model_menu.Append(wx_id, 'New Plugin Model',
-                                   'Add a new model function')
+                                    'Add a new model function')
         wx.EVT_MENU(owner, wx_id, self.make_new_model)
 
@@ -575 +585 @@
         else:
             if len(data_list) > MAX_NBR_DATA:
-                from fitting_widgets import DataDialog
                 dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
                 if dlg.ShowModal() == wx.ID_OK:
@@ -620 +629 @@
         : param datainfo: data
         """
-        from pagestate import PageState
-        from simfitpage import SimFitPageState
         if isinstance(state, PageState):
             state = state.clone()
             self.temp_state.append(state)
         elif isinstance(state, SimFitPageState):
-            state.load_from_save_state(self)
+            if self.fit_panel.sim_page is None:
+                self.fit_panel.add_sim_page()
+            self.fit_panel.sim_page.load_from_save_state(state)
         else:
             self.temp_state = []
@@ -661 +670 @@
                 self.parent.add_data(data_list={data.id: data})
                 wx.PostEvent(self.parent, NewPlotEvent(plot=data,
-                                        title=data.title))
+                             title=data.title))
                 #need to be fix later make sure we are sendind guiframe.data
                 #to panel
@@ -672 +681 @@
                 self.parent.add_data(data_list={data.id: data})
                 wx.PostEvent(self.parent, NewPlotEvent(plot=data,
-                                        title=data.title))
+                             title=data.title))
                 page = self.add_fit_page([data])
                 caption = page.window_caption
                 self.store_data(uid=page.uid, data_list=page.get_data_list(),
-                        caption=caption)
+                                caption=caption)
                 self.mypanels.append(page)
 
@@ -793 +802 @@
         """
         if item.find(".") >= 0:
-            param_names = re.split("\.", item)
+            param_names = re.split(r"\.", item)
             model_name = param_names[0]
             ##Assume max len is 3; eg., M0.radius.width
@@ -896 +905 @@
 
             self.draw_model(model=model, data=data, page_id=uid, smearer=smear,
-                enable1D=enable1D, enable2D=enable2D,
-                qmin=qmin, qmax=qmax, weight=weight)
+                            enable1D=enable1D, enable2D=enable2D,
+                            qmin=qmin, qmax=qmax, weight=weight)
 
     def draw_model(self, model, page_id, data=None, smearer=None,
@@ -940 +949 @@
             ## draw model 2D with no initial data
             self._draw_model2D(model=model,
-                                page_id=page_id,
-                                data=data,
-                                enable2D=enable2D,
-                                smearer=smearer,
-                                qmin=qmin,
-                                qmax=qmax,
-                                fid=fid,
-                                weight=weight,
-                                state=state,
-                                toggle_mode_on=toggle_mode_on,
-                                update_chisqr=update_chisqr,
-                                source=source)
+                               page_id=page_id,
+                               data=data,
+                               enable2D=enable2D,
+                               smearer=smearer,
+                               qmin=qmin,
+                               qmax=qmax,
+                               fid=fid,
+                               weight=weight,
+                               state=state,
+                               toggle_mode_on=toggle_mode_on,
+                               update_chisqr=update_chisqr,
+                               source=source)
 
     def onFit(self, uid):
@@ -960 +969 @@
         :param uid: id related to the panel currently calling this fit function.
         """
-        if uid is None: raise RuntimeError("no page to fit") # Should never happen
+        if uid is None:
+            raise RuntimeError("no page to fit") # Should never happen
 
         sim_page_uid = getattr(self.sim_page, 'uid', None)
@@ -994 +1004 @@
                     page = self.fit_panel.get_page_by_id(page_id)
                     self.set_fit_weight(uid=page.uid,
-                                     flag=page.get_weight_flag(),
-                                     is2d=page._is_2D())
+                                        flag=page.get_weight_flag(),
+                                        is2d=page._is_2D())
                     if not page.param_toFit:
                         msg = "No fitting parameters for %s" % page.window_caption
@@ -1019 +1029 @@
                             fitter = sim_fitter
                         self._add_problem_to_fit(fitproblem=fitproblem,
-                                             pars=pars,
-                                             fitter=fitter,
-                                             fit_id=fit_id)
+                                                 pars=pars,
+                                                 fitter=fitter,
+                                                 fit_id=fit_id)
                         fit_id += 1
                     list_page_id.append(page_id)
@@ -1068 +1078 @@
             ## Perform more than 1 fit at the time
             calc_fit = FitThread(handler=handler,
-                                    fn=fitter_list,
-                                    batch_inputs=batch_inputs,
-                                    batch_outputs=batch_outputs,
-                                    page_id=list_page_id,
-                                    updatefn=handler.update_fit,
-                                    completefn=self._fit_completed)
+                                 fn=fitter_list,
+                                 batch_inputs=batch_inputs,
+                                 batch_outputs=batch_outputs,
+                                 page_id=list_page_id,
+                                 updatefn=handler.update_fit,
+                                 completefn=self._fit_completed)
         #self.fit_thread_list[current_page_id] = calc_fit
         self.fit_thread_list[uid] = calc_fit
@@ -1134 +1144 @@
                 evt = StatusEvent(status=msg, info="warning")
                 wx.PostEvent(self.parent, evt)
-        except:
+        except Exception:
             msg = "Creating Fit page: %s" % sys.exc_value
             wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
@@ -1158 +1168 @@
                     group_id = str(page.uid) + " Model1D"
                     wx.PostEvent(self.parent,
-                             NewPlotEvent(group_id=group_id,
-                                               action="delete"))
+                                 NewPlotEvent(group_id=group_id,
+                                              action="delete"))
                     self.parent.update_data(prev_data=theory_data,
-                                             new_data=data)
+                                            new_data=data)
             else:
                 if theory_data is not None:
@@ -1167 +1177 @@
                     data.group_id = theory_data.group_id
                     wx.PostEvent(self.parent,
-                             NewPlotEvent(group_id=group_id,
-                                               action="delete"))
+                                 NewPlotEvent(group_id=group_id,
+                                              action="delete"))
                     self.parent.update_data(prev_data=theory_data,
-                                             new_data=data)
+                                            new_data=data)
         self.store_data(uid=page.uid, data_list=page.get_data_list(),
                         caption=page.window_caption)
@@ -1479 +1489 @@
         if "Data" not in batch_outputs.keys():
             batch_outputs["Data"] = []
-        from sas.sasgui.guiframe.data_processor import BatchCell
         cell = BatchCell()
         cell.label = data.name
@@ -1579 +1588 @@
                     except KeyboardInterrupt:
                         fit_msg += "\nSingular point: Fitting stopped."
-                    except:
+                    except Exception:
                         fit_msg += "\nSingular point: Fitting error occurred."
                 if fit_msg:
-                   evt = StatusEvent(status=fit_msg, info="warning", type="stop")
-                   wx.PostEvent(self.parent, evt)
-
-        except:
+                    evt = StatusEvent(status=fit_msg, info="warning", type="stop")
+                    wx.PostEvent(self.parent, evt)
+
+        except Exception:
             msg = ("Fit completed but the following error occurred: %s"
                    % sys.exc_value)
-            #import traceback; msg = "\n".join((traceback.format_exc(), msg))
+            #msg = "\n".join((traceback.format_exc(), msg))
             evt = StatusEvent(status=msg, info="warning", type="stop")
             wx.PostEvent(self.parent, evt)
@@ -1743 +1752 @@
                                                   fid=data.id)
         self.parent.update_theory(data_id=data.id, theory=new_plot,
-                                   state=state)
+                                  state=state)
         return new_plot
 
@@ -1767 +1776 @@
         # Create the new theories
         if unsmeared_model is not None:
-            unsmeared_model_plot = self.create_theory_1D(x, unsmeared_model, 
+            unsmeared_model_plot = self.create_theory_1D(x, unsmeared_model,
                                   page_id, model, data, state,
                                   data_description=model.name + " unsmeared",
@@ -1774 +1783 @@
 
             if unsmeared_data is not None and unsmeared_error is not None:
-                unsmeared_data_plot = self.create_theory_1D(x, unsmeared_data, 
+                unsmeared_data_plot = self.create_theory_1D(x, unsmeared_data,
                                       page_id, model, data, state,
                                       data_description="Data unsmeared",
@@ -1792 +1801 @@
             plots_to_update.append(pq_plot)
         # Update the P(Q), S(Q) and unsmeared theory plots if they exist
-        wx.PostEvent(self.parent, NewPlotEvent(plots=plots_to_update, 
+        wx.PostEvent(self.parent, NewPlotEvent(plots=plots_to_update,
                                               action='update'))
 
@@ -1808 +1817 @@
 
         self.page_finder[page_id].set_theory_data(data=new_plot,
-                                                      fid=data.id)
+                                                  fid=data.id)
         if toggle_mode_on:
             wx.PostEvent(self.parent,
                          NewPlotEvent(group_id=str(page_id) + " Model2D",
-                                          action="Hide"))
+                                      action="Hide"))
         else:
             if update_chisqr:
-                wx.PostEvent(current_pg,
-                             Chi2UpdateEvent(output=self._cal_chisqr(
-                                                                data=data,
-                                                                fid=fid,
-                                                                weight=weight,
-                                                                page_id=page_id,
-                                                                index=index)))
+                output = self._cal_chisqr(data=data,
+                                          fid=fid,
+                                          weight=weight,
+                                          page_id=page_id,
+                                          index=index)
+                wx.PostEvent(current_pg, Chi2UpdateEvent(output=output))
             else:
                 self._plot_residuals(page_id=page_id, data=data, fid=fid,
@@ -1829 +1837 @@
             logger.error("Using the present parameters the model does not return any finite value. ")
             msg = "Computing Error: Model did not return any finite value."
-            wx.PostEvent(self.parent, StatusEvent(status = msg, info="error"))
+            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
         else:
             msg = "Computation  completed!"
@@ -1854 +1862 @@
 
     def _complete2D(self, image, data, model, page_id, elapsed, index, qmin,
-                qmax, fid=None, weight=None, toggle_mode_on=False, state=None,
-                     update_chisqr=True, source='model', plot_result=True):
+                    qmax, fid=None, weight=None, toggle_mode_on=False, state=None,
+                    update_chisqr=True, source='model', plot_result=True):
         """
         Complete get the result of modelthread and create model 2D
@@ -1896 +1904 @@
                                                   fid=data.id)
         self.parent.update_theory(data_id=data.id,
-                                       theory=new_plot,
-                                       state=state)
+                                  theory=new_plot,
+                                  state=state)
         current_pg = self.fit_panel.get_page_by_id(page_id)
         title = new_plot.title
         if not source == 'fit' and plot_result:
-            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
-                                               title=title))
+            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title))
         if toggle_mode_on:
             wx.PostEvent(self.parent,
-                             NewPlotEvent(group_id=str(page_id) + " Model1D",
-                                               action="Hide"))
+                         NewPlotEvent(group_id=str(page_id) + " Model1D",
+                                      action="Hide"))
         else:
             # Chisqr in fitpage
             if update_chisqr:
-                wx.PostEvent(current_pg,
-                             Chi2UpdateEvent(output=self._cal_chisqr(data=data,
-                                                                    weight=weight,
-                                                                    fid=fid,
-                                                         page_id=page_id,
-                                                         index=index)))
+                output = self._cal_chisqr(data=data,
+                                          weight=weight,
+                                          fid=fid,
+                                          page_id=page_id,
+                                          index=index)
+                wx.PostEvent(current_pg, Chi2UpdateEvent(output=output))
             else:
                 self._plot_residuals(page_id=page_id, data=data, fid=fid,
-                                      index=index, weight=weight)
+                                     index=index, weight=weight)
 
         if not number_finite:
             logger.error("Using the present parameters the model does not return any finite value. ")
             msg = "Computing Error: Model did not return any finite value."
-            wx.PostEvent(self.parent, StatusEvent(status = msg, info="error"))
+            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
         else:
             msg = "Computation  completed!"
@@ -1939 +1946 @@
                       weight=None,
                       toggle_mode_on=False,
-                       update_chisqr=True, source='model'):
+                      update_chisqr=True, source='model'):
         """
         draw model in 2D
@@ -1954 +1961 @@
             return None
         try:
-            from model_thread import Calc2D
             ## If a thread is already started, stop it
             if (self.calc_2D is not None) and self.calc_2D.isrunning():
@@ -1986 +1992 @@
     def _draw_model1D(self, model, page_id, data,
                       qmin, qmax, smearer=None,
-                state=None,
-                weight=None,
-                fid=None,
-                toggle_mode_on=False, update_chisqr=True, source='model',
-                enable1D=True):
+                      state=None, weight=None, fid=None,
+                      toggle_mode_on=False, update_chisqr=True, source='model',
+                      enable1D=True):
         """
         Draw model 1D from loaded data1D
@@ -2001 +2005 @@
             return
         try:
-            from model_thread import Calc1D
             ## If a thread is already started, stop it
             if (self.calc_1D is not None) and self.calc_1D.isrunning():

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

@@ -1 +1 @@
 """
-    Calculation thread for modeling
+Calculation thread for modeling
 """
 
 import time
+import math
+
 import numpy as np
-import math
+
 from sas.sascalc.data_util.calcthread import CalcThread
 from sas.sascalc.fit.MultiplicationModel import MultiplicationModel
@@ -28 +30 @@
                  worktime=0.04,
                  exception_handler=None,
-                 ):
+                ):
         CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime,
                             exception_handler=exception_handler)
@@ -57 +59 @@
         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)
-                newy = math.pow(max(math.fabs(self.data.ymax),
-                                   math.fabs(self.data.ymin)), 2)
-                self.qmax = math.sqrt(newx + newy)
+                newx = max(math.fabs(self.data.xmax), math.fabs(self.data.xmin))
+                newy = max(math.fabs(self.data.ymax), math.fabs(self.data.ymin))
+                self.qmax = math.sqrt(newx**2 + newy**2)
 
         if self.data is None:
@@ -68 +68 @@
 
         # Define matrix where data will be plotted
-        radius = np.sqrt((self.data.qx_data * self.data.qx_data) + \
-                    (self.data.qy_data * self.data.qy_data))
+        radius = np.sqrt(self.data.qx_data**2 + self.data.qy_data**2)
 
         # For theory, qmax is based on 1d qmax
         # so that must be mulitified by sqrt(2) to get actual max for 2d
         index_model = (self.qmin <= radius) & (radius <= self.qmax)
-        index_model = index_model & self.data.mask
-        index_model = index_model & np.isfinite(self.data.data)
+        index_model &= self.data.mask
+        index_model &= np.isfinite(self.data.data)
 
         if self.smearer is not None:
@@ -101 +100 @@
         elapsed = time.time() - self.starttime
         self.complete(image=output,
-                       data=self.data,
-                       page_id=self.page_id,
-                       model=self.model,
-                       state=self.state,
-                       toggle_mode_on=self.toggle_mode_on,
-                       elapsed=elapsed,
-                       index=index_model,
-                       fid=self.fid,
-                       qmin=self.qmin,
-                       qmax=self.qmax,
-                       weight=self.weight,
-                       #qstep=self.qstep,
-                       update_chisqr=self.update_chisqr,
-                       source=self.source)
+                      data=self.data,
+                      page_id=self.page_id,
+                      model=self.model,
+                      state=self.state,
+                      toggle_mode_on=self.toggle_mode_on,
+                      elapsed=elapsed,
+                      index=index_model,
+                      fid=self.fid,
+                      qmin=self.qmin,
+                      qmax=self.qmax,
+                      weight=self.weight,
+                      #qstep=self.qstep,
+                      update_chisqr=self.update_chisqr,
+                      source=self.source)
 
 
@@ -138 +137 @@
                  worktime=0.01,
                  exception_handler=None,
-                 ):
+                ):
         """
         """
@@ -193 +192 @@
                                                         * unsmeared_output[first_bin:last_bin+1]\
                                                         / output[first_bin:last_bin+1]
-                unsmeared_output=unsmeared_output[index]
-                unsmeared_data=unsmeared_data[index]
-                unsmeared_error=unsmeared_error
+                unsmeared_output = unsmeared_output[index]
+                unsmeared_data = unsmeared_data[index]
+                unsmeared_error = unsmeared_error
         else:
             output[index] = self.model.evalDistribution(self.data.x[index])
@@ -243 +242 @@
     class CalcCommandline:
         def __init__(self, n=20000):
-            #print thread.get_ident()
-            from sas.models.CylinderModel import CylinderModel
-
-            model = CylinderModel()
-
-
-            print model.runXY([0.01, 0.02])
+            #print(thread.get_ident())
+
+            from sasmodels.sasview_model import _make_standard_model
+            cylinder = _make_standard_model('cylinder')
+            model = cylinder()
+
+            print(model.runXY([0.01, 0.02]))
 
             qmax = 0.01
@@ -258 +257 @@
             y = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
 
-
             calc_thread_2D = Calc2D(x, y, None, model.clone(),None,
                                     -qmax, qmax,qstep,
-                                            completefn=self.complete,
-                                            updatefn=self.update ,
-                                            yieldtime=0.0)
+                                    completefn=self.complete,
+                                    updatefn=self.update ,
+                                    yieldtime=0.0)
 
             calc_thread_2D.queue()
@@ -272 +270 @@
 
         def update(self,output):
-            print "update"
+            print("update")
 
         def complete(self, image, data, model, elapsed, qmin, qmax,index, qstep ):
-            print "complete"
+            print("complete")
             self.done = True
 

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

@@ -38 +38 @@
         # number of images of plot
         self.nimages = len(self.report_list[2])
-
-        if self.report_list[2] is not None:
-            # put image path in the report string
-            if len(self.report_list[2]) == 1:
-                self.report_html = self.report_list[0] % \
-                                    "memory:img_fit0.png"
-            elif len(self.report_list[2]) == 2:
-                self.report_html = self.report_list[0] % \
-                                    ("memory:img_fit0.png",
-                                     "memory:img_fit1.png")
-            # allows up to three images
-            else:
-                self.report_html = self.report_list[0] % \
-                                    ("memory:img_fit0.png",
-                                     "memory:img_fit1.png",
-                                     "memory:img_fit2.png")
-        else:
-            self.report_html = self.report_list[0]
+        self.report_html = self.report_list[0]
         # layout
         self._setup_layout()
@@ -105 +88 @@
             elif self.nimages == 3:
                 html = report_frame % (str(pic_fname[0]), str(pic_fname[1]),
-                                          str(pic_fname[2]))
+                                       str(pic_fname[2]))
 
             # make/open file in case of absence
@@ -118 +101 @@
                     #Windows
                     os.startfile(str(fName))
-                except:
+                except Exception:
                     try:
                         #Mac
                         os.system("open %s" % fName)
-                    except:
+                    except Exception:
                         #DO not open
                         pass

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

@@ -2 +2 @@
     Simultaneous or Batch fit page
 """
-# Note that this is used for both Simultaneous/Constrained fit AND for 
+# Note that this is used for both Simultaneous/Constrained fit AND for
 # combined batch fit.  This is done through setting of the batch_on parameter.
-# There are the a half dozen or so places where an if statement is used as in 
+# There are the a half dozen or so places where an if statement is used as in
 # if not batch_on:
 #     xxxx
@@ -11 +11 @@
 # This is just wrong but dont have time to fix this go. Proper approach would be
 # to strip all parts of the code that depend on batch_on and create the top
-# level class from which a contrained/simultaneous fit page and a combined 
+# level class from which a contrained/simultaneous fit page and a combined
 # batch page inherit.
 #
@@ -23 +23 @@
 from wx.lib.scrolledpanel import ScrolledPanel
 
+from sas.sascalc.fit.pagestate import SimFitPageState
 from sas.sasgui.guiframe.events import StatusEvent, PanelOnFocusEvent
 from sas.sasgui.guiframe.panel_base import PanelBase
@@ -60 +61 @@
 
     return fittable_param
-
 
 class SimultaneousFitPage(ScrolledPanel, PanelBase):
@@ -157 +157 @@
         return self.state
 
+    def load_from_save_state(self, sim_state):
+        """
+        Load in a simultaneous/constrained fit from a save state
+        :param fit: Fitpanel object
+        :return: None
+        """
+        model_map = {}
+        # Process each model and associate old M# with new M#
+        i = 0
+        for model in self.model_list:
+            model_id = self._format_id(model[1].keys()[0])
+            for saved_model in sim_state.model_list:
+                save_id = saved_model.pop('name')
+                saved_model['name'] = save_id
+                save_id = self._format_id(save_id)
+                if save_id == model_id:
+                    model_map[saved_model.pop('fit_page_source')] = \
+                        model[3].name
+                    check = bool(saved_model.pop('checked'))
+                    self.model_list[i][0].SetValue(check)
+                    break
+            i += 1
+
+        self.check_model_name(None)
+
+        if len(sim_state.constraints_list) > 0:
+            self.hide_constraint.SetValue(False)
+            self.show_constraint.SetValue(True)
+            self._display_constraint(None)
+
+        for index, item in enumerate(sim_state.constraints_list):
+            model_cbox = item.pop('model_cbox')
+            if model_cbox != "":
+                constraint_value = item.pop('constraint')
+                param = item.pop('param_cbox')
+                equality = item.pop('egal_txt')
+                for key, value in model_map.iteritems():
+                    model_cbox.replace(key, value)
+                    constraint_value.replace(key, value)
+
+                self.constraints_list[index][0].SetValue(model_cbox)
+                self._on_select_model(None)
+                self.constraints_list[index][1].SetValue(param)
+                self.constraints_list[index][2].SetLabel(equality)
+                self.constraints_list[index][3].SetValue(constraint_value)
+                self._on_add_constraint(None)
+                self._manager.sim_page = self
+
+    def _format_id(self, original_id):
+        original_id = original_id.rstrip('1234567890.')
+        new_id_list = original_id.split()
+        new_id = ' '.join(new_id_list)
+        return new_id
+
+
+
     def draw_page(self):
         """
         Construct the Simultaneous/Constrained fit page. fills the first
-        region (sizer1) with the list of available fit page pairs of data 
+        region (sizer1) with the list of available fit page pairs of data
         and models.  Then fills sizer2 with the checkbox for adding
         constraints, and finally fills sizer3 with the fit button and
@@ -1043 +1099 @@
         cbox.Append(name, value)
     cbox.SetStringSelection(selected)
-
-
-class SimFitPageState:
-    """
-    State of the simultaneous fit page for saving purposes
-    """
-
-    def __init__(self):
-        # Sim Fit Page Number
-        self.fit_page_no = None
-        # Select all data
-        self.select_all = False
-        # Data sets sent to fit page
-        self.model_list = []
-        # Data sets to be fit
-        self.model_to_fit = []
-        # Number of constraints
-        self.no_constraint = 0
-        # Dictionary of constraints
-        self.constraint_dict = {}
-        # List of constraints
-        self.constraints_list = []
-
-    def load_from_save_state(self, fit):
-        """
-        Load in a simultaneous/constrained fit from a save state
-        :param fit: Fitpanel object
-        :return: None
-        """
-
-        model_map = {}
-        if fit.fit_panel.sim_page is None:
-            fit.fit_panel.add_sim_page()
-        sim_page = fit.fit_panel.sim_page
-
-        # Process each model and associate old M# with new M#
-        i = 0
-        for model in sim_page.model_list:
-            model_id = self._format_id(model[1].keys()[0])
-            for saved_model in self.model_list:
-                save_id = saved_model.pop('name')
-                saved_model['name'] = save_id
-                save_id = self._format_id(save_id)
-                if save_id == model_id:
-                    model_map[saved_model.pop('fit_page_source')] = \
-                        model[3].name
-                    check = bool(saved_model.pop('checked'))
-                    sim_page.model_list[i][0].SetValue(check)
-                    break
-            i += 1
-        sim_page.check_model_name(None)
-
-        if len(self.constraints_list) > 0:
-            sim_page.hide_constraint.SetValue(False)
-            sim_page.show_constraint.SetValue(True)
-            sim_page._display_constraint(None)
-
-        for index, item in enumerate(self.constraints_list):
-            model_cbox = item.pop('model_cbox')
-            if model_cbox != "":
-                constraint_value = item.pop('constraint')
-                param = item.pop('param_cbox')
-                equality = item.pop('egal_txt')
-                for key, value in model_map.iteritems():
-                    model_cbox.replace(key, value)
-                    constraint_value.replace(key, value)
-
-                sim_page.constraints_list[index][0].SetValue(model_cbox)
-                sim_page._on_select_model(None)
-                sim_page.constraints_list[index][1].SetValue(param)
-                sim_page.constraints_list[index][2].SetLabel(equality)
-                sim_page.constraints_list[index][3].SetValue(constraint_value)
-                sim_page._on_add_constraint(None)
-                sim_page._manager.sim_page = sim_page
-
-    def _format_id(self, original_id):
-        original_id = original_id.rstrip('1234567890.')
-        new_id_list = original_id.split()
-        new_id = ' '.join(new_id_list)
-        return new_id