← Previous Changeset
Next Changeset →

Changeset 2f4b430 in sasview

Timestamp:

Mar 4, 2015 3:39:45 PM (10 years ago)

Author:

Doucet, Mathieu <doucetm@…>

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, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

Parents:

Message:

Take care of white spaces (pylint)

Location:

src/sas/perspectives/fitting

Files:

: 15 edited

batchfitpage.py (modified) (7 diffs)
console.py (modified) (13 diffs)
fit_thread.py (modified) (9 diffs)
fitpage.py (modified) (180 diffs)
fitpanel.py (modified) (37 diffs)
fitproblem.py (modified) (63 diffs)
fitting.py (modified) (106 diffs)
fitting_widgets.py (modified) (9 diffs)
hint_fitpage.py (modified) (4 diffs)
model_thread.py (modified) (10 diffs)
models.py (modified) (32 diffs)
pagestate.py (modified) (96 diffs)
report_dialog.py (modified) (11 diffs)
resultpanel.py (modified) (4 diffs)
simfitpage.py (modified) (53 diffs)

Legend:

: Unmodified
: Added
: Removed

src/sas/perspectives/fitting/batchfitpage.py

-                      rfa09d62
+                      r2f4b430
 """
+"""
 Batch panel
 """
 …
 import wx.lib.newevent
 import math
 from sas.guiframe.events import StatusEvent
 from sas.guiframe.events import NewPlotEvent
 (Chi2UpdateEvent, EVT_CHI2_UPDATE)   = wx.lib.newevent.NewEvent()
+from sas.guiframe.events import StatusEvent
+from sas.guiframe.events import NewPlotEvent
+(Chi2UpdateEvent, EVT_CHI2_UPDATE) = wx.lib.newevent.NewEvent()
 _BOX_WIDTH = 76
 _DATA_BOX_WIDTH = 300
 …
     """
     window_name = "BatchFit"
     window_caption  = "BatchFit"
+    window_caption = "BatchFit"
     def __init__(self, parent, color=None):
         """
+        """
         Initialization of the Panel
         """
         FitPage.__init__(self, parent, color=color)
         ## draw sizer
     def _fill_data_sizer(self):
         """
 …
         text2.SetForegroundColour(wx.RED)
         sizer_data.Add(text2)
         combo = wx.BoxSizer(wx.HORIZONTAL)
         self.dataSource = wx.ComboBox(self, -1, style=wx.CB_READONLY)
         wx.EVT_COMBOBOX(self.dataSource, -1, self.on_select_data)
         self.dataSource.SetMinSize((_DATA_BOX_WIDTH, -1))
         combo.Add(wx.StaticText(self, -1, 'Name : '))
         combo.Add((0,5))
+        combo.Add((0, 5))
         combo.Add(self.dataSource)
         sizer_data.Add(combo, 0, wx.ALL, 10)
         boxsizer1.Add(sizer_data, 0, wx.ALL, 0)
 …
 #    COMMENTED OUT TO USE METHODS INHERITED FROM fitpage.py
 #     def _fill_range_sizer(self):
 #         """
 …
 #                                       caption=self.window_name)
 #             self._draw_model()
 class BGTextCtrl(wx.TextCtrl):
     """
     Text control used to display outputs.
     No editing allowed. The background is
+    No editing allowed. The background is
     grayed out. User can't select text.
     """
 …
         self.SetEditable(False)
         self.SetBackgroundColour(self.GetParent().parent.GetBackgroundColour())
         # Bind to mouse event to avoid text highlighting
         # The event will be skipped once the call-back
         # is called.
         self.Bind(wx.EVT_MOUSE_EVENTS, self._click)
     def _click(self, event):
         """
         Prevent further handling of the mouse event
         by not calling Skip().
         """
+        """
         pass

src/sas/perspectives/fitting/console.py

-                      rb9a5f0e
+                      r2f4b430
 from sas.guiframe.events import StatusEvent
+from sas.guiframe.events import StatusEvent
 import time
 import wx
 …
     isbetter = False
     """Record whether results improved since last update"""
     progress_delta =  60
+    progress_delta = 60
     """Number of seconds between progress updates"""
     improvement_delta = 5
     """Number of seconds between improvement updates"""
     def __init__(self, parent, manager=None,
                  quiet=False,progress_delta=60,improvement_delta=5):
+                 quiet=False, progress_delta=60, improvement_delta=5):
         """
         If quiet is true, only print out final summary, not progress and
         improvements.
         :attr parent: the object that handle the messages
         """
         self.parent= parent
+        self.parent = parent
         self.manager = manager
         self.progress_time = time.time()
 …
         self.update_duration = time.time()
         self.fit_duration = 0
     def progress(self, k, n):
         """
 …
         t = time.time()
         p = int((100*k)//n)
+        p = int((100 * k) // n)
         # Show improvements if there are any
         dt = t - self.improvement_time
 …
             self.isbetter = False
             self.improvement_time = t
         # Update percent complete
         dp = p-self.progress_percent
+        dp = p - self.progress_percent
         if dp < 1: return
         dt = t - self.progress_time
 …
                 self.update_fit()
             elif 2 < dp <= 5:
                 if p//5 != self.progress_percent//5:
+                if p // 5 != self.progress_percent // 5:
                     self.progress_percent = p
                     self.progress_time = t
             else:
                 if p//10 != self.progress_percent//10:
+                if p // 10 != self.progress_percent // 10:
                     self.progress_percent = p
                     self.progress_time = t
                     self.update_fit()
     def improvement(self):
         """
 …
         """
         self.isbetter = True
     def print_result(self):
         """
 …
         msg = " \n %s \n" % str(self.result)
         wx.PostEvent(self.parent, StatusEvent(status=msg))
     def error(self, msg):
         """
 …
         wx.PostEvent(self.parent, StatusEvent(status=message,
                                    info="info", type="stop"))
     def finalize(self):
         """
 …
             #self.result.print_summary()
             self.update_fit()
     def update_fit(self, last=False):
         """
         """
         t1 = time.time()
         self.elapsed_time =  t1 - self.update_duration
+        self.elapsed_time = t1 - self.update_duration
         self.update_duration = t1
         self.fit_duration += self.elapsed_time
 …
                 d_flag = (hasattr(self.result, "data") and \
                     self.result.data is not None and \
                     hasattr(self.result.data, "sas_data") and
+                    hasattr(self.result.data, "sas_data") and
                     self.result.data.sas_data is not None)
                 m_flag = (hasattr(self.result, "model") and \
 …
                     model_name = str(self.result.model.name)
                 if m_flag and d_flag:
                     msg += "Data : %s \n"  % (str(data_name))#,
+                    msg += "Data : %s \n" % (str(data_name))#,
                                                      #str(model_name))
                 msg +=  str(self.result)
+                msg += str(self.result)
                 msg += "\n"
             else:
 …
             wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
                                               type="progress"))
     def starting_fit(self):
         """
         """
         wx.PostEvent(self.parent, StatusEvent(status="Starting the Fit...",
                                         info="info",type="progress"))
+                                        info="info", type="progress"))
     def set_result(self, result):
         """
         """
         self.result = result
     def get_result(self):
         """
         """
         return self.result

src/sas/perspectives/fitting/fit_thread.py

-                      r386ffe1
+                      r2f4b430
     Execute class.function and return result
     """
     return  getattr(classInstance,classFunc)(*args)
+    return  getattr(classInstance, classFunc)(*args)
 def map_apply(arguments):
 …
 class FitThread(CalcThread):
     """Thread performing the fit """
     def __init__(self,
+    def __init__(self,
                  fn,
                  page_id,
 …
                  batch_inputs=None,
                  pars=None,
                  completefn = None,
                  updatefn   = None,
                  yieldtime  = 0.03,
                  worktime   = 0.03,
                  reset_flag = False):
+                 completefn=None,
+                 updatefn=None,
+                 yieldtime=0.03,
+                 worktime=0.03,
+                 reset_flag=False):
         CalcThread.__init__(self,
                  completefn,
 …
         #Relative error desired in the sum of squares.
         self.reset_flag = reset_flag
     def isquit(self):
         """
         :raise KeyboardInterrupt: when the thread is interrupted
         """
         try:
 …
             msg = "Fitting: terminated by the user."
             raise KeyboardInterrupt, msg
     def compute(self):
         """
         Perform a fit
+        Perform a fit
         """
         msg = ""
 …
             import copy
             list_handler = []
             list_curr_thread = []
+            list_curr_thread = []
             list_reset_flag = []
             list_map_get_attr = []
 …
             #from multiprocessing import Pool
             inputs = zip(list_map_get_attr, self.fitter, list_fit_function,
                          list_q, list_q, list_handler,list_curr_thread,
+                         list_q, list_q, list_handler, list_curr_thread,
                          list_reset_flag)
             result =  map(map_apply, inputs)
+            result = map(map_apply, inputs)
             self.complete(result=result,
                           batch_inputs=self.batch_inputs,
                           batch_outputs=self.batch_outputs,
                           page_id=self.page_id,
                           pars = self.pars,
                           elapsed=time.time()-self.starttime)
+                          pars=self.pars,
+                          elapsed=time.time() - self.starttime)
         except KeyboardInterrupt, msg:
             # Thread was interrupted, just proceed and re-raise.
 …
             #Stop on exception during fitting. Todo: need to put
             #some mssg and reset progress bar.
             if self.handler is not None:
                 self.handler.stop(msg=msg)
 …
             if self.handler is not None:
                 self.handler.error(msg=traceback.format_exc())

src/sas/perspectives/fitting/fitpage.py

-                      r386ffe1
+                      r2f4b430
     FitPanel class contains fields allowing to display results when
     fitting  a model and one data
     :note: For Fit to be performed the user should check at least one parameter
         on fit Panel window.
 …
         """
         BasicPage.__init__(self, parent, color=color)
         ## draw sizer
         self._fill_data_sizer()
 …
         self.create_default_data()
         #self._manager.frame.Bind(wx.EVT_SET_FOCUS, self.on_set_focus)
     def enable_fit_button(self):
         """
 …
         flag = check_data_validity(self.data) & (self.model is not None)
         self.btFit.Enable(flag)
     def _fill_data_sizer(self):
         """
 …
         self.sizer0.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10)
         self.sizer0.Layout()
     def enable_datasource(self):
         """
 …
         else:
             self.dataSource.Enable()
     def fill_data_combobox(self, data_list):
         """
 …
         if len(data_list) == 1:
             self.dataSource.Disable()
     def on_select_data(self, event=None):
         """
 …
             data = self.dataSource.GetClientData(pos)
             self.set_data(data)
     def _on_fit_complete(self):
         """
 …
         self.fit_started = False
         self.set_fitbutton()
     def _is_2D(self):
         """
         Check if data_name is Data2D
         :return: True or False
         """
         if self.data.__class__.__name__ == "Data2D" or \
 …
             return True
         return False
     def _on_engine_change(self, name):
         """
 …
          and update the panel accordingly
         """
         self.engine_type = str(name)
         self.state.engine_type = self.engine_type
 …
             self.Layout()
             self.Refresh()
     def _fill_range_sizer(self):
         """
 …
         """
         is_2Ddata = False
         # Check if data is 2D
         if self.data.__class__.__name__ == "Data2D" or \
                         self.enable2D:
             is_2Ddata = True
         title = "Fitting"
         #smear messages & titles
 …
         smear_message_slit_height_title = "Slit height[1/A]:"
         smear_message_slit_width_title = "Slit width[1/A]:"
         self._get_smear_info()
         #Sizers
         box_description_range = wx.StaticBox(self, -1, str(title))
 …
         sizer_smearer_box = wx.StaticBoxSizer(smear_set_box, wx.HORIZONTAL)
         sizer_smearer_box.SetMinSize((_DATA_BOX_WIDTH, 60))
         weighting_set_box = wx.StaticBox(self, -1, \
                                 'Set Weighting by Selecting dI Source')
 …
         self.dI_idata.Enable(False)
         weighting_box.Add(sizer_weighting)
         sizer_fit = wx.GridSizer(2, 4, 2, 6)
         # combobox for smear2d accuracy selection
         self.smear_accuracy = wx.ComboBox(self, -1, size=(50, -1),
 …
         self.smear_accuracy.SetToolTipString(\
             "'Higher' uses more Gaussian points for smearing computation.")
         wx.EVT_COMBOBOX(self.smear_accuracy, -1, self._on_select_accuracy)
 …
         self.btFit.Bind(wx.EVT_BUTTON, self._onFit, id=self.btFit.GetId())
         self.btFit.SetToolTipString("Start fitting.")
         #textcntrl for custom resolution
         self.smear_pinhole_max = self.ModelTextCtrl(self, -1,
 …
                   id=self.slit_smearer.GetId())
         self.disable_smearer.SetValue(True)
         # add 4 types of smearing to the sizer
         sizer_smearer.Add(self.disable_smearer, 0, wx.LEFT, 10)
 …
         sizer_smearer.Add(self.slit_smearer)
         sizer_smearer.Add((10, 10))
         # StaticText for chi2, N(for fitting), Npts + Log/linear spacing
         self.tcChi = BGTextCtrl(self, -1, "-", size=(75, 20), style=0)
 …
         self.Npts_total.SetToolTipString(\
                                 " Total Npts : total number of data points")
         # Update and Draw button
         self.draw_button = wx.Button(self, wx.NewId(),
 …
                               self._onDraw, id=self.draw_button.GetId())
         self.draw_button.SetToolTipString("Compute and Draw.")
         self.points_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.points_sizer = wx.BoxSizer(wx.HORIZONTAL)
         self.pointsbox = wx.CheckBox(self, -1, 'Log?', (10, 10))
         self.pointsbox.SetValue(False)
         self.pointsbox.SetToolTipString("Check mark to use log spaced points")
         wx.EVT_CHECKBOX(self, self.pointsbox.GetId(), self.select_log)
         self.points_sizer.Add(wx.StaticText(self, -1, 'Npts    '))
         self.points_sizer.Add(self.pointsbox)
 …
         #box_description_3.SetToolTipString( \
         #                        " Total Npts : total number of data points")
         sizer_fit.Add(box_description_1, 0, 0)
         sizer_fit.Add(box_description_2, 0, 0)
 …
                                     smear_message_none, style=wx.ALIGN_LEFT)
         self.smear_description_dqdata = wx.StaticText(self,
                                 -1, smear_message_dqdata, style=wx.ALIGN_LEFT)
+                                - 1, smear_message_dqdata, style=wx.ALIGN_LEFT)
         self.smear_description_type = wx.StaticText(self,
                                      -1, "Type:", style=wx.ALIGN_LEFT)
+                                     - 1, "Type:", style=wx.ALIGN_LEFT)
         self.smear_description_accuracy_type = wx.StaticText(self, -1,
                                         "Accuracy:", style=wx.ALIGN_LEFT)
 …
         self.smear_description_slit_width = wx.StaticText(self, -1,
                         smear_message_slit_width_title, style=wx.ALIGN_LEFT)
         #arrange sizers
         self.sizer_set_smearer.Add(sizer_smearer)
 …
         self.sizer_new_smear.Add((20, -1))
         self.sizer_new_smear.Add(self.smear_description_2d_y,
 , wx.CENTER, 10 )
+, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_description_pin_max,
 , wx.CENTER, 10 )
+, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_description_slit_width,
 , wx.CENTER, 10 )
+, wx.CENTER, 10)
         self.sizer_new_smear.Add(self.smear_pinhole_max, 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)
         self.sizer_set_smearer.Add(self.smear_message_new_s, 0, wx.CENTER, 10)
         self.sizer_set_smearer.Add(self.smear_message_new_p, 0, wx.CENTER, 10)
         self.sizer_set_smearer.Add((5, 2))
         self.sizer_set_smearer.Add(self.sizer_new_smear, 0, wx.CENTER, 10)
         # add all to chi2 sizer
         sizer_smearer_box.Add(self.sizer_set_smearer)
 …
         sizer_chi2.Add(weighting_box)
         sizer_chi2.Add((-1, 5))
         # hide all smear messages and textctrl
         self._hide_all_smear_info()
         # get smear_selection
         self.current_smearer = smear_selection(self.data, self.model)
 …
         #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 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
                                     style=wx.TE_PROCESS_ENTER,
 …
         qmin_tip += q_tip
         self.qmin.SetToolTipString(qmin_tip)
         self.qmax = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
                                        style=wx.TE_PROCESS_ENTER,
 …
         id = wx.NewId()
         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")
         sizer = wx.GridSizer(2, 4, 2, 6)
 …
         self.btEditMask.SetToolTipString("Edit Mask.")
         self.EditMask_title = wx.StaticText(self, -1, ' Masking(2D)')
         sizer.Add(wx.StaticText(self, -1, '   Q range'))
         sizer.Add(wx.StaticText(self, -1, ' Min[1/A]'))
 …
         boxsizer_range.Add((10, 10))
         boxsizer_range.Add(sizer)
         boxsizer_range.Add((10, 15))
         boxsizer_range.Add(sizer_fit)
 …
         self.sizer5.Layout()
     def _set_sizer_dispersion(self):
         """
 …
             ## the user didn't select dispersity display
             return
         self._reset_dispersity()
         ## fill a sizer with the combobox to select dispersion type
         model_disp = wx.StaticText(self, -1, 'Function')
 …
         self.sizer4_4.Add(self.text_disp_1, (iy, ix), (1, 1), \
                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
         ix += 1
         self.text_disp_min = wx.StaticText(self, -1, 'Min')
 …
         self.sizer4_4.Add(self.text_disp_max, (iy, ix), (1, 1),
                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
         ix += 1
         npts = wx.StaticText(self, -1, 'Npts')
 …
         self.sizer4_4.Add(model_disp, (iy, ix), (1, 1),
                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
         self.text_disp_max.Show(True)
         self.text_disp_min.Show(True)
 …
                 iy += 1
                 for p in self.model.dispersion[item].keys():
                     if p == "width":
                         ix = 0
 …
                                            size=(_BOX_WIDTH / 1.3, 20),
                                            style=0)
                         self.sizer4_4.Add(ctl2, (iy, ix), (1, 1),
                                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
 …
                                                   style=wx.TE_PROCESS_ENTER,
                                 text_enter_callback=self._onparamRangeEnter)
                         self.sizer4_4.Add(ctl3, (iy, ix), (1, 1),
                                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
                         ix = 5
                         ctl4 = self.ModelTextCtrl(self, -1,
 …
                                                   style=wx.TE_PROCESS_ENTER,
                             text_enter_callback=self._onparamRangeEnter)
                         self.sizer4_4.Add(ctl4, (iy, ix), (1, 1),
                                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
 …
                         ctl3.Show(True)
                         ctl4.Show(True)
                     elif p == "npts":
                         ix = 6
 …
                                                   size=(_BOX_WIDTH / 2.2, 20),
                                                   style=wx.TE_PROCESS_ENTER)
                         Tctl.SetValue(str(format_number(value)))
                         self.sizer4_4.Add(Tctl, (iy, ix), (1, 1),
 …
                                                   size=(_BOX_WIDTH / 2.2, 20),
                                                   style=wx.TE_PROCESS_ENTER)
                         Tct2.SetValue(str(format_number(value)))
                         self.sizer4_4.Add(Tct2, (iy, ix), (1, 1),
 …
                 self.fittable_param.append([cb, name1, ctl1, text2,
                                             ctl2, ctl3, ctl4, disp_box])
         ix = 0
         iy += 1
 …
                 name2 = item + ".npts"
                 name3 = item + ".nsigmas"
                 if not name1 in self.model.details:
                     self.model.details[name1] = ["", None, None]
                 iy += 1
                 for p in self.model.dispersion[item].keys():
                     if p == "width":
                         ix = 0
 …
                                 poly_text += "It is the STD (ratio*mean)"
                                 poly_text += " of the distribution.\n "
                                 values.SetToolTipString(poly_text)
                                 first_orient = False
 …
                         elif ctl1.IsShown():
                             ctl1.Hide()
                         self.sizer4_4.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
                         ## text to show error sign
 …
                                            size=(_BOX_WIDTH / 1.3, 20),
                                            style=0)
                         self.sizer4_4.Add(ctl2, (iy, ix), (1, 1),
                                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
 …
                                 text2.Show(True)
                                 ctl2.Show(True)
                         ix = 4
                         ctl3 = self.ModelTextCtrl(self, -1,
 …
                         ctl3.Hide()
                         ix = 5
                         ctl4 = self.ModelTextCtrl(self, -1,
 …
                                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
                         ctl4.Hide()
                         if self.data.__class__.__name__ == "Data2D" or \
                                 self.enable2D:
                             ctl3.Show(True)
                             ctl4.Show(True)
                     elif p == "npts":
                         ix = 6
 …
                                                  size=(_BOX_WIDTH / 2.2, 20),
                                                  style=wx.TE_PROCESS_ENTER)
                         Tctl.SetValue(str(format_number(value)))
                         if self.data.__class__.__name__ == "Data2D" or \
 …
                                                   size=(_BOX_WIDTH / 2.2, 20),
                                                   style=wx.TE_PROCESS_ENTER)
                         Tct2.SetValue(str(format_number(value)))
                         if self.data.__class__.__name__ == "Data2D" or \
 …
                         self.fixed_param.append([None, name3, Tct2,
                                                  None, None, None, None, None])
                         self.orientation_params_disp.append([None, name3,
                                         Tct2, None, None, None, None, None])
 …
                 self.orientation_params_disp.append([cb, name1, ctl1,
                                             text2, ctl2, ctl3, ctl4, disp_box])
                 if self.data.__class__.__name__ == "Data2D" or \
                                 self.enable2D:
 …
                 else:
                     disp_box.Hide()
         self.state.disp_cb_dict = copy.deepcopy(self.disp_cb_dict)
         self.state.model = self.model.clone()
         ## save state into
 …
         """
         flag = self._update_paramv_on_fit()
         wx.CallAfter(self._onparamEnter_helper)
         if not flag:
 …
             wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
             return
     def _onFit(self, event):
         """
 …
                          StatusEvent(status="Fit: %s" % msg, type="stop"))
             return
         if len(self.param_toFit) <= 0:
             msg = "Select at least one parameter to fit"
 …
                          StatusEvent(status=msg, type="stop"))
             return
         flag = self._update_paramv_on_fit()
         if self.batch_on and not self._is_2D():
             if not self._validate_Npts_1D():
                 return
         if not flag:
             msg = "Fitting range or parameters are invalid"
 …
                          StatusEvent(status=msg, type="stop"))
             return
         self.select_param(event=None)
 …
         self.fit_started = self._manager.onFit(uid=self.uid)
         wx.CallAfter(self.set_fitbutton)
     def set_fitbutton(self):
         """
 …
         if self.is_mac:
             return
         if self.fit_started:
             label = "Stop"
 …
         self.btFit.SetForegroundColour(color)
         self.btFit.Enable(True)
     def get_weight_flag(self):
         """
 …
                 break
         return flag
     def _StopFit(self, event=None):
         """
 …
         self._manager._reset_schedule_problem(value=0)
         self._on_fit_complete()
     def rename_model(self):
         """
 …
         if self.model is not None:
             self.model.name = "M" + str(self.index_model)
     def _on_select_model(self, event=None):
         """
 …
         self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
         self.state.slit_smearer = self.slit_smearer.GetValue()
         self.state.structurecombobox = self.structurebox.GetLabel()
         self.state.formfactorcombobox = self.formfactorbox.GetLabel()
 …
                 self.disable_smearer.SetValue(True)
                 self.enable_smearer.SetValue(False)
             # more disables for 2D
             self._set_smear_buttons()
             try:
                 # update smearer sizer
 …
             ## event to post model to fit to fitting plugins
             (ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent()
             ## set smearing value whether or not
             #    the data contain the smearing info
 …
                             caption=self.window_caption,
                             qmax=float(self.qmax_x))
             self._manager._on_model_panel(evt=evt)
             self.mbox_description.SetLabel("Model [ %s ]"% str(self.model.name))
+            self.mbox_description.SetLabel("Model [ %s ]" % str(self.model.name))
             self.mbox_description.SetForegroundColour(wx.BLUE)
             self.state.model = self.model.clone()
 …
                 self.get_paste_params(copy_flag)
                 wx.CallAfter(self._onDraw, None)
         else:
             self._draw_model()
         if self.batch_on:
             self.slit_smearer.Enable(False)
 …
             self.btEditMask.Disable()
             self.EditMask_title.Disable()
         self.Show(True)
         self.SetupScrolling()
     def _onparamEnter(self, event):
         """
 …
                 if flag:
                     #self.compute_chisqr(smearer= temp_smearer)
                     ## new state posted
                     if self.state_change:
 …
             msg = "Cannot Plot :Must enter a number!!!  "
             wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
         self.save_current_state()
         return
     def _onparamRangeEnter(self, event):
         """
 …
         else:
             tcrtl.SetBackgroundColour(wx.WHITE)
         #self._undo.Enable(True)
         self.save_current_state()
 …
         wx.PostEvent(self.parent, event)
         self.state_change = False
     def qrang_set_focus(self, event=None):
+    def qrang_set_focus(self, event=None):
         """
         ON Qrange focus
 …
         #tcrtl = event.GetEventObject()
         self._validate_qrange(self.qmin, self.qmax)
     def qrange_click(self, event):
         """
 …
             d_group_id = self.data.group_id
             act_ctrl = event.GetEventObject()
             wx.PostEvent(self._manager.parent,
                          PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
+            wx.PostEvent(self._manager.parent,
+                         PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
                                      group_id=d_group_id, leftdown=is_click,
                                      active=act_ctrl))
     def on_qrange_text(self, event):
         """
 …
         d_id = self.data.id
         d_group_id = self.data.group_id
         wx.PostEvent(self._manager.parent,
                      PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
                                      group_id=d_group_id, leftdown=False,
+        wx.PostEvent(self._manager.parent,
+                     PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
+                                     group_id=d_group_id, leftdown=False,
                                      active=act_ctrl))
         self._validate_qrange(self.qmin, self.qmax)
     def on_key(self, event):
+    def on_key(self, event):
         """
         On Key down
 …
             x_data = float(ctrl.GetValue())
         except:
             return
+            return
         key = event.GetKeyCode()
         length = len(self.data.x)
 …
         ctrl.SetValue(str(self.data.x[indx]))
         self._validate_qrange(self.qmin, self.qmax)
     def _onQrangeEnter(self, event):
         """
 …
                               (self.data.x <= self.qmax_x))
                 self.Npts_fit.SetValue(str(len(self.data.x[index_data])))
             self.npts_x = self.Npts_total.GetValue()
             self.create_default_data()
 …
             msg = "Model Error:wrong value entered!!!"
             wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
         self._draw_model()
         self.save_current_state()
 …
         self.state_change = False
         return
     def _clear_Err_on_Fit(self):
         """
 …
                     if item[4] != None and item[4].IsShown():
                         item[4].Hide()
         if len(self.fittable_param) > 0:
             for item in self.fittable_param:
 …
                         item[4].Hide()
         return
     def _get_defult_custom_smear(self):
         """
 …
         if self.dx_max == None:
             self.dx_max = SMEAR_SIZE_H
     def _get_smear_info(self):
         """
         Get the smear info from data.
         :return: self.smear_type, self.dq_l and self.dq_r,
             respectively the type of the smear, dq_min and
 …
             self.dq_l = data.dx[0]
             self.dq_r = data.dx[-1]
         # check if it is slit smear and get min max if it is.
         elif data.dxl != None or data.dxw != None:
 …
                 self.dq_r = data.dxw[0]
         #return self.smear_type,self.dq_l,self.dq_r
     def _show_smear_sizer(self):
         """
 …
         self.smear_description_2d_y.Hide()
         self.smear_description_2d.Hide()
         self.smear_accuracy.Hide()
         self.smear_data_left.Hide()
 …
         self.smear_message_new_p.Hide()
         self.smear_message_new_s.Hide()
     def _set_accuracy_list(self):
         """
 …
         for idx in range(len(list)):
             self.smear_accuracy.Append(list[idx], idx)
     def _set_fun_box_list(self, fun_box):
         """
 …
                     break
             ind += 1
     def _on_select_accuracy(self, event):
         """
 …
             if self.current_smearer != None:
                 self.current_smearer.set_accuracy(accuracy=\
                                                   self.smear2d_accuracy)
+                                                  self.smear2d_accuracy)
         event.Skip()
 …
         # get ready for new event
         event.Skip()
     def _onMask(self, event):
         """
 …
         from sas.guiframe.local_perspectives.plotting.masking \
         import MaskPanel as MaskDialog
         self.panel = MaskDialog(base=self, data=self.data, id=wx.NewId())
         self.panel.ShowModal()
     def _draw_masked_model(self, event):
         """
 …
         """
         return self.enable2D
     def compute_data_set_range(self, data_list):
         """
 …
                 self.npts_data_set += npts
         return self.qmin_data_set, self.qmax_data_set, self.npts_data_set
     def compute_data_range(self, data):
         """
 …
                     npts = len(data.x)
                 except:
                     msg = "Unable to find min/max/length of \n data named %s"% \
                                 data.filename
+                    msg = "Unable to find min/max/length of \n data named %s" % \
+                                data.filename
                     wx.PostEvent(self._manager.parent, StatusEvent(status=msg,
                                                info="error"))
                     raise ValueError, msg
             else:
                 qmin = 0
 …
                     y = max(math.fabs(data.ymin), math.fabs(data.ymax))
                 except:
                     msg = "Unable to find min/max of \n data named %s"% \
                                 data.filename
+                    msg = "Unable to find min/max of \n data named %s" % \
+                                data.filename
                     wx.PostEvent(self._manager.parent, StatusEvent(status=msg,
                                                info="error"))
 …
                 npts = len(data.data)
         return qmin, qmax, npts
     def set_data(self, data):
         """
 …
             self.graph_id = data.group_id
         self.data.group_id = self.graph_id
         if self.data is None:
             data_name = ""
 …
                 self._set_bookmark_flag(not self.batch_on)
                 self._keep.Enable(not self.batch_on)
             if self.data.is_data:
+            if self.data.is_data:
                 self._set_save_flag(True)
                 self._set_preview_flag(True)
 …
             self.dI_sqrdata.Enable(True)
             self.dI_idata.Enable(True)
             self.formfactorbox.Enable()
             self.structurebox.Enable()
 …
                 self.btEditMask.Enable()
                 self.EditMask_title.Enable()
         self.Npts_total.SetValue(str(npts))
         #default:number of data points selected to fit
 …
         self.Npts_total.SetBackgroundColour(\
                                     self.GetParent().GetBackgroundColour())
         self.Npts_total.Bind(wx.EVT_MOUSE_EVENTS, self._npts_click)
         self.pointsbox.Disable()
 …
         if check_data_validity(data):
             self.data_box_description.SetForegroundColour(wx.BLUE)
         if self.batch_on:
             self.slit_smearer.Enable(False)
 …
                                       title=str(self.data.title)))
             self._draw_model()
     def _npts_click(self, event):
         """
 …
         """
         pass
     def reset_page(self, state, first=False):
         """
 …
         try:
             self.reset_page_helper(state)
             self.select_param(event=None)
             #Save state_fit
 …
             msg = "Error: This model state has missing or outdated "
             msg += "information.\n"
             msg += "%s"% (sys.exc_value)
+            msg += "%s" % (sys.exc_value)
             wx.PostEvent(self._manager.parent,
                          StatusEvent(status=msg, info="error"))
         self._lay_out()
         self.Refresh()
     def get_range(self):
         """
 …
         """
         return float(self.qmin_x), float(self.qmax_x)
     def get_npts2fit(self):
         """
         return numbers of data points within qrange
         :Note: This is to normalize chisq by Npts of fit
         """
         if self.data is None:
 …
         """
         self.Npts_fit.SetValue(str(self.get_npts2fit()))
     def get_chi2(self):
         """
 …
         """
         return self.tcChi.GetValue()
     def onsetValues(self, chisqr, p_name, out, cov):
         """
         Build the panel from the fit result
         :param chisqr: Value of the goodness of fit metric
         :param p_name: the name of parameters
         :param out: list of parameter with the best value found during fitting
         :param cov: Covariance matrix
         """
+        """
         # make sure stop button to fit button all the time
         self._on_fit_complete()
         if out == None or not numpy.isfinite(chisqr):
             raise ValueError, "Fit error occured..."
         is_modified = False
         has_error = False
         dispersity = ''
         #Hide textctrl boxes of errors.
         self._clear_Err_on_Fit()
         #Check if chi2 is finite
         if chisqr != None and numpy.isfinite(chisqr):
 …
         else:
             self.tcChi.SetValue("-")
         #Hide error title
         if self.text2_3.IsShown() and not self.is_mac:
             self.text2_3.Hide()
         try:
             if self.enable_disp.GetValue():
 …
             dispersity = None
             pass
         i = 0
         #Set the panel when fit result are list
 …
                         val_out = format_number(out[ind], True)
                         item[2].SetValue(val_out)
                     if(cov != None and len(cov) == len(out)):
                         try:
 …
                         except:
                             pass
                         if cov[ind] != None:
                             if numpy.isfinite(float(cov[ind])):
 …
         ## save current state
         self.save_current_state()
         if not self.is_mac:
             self.Layout()
 …
         #plot model ( when drawing, do not update chisqr value again)
         self._draw_model(update_chisqr=False, source='fit')
     def onWeighting(self, event):
         """
 …
         self.weightbt_string = event.GetEventObject().GetLabelText()
         self._set_weight()
     def _set_weight(self, is_2D=None):
         """
 …
                                      is2d=is_2D,
                                      fid=None)
     def onPinholeSmear(self, event):
         """
         Create a custom pinhole smear object that will change the way residuals
         are compute when fitting
         :Note: accuracy is given by strings'High','Med', 'Low' FOR 2d,
                      None for 1D
         """
         if self.model == None:
 …
         # hide all silt sizer
         self._hide_all_smear_info()
         # show relevant slit sizers
         self._show_smear_sizer()
 …
         self.sizer_set_smearer.Layout()
         self.Layout()
         if event != None:
             event.Skip()
 …
         event = PageInfoEvent(page=self)
         wx.PostEvent(self.parent, event)
     def _is_changed_pinhole(self):
         """
         check if any of pinhole smear is changed
         :return: True or False
         """
         # get the values
         pin_min = self.smear_pinhole_min.GetValue()
         pin_max = self.smear_pinhole_max.GetValue()
         # Check changes in slit width
         try:
 …
         if self.dx_min != dx_min:
             return True
         # Check changes in slit heigth
         try:
 …
             return True
         return False
     def _set_pinhole_smear(self):
         """
         Set custom pinhole smear
         :return: msg
         """
         # copy data
 …
             data.dxw = None
         msg = None
         get_pin_min = self.smear_pinhole_min
         get_pin_max = self.smear_pinhole_max
 …
             get_pin_max.SetBackgroundColour("white")
         ## set smearing value whether or not the data contain the smearing info
         self._manager.set_smearer(smearer=self.current_smearer,
                             fid=self.data.id,
 …
                             uid=self.uid)
         return msg
     def update_pinhole_smear(self):
         """
         called by kill_focus on pinhole TextCntrl
         to update the changes
         :return: False when wrong value was entered
         """
         # msg default
 …
         else:
             return True
     def onSlitSmear(self, event):
         """
 …
         else:
             is_new_slit = True
         # if any value is changed
         if is_new_slit:
             msg = self._set_slit_smear()
         # hide all silt sizer
         self._hide_all_smear_info()
 …
         """
         check if any of slit lengths is changed
         :return: True or False
         """
         # get the values
         width = self.smear_slit_width.GetValue()
         height = self.smear_slit_height.GetValue()
         # check and change the box bg color if it was pink
         #    but it should be white now
 …
         if width.lstrip().rstrip() == "":
             self.smear_slit_width.SetBackgroundColour(wx.WHITE)
         # Check changes in slit width
         if width == "":
 …
         if self.dxw != dxw:
             return True
         # Check changes in slit heigth
         if height == "":
 …
         return False
     def _set_slit_smear(self):
         """
         Set custom slit smear
         :return: message to inform the user about the validity
             of the values entered for slit smear
 …
         data.dxw = None
         msg = None
         try:
             self.dxl = float(self.smear_slit_height.GetValue())
 …
             else:
                 self.smear_slit_width.SetBackgroundColour(wx.WHITE)
         self.current_smearer = smear_selection(data, self.model)
         ## set smearing value whether or not the data contain the smearing info
 …
                                  uid=self.uid)
         return msg
     def update_slit_smear(self):
         """
         called by kill_focus on pinhole TextCntrl
         to update the changes
         :return: False when wrong value was entered
         """
         # msg default
 …
         else:
             return True
     def onSmear(self, event):
         """
 …
                 self._manager.page_finder[self.uid].add_data(data=self.data)
         temp_smearer = self.on_smear_helper()
         self.sizer_set_smearer.Layout()
         self.Layout()
         self._set_weight()
         ## set smearing value whether or not the data contain the smearing info
         wx.CallAfter(self._manager.set_smearer, uid=self.uid,
 …
                      enable_smearer=not self.disable_smearer.GetValue(),
                      draw=True)
         self.state.enable_smearer = self.enable_smearer.GetValue()
         self.state.disable_smearer = self.disable_smearer.GetValue()
         self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
         self.state.slit_smearer = self.slit_smearer.GetValue()
     def on_smear_helper(self, update=False):
         """
         Help for onSmear
         :param update: force or not to update
         """
 …
         self._hide_all_smear_info()
         data = copy.deepcopy(self.data)
         # make sure once more if it is smearer
         temp_smearer = smear_selection(data, self.model)
 …
             self.onSlitSmear(None)
         self._show_smear_sizer()
         return temp_smearer
     def on_complete_chisqr(self, event):
         """
 …
         except:
             pass
     def get_all_checked_params(self):
         """
 …
                     self.param_toFit.append(item)
         self.save_current_state_fit()
         event = PageInfoEvent(page=self)
         wx.PostEvent(self.parent, event)
 …
                 param2fit.append(item[1])
         self._manager.set_param2fit(self.uid, param2fit)
     def select_all_param(self, event):
         """
 …
                             except:
                                 pass
                         else:
                             ## for 1D all parameters except orientation
 …
                     item[0].SetValue(False)
                 self.param_toFit = []
         self.save_current_state_fit()
         if event != None:
             #self._undo.Enable(True)
 …
                 param2fit.append(item[1])
         self.parent._manager.set_param2fit(self.uid, param2fit)
     def select_param(self, event):
         """
 …
         else:
             self.cb1.SetValue(False)
         self.save_current_state_fit()
         if event != None:
 …
             event = PageInfoEvent(page=self)
             wx.PostEvent(self.parent, event)
         param2fit = []
         for item in self.param_toFit:
 …
                 param2fit.append(item[1])
         self._manager.set_param2fit(self.uid, param2fit)
     def set_model_param_sizer(self, model):
         """
         Build the panel from the model content
         :param model: the model selected in combo box for fitting purpose
         """
         self.sizer3.Clear(True)
 …
         self.orientation_params = []
         self.orientation_params_disp = []
         if model == None:
             self.sizer3.Layout()
 …
         ## save the current model
         self.model = model
         keys = self.model.getParamList()
         #list of dispersion parameters
         self.disp_list = self.model.getDispParamList()
 …
         keys.sort(custom_compare)
         iy = 0
         ix = 0
 …
         self.cb1.SetToolTipString("To check/uncheck all the boxes below.")
         self.cb1.SetValue(True)
         sizer.Add(self.cb1, (iy, ix), (1, 1), \
                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5)
 …
                             wx.EXPAND | wx.ADJUST_MINSIZE, 0)
         self.text2_4.Hide()
         CHECK_STATE = self.cb1.GetValue()
         for item in keys:
             if not item in self.disp_list and not item in \
                     self.model.orientation_params:
                 ##prepare a spot to store errors
                 if not item in self.model.details:
                     self.model.details[item] = ["", None, None]
                 iy += 1
                 ix = 0
 …
                     #cb.SetValue(True)
                     wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
                     sizer.Add(cb, (iy, ix), (1, 1),
                               wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5)
 …
                     sizer.Add(ctl3, (iy, ix), (1, 1),
                               wx.EXPAND | wx.ADJUST_MINSIZE, 0)
                     ix += 1
                     ctl4 = self.ModelTextCtrl(self, -1,
 …
                     sizer.Add(ctl4, (iy, ix), (1, 1),
                               wx.EXPAND | wx.FIXED_MINSIZE, 0)
                     ix += 1
                     # Units
 …
                     sizer.Add(units, (iy, ix), (1, 1),
                               wx.EXPAND | wx.ADJUST_MINSIZE, 0)
                     self.parameters.append([cb, item, ctl1,
                                             text2, ctl2, ctl3, ctl4, units])
         iy += 1
         sizer.Add((10, 10), (iy, ix), (1, 1),
                   wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
         # type can be either Guassian or Array
         if len(self.model.dispersion.values()) > 0:
 …
         else:
             type = "Gaussian"
         iy += 1
         ix = 0
 …
             if item in self.model.orientation_params:
                 orient_angle = wx.StaticText(self, -1, '[For 2D only]:')
                 mag_on_button = wx.Button(self, -1, "Magnetic ON" )
+                mag_on_button = wx.Button(self, -1, "Magnetic ON")
                 mag_on_button.Bind(wx.EVT_BUTTON, self._on_mag_on)
                 mag_help_button = wx.Button(self, -1,"Magnetic angles?" )
                 mag_help_button.Bind(wx.EVT_BUTTON,self._on_mag_help)
+                mag_help_button = wx.Button(self, -1, "Magnetic angles?")
+                mag_help_button.Bind(wx.EVT_BUTTON, self._on_mag_help)
                 sizer.Add(orient_angle, (iy, ix), (1, 1),
                           wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
                 iy += 1
                 sizer.Add(mag_on_button,(iy, ix ),(1,1),
                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
                 sizer.Add(mag_help_button,(iy, ix + 1),(1,1),
                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
+                sizer.Add(mag_on_button, (iy, ix), (1, 1),
+                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
+                sizer.Add(mag_help_button, (iy, ix + 1), (1, 1),
+                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
                 #handle the magnetic buttons
                 if not self._has_magnetic:
 …
                     if self.magnetic_on:
                         mag_on_button.SetLabel("Magnetic OFF")
                         mag_help_button.Show(True)
+                        mag_help_button.Show(True)
                     else:
                         mag_on_button.SetLabel("Magnetic ON")
                         mag_help_button.Show(False)
                 if not self.data.__class__.__name__ == "Data2D" and \
                         not self.enable2D:
 …
                     orient_angle.Show(True)
                 break
         #For Gaussian only
         if type.lower() != "array":
 …
                     if not item in self.model.details:
                         self.model.details[item] = ["", None, None]
                     iy += 1
                     ix = 0
 …
                     sizer.Add(cb, (iy, ix), (1, 1),
                               wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5)
                     ## add parameter value
                     ix += 1
 …
                     ctl2.Hide()
                     ix += 1
                     ctl3 = self.ModelTextCtrl(self, -1,
 …
                                               style=wx.TE_PROCESS_ENTER,
                                 text_enter_callback=self._onparamRangeEnter)
                     sizer.Add(ctl3, (iy, ix), (1, 1),
                               wx.EXPAND | wx.ADJUST_MINSIZE, 0)
                     ctl3.Hide()
                     ix += 1
                     ctl4 = self.ModelTextCtrl(self, -1,
 …
                     sizer.Add(ctl4, (iy, ix), (1, 1),
                               wx.EXPAND | wx.ADJUST_MINSIZE, 0)
                     ctl4.Hide()
                     if self.data.__class__.__name__ == "Data2D" or \
                             self.enable2D:
 …
                         ctl3.Show(True)
                         ctl4.Show(True)
                     ix += 1
                     # Units
 …
                     else:
                         units.Hide()
                     sizer.Add(units, (iy, ix), (1, 1),
                               wx.EXPAND | wx.ADJUST_MINSIZE, 0)
                     self.parameters.append([cb, item, ctl1,
                                             text2, ctl2, ctl3, ctl4, units])
                     self.orientation_params.append([cb, item, ctl1,
                                             text2, ctl2, ctl3, ctl4, units])
         iy += 1
         box_description.SetForegroundColour(wx.BLUE)
 …
             wx.PostEvent(self._manager.parent,
                         StatusEvent(status=msg, info=infor))
     def _onModel2D(self, event):
         """
 …
             self.model_view.SetLabel("Show 1D")
             self.enable2D = True
         else:
             self.model_view.SetLabel("Show 2D")
 …
         self.SetupScrolling()
         self._draw_model()
         self.state.enable2D = copy.deepcopy(self.enable2D)
     def _set_smear_buttons(self):
         """
 …
             self.slit_smearer.Enable(True)
             self.pinhole_smearer.Enable(True)
 class BGTextCtrl(wx.TextCtrl):
     """
 …
         self.SetEditable(False)
         self.SetBackgroundColour(self.GetParent().parent.GetBackgroundColour())
         # Bind to mouse event to avoid text highlighting
         # The event will be skipped once the call-back
         # is called.
         self.Bind(wx.EVT_MOUSE_EVENTS, self._click)
     def _click(self, event):
         """

src/sas/perspectives/fitting/fitpanel.py

-                      r386ffe1
+                      r2f4b430
 :note: For Fit to be performed the user should check at least one parameter
     on fit Panel window.
 """
 import wx
 …
     """
     FitPanel class contains fields allowing to fit  models and  data
     :note: For Fit to be performed the user should check at least one parameter
         on fit Panel window.
     """
     ## Internal name for the AUI manager
 …
     window_caption = "Fit Panel "
     CENTER_PANE = True
     def __init__(self, parent, manager=None, *args, **kwargs):
         """
         """
         nb.__init__(self, parent, -1,
                     style=wx.aui.AUI_NB_WINDOWLIST_BUTTON|
                     wx.aui.AUI_NB_DEFAULT_STYLE|
+                    style=wx.aui.AUI_NB_WINDOWLIST_BUTTON |
+                    wx.aui.AUI_NB_DEFAULT_STYLE |
                     wx.CLIP_CHILDREN)
         PanelBase.__init__(self, parent)
 …
         self.model_dictionary = self.menu_mng.get_model_dictionary()
         self.pageClosedEvent = wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE
         self.Bind(self.pageClosedEvent, self.on_close_page)
         ## save the title of the last page tab added
 …
         self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, self.on_page_changing)
         self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSED, self.on_closed)
     def on_closed(self, event):
         """
 …
             self.add_empty_page()
             self.enable_close_button()
     def save_project(self, doc=None):
         """
 …
                                                             info="warning"))
         return doc
     def update_model_list(self):
         """
 …
             self.model_list_box = temp
         return temp
     def reset_pmodel_list(self):
         """
 …
             self.model_list_box = temp
         return temp
     def get_page_by_id(self, uid):
         """
 …
         else:
             return self.opened_pages[uid]
     def on_page_changing(self, event):
         """
 …
         """
         wx.CallAfter(self.helper_on_page_change)
     def helper_on_page_change(self):
         """
 …
         if pos != -1:
             selected_page = self.GetPage(pos)
             wx.PostEvent(self._manager.parent,
+            wx.PostEvent(self._manager.parent,
                          PanelOnFocusEvent(panel=selected_page))
         self.enable_close_button()
     def on_set_focus(self, event):
         """
 …
         if pos != -1:
             selected_page = self.GetPage(pos)
             wx.PostEvent(self._manager.parent,
+            wx.PostEvent(self._manager.parent,
                          PanelOnFocusEvent(panel=selected_page))
     def get_data(self):
         """
 …
             selected_page = self.GetPage(pos)
             return selected_page.get_data()
     def set_model_state(self, state):
         """
 …
             selected_page = self.GetPage(pos)
             selected_page.set_model_state(state)
     def get_state(self):
         """
 …
             selected_page = self.GetPage(pos)
             return selected_page.get_state()
     def close_all(self):
         """
         remove all pages, used when a svs file is opened
         """
         #get number of pages
         nop = self.GetPageCount()
 …
             self.DeletePage(0)
             nop = nop - 1
         ## save the title of the last page tab added
         self.fit_page_name = {}
         ## list of existing fit page
         self.opened_pages = {}
     def set_state(self, state):
         """
 …
                     panel.reset_page(state=state)
                     panel.save_current_state()
     def clear_panel(self):
         """
         Clear and close all panels, used by guimanager
         """
         #close all panels only when svs file opened
         self.close_all()
         self._manager.mypanels = []
     def on_close_page(self, event=None):
         """
 …
                 return
         self._close_helper(selected_page=selected_page)
     def close_page_with_data(self, deleted_data):
         """
 …
             if hasattr(selected_page, "get_data"):
                 data = selected_page.get_data()
                 if data is None:
                     #the fitpanel exists and only the initial fit page is open
 …
                     self.DeletePage(index)
                     break
     def set_manager(self, manager):
         """
         set panel manager
         :param manager: instance of plugin fitting
         """
         self._manager = manager
 …
         """
         copy a dictionary of model into its own dictionary
         :param m_dict: dictionnary made of model name as key and model class
         as value
         """
         self.model_list_box = dict
     def set_model_dict(self, m_dict):
         """
 …
         """
         :return: the current page selected
         """
         return self.GetPage(self.GetSelection())
     def add_sim_page(self, caption="Const & Simul Fit"):
         """
 …
         if caption == "Const & Simul Fit":
             self.sim_page = SimultaneousFitPage(self, page_finder=page_finder,
                                                  id=-1, batch_on=False)
+                                                 id= -1, batch_on=False)
             self.sim_page.window_caption = caption
             self.sim_page.window_name = caption
 …
             self.enable_close_button()
             return self.batch_page
     def add_empty_page(self):
         """
 …
         panel.on_set_focus(None)
         return panel
     def enable_close_button(self):
         """
 …
                 style |= wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
                 self.SetWindowStyle(style)
     def delete_data(self, data):
         """
 …
             if self.GetPageCount() == 0:
                 self._manager.on_add_new_page(event=None)
     def set_data_on_batch_mode(self, data_list):
         """
         Add all data to a single tab when the application is on Batch mode.
         However all data in the set of data must be either 1D or 2D type.
         This method presents option to select the data type before creating a
+        However all data in the set of data must be either 1D or 2D type.
+        This method presents option to select the data type before creating a
         tab.
         """
 …
             #check if there is an empty page to fill up
             if not check_data_validity(p.get_data()) and p.batch_on:
                 #make sure data get placed in 1D empty tab if data is 1D
                 #else data get place on 2D tab empty tab
 …
             elif not data_1d_list and data_2d_list:
                 page.fill_data_combobox(data_2d_list)
         pos = self.GetPageIndex(page)
         page.batch_on = self.batch_on
 …
         self.opened_pages[page.uid] = page
         return page
     def set_data(self, data_list):
         """
         Add a fitting page on the notebook contained by fitpanel
         :param data: data to fit
         :return panel : page just added for further used.
         is used by fitting module
         """
         if not data_list:
 …
                 data_list = [data]
                 data = data_list[0]
             if data is None:
                 return None
 …
         self.SetSelection(pos)
         return page
     def _onGetstate(self, event):
         """
 …
         if page.uid in self.fit_page_name:
             self.fit_page_name[page.uid].appendItem(page.createMemento())
     def _onUndo(self, event):
         """
 …
                 page._redo.Enable(True)
             page.reset_page(state)
     def _onRedo(self, event):
         """
 …
                 state = self.fit_page_name[page.uid].getNextItem()
             page.reset_page(state)
     def _close_helper(self, selected_page):
         """
 …
             for uid, list in self.opened_pages.iteritems():
                 #Don't return any panel is the exact same page is created
                 if flag and selected_page.uid == uid:
                     self._manager.remove_plot(uid, theory=False)
                     break
             del page_finder[selected_page]
         #Delete the name of the page into the list of open page
         for uid, list in self.opened_pages.iteritems():

src/sas/perspectives/fitting/fitproblem.py

-                      r7a04dbb
+                      r2f4b430
         flag is 0 ingore smear value.
         """
     def get_smearer(self):
         """
 …
         """
         """
     def get_name(self):
         """
         """
     def set_model(self, model):
         """
 …
         :param name: name created for model
         """
     def get_model(self):
         """
         :return: saved model
         """
     def set_residuals(self, residuals):
         """
 …
         :param data: data selected
         """
     def get_residuals(self):
         """
         :return: residuals
         """
     def set_theory_data(self, data):
         """
 …
         :param data: data selected
         """
     def get_theory_data(self):
         """
         :return: list of data dList
         """
     def set_fit_data(self, data):
         """
 …
         :param data: list of data selected
         """
     def get_fit_data(self):
         """
         """
     def set_model_param(self, name, value=None):
         """
 …
         :param value: value of that parameter
         """
     def set_param2fit(self, list):
         """
 …
         :param list: list of the param names
         """
     def get_param2fit(self):
         """
         return the list param names to fit
         """
     def get_model_param(self):
         """
         return list of couple of parameter name and value
         """
     def schedule_tofit(self, schedule=0):
         """
         set schedule to true to decide if this fit  must be performed
         """
     def get_scheduled(self):
         """
         return true or false if a problem as being schedule for fitting
         """
     def set_range(self, qmin=None, qmax=None):
         """
         set fitting range
         """
     def get_range(self):
         """
         :return: fitting range
         """
     def set_weight(self, flag=None):
         """
         set fitting range
         """
     def get_weight(self):
         """
         get fitting weight
         """
     def clear_model_param(self):
         """
         clear constraint info
         """
     def set_fit_tab_caption(self, caption):
         """
         store the caption of the page associated with object
         """
     def get_fit_tab_caption(self):
         """
         Return the caption of the page associated with object
         """
     def set_graph_id(self, id):
         """
         Set graph id (from data_group_id at the time the graph produced)
         """
+        Set graph id (from data_group_id at the time the graph produced)
+        """
     def get_graph_id(self):
         """
 …
         """
 class FitProblemDictionary(FitProblemComponent, dict):
     """
 …
         self.batch_inputs = {}
         self.batch_outputs = {}
     def enable_smearing(self, flag=False, fid=None):
         """
 …
             if fid in self.iterkeys():
                 self[fid].enable_smearing(flag)
     def set_smearer(self, smearer, fid=None):
         """
 …
             if fid in self.iterkeys():
                 self[fid].set_smearer(smearer)
     def get_smearer(self, fid=None):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_smearer()
     def save_model_name(self, name, fid=None):
         """
 …
             if fid in self.iterkeys():
                 self[fid].save_model_name(name)
     def get_name(self, fid=None):
         """
 …
                 result.append(self[fid].get_name())
         return result
     def set_model(self, model, fid=None):
         """
 …
             if fid in self.iterkeys():
                 self[fid].set_model(self.model)
     def get_model(self, fid):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_model()
     def set_fit_tab_caption(self, caption):
         """
 …
         """
         self.fit_tab_caption = caption
     def get_fit_tab_caption(self):
         """
 …
         """
         return self.fit_tab_caption
     def set_residuals(self, residuals, fid):
         """
 …
         if fid in self.iterkeys():
             self[fid].set_residuals(residuals)
     def get_residuals(self, fid):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_residuals()
     def set_theory_data(self, fid, data=None):
         """
 …
         if fid in self.iterkeys():
             self[fid].set_theory_data(data)
     def get_theory_data(self, fid):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_theory_data()
     def add_data(self, data):
         """
 …
             self[data.id] = FitProblem()
         self[data.id].set_fit_data(data)
     def set_fit_data(self, data):
         """
         save a copy of the data select to fit
         :param data: data selected
         """
         self.clear()
 …
                 self[d.id].set_model(self.model)
                 self[d.id].set_range(self.qmin, self.qmax)
     def get_fit_data(self, fid):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_fit_data()
     def set_model_param(self, name, value=None, fid=None):
         """
 …
             if fid in self.iterkeys():
                 self[fid].set_model_param(name, value)
     def get_model_param(self, fid):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_model_param()
     def set_param2fit(self, list):
         """
 …
         """
         self.list_param2fit = list
     def get_param2fit(self):
         """
 …
         """
         return self.list_param2fit
     def schedule_tofit(self, schedule=0):
         """
 …
         for value in self.itervalues():
             value.schedule_tofit(schedule)
     def get_scheduled(self):
         """
 …
         """
         return self.scheduled
     def set_range(self, qmin=None, qmax=None, fid=None):
         """
 …
             if fid in self.iterkeys():
                 self[fid].value.set_range(self.qmin, self.qmax)
     def get_range(self, fid):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_range()
     def set_weight(self, is2d, flag=None, fid=None):
         """
 …
             if fid in self.iterkeys():
                 self[fid].set_weight(flag=flag, is2d=is2d)
     def get_weight(self, fid=None):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_weight()
     def clear_model_param(self, fid=None):
         """
 …
             if fid in self.iterkeys():
                 self[fid].clear_model_param()
     def get_fit_problem(self):
         """
 …
         """
         return self.itervalues()
     def set_result(self, result, fid):
         """
 …
         if fid in self.iterkeys():
             self[fid].set_result(result)
     def set_batch_result(self, batch_inputs, batch_outputs):
         """
 …
         self.batch_inputs = batch_inputs
         self.batch_outputs = batch_outputs
     def get_result(self, fid):
         """
 …
         if fid in self.iterkeys():
             return self[fid].get_result()
     def get_batch_result(self):
         """
 …
         """
         return self.batch_inputs, self.batch_outputs
     def set_graph_id(self, id):
         """
         Set graph id (from data_group_id at the time the graph produced)
+        Set graph id (from data_group_id at the time the graph produced)
         """
         self.graph_id = id
     def get_graph_id(self):
         """
 …
         """
         return self.graph_id
 class FitProblem(FitProblemComponent):
     """
 …
         self.weight = None
         self.result = None
     def enable_smearing(self, flag=False):
         """
 …
         """
         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):
         """
 …
             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):
         """
 …
                                                            self.model)
         self.smearer_computed = True
     def get_model(self):
         """
 …
         """
         return self.model
     def set_residuals(self, residuals):
         """
 …
         """
         self.residuals = residuals
     def get_residuals(self):
         """
 …
         """
         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):
         """
 …
         self.smearer_computed = True
         self.result = None
     def get_fit_data(self):
         """
 …
         """
         return self.fit_data
     def get_origin_data(self):
         """
         """
         return self.original_data
     def set_weight(self, is2d, flag=None):
         """
 …
         """
         return self.weight
     def set_param2fit(self, list):
         """
 …
         """
         self.list_param2fit = list
     def get_param2fit(self):
         """
 …
         """
         return self.list_param2fit
     def set_model_param(self, name, value=None):
         """
 …
         """
         self.list_param.append([name, value])
     def get_model_param(self):
         """
 …
         """
         return self.list_param
     def schedule_tofit(self, schedule=0):
         """
 …
         """
         self.schedule = schedule
     def get_scheduled(self):
         """
 …
         """
         return self.schedule
     def set_range(self, qmin=None, qmax=None):
         """
 …
         self.qmin = qmin
         self.qmax = qmax
     def get_range(self):
         """
         :return: fitting range
         """
         return self.qmin, self.qmax
     def clear_model_param(self):
         """
 …
         """
         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):
         """
 …
         """
         self.graph_id = id
     def get_graph_id(self):
         """
 …
         """
         return self.graph_id
     def set_result(self, result):
         """
         """
         self.result = result
     def get_result(self):
         """

src/sas/perspectives/fitting/fitting.py

-                      r39356b5
+                      r2f4b430
 from sas.guiframe.dataFitting import Data1D
 from sas.guiframe.dataFitting import check_data_validity
 from sas.guiframe.events import NewPlotEvent
 from sas.guiframe.events import StatusEvent
+from sas.guiframe.events import NewPlotEvent
+from sas.guiframe.events import StatusEvent
 from sas.guiframe.events import EVT_SLICER_PANEL
 from sas.guiframe.events import EVT_SLICER_PARS_UPDATE
 from sas.guiframe.gui_style import GUIFRAME_ID
 from sas.guiframe.plugin_base import PluginBase
+from sas.guiframe.plugin_base import PluginBase
 from sas.guiframe.data_processor import BatchCell
 from sas.fit.Fitting import Fit
 …
     def __init__(self, standalone=False):
         PluginBase.__init__(self, name="Fitting", standalone=standalone)
         #list of panel to send to guiframe
         self.mypanels = []
 …
         self.calc_2D = None
         self.calc_1D = None
         self.color_dict = {}
         self.fit_thread_list = {}
         self.residuals = None
 …
         self.menu1 = None
         self.new_model_frame = None
         self.temp_state = []
         self.state_index = 0
 …
         logging.info("Fitting plug-in started")
         self.batch_capable = self.get_batch_capable()
     def get_batch_capable(self):
         """
 …
         """
         return True
     def create_fit_problem(self, page_id):
         """
 …
         """
         self.page_finder[page_id] = FitProblemDictionary()
     def delete_fit_problem(self, page_id):
         """
 …
         if page_id in self.page_finder.iterkeys():
             del self.page_finder[page_id]
     def add_color(self, color, id):
         """
 …
         """
         self.color_dict[id] = color
     def on_batch_selection(self, flag):
         """
 …
         if self.fit_panel is not None:
             self.fit_panel.batch_on = self.batch_on
     def populate_menu(self, owner):
         """
         Create a menu for the Fitting plug-in
         :param id: id to create a menu
         :param owner: owner of menu
         :return: list of information to populate the main menu
         """
         #Menu for fitting
 …
         wx.EVT_MENU(owner, self.id_result_panel, lambda ev: self.result_frame.Show())
         self.menu1.AppendSeparator()
         self.id_reset_flag = wx.NewId()
         resetf_help = "BatchFit: If checked, the initial param values will be "
 …
         chain_menu.Check(not self.batch_reset_flag)
         chain_menu.Enable(self.batch_on)
         self.menu1.AppendSeparator()
         self.edit_model_menu = wx.Menu()
 …
         except:
             raise
         self.id_edit = wx.NewId()
         editmodel_help = "Edit customized model sample file"
 …
         #create  menubar items
         return [(self.menu1, self.sub_menu)]
     def edit_custom_model(self, event):
         """
 …
         self.put_icon(frame)
         frame.Show(True)
     def delete_custom_model(self, event):
         """
 …
                     if item.GetLabel() == label:
                         self.edit_menu.DeleteItem(item)
                         msg = "The custom model, %s, has been deleted."% label
                         wx.PostEvent(self.parent, StatusEvent(status=msg,
+                        msg = "The custom model, %s, has been deleted." % label
+                        wx.PostEvent(self.parent, StatusEvent(status=msg,
                                                 type='stop', info='info'))
                         break
         except:
             msg ='Delete Error: \nCould not delete the file; Check if in use.'
+            msg = 'Delete Error: \nCould not delete the file; Check if in use.'
             wx.MessageBox(msg, 'Error')
     def make_sum_model(self, event):
         """
 …
         model_list = model_manager.get_model_name_list()
         plug_dir = models.find_plugins_dir()
         textdial = TextDialog(None, self, -1, 'Easy Sum/Multi(p1, p2) Editor',
+        textdial = TextDialog(None, self, -1, 'Easy Sum/Multi(p1, p2) Editor',
                               model_list, plug_dir)
         self.put_icon(textdial)
         textdial.ShowModal()
         textdial.Destroy()
     def make_new_model(self, event):
         """
 …
         except:
             pass
     def set_edit_menu(self, owner):
         """
 …
         e_id = wx.NewId()
         self.edit_menu = wx.Menu()
         self.edit_model_menu.AppendMenu(e_id,
                                     'Advanced', self.edit_menu)
+        self.edit_model_menu.AppendMenu(e_id,
+                                    'Advanced', self.edit_menu)
         self.set_edit_menu_helper(owner, self.edit_custom_model)
 …
                                         'Delete', self.delete_menu)
         self.set_edit_menu_helper(owner, self.delete_custom_model)
     def set_edit_menu_helper(self, owner=None, menu=None):
         """
 …
             caption = "Combined Batch"
             page = self.batch_page
         def set_focus_page(page):
             page.Show(True)
 …
             msg = "%s already opened\n" % str(page.window_caption)
             wx.PostEvent(self.parent, StatusEvent(status=msg))
         if page != None:
             return set_focus_page(page)
 …
         else:
             self.batch_page = self.fit_panel.add_sim_page(caption=caption)
     def help(self, evt):
         """
 …
                     pass
         frame.Show(True)
     def get_context_menu(self, plotpanel=None):
         """
         Get the context menu items available for P(r).them allow fitting option
         for Data2D and Data1D only.
         :param graph: the Graph object to which we attach the context menu
         :return: a list of menu items with call-back function
         :note: if Data1D was generated from Theory1D
                 the fitting option is not allowed
         """
         self.plot_panel = plotpanel
         graph = plotpanel.graph
         fit_option = "Select data for fitting"
         fit_hint =  "Dialog with fitting parameters "
+        fit_hint = "Dialog with fitting parameters "
         if graph.selected_plottable not in plotpanel.plots:
             return []
 …
                     return [[fit_option, fit_hint, self._onSelect]]
                 else:
                     return []
+                    return []
             return [[fit_option, fit_hint, self._onSelect]]
         else:
             # if is_data is true , this in an actual data loaded
             #else it is a data created from a theory model
 …
         self.result_panel = ResultPanel(parent=self.result_frame, manager=self)
         self.perspective.append(self.result_panel.window_name)
         #index number to create random model name
         self.index_model = 0
 …
         self.mypanels.append(self.result_panel)
         return self.mypanels
     def clear_panel(self):
         """
         """
         self.fit_panel.clear_panel()
     def delete_data(self, data):
         """
 …
         """
         self.fit_panel.delete_data(data)
     def set_data(self, data_list=None):
         """
 …
                     selected_data_list = dlg.get_data()
                 dlg.Destroy()
             else:
                 selected_data_list = data_list
 …
                 msg = "Fitting Set_data: " + str(sys.exc_value)
                 wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
     def set_theory(self, theory_list=None):
         """
 …
                 wx.PostEvent(self.parent,
                              StatusEvent(status=msg, info="error"))
     def set_state(self, state=None, datainfo=None, format=None):
         """
         Call-back method for the fit page state reader.
         This method is called when a .fitv/.svs file is loaded.
         : param state: PageState object
         : param datainfo: data
 …
         # state file format
         self.sfile_ext = format
         self.on_set_state_helper(event=None)
 …
         Set_state_helper. This actually sets state
         after plotting data from state file.
         : event: FitStateUpdateEvent called
             by dataloader.plot_data from guiframe
 …
                 self.state_index = 0
             return
         try:
             # Load fitting state
 …
                         caption=caption)
                 self.mypanels.append(page)
             # get ready for the next set_state
             self.state_index += 1
 …
             #reset state variables to default when all set_state is finished.
             if len(self.temp_state) == self.state_index:
                 self.temp_state = []
                 #self.state_index = 0
 …
             self.temp_state = []
             raise
     def set_param2fit(self, uid, param2fit):
         """
 …
         """
         self.page_finder[uid].set_param2fit(param2fit)
     def set_graph_id(self, uid, graph_id):
         """
 …
         """
         self.page_finder[uid].set_graph_id(graph_id)
     def get_graph_id(self, uid):
         """
 …
         """
         return self.page_finder[uid].get_graph_id()
     def save_fit_state(self, filepath, fitstate):
         """
 …
         if uid in self.page_finder.keys():
             self.page_finder[uid].set_weight(flag=flag, is2d=is2d)
     def set_fit_range(self, uid, qmin, qmax, fid=None):
         """
 …
         if uid in self.page_finder.keys():
             self.page_finder[uid].set_range(qmin=qmin, qmax=qmax, fid=fid)
     def schedule_for_fit(self, value=0, uid=None):
         """
 …
         if uid in self.page_finder.keys():
             self.page_finder[uid].schedule_tofit(value)
     def get_page_finder(self):
         """
 …
         """
         return self.page_finder
     def set_page_finder(self, modelname, names, values):
         """
         Used by simfitpage.py to reset a parameter given the string constrainst.
         :param modelname: the name ot the model for with the parameter
                             has to reset
 …
                     value.set_model_param(names, values)
                     break
     def split_string(self, item):
         """
         receive a word containing dot and split it. used to split parameterset
         name into model name and parameter name example: ::
             paramaterset (item) = M1.A
             Will return model_name = M1 , parameter name = A
         """
         if item.find(".") >= 0:
 …
                 param_name = param_names[1]
             return model_name, param_name
     def on_bumps_options(self, event=None):
         from bumps.gui.fit_dialog import OpenFitOptions
 …
                         panel = self.fit_panel.opened_pages[uid]
                         panel._on_fit_complete()
     def set_smearer(self, uid, smearer, fid, qmin=None, qmax=None, draw=True,
                     enable_smearer=False):
 …
         Get a smear object and store it to a fit problem of fid as id. If proper
         flag is enable , will plot the theory with smearing information.
         :param smearer: smear object to allow smearing data of id fid
         :param enable_smearer: Define whether or not all (data, model) contained
 …
                 qmin=qmin, qmax=qmax, weight=weight)
             self._mac_sleep(0.2)
     def _mac_sleep(self, sec=0.2):
         """
 …
         if ON_MAC:
             time.sleep(sec)
     def draw_model(self, model, page_id, data=None, smearer=None,
                    enable1D=True, enable2D=False,
 …
         """
         Draw model.
         :param model: the model to draw
         :param name: the name of the model to draw
 …
         :param qstep: number of step to divide the x and y-axis
         :param update_chisqr: update chisqr [bool]
         """
         #self.weight = weight
 …
                                 update_chisqr=update_chisqr,
                                 source=source)
     def onFit(self, uid):
         """
 …
                                      is2d=page._is_2D())
                     if not page.param_toFit:
                         msg = "No fitting parameters for %s"%page.window_caption
+                        msg = "No fitting parameters for %s" % page.window_caption
                         wx.PostEvent(page.parent.parent,
                                      StatusEvent(status=msg, info="error",
 …
         msg = "Fitting is in progress..."
         wx.PostEvent(self.parent, StatusEvent(status=msg, type="progress"))
         #Handler used for fit engine displayed message
         handler = ConsoleUpdate(parent=self.parent,
 …
         msg = "Fitting is in progress..."
         wx.PostEvent(self.parent, StatusEvent(status=msg, type="progress"))
         return True
 …
                                                    group_id=group_id,
                                                    action='remove'))
     def store_data(self, uid, data_list=None, caption=None):
         """
 …
         if data_list is None:
             data_list = []
         self.page_finder[uid].set_fit_data(data=data_list)
         if caption is not None:
             self.page_finder[uid].set_fit_tab_caption(caption=caption)
     def on_add_new_page(self, event=None):
         """
 …
                                                        info="warning"))
         except:
             msg = "Creating Fit page: %s"%sys.exc_value
+            msg = "Creating Fit page: %s" % sys.exc_value
             wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
     def add_fit_page(self, data):
         """
 …
                     group_id = str(page.uid) + " Model2D"
                     data.group_id = theory_data.group_id
                     wx.PostEvent(self.parent,
+                    wx.PostEvent(self.parent,
                              NewPlotEvent(group_id=group_id,
                                                action="delete"))
 …
         if self.batch_page is not None and self.batch_on:
             self.batch_page.draw_page()
         return page
     def _onEVT_SLICER_PANEL(self, event):
         """
 …
         event.panel_name. this method update slicer panel
         for a given interactor.
         :param event: contains type of slicer , paramaters for updating
             the panel and panel_name to find the slicer 's panel concerned.
 …
             if self.parent.panels[item].window_caption.startswith(name):
                 self.parent.panels[item].set_slicer(event.type, event.params)
         #self.parent._mgr.Update()
     def _closed_fitpage(self, event):
         """
 …
                 event.data.__class__.__name__ == "Data1D":
                 self.fit_panel.close_page_with_data(event.data)
     def _reset_schedule_problem(self, value=0, uid=None):
         """
 …
             if uid in self.page_finder.keys():
                 self.page_finder[uid].schedule_tofit(value)
     def _add_problem_to_fit(self, fitproblem, pars, fitter, fit_id):
         """
 …
                         qmax=qmax)
         fitter.select_problem_for_fit(id=fit_id, value=1)
     def _onSelect(self, event):
         """
 …
         Plugin.on_perspective(self, event=event)
         self.select_data(panel)
     def select_data(self, panel):
         """
 …
                 data = plottable
                 self.add_fit_page(data=[data])
     def update_fit(self, result=None, msg=""):
         """
         """
         print "update_fit result", result
     def _batch_fit_complete(self, result, pars, page_id,
                             batch_outputs, batch_inputs, elapsed=None):
 …
         if uid in self.fit_thread_list.keys():
             del self.fit_thread_list[uid]
         self._update_fit_button(page_id)
         t1 = time.time()
 …
         wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
                                               type="stop"))
         if batch_outputs is None:
             batch_outputs = {}
         # format batch_outputs
         batch_outputs["Chi2"] = []
 …
                 if data is not None and hasattr(data, "sas_data"):
                     data = data.sas_data
                 is_data2d = issubclass(data.__class__, Data2D)
                 #check consistency of arrays
 …
                     if res.pvec.__class__ == numpy.float64:
                         res.pvec = [res.pvec]
                     cell = BatchCell()
                     cell.label = res.fitness
 …
                     if key not in param_list and key not in ["Chi2", "Data"]:
                         batch_outputs[key].append(EMPTY)
                 self.page_finder[pid].set_batch_result(batch_inputs=batch_inputs,
                                                        batch_outputs=batch_outputs)
                 cpage = self.fit_panel.get_page_by_id(pid)
                 cpage._on_fit_complete()
 …
                                          batch_outputs=batch_outputs,
                                          batch_inputs=batch_inputs)
         wx.PostEvent(self.parent, StatusEvent(status=msg, error="info",
                                               type="stop"))
 …
             if key in ["Chi2", "Data"] or shownkeystr.count(key) > 0:
                 tbatch_outputs[key] = batch_outputs[key]
         wx.CallAfter(self.parent.on_set_batch_result, tbatch_outputs,
                      batch_inputs, self.sub_menu)
     def on_set_batch_result(self, page_id, fid, batch_outputs, batch_inputs):
         """
 …
         cell.label = data.name
         cell.value = index
         if theory_data != None:
             #Suucessful fit
 …
                 if group_id not in theory_data.list_group_id:
                     theory_data.list_group_id.append(group_id)
             try:
                 # associate residuals plot
 …
                 batch_inputs[param] = []
             batch_inputs[param].append(data.sample.temperature)
     def _fit_completed(self, result, page_id, batch_outputs,
                        batch_inputs=None, pars=None, elapsed=None):
 …
                                                               info="error",
                                                               type="stop"))
         except:
             msg = "Fit completed but Following"
 …
             wx.PostEvent(self.parent, StatusEvent(status=msg, info="warning",
                                                   type="stop"))
     def _update_fit_button(self, page_id):
         """
         Update Fit button when fit stopped
         : parameter page_id: fitpage where the button is
         """
 …
             page = self.fit_panel.get_page_by_id(uid)
             page._on_fit_complete()
     def _on_show_panel(self, event):
         """
         """
         pass
     def on_reset_batch_flag(self, event):
         """
 …
             menu_item.Check(True)
             self.batch_reset_flag = False
         ## post a message to status bar
         msg = "Set Chain Fitting: %s" % str(not self.batch_reset_flag)
 …
         """
         Receive a panel as event and send it to guiframe
         :param event: event containing a panel
         """
         if event.panel is not None:
 …
             event.panel.uid = event_id
             self.mypanels.append(event.panel)
     def _onclearslicer(self, event):
         """
 …
         for panel in self.slicer_panels:
             if panel.window_caption == name:
                 for item in self.parent.panels:
                     if hasattr(self.parent.panels[item], "uid"):
 …
                             break
                 break
     def _on_model_panel(self, evt):
         """
         react to model selection on any combo box or model menu.plot the model
+        react to model selection on any combo box or model menu.plot the model
         :param evt: wx.combobox event
         """
         model = evt.model
 …
         if self.batch_page is not None and self.batch_on:
             self.batch_page.draw_page()
     def _update1D(self, x, output):
         """
 …
         msg = "Plot updating ... "
         wx.PostEvent(self.parent, StatusEvent(status=msg, type="update"))
     def _complete1D(self, x, y, page_id, elapsed, index, model,
                     weight=None, fid=None,
 …
         try:
             numpy.nan_to_num(y)
             new_plot = Data1D(x=x, y=y)
             new_plot.is_data = False
 …
             #the same id
             theory_data = self.page_finder[page_id].get_theory_data(fid=data.id)
             if data.is_data:
                 data_name = str(data.name)
             else:
                 data_name = str(model.__class__.__name__)
             new_plot.name = model.name + " [" + data_name +"]"
+            new_plot.name = model.name + " [" + data_name + "]"
             new_plot.xaxis(_xaxis, _xunit)
             new_plot.yaxis(_yaxis, _yunit)
 …
             caption = current_pg.window_caption
             self.page_finder[page_id].set_fit_tab_caption(caption=caption)
             self.page_finder[page_id].set_theory_data(data=new_plot,
                                                       fid=data.id)
 …
         except:
             raise
     def _update2D(self, output, time=None):
         """
 …
         #updating ... ", type="update"))
         #self.ready_fit()
     def _complete2D(self, image, data, model, page_id, elapsed, index, qmin,
                 qmax, fid=None, weight=None, toggle_mode_on=False, state=None,
 …
         new_plot.xmax = data.xmax
         title = data.title
         new_plot.is_data = False
         if data.is_data:
 …
         if len(title) > 1:
             new_plot.title = "Model2D for %s "% model.name + data_name
+            new_plot.title = "Model2D for %s " % model.name + data_name
         new_plot.name = model.name + " [" + \
                                     data_name + "]"
         theory_data = deepcopy(new_plot)
         self.page_finder[page_id].set_theory_data(data=theory_data,
                                                   fid=data.id)
 …
         msg = "Computation  completed!"
         wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
     def _draw_model2D(self, model, page_id, qmin,
                       qmax,
 …
         """
         draw model in 2D
         :param model: instance of the model to draw
         :param description: the description of the model
 …
         :param qmax: the maximum value to draw model 2D
         :param qstep: the number of division of Qx and Qy of the model to draw
         """
         if not enable2D:
 …
                                     qmin=qmin,
                                     qmax=qmax,
                                     weight=weight,
+                                    weight=weight,
                                     fid=fid,
                                     toggle_mode_on=toggle_mode_on,
 …
         """
         Draw model 1D from loaded data1D
         :param data: loaded data
         :param model: the model to plot
         """
         if not enable1D:
 …
             self.calc_1D = Calc1D(data=data,
                                   model=model,
                                   page_id=page_id,
+                                  page_id=page_id,
                                   qmin=qmin,
                                   qmax=qmax,
 …
             msg += " %s" % sys.exc_value
             wx.PostEvent(self.parent, StatusEvent(status=msg))
     def _cal_chisqr(self, page_id, data, weight, fid=None, index=None):
         """
         Get handy Chisqr using the output from draw1D and 2D,
+        Get handy Chisqr using the output from draw1D and 2D,
         instead of calling expansive CalcChisqr in guithread
         """
 …
         else:
             # 1 d theory from model_thread is only in the range of index
             if index == None:
+            if index == None:
                 index = numpy.ones(len(data_copy.y), dtype=bool)
             if weight != None:
 …
                 dy[dy == 0] = 1
             fn = data_copy.y[index]
             theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id)
             if theory_data == None:
 …
             gn = theory_data.y
             en = dy[index]
         # residual
         try:
             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)]
         # get chisqr only w/finite
         chisqr = numpy.average(residuals * residuals)
         self._plot_residuals(page_id=page_id, data=data_copy,
                              fid=fid,
                              weight=weight, index=index)
         return chisqr
     def _plot_residuals(self, page_id, weight, fid=None,
                         data=None, index=None):
         """
         Plot the residuals
         :param data: data
         :param index: index array (bool)
 …
         theory_name = str(theory_data.name.split()[0])
         new_plot = residuals
         new_plot.name = "Residuals for " + str(theory_name) + "[" +\
                         str(data.name) +"]"
+        new_plot.name = "Residuals for " + str(theory_name) + "[" + \
+                        str(data.name) + "]"
         ## allow to highlight data when plotted
         new_plot.interactive = True

src/sas/perspectives/fitting/fitting_widgets.py

-                      r79492222
+                      r2f4b430
         ScrolledPanel.__init__(self, *args, **kwds)
         self.SetupScrolling()
 class BatchDataDialog(wx.Dialog):
     """
 …
         self.data_2d_selected = None
         self._do_layout()
     def _do_layout(self):
         """
 …
         box_description = wx.StaticBox(self, -1, str("Hint"))
         hint_sizer = wx.StaticBoxSizer(box_description, wx.VERTICAL)
         selection_sizer = wx.GridBagSizer(5,5)
+        selection_sizer = wx.GridBagSizer(5, 5)
         button_sizer = wx.BoxSizer(wx.HORIZONTAL)
         self.data_1d_selected = wx.RadioButton(self, -1, 'Data1D',
 …
         iy = 0
         selection_sizer.Add(self.data_1d_selected, (iy, ix),
                            (1, 1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
+                           (1, 1), wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
         iy += 1
         selection_sizer.Add(self.data_2d_selected, (iy, ix),
                            (1, 1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
+                           (1, 1), wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
         #contruction the sizer contaning button
         button_sizer.Add((20, 20), 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+        button_sizer.Add((20, 20), 1, wx.EXPAND | wx.ADJUST_MINSIZE, 0)
         button_sizer.Add(button_cancel, 0,
                          wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
+                         wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 10)
         button_sizer.Add(button_OK, 0,
                                 wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
         vbox.Add(hint_sizer, 0, wx.EXPAND|wx.ALL, 10)
         vbox.Add(selection_sizer, 0, wx.TOP|wx.BOTTOM, 10)
         vbox.Add(wx.StaticLine(self, -1),  0, wx.EXPAND, 0)
         vbox.Add(button_sizer, 0, wx.TOP|wx.BOTTOM, 10)
+                                wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 10)
+        vbox.Add(hint_sizer, 0, wx.EXPAND | wx.ALL, 10)
+        vbox.Add(selection_sizer, 0, wx.TOP | wx.BOTTOM, 10)
+        vbox.Add(wx.StaticLine(self, -1), 0, wx.EXPAND, 0)
+        vbox.Add(button_sizer, 0, wx.TOP | wx.BOTTOM, 10)
         self.SetSizer(vbox)
         self.Layout()
     def get_data(self):
         """
 …
         self._max_data = nb_data
         self._nb_selected_data = nb_data
         self.SetSize((WIDTH, HEIGHT))
         self.list_of_ctrl = []
 …
         select_data_text = " %s Data selected.\n" % str(self._nb_selected_data)
         self._data_text_ctrl = wx.StaticText(self, -1, str(select_data_text))
         self._data_text_ctrl.SetForegroundColour('blue')
         self._sizer_main = wx.BoxSizer(wx.VERTICAL)
 …
         self._choice_sizer = wx.GridBagSizer(5, 5)
         self._panel = DialogPanel(self, style=wx.RAISED_BORDER,
                                size=(WIDTH-20, HEIGHT/3))
+                               size=(WIDTH - 20, HEIGHT / 3))
         self.__do_layout(data_list, text=text)
     def __do_layout(self, data_list, text=''):
         """
 …
             self.list_of_ctrl.append((cb, data_list[i]))
             self._choice_sizer.Add(cb, (iy, ix),
                            (1, 1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
+                           (1, 1), wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
             iy += 1
         self._panel.SetSizer(self._choice_sizer)
         #add sizer
         self._sizer_button.Add((20, 20), 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+        self._sizer_button.Add((20, 20), 1, wx.EXPAND | wx.ADJUST_MINSIZE, 0)
         button_cancel = wx.Button(self, wx.ID_CANCEL, "Cancel")
         self._sizer_button.Add(button_cancel, 0,
                           wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
+                          wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 10)
         button_OK = wx.Button(self, wx.ID_OK, "Ok")
         button_OK.SetFocus()
         self._sizer_button.Add(button_OK, 0,
                                 wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
+                                wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 10)
         static_line = wx.StaticLine(self, -1)
         self._sizer_txt.Add(self._panel, 0, wx.EXPAND|wx.ALL, 10)
         self._sizer_main.Add(self._sizer_txt, 0, wx.EXPAND|wx.ALL, 10)
         self._sizer_main.Add(self._data_text_ctrl, 0,  wx.EXPAND|wx.ALL, 10)
+        self._sizer_txt.Add(self._panel, 0, wx.EXPAND | wx.ALL, 10)
+        self._sizer_main.Add(self._sizer_txt, 0, wx.EXPAND | wx.ALL, 10)
+        self._sizer_main.Add(self._data_text_ctrl, 0, wx.EXPAND | wx.ALL, 10)
         self._sizer_main.Add(static_line, 0, wx.EXPAND, 0)
         self._sizer_main.Add(self._sizer_button, 0, wx.EXPAND|wx.ALL, 10)
+        self._sizer_main.Add(self._sizer_button, 0, wx.EXPAND | wx.ALL, 10)
         self.SetSizer(self._sizer_main)
         self.Layout()
     def get_data(self):
         """
 …
                 temp.append(data)
         return temp
     def _count_selected_data(self, event):
         """

src/sas/perspectives/fitting/hint_fitpage.py

-                      r79492222
+                      r2f4b430
     ## Title to appear on top of the window
     window_caption = "Hint page "
     def __init__(self, parent):
         wx.ScrolledWindow.__init__(self, parent,
                  style = wx.FULL_REPAINT_ON_RESIZE)
+                 style=wx.FULL_REPAINT_ON_RESIZE)
         PanelBase.__init__(self, parent)
         msg = "right click on the data when it is highlighted "
         msg += "the select option to fit for futher options"
         self.do_layout()
     def do_layout(self):
         """
 …
         """
         name = "Hint"
         box_description= wx.StaticBox(self, -1, name)
+        box_description = wx.StaticBox(self, -1, name)
         boxsizer = wx.StaticBoxSizer(box_description, wx.VERTICAL)
         msg = "    How to link data to the control panel: \n \n"
 …
         msg += "    Finally, select 'Select data for fitting' in the pop-up menu. \n"
         self.hint_txt = wx.StaticText(self, -1, msg, style=wx.ALIGN_LEFT)
         boxsizer.Add(self.hint_txt, wx.ALL|wx.EXPAND, 20)
+        boxsizer.Add(self.hint_txt, wx.ALL | wx.EXPAND, 20)
         self.vbox = wx.BoxSizer(wx.VERTICAL)
         self.vbox.Add(boxsizer)
 …
         self.SetScrollbars(20, 20, 25, 65)
         self.Layout()
     def createMemento(self):
         return
 class HelpWindow(wx.Frame):
     def __init__(self, parent, id, title):
         wx.Frame.__init__(self, parent, id, title, size=(570, 400))
         self.page = HintFitPage(self)
         self.Centre()

src/sas/perspectives/fitting/model_thread.py

-                      r79492222
+                      r2f4b430
         self.update_chisqr = update_chisqr
         self.source = source
     def compute(self):
         """
 …
                                    math.fabs(self.data.ymin)), 2)
                 self.qmax = math.sqrt(newx + newy)
         if self.data is None:
             msg = "Compute Calc2D receive data = %s.\n" % str(self.data)
             raise ValueError, msg
         # Define matrix where data will be plotted
         radius = numpy.sqrt((self.data.qx_data * self.data.qx_data) + \
 …
         index_model = index_model & self.data.mask
         index_model = index_model & numpy.isfinite(self.data.data)
         if self.smearer is not None:
             # Set smearer w/ data, model and index.
 …
                        update_chisqr=self.update_chisqr,
                        source=self.source)
 class Calc1D(CalcThread):
 …
         self.out = None
         self.index = None
     def compute(self):
         """
 …
         output = numpy.zeros((len(self.data.x)))
         index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax)
         ##smearer the ouput of the plot
         if self.smearer is not None:
 …
         else:
             output[index] = self.model.evalDistribution(self.data.x[index])
         elapsed = time.time() - self.starttime
         self.complete(x=self.data.x[index], y=output[index],
                       page_id=self.page_id,
 …
                       update_chisqr=self.update_chisqr,
                       source=self.source)
     def results(self):
         """
 …
 """
 Example: ::
     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])
             qmax = 0.01
             qstep = 0.0001
             self.done = False
             x = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
             y = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
             calc_thread_2D = Calc2D(x, y, None, model.clone(),None,
                                     -qmax, qmax,qstep,
 …
                                             updatefn=self.update ,
                                             yieldtime=0.0)
             calc_thread_2D.queue()
             calc_thread_2D.ready(2.5)
             while not self.done:
                 time.sleep(1)
         def update(self,output):
             print "update"
         def complete(self, image, data, model, elapsed, qmin, qmax,index, qstep ):
             print "complete"
             self.done = True
     if __name__ == "__main__":
         CalcCommandline()

src/sas/perspectives/fitting/models.py

-                      r6f82ba1
+                      r2f4b430
 from sas.models.BaseComponent import BaseComponent
 from sas.guiframe.CategoryInstaller import CategoryInstaller
 PLUGIN_DIR = 'plugin_models'
 …
     """
     Do some checking before model adding plugins in the list
     :param model: class model to add into the plugin list
     :param name:name of the module plugin
     :return model: model if valid model or None if not valid
     """
     #Check if the plugin is of type Model1DPlugin
 …
         log(msg)
         return None
     if hasattr(new_instance, "function"):
         try:
 …
         return None
     return model
 def find_plugins_dir():
     """
 …
     """
     dir = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR)
     # If the plugin directory doesn't exist, create it
     if not os.path.isdir(dir):
         os.makedirs(dir)
     # Find paths needed
     try:
 …
             raise type, value, traceback
         return 1
 report_problem = ReportProblem()
 …
             if toks[1] == '.py' and not toks[0] == '__init__':
                 name = toks[0]
                 path = [os.path.abspath(dir)]
                 file = None
 …
                     log(msg)
                 finally:
                     if not file == None:
                         file.close()
 …
         """
         self.mydict = {}
     def set_list(self, name, mylist):
         """
         :param name: the type of the list
         :param mylist: the list to add
         """
         if name not in self.mydict.keys():
             self.reset_list(name, mylist)
     def reset_list(self, name, mylist):
         """
 …
         """
         self.mydict[name] = mylist
     def get_list(self):
         """
 …
         """
         return self.mydict
 class ModelManagerBase:
     """
 …
     event_owner = None
     last_time_dir_modified = 0
     def __init__(self):
         """
 …
         self.stored_plugins = {}
         self._getModelList()
     def findModels(self):
         """
 …
         logging.info("pluging model : %s\n" % str(temp))
         return temp
     def _getModelList(self):
         """
         List of models we want to make available by default
         for this application
         :return: the next free event ID following the new menu events
         """
 …
             #        self.shape_indep_list.append(BEPolyelectrolyte)
             self.model_name_list.append(BEPolyelectrolyte.__name__)
             self.form_factor_dict[str(wx.NewId())] =  [SphereModel]
+            self.form_factor_dict[str(wx.NewId())] = [SphereModel]
         except:
             pass
 …
         #self.shape_indep_list.append(FractalO_Z)
         #self.model_name_list.append(FractalO_Z.__name__)
         #Looking for plugins
         self.stored_plugins = self.findModels()
 …
         for name, plug in self.stored_plugins.iteritems():
             self.model_dictionary[name] = plug
         self._get_multifunc_models()
         return 0
 …
                 is_modified = True
                 self.last_time_dir_modified = temp
         return is_modified
     def update(self):
         """
 …
         else:
             return {}
     def pulgins_reset(self):
         """
 …
         self.model_combobox.reset_list("Customized Models", self.plugins)
         return self.model_combobox.get_list()
 ##   I believe the next four methods are for the old form factor GUI
 ##   where the dropdown showed a list of categories which then rolled out
 …
         ## guiframe reference
 #        self.event_owner = event_owner
 #        shape_submenu = wx.Menu()
 #        shape_indep_submenu = wx.Menu()
 …
 #                                         " simple shape"],
 #                         list1=self.shape_list)
 #        self._fill_simple_menu(menuinfo=["Shape-Independent",
 #                                         shape_indep_submenu,
 #                                         "List of shape-independent models"],
 #                         list1=self.shape_indep_list)
 #        self._fill_simple_menu(menuinfo=["Structure Factors",
 #                                         structure_factor,
 #                                         "List of Structure factors models"],
 #                                list1=self.struct_list)
 #        self._fill_plugin_menu(menuinfo=["Customized Models", added_models,
 #                                            "List of additional models"],
 #                                 list1=self.plugins)
 #        self._fill_menu(menuinfo=["P(Q)*S(Q)", multip_models,
 #                                  "mulplication of 2 models"],
 …
 #                                   list2=self.struct_list)
 #        return 0
 #    def _fill_plugin_menu(self, menuinfo, list1):
 #        """
 …
 #            menuinfo[1].Append(int(id), "Empty", msg)
 #        self._fill_simple_menu(menuinfo, list1)
 #   def _fill_simple_menu(self, menuinfo, list1):
 #       """
 …
 #       if len(list1) > 0:
 #           self.model_combobox.set_list(menuinfo[0], list1)
 #            for item in list1:
 #                try:
 …
 #        id = wx.NewId()
 #        self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2])
     def _on_model(self, evt):
         """
         React to a model menu event