Changeset 5062bbf for sansview/perspectives/fitting – SasView

sansview/perspectives/fitting/basepage.py

-                      rbb70474
+                      r5062bbf
 class BasicPage(wx.ScrolledWindow):
     """
         This class provide general structure of  fitpanel page
+    This class provide general structure of  fitpanel page
     """
      ## Internal name for the AUI manager
 …
     def __init__(self,parent, page_info):
+        """
+        """
         wx.ScrolledWindow.__init__(self, parent,
                  style= wx.FULL_REPAINT_ON_RESIZE )
 …
     class ModelTextCtrl(wx.TextCtrl):
         """
+            Text control for model and fit parameters.
+            Binds the appropriate events for user interactions.
+            Default callback methods can be overwritten on initialization
+            @param kill_focus_callback: callback method for EVT_KILL_FOCUS event
+            @param set_focus_callback:  callback method for EVT_SET_FOCUS event
+            @param mouse_up_callback:   callback method for EVT_LEFT_UP event
+            @param text_enter_callback: callback method for EVT_TEXT_ENTER event
+        Text control for model and fit parameters.
+        Binds the appropriate events for user interactions.
+        Default callback methods can be overwritten on initialization
+        :param kill_focus_callback: callback method for EVT_KILL_FOCUS event
+        :param set_focus_callback:  callback method for EVT_SET_FOCUS event
+        :param mouse_up_callback:   callback method for EVT_LEFT_UP event
+        :param text_enter_callback: callback method for EVT_TEXT_ENTER event
         """
         ## Set to True when the mouse is clicked while the whole string is selected
 …
         def _on_set_focus(self, event):
             """
+                Catch when the text control is set in focus to highlight the whole
+                text if necessary
+                @param event: mouse event
+            Catch when the text control is set in focus to highlight the whole
+            text if necessary
+            :param event: mouse event
             """
 …
         def _highlight_text(self, event):
             """
+                Highlight text of a TextCtrl only of no text has be selected
+                @param event: mouse event
+            Highlight text of a TextCtrl only of no text has be selected
+            :param event: mouse event
             """
             # Make sure the mouse event is available to other listeners
 …
         def _silent_kill_focus(self,event):
             """
                do nothing to kill focus
+            do nothing to kill focus
             """
             event.Skip()
 …
     def set_page_info(self, page_info):
         """
             set some page important information at once
+        set some page important information at once
         """
        ##window_name
 …
     def onContextMenu(self, event):
         """
             Retrieve the state selected state
+        Retrieve the state selected state
         """
         # Skipping the save state functionality for release 0.9.0
 …
     def onUndo(self, event):
         """
             Cancel the previous action
+        Cancel the previous action
         """
         #print "enable undo"
 …
         wx.PostEvent(self.parent, event)
     def onRedo(self, event):
         """
             Restore the previous action cancelled
+        Restore the previous action cancelled
         """
         #print "enable redo"
         event = NextStateEvent(page= self)
         wx.PostEvent(self.parent, event)
     def define_page_structure(self):
         """
             Create empty sizer for a panel
+        Create empty sizer for a panel
         """
         self.vbox  = wx.BoxSizer(wx.VERTICAL)
 …
     def set_layout(self):
         """
              layout
+        layout
         """
         self.vbox.Layout()
 …
         self.set_scroll()
         self.Centre()
     def set_scroll(self):
+        """
+        """
         self.SetScrollbars(20,20,25,65)
         self.Layout()
         self.SetAutoLayout(True)
     def set_owner(self,owner):
         """
+            set owner of fitpage
+            @param owner: the class responsible of plotting
+        set owner of fitpage
+        :param owner: the class responsible of plotting
         """
         self.event_owner = owner
 …
     def get_data(self):
         """
             return the current data
+        return the current data
         """
         return self.data
 …
     def set_manager(self, manager):
         """
+             set panel manager
+             @param manager: instance of plugin fitting
+        set panel manager
+        :param manager: instance of plugin fitting
         """
         self.manager = manager
 …
     def populate_box(self, dict):
         """
+             Store list of model
+             @param dict: dictionary containing list of models
+        Store list of model
+        :param dict: dictionary containing list of models
         """
         self.model_list_box = dict
 …
     def initialize_combox(self):
         """
             put default value in the combobox
+        put default value in the combobox
         """
         ## fill combox box
 …
     def set_dispers_sizer(self):
         """
             fill sizer containing dispersity info
+        fill sizer containing dispersity info
         """
         self.sizer4.Clear(True)
 …
         self.state.enable_disp= self.enable_disp.GetValue()
         self.state.disable_disp= self.disable_disp.GetValue()
     def select_disp_angle(self, event):
         """
+            Event for when a user select a parameter to average over.
+            @param event: radiobutton event
+        Event for when a user select a parameter to average over.
+        :param event: radiobutton event
         """
         self.values=[]
 …
     def onResetModel(self, event):
         """
             Reset model state
+        Reset model state
         """
         ## post help message for the selected model
 …
     def on_save_state(self, event):
         """
             Save the current state into file
+        Save the current state into file
         """
         self.save_current_state()
 …
     def on_bookmark(self, event):
         """
             save history of the data and model
+        save history of the data and model
         """
         if self.model==None:
 …
     def onSetFocus(self, evt):
         """
+            highlight the current textcrtl and hide the error text control shown
+            after fitting
+            :Not implemented.
+        highlight the current textcrtl and hide the error text control shown
+        after fitting
         """
         return
 …
     def read_file(self, path):
         """
+            Read two columns file
+            @param path: the path to the file to read
+        Read two columns file
+        :param path: the path to the file to read
         """
         try:
 …
         except:
             raise
     def createMemento(self):
         """
             return the current state of the page
+        return the current state of the page
         """
         return self.state.clone()
 …
     def save_current_state(self):
         """
             Store current state
+        Store current state
         """
         ## save model option
 …
     def save_current_state_fit(self):
         """
             Store current state for fit_page
+        Store current state for fit_page
         """
         ## save model option
 …
     def check_invalid_panel(self):
         """
             check if the user can already perform some action with this panel
+        check if the user can already perform some action with this panel
         """
         flag = False
 …
             wx.MessageBox(msg, 'Info')
             return  True
     def reset_page_helper(self, state):
         """
+            Use page_state and change the state of existing page
+            @precondition: the page is already drawn or created
+            @postcondition: the state of the underlying data change as well as the
+        Use page_state and change the state of existing page
+        :precondition: the page is already drawn or created
+        :postcondition: the state of the underlying data change as well as the
             state of the graphic interface
         """
 …
     def _selectDlg(self):
         """
             open a dialog file to selected the customized dispersity
+        open a dialog file to selected the customized dispersity
         """
         import os
 …
         dlg.Destroy()
         return path
     def _reset_context_menu(self):
         """
             reset the context menu
+        reset the context menu
         """
         for name, state in self.state.saved_states.iteritems():
 …
             wx.EVT_MENU(self, id, self.onResetModel)
     def _reset_plotting_range(self, state):
         """
             Reset the plotting range to a given state
+        Reset the plotting range to a given state
         """
         if self.check_invalid_panel():
 …
             self.npts.SetValue(str(state.npts))
     def _save_typeOfmodel(self):
         """
             save radiobutton containing the type model that can be selected
+        save radiobutton containing the type model that can be selected
         """
         self.state.shape_rbutton = self.shape_rbutton.GetValue()
 …
         wx.PostEvent(self.parent, event)
     def _save_plotting_range(self ):
         """
             save the state of plotting range
+        save the state of plotting range
         """
         self.state.qmin = self.qmin_x
 …
     def _onparamEnter_helper(self):
         """
+             check if values entered by the user are changed and valid to replot
+             model
+             use : _check_value_enter
+        check if values entered by the user are changed and valid to replot
+        model
         """
         # Flag to register when a parameter has changed.
 …
     def _update_paramv_on_fit(self):
         """
              make sure that update param values just before the fitting
+        make sure that update param values just before the fitting
         """
         #flag for qmin qmax check values
 …
             if self._is_2D():self.btEditMask.Enable(True)
         if not flag:
             msg= "Cannot Plot or Fit :Must select a model or Fitting range is not valid!!!  "
 …
     def _is_modified(self, is_modified):
         """
             return to self._is_modified
+        return to self._is_modified
         """
         return is_modified
 …
     def _reset_parameters_state(self, listtorestore,statelist):
         """
             Reset the parameters at the given state
+        Reset the parameters at the given state
         """
         if len(statelist)==0 or  len(listtorestore)==0 :
 …
                 else:
                     item_page[6].Hide()
     def _copy_parameters_state(self, listtocopy, statelist):
         """
+            copy the state of button
+            @param listtocopy: the list of check button to copy
+            @param statelist: list of state object to store the current state
+        copy the state of button
+        :param listtocopy: the list of check button to copy
+        :param statelist: list of state object to store the current state
         """
         if len(listtocopy)==0:
 …
                                 [min_state,min_value],[max_state , max_value],unit])
     def _set_model_sizer_selection(self, model):
         """
             Display the sizer according to the type of the current model
         """
         if model ==None:
+        Display the sizer according to the type of the current model
+        """
+        if model == None:
             return
         if hasattr(model ,"s_model"):
 …
                     break
     def _draw_model(self):
         """
+            Method to draw or refresh a plotted model.
+            The method will use the data member from the model page
+            to build a call to the fitting perspective manager.
+            [Note to coder: This way future changes will be done in only one place.]
+        Method to draw or refresh a plotted model.
+        The method will use the data member from the model page
+        to build a call to the fitting perspective manager.
         """
         if self.check_invalid_panel():
 …
     def _set_model_sizer(self,sizer, box_sizer, title="", object=None):
         """
             Use lists to fill a sizer for model info
+        Use lists to fill a sizer for model info
         """
 …
         self.SetScrollbars(20,20,25,65)
     def _show_combox(self, event):
         """
             Show combox box associate with type of model selected
+        Show combox box associate with type of model selected
         """
         if self.check_invalid_panel():
 …
     def _populate_box(self, combobox, list):
         """
+            fill combox box with dict item
+            @param list: contains item to fill the combox
+        fill combox box with dict item
+        :param list: contains item to fill the combox
             item must model class
         """
 …
                     name = model.name
                 combobox.Append(name,models)
         return 0
-    #def _onparamEnter(self,event):
-        """
-        #when enter value on panel redraw model according to changed
-        """
-        """
-        tcrtl= event.GetEventObject()
-        #Clear msg if previously shown.
-        msg= ""
-        wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
-        ## save current state
-        self.save_current_state()
-        if event !=None:
-            #self._undo.Enable(True)
-            event = PageInfoEvent(page = self)
-            wx.PostEvent(self.parent, event)
-        if check_float(tcrtl):
-            self._onparamEnter_helper()
-            #event.Skip()
-        else:
-            msg= "Cannot Plot :Must enter a number!!!  "
-            wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
-            #event.Skip()
-            return
-       """
     def _onQrangeEnter(self, event):
         """
             Check validity of value enter in the Q range field
+        Check validity of value enter in the Q range field
         """
 …
     def _on_select_model_helper(self):
         """
              call back for model selection
+        call back for model selection
         """
         ## reset dictionary containing reference to dispersion
 …
     def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
         """
+            Verify that the Q range controls have valid values
+            and that Qmin < Qmax.
+            @param qmin_ctrl: text control for Qmin
+            @param qmax_ctrl: text control for Qmax
+            @return: True is the Q range is value, False otherwise
+        Verify that the Q range controls have valid values
+        and that Qmin < Qmax.
+        :param qmin_ctrl: text control for Qmin
+        :param qmax_ctrl: text control for Qmax
+        :return: True is the Q range is value, False otherwise
         """
         qmin_validity = check_float(qmin_ctrl)
 …
     def _validate_Npts(self):
         """
             Validate the number of points for fitting is more than 10 points.
             If valid, setvalues Npts_fit otherwise post msg.
+        Validate the number of points for fitting is more than 10 points.
+        If valid, setvalues Npts_fit otherwise post msg.
         """
         #default flag
 …
     def _check_value_enter(self, list, modified):
         """
+            @param list: model parameter and panel info
+            each item of the list should be as follow:
+            item=[cb state, name, value, "+/-", error of fit, min, max , units]
+        :param list: model parameter and panel info
+        :Note: each item of the list should be as follow:
+            item=[check button state, parameter's name,
+                paramater's value, string="+/-",
+                parameter's error of fit,
+                parameter's minimum value,
+                parrameter's maximum value ,
+                parameter's units]
         """
         is_modified =  modified
 …
     def _set_dipers_Param(self, event):
         """
             respond to self.enable_disp and self.disable_disp radio box.
             The dispersity object is reset inside the model into Gaussian.
             When the user select yes , this method display a combo box for more selection
             when the user selects No,the combo box disappears.
             Redraw the model with the default dispersity (Gaussian)
+        respond to self.enable_disp and self.disable_disp radio box.
+        The dispersity object is reset inside the model into Gaussian.
+        When the user select yes , this method display a combo box for more selection
+        when the user selects No,the combo box disappears.
+        Redraw the model with the default dispersity (Gaussian)
         """
         if self.check_invalid_panel():
 …
     def _layout_sizer_noDipers(self):
         """
             Draw a sizer with no dispersity info
+        Draw a sizer with no dispersity info
         """
         ix=0
 …
     def _reset_dispersity(self):
         """
              put gaussian dispersity into current model
+        put gaussian dispersity into current model
         """
         if len(self.param_toFit)>0:
 …
         self.Refresh()
     def _on_select_Disp(self,event):
         """
              allow selecting different dispersion
              self.disp_list should change type later .now only gaussian
+        allow selecting different dispersion
+        self.disp_list should change type later .now only gaussian
         """
         n = self.disp_box.GetCurrentSelection()
 …
     def _set_sizer_arraydispersion(self):
         """
             draw sizer with array dispersity  parameters
+        draw sizer with array dispersity  parameters
         """
 …
         wx.PostEvent(self.parent, event)
     def _set_range_sizer(self, title, box_sizer=None, object1=None,object=None):
         """
             Fill the Q range sizer
+        Fill the Q range sizer
         """
         #2D data? default
 …
     def _fill_save_sizer(self):
         """
             Draw the layout for saving option
+        Draw the layout for saving option
         """
         self.sizer6.Clear(True)
 …
     def _lay_out(self):
         """
+            returns self.Layout
+            Note: Mac seems to like this better when self.Layout is called after fitting.
+        returns self.Layout
+        :Note: Mac seems to like this better when self.
+            Layout is called after fitting.
         """
         self._sleep4sec()
 …
     def on_reset_clicked(self,event):
         """
         #On 'Reset' button  for Q range clicked
+        On 'Reset' button  for Q range clicked
         """
         flag = True
 …
             self._onparamEnter_helper()
         self.save_current_state()
         self.state.qmin = self.qmin_x
 …
     def on_model_help_clicked(self,event):
         """
         #On 'More details' button
+        on 'More details' button
         """
         from help_panel import  HelpWindow

sansview/perspectives/fitting/console.py

-                      re54d2c32
+                      r5062bbf
         If quiet is true, only print out final summary, not progress and
         improvements.
+        :attr parent: the object that handle the messages
         """
         self.parent= parent
 …
     def finalize(self):
+        """
+        """
         if self.isbetter:
             self.result.print_summary()
     def abort(self):
+        """
+        """
         if self.isbetter:
             self.result.print_summary()
     def update_fit(self, msg=""):
+        """
+        """
         self.elapsed_time = time.time() - self.elapsed_time
         msg = " Updating fit ...\n result:\n %s \n"%self.result.__str__()
 …
     def starting_fit(self):
+        """
+        """
         wx.PostEvent(self.parent, StatusEvent(status="Starting the Fit...",
                                         info="info",type="progress"))
     def set_result(self, result):
+        """
+        """
         self.result = result

sansview/perspectives/fitting/fit_thread.py

-                      re54d2c32
+                      r5062bbf
     def isquit(self):
         """
+             @raise KeyboardInterrupt: when the thread is interrupted
+        :raise KeyboardInterrupt: when the thread is interrupted
         """
         try:
 …
     def compute(self):
         """
             Perform a fit
+        Perform a fit
         """
         try:
 …
             self.handler.error(msg=msg)

sansview/perspectives/fitting/fitpage.py

-                      rcb190a19
+                      r5062bbf
 class FitPage(BasicPage):
     """
+        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
+    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.
     """
     def __init__(self,parent, page_info):
+        """
+        Initialization of the Panel
+        """
         BasicPage.__init__(self, parent, page_info)
-        """
-            Initialization of the Panel
-        """
         ## total number of point: float
         self.npts=None
 …
     def _on_fit_complete(self, event):
         """
             When fit is complete ,reset the fit button label.
+        When fit is complete ,reset the fit button label.
         """
         #self.btFit.SetLabel("Fit")
 …
     def _is_2D(self):
         """
+            Check if data_name is Data2D
+            @return: True or False
+        Check if data_name is Data2D
+        :return: True or False
         """
 …
     def _on_engine_change(self, event):
         """
+            get an event containing the current name of the fit engine type
+            @param event: FitterTypeEvent containing  the name of the current engine
+        get an event containing the current name of the fit engine type
+        :param event: FitterTypeEvent containing  the name of the current engine
         """
         self.engine_type = event.type
 …
     def _fill_range_sizer(self):
         """
             Fill the sizer containing the plotting range
             add  access to npts
+        Fill the sizer containing the plotting range
+        add  access to npts
         """
         is_2Ddata = False
 …
         self.smear_accuracy.SetToolTipString("'Higher' uses more Gaussian points for smearing computation.")
         wx.EVT_COMBOBOX(self.smear_accuracy,-1, self._on_select_accuracy)
 …
     def _fill_datainfo_sizer(self):
         """
             fill sizer 0 with data info
+        fill sizer 0 with data info
         """
         ## no loaded data , don't fill the sizer
 …
     def _fill_model_sizer(self, sizer):
         """
             fill sizer containing model info
+        fill sizer containing model info
         """
         ##Add model function Details button in fitpanel.
 …
         ## class base method  to add view 2d button
         self._set_model_sizer(sizer=sizer, box_sizer=boxsizer1, title="Model",object=self.model_help )
     def _set_sizer_dispersion(self, dispersity):
         """
             draw sizer with gaussian dispersity parameters
+        draw sizer with gaussian dispersity parameters
         """
         self.fittable_param=[]
 …
                                                      ,None,None, None, None,None])
         self.state.disp_cb_dict = copy.deepcopy(self.disp_cb_dict)
 …
         self.Layout()
     def _onFit(self, event):
         """
             Allow to fit
+        Allow to fit
         """
         #make sure all parameter values are updated.
 …
             return
         self.select_param(event =None)
 …
         #    self.btFit.Bind(event= wx.EVT_BUTTON, handler=self._onFit, id=self.btFit.GetId())
     def _StopFit(self, event):
         """
             Stop fit
+        Stop fit
         """
         self.btFit.SetLabel("Fit")
 …
     def _on_select_model(self, event):
         """
              call back for model selection
+        call back for model selection
         """
         self._on_select_model_helper()
 …
             event = PageInfoEvent(page = self)
             wx.PostEvent(self.parent, event)
     def _onparamEnter(self,event):
         """
             when enter value on panel redraw model according to changed
+        when enter value on panel redraw model according to changed
         """
         if self.model ==None:
 …
     def _onparamRangeEnter(self, event):
         """
             Check validity of value enter in the parameters range field
+        Check validity of value enter in the parameters range field
         """
         if self.check_invalid_panel():
 …
     def _onQrangeEnter(self, event):
         """
             Check validity of value enter in the Q range field
+        Check validity of value enter in the Q range field
         """
         if self.check_invalid_panel():
 …
         wx.PostEvent(self.parent, event)
         self.state_change= False
         return
     def _clear_Err_on_Fit(self):
         """
             hide the error text control shown
             after fitting
+        hide the error text control shown
+        after fitting
         """
 …
     def _get_defult_custom_smear(self):
         """
+           Get the defult values for custum smearing.
+        """
+        Get the defult values for custum smearing.
+        """
         # get the default values
         if self.dxl == None: self.dxl = 0.0
 …
     def _get_smear_info(self):
         """
+           Get the smear info from data.
+           @return: self.smear_type, self.dq_l and self.dq_r,
+        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 dq_max for pinhole smear data
             while dxl and dxw for slit smear
         """
 …
             else:
                 return
         # check if it is pinhole smear and get min max if it is.
         if data.dx != None and all(data.dx !=0):
 …
                 self.dq_l = data.dxl[0]
             if data.dxw != None and all(data.dxw !=0):
+                self.dq_r = data.dxw[0]
+                self.dq_r = data.dxw[0]
         #return self.smear_type,self.dq_l,self.dq_r
     def _show_smear_sizer(self):
         """
             Show only the sizers depending on smear selection
+        Show only the sizers depending on smear selection
         """
         # smear disabled
 …
     def _hide_all_smear_info(self):
         """
            Hide all smearing messages in the set_smearer sizer
+        Hide all smearing messages in the set_smearer sizer
         """
         self.smear_description_none.Hide()
 …
     def _set_accuracy_list(self):
         """
             Set the list of an accuracy in 2D custum smear: Xhigh, High, Med, or Low
+        Set the list of an accuracy in 2D custum smear: Xhigh, High, Med, or Low
         """
         # list of accuracy choices
 …
     def _on_select_accuracy(self,event):
         """
             Select an accuracy in 2D custom smear: Xhigh, High, Med, or Low
+        Select an accuracy in 2D custom smear: Xhigh, High, Med, or Low
         """
         #event.Skip()
         # Check if the accuracy is same as before
         #self.smear2d_accuracy = event.GetEventObject().GetValue()
         self.smear2d_accuracy = self.smear_accuracy.GetValue()
 …
             self.onSmear(event=None)
             if self.current_smearer != None:
+                self.current_smearer.set_accuracy(accuracy = self.smear2d_accuracy)
+                self.current_smearer.set_accuracy(accuracy = self.smear2d_accuracy)
         event.Skip()
     def _onMask(self, event):
         """
             Build a panel to allow to edit Mask
+        Build a panel to allow to edit Mask
         """
 …
     def set_data(self, data):
         """
             reset the current data
+        reset the current data
         """
         self.data = data
         if self.data is None:
             data_min = ""
 …
                 self.slit_smearer.Disable()
                 self.default_mask = copy.deepcopy(self.data.mask)
             self.formfactorbox.Enable()
 …
                 self.btEditMask.Enable()
                 self.EditMask_title.Enable()
         self.dataSource.SetValue(data_name)
         self.qmin_x = data_min
 …
         self.state.qmax = self.qmax_x
     def reset_page(self, state,first=False):
         """
             reset the state
+        reset the state
         """
         self.reset_page_helper(state)
 …
     def get_range(self):
         """
             return the fitting range
+        return the fitting range
         """
         return float(self.qmin_x) , float(self.qmax_x)
 …
     def get_npts2fit(self):
         """
+            return numbers of data points within qrange
+            Note: This is for Park where chi2 is not normalized by Npts of fit
+        return numbers of data points within qrange
+        :Note: This is for Park where chi2 is not normalized by Npts of fit
         """
         npts2fit = 0
 …
     def set_npts2fit(self):
         """
             setValue Npts for fitting
+        setValue Npts for fitting
         """
         self.Npts_fit.SetValue(str(self.get_npts2fit()))
     def get_chi2(self):
         """
             return the current chi2
+        return the current chi2
         """
         return self.tcChi.GetValue()
 …
     def get_param_list(self):
         """
             @return self.param_toFit: list containing  references to TextCtrl
+        :return self.param_toFit: list containing  references to TextCtrl
             checked.Theses TextCtrl will allow reference to parameters to fit.
+            @raise: if return an empty list of parameter fit will nnote work
+        :raise: if return an empty list of parameter fit will nnote work
             properly so raise ValueError,"missing parameter to fit"
         """
 …
     def onsetValues(self,chisqr,p_name, out,cov):
         """
+            Build the panel from the fit result
+            @param chisqr:Value of the goodness of fit metric
+            @p_name: the name of parameters
+            @param out:list of parameter with the best value found during fitting
+            @param cov:Covariance matrix
+        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
         """
         if out == None or not numpy.isfinite(chisqr):
 …
     def onPinholeSmear(self, event):
         """
+            Create a custom pinhole smear object that will change the way residuals
+            are compute when fitting
+            @ accuracy: given by strings'High','Med', 'Low' FOR 2d,  None for 1D
+        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
         """
 …
     def _is_changed_pinhole(self):
         """
+            check if any of pinhole smear is changed
+            return: True or False
+        check if any of pinhole smear is changed
+        :return: True or False
         """
         # get the values
 …
     def _set_pinhole_smear(self):
         """
+            Set custom pinhole smear
+            return: msg
+        Set custom pinhole smear
+        :return: msg
         """
         # copy data
 …
     def update_pinhole_smear(self):
         """
+            called by kill_focus on pinhole TextCntrl
+            to update the changes
+            return: msg: False when wrong value was entered
+        called by kill_focus on pinhole TextCntrl
+        to update the changes
+        :return: False when wrong value was entered
         """
         # msg default
 …
     def onSlitSmear(self, event):
         """
             Create a custom slit smear object that will change the way residuals
             are compute when fitting
+        Create a custom slit smear object that will change the way residuals
+        are compute when fitting
         """
 …
             wx.PostEvent(self.manager.parent, StatusEvent(status = msg))
     def _is_changed_slit(self):
         """
+            check if any of slit lengths is changed
+            return: True or False
+        """
+        check if any of slit lengths is changed
+        :return: True or False
+        """
         # get the values
         width = self.smear_slit_width.GetValue()
 …
     def _set_slit_smear(self):
         """
+            Set custom slit smear
+            return: msg
+        Set custom slit smear
+        :return: message to inform the user about the validity
+            of the values entered for slit smear
         """
         temp_smearer = None
 …
         ## set smearing value whether or not the data contain the smearing info
         self.manager.set_smearer(smearer=self.current_smearer, qmin= float(self.qmin_x), qmax= float(self.qmax_x))
         return msg
     def update_slit_smear(self):
         """
+            called by kill_focus on pinhole TextCntrl
+            to update the changes
+            return: msg: False when wrong value was entered
+        called by kill_focus on pinhole TextCntrl
+        to update the changes
+        :return: False when wrong value was entered
         """
         # msg default
 …
             return True
     def onSmear(self, event):
         """
             Create a smear object that will change the way residuals
             are compute when fitting
+        Create a smear object that will change the way residuals
+        are compute when fitting
         """
         if event != None:
 …
     def on_complete_chisqr(self, event):
         """
+            print result chisqr
+            @event: activated by fitting/ complete after draw
+        print result chisqr
+        :event: activated by fitting/ complete after draw
         """
         try:
 …
             pass
     def select_all_param(self,event):
         """
              set to true or false all checkBox given the main checkbox value cb1
+        set to true or false all checkBox given the main checkbox value cb1
         """
         self.param_toFit=[]
         if  self.parameters !=[]:
 …
             wx.PostEvent(self.parent, event)
     def select_param(self,event):
         """
             Select TextCtrl  checked for fitting purpose and stores them
             in  self.param_toFit=[] list
+        Select TextCtrl  checked for fitting purpose and stores them
+        in  self.param_toFit=[] list
         """
         self.param_toFit=[]
 …
             event = PageInfoEvent(page = self)
             wx.PostEvent(self.parent, event)
     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
+        Build the panel from the model content
+        :param model: the model selected in combo box for fitting purpose
         """
         self.sizer3.Clear(True)
 …
             self.engine_type= self.manager._return_engine_type()
         box_description= wx.StaticBox(self, -1,str("Model Parameters"))
         boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
 …
         self.Refresh()
         self.SetScrollbars(20,20,25,65)
 class BGTextCtrl(wx.TextCtrl):
     """
         Text control used to display outputs.
         No editing allowed. The background is
         grayed out. User can't select text.
+    Text control used to display outputs.
+    No editing allowed. The background is
+    grayed out. User can't select text.
     """
     def __init__(self, *args, **kwds):
 …
     def _click(self, event):
         """
             Prevent further handling of the mouse event
             by not calling Skip().
+        Prevent further handling of the mouse event
+        by not calling Skip().
         """
         pass
+class HelpWindow(wx.Frame):
+    def __init__(self, parent, id, title):
+        wx.Frame.__init__(self, parent, id, title, size=(570, 400))
+        from sans.models.CylinderModel import CylinderModel
+        model = CylinderModel()
+        from danse.common.plottools.plottables import Data1D
+        data= Data1D(x=[1,2], y=[3,4], dy=[0.1, 0,1])
+"""
+Example: ::
+        from fitpanel import PageInfo
+        myinfo = PageInfo(self,  model, data=data )
+        ## add data
+        from models import ModelList
+        mylist= ModelList()
+        from sans.models.SphereModel import SphereModel
+        from sans.models.SquareWellStructure import SquareWellStructure
+        from sans.models.DebyeModel import DebyeModel
+        from sans.models.LineModel import LineModel
+        name= "shapes"
+        list1= [SphereModel]
+        mylist.set_list( name, list1)
+        name= "Shape-independent"
+        list1= [DebyeModel]
+        mylist.set_list( name, list1)
+        name= "Structure Factors"
+        list1= [SquareWellStructure]
+        mylist.set_list( name, list1)
+        name= "Added models"
+        list1= [LineModel]
+        mylist.set_list( name, list1)
+        myinfo.model_list_box = mylist.get_list()
+        self.page = FitPage(self, myinfo)
+        self.Centre()
+        self.Show(True)
+if __name__=="__main__":
+    app = wx.App()
+    HelpWindow(None, -1, 'HelpWindow')
+    app.MainLoop()
+    class HelpWindow(wx.Frame):
+        def __init__(self, parent, id, title):
+            wx.Frame.__init__(self, parent, id, title, size=(570, 400))
+            from sans.models.CylinderModel import CylinderModel
+            model = CylinderModel()
+            from danse.common.plottools.plottables import Data1D
+            data= Data1D(x=[1,2], y=[3,4], dy=[0.1, 0,1])
+            from fitpanel import PageInfo
+            myinfo = PageInfo(self,  model, data=data )
+            ## add data
+            from models import ModelList
+            mylist= ModelList()
+            from sans.models.SphereModel import SphereModel
+            from sans.models.SquareWellStructure import SquareWellStructure
+            from sans.models.DebyeModel import DebyeModel
+            from sans.models.LineModel import LineModel
+            name= "shapes"
+            list1= [SphereModel]
+            mylist.set_list( name, list1)
+            name= "Shape-independent"
+            list1= [DebyeModel]
+            mylist.set_list( name, list1)
+            name= "Structure Factors"
+            list1= [SquareWellStructure]
+            mylist.set_list( name, list1)
+            name= "Added models"
+            list1= [LineModel]
+            mylist.set_list( name, list1)
+            myinfo.model_list_box = mylist.get_list()
+            self.page = FitPage(self, myinfo)
+            self.Centre()
+            self.Show(True)
+    if __name__=="__main__":
+        app = wx.App()
+        HelpWindow(None, -1, 'HelpWindow')
+        app.MainLoop()
+"""

sansview/perspectives/fitting/fitpanel.py

-                      r31b0c47
+                      r5062bbf
 class StateIterator(object):
     """
         Contains all saved state of a given page.
         Provide position of the current state of a page, the first save state
         and the last state for a given page.
         Allow easy undo or redo for a given page
+    Contains all saved state of a given page.
+    Provide position of the current state of a page, the first save state
+    and the last state for a given page.
+    Allow easy undo or redo for a given page
     """
     def __init__(self):
+        """
+        """
         self._current=0
     def __iter__(self):
+        """
+        """
         return self
     def first(self):
+        """
+        """
         self._current =0
         return self._current
     def next(self, max ):
+        """
+        """
         if self._current < max:
             self._current += 1
 …
     def previous(self):
+        """
+        """
         if self._current > 0:
             self._current = self._current -1
 …
     def currentPosition(self):
+        """
+        """
         return self._current
     def setPosition(self, value):
+        """
+        """
         if value >=0:
             self._current = int(value)
+class ListOfState(list):
+class ListOfState(list):
+    """
+    """
     def __init__(self, *args, **kw):
         list.__init__(self, *args, **kw)
 …
     def appendItem(self, x):
+        """
+        """
         self.append(x)
         self.iterator.setPosition(value= len(self)-1)
     def removeItem(self, x):
+        """
+        """
         self.iterator.previous()
         self.remove(x)
     def getPreviousItem(self):
+        """
+        """
         position = self.iterator.previous()
 …
     def getNextItem(self):
+        """
+        """
         position = self.iterator.next(max= len(self)-1)
         if position >= len(self):
 …
     def getCurrentItem(self):
+        """
+        """
         postion = self.iterator.currentPosition()
         if postion >= 0 and position < len(self):
 …
     def getCurrentPosition(self):
+        """
+        """
         return self.iterator.currentPosition()
 …
 class PageInfo(object):
     """
         this class contains the minimum numbers of data members
         a fitpage or model page need to be initialized.
+    this class contains the minimum numbers of data members
+    a fitpage or model page need to be initialized.
     """
     data = None
 …
                   event_owner=None, model_list_box=None, name=None):
         """
             Initialize data members
+        Initialize data members
         """
         self.data = data
 …
     """
+        FitPanel class contains fields allowing to fit  models and  data
+        @note: For Fit to be performed the user should check at least one parameter
+    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.
 …
     def __init__(self, parent, *args, **kwargs):
+        """
+        """
         wx.aui.AuiNotebook.__init__(self, parent, -1,
                     style= wx.aui.AUI_NB_WINDOWLIST_BUTTON|
 …
     def set_state(self, state):
         """
             Restore state of the panel
+        Restore state of the panel
         """
         page_is_opened = False
 …
     def on_close_page(self, event):
         """
              close page and remove all references to the closed page
+        close page and remove all references to the closed page
         """
         nbr_page = self.GetPageCount()
 …
     def close_page_with_data(self, deleted_data):
         """
             close a fit page when its data is completely remove from the graph
+        close a fit page when its data is completely remove from the graph
         """
         if deleted_data is None:
 …
     def set_manager(self, manager):
         """
+             set panel manager
+             @param manager: instance of plugin fitting
+        set panel manager
+        :param manager: instance of plugin fitting
         """
         self.manager = manager
 …
     def set_owner(self,owner):
         """
+            set and owner for fitpanel
+            @param owner: the class responsible of plotting
+        set and owner for fitpanel
+        :param owner: the class responsible of plotting
         """
         self.event_owner = owner
 …
     def set_model_list(self, dict):
          """
+             copy a dictionary of model into its own dictionary
+             @param dict: dictionnary made of model name as key and model class
+         copy a dictionary of model into its own dictionary
+         :param dict: dictionnary made of model name as key and model class
              as value
          """
          self.model_list_box = dict
     def get_current_page(self):
         """
+            @return the current page selected
+        :return: the current page selected
         """
         return self.GetPage(self.GetSelection() )
 …
     def add_sim_page(self):
         """
             Add the simultaneous fit page
+        Add the simultaneous fit page
         """
         from simfitpage import SimultaneousFitPage
 …
     def get_page_info(self, data=None):
         """
             fill information required to add a page in the fit panel
+        fill information required to add a page in the fit panel
         """
         name = "Fit Page"
 …
     def add_empty_page(self):
         """
             add an empty page
+        add an empty page
         """
         page_info = self.get_page_info()
 …
     def add_page(self, page_info):
         """
             add a new page
+        add a new page
         """
         from fitpage import FitPage
 …
     def change_page_content(self, data, index):
         """
             replace the contains of an existing page
+        replace the contains of an existing page
         """
         page_info = self.get_page_info(data=data)
 …
     def replace_page(self, index, page_info, type):
         """
             replace an existing page
+        replace an existing page
         """
         self.DeletePage(index)
 …
     def add_fit_page(self, data, reset=False):
         """
+            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
+        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 data is None:
 …
     def  _onGetstate(self, event):
         """
             copy the state of a page
+        copy the state of a page
         """
         page= event.page
 …
     def _onUndo(self, event ):
         """
             return the previous state of a given page is available
+        return the previous state of a given page is available
         """
         page = event.page
 …
     def _onRedo(self, event):
         """
             return the next state available
+        return the next state available
         """
         page = event.page
 …
     def _close_helper(self, selected_page):
         """
             Delete the given page from the notebook
+        Delete the given page from the notebook
         """
         #remove hint page

sansview/perspectives/fitting/fitproblem.py

-                      r2f189dc
+                      r5062bbf
 class FitProblem:
     """
         FitProblem class allows to link a model with the new name created in _on_model,
         a name theory created with that model  and the data fitted with the model.
         FitProblem is mostly used  as value of the dictionary by fitting module.
+    FitProblem class allows to link a model with the new name created in _on_model,
+    a name theory created with that model  and the data fitted with the model.
+    FitProblem is mostly used  as value of the dictionary by fitting module.
     """
     def __init__(self):
         """
            contains information about data and model to fit
+        contains information about data and model to fit
         """
         ## data used for fitting
 …
     def clone(self):
         """
             copy fitproblem
+        copy fitproblem
         """
         import copy
 …
         obj.qmin = copy.deepcopy(self.qmin)
         obj.qmax = copy.deepcopy(self.qmax)
         return obj
     def set_smearer(self, smearer):
         """
+          save reference of  smear object on fitdata
+          @param smear : smear object from DataLoader
+        save reference of  smear object on fitdata
+        :param smear: smear object from DataLoader
         """
         self.smearer= smearer
 …
     def get_smearer(self):
         """
             return smear object
+        return smear object
         """
         return self.smearer
+    def save_model_name(self, name):
+    def save_model_name(self, name):
+        """
+        """
         self.name_per_page= name
     def get_name(self):
+        """
+        """
         return self.name_per_page
     def set_model(self,model):
         """
+             associates each model with its new created name
+             @param model: model selected
+             @param name: name created for model
+        associates each model with its new created name
+        :param model: model selected
+        :param name: name created for model
         """
         self.model= model
+    def get_model(self):
+        """
+        :return: saved model
+    def get_model(self):
+        """ @return: saved model """
+        """
         return self.model
     def set_index(self, index):
         """
             set index of the model name
+        set index of the model name
         """
         self.model_index = index
 …
     def get_index(self):
         """
             get index of the model name
+        get index of the model name
         """
         return self.model_index
 …
     def add_plotted_data(self,data):
         """
+            save a copy of the data select to fit
+            @param data: data selected
+        save a copy of the data select to fit
+        :param data: data selected
         """
         self.plotted_data = data
 …
     def get_plotted_data(self):
+        """ @return:  list of data dList"""
+        """
+        :return: list of data dList
+        """
         return self.plotted_data
     def add_fit_data(self,data):
         """
+            save a copy of the data select to fit
+            @param data: data selected
+        save a copy of the data select to fit
+        :param data: data selected
         """
         self.fit_data = data
     def get_fit_data(self):
+        """
+        """
         return self.fit_data
     def set_model_param(self,name,value=None):
         """
+            Store the name and value of a parameter of this fitproblem's model
+            @param name: name of the given parameter
+            @param value: value of that parameter
+        Store the name and value of a parameter of this fitproblem's model
+        :param name: name of the given parameter
+        :param value: value of that parameter
         """
         self.list_param.append([name,value])
     def get_model_param(self):
         """
             @return list of couple of parameter name and value
+        return list of couple of parameter name and value
         """
         return self.list_param
     def schedule_tofit(self, schedule=0):
         """
              set schedule to true to decide if this fit  must be performed
+        set schedule to true to decide if this fit  must be performed
         """
         self.schedule=schedule
     def get_scheduled(self):
+        """ return true or false if a problem as being schedule for fitting"""
+        """
+        return true or false if a problem as being schedule for fitting
+        """
         return self.schedule
     def set_range(self, qmin=None, qmax=None):
         """
             set fitting range
+        set fitting range
         """
         self.qmin = qmin
         self.qmax = qmax
     def get_range(self):
         """
+            @return fitting range:
+        :return: fitting range
         """
         return self.qmin, self.qmax
 …
         """
         self.list_param=[]

sansview/perspectives/fitting/fitting.py

-                      r2882fb5
+                      r5062bbf
+"""
+This software was developed by the University of Tennessee as part of the
+Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
+project funded by the US National Science Foundation.
+See the license text in license.txt
+copyright 2009, University of Tennessee
+"""
+################################################################################
+#This software was developed by the University of Tennessee as part of the
+#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
+#project funded by the US National Science Foundation.
+#
+#See the license text in license.txt
+#
+#copyright 2009, University of Tennessee
+################################################################################
 import  re
 import sys
 …
 from fitpage import Chi2UpdateEvent
 class PlotInfo:
     """
         store some plotting field
+    store some plotting field
     """
     _xunit = 'A^{-1}'
 …
 class Plugin:
     """
         Fitting plugin is used to perform fit
+    Fitting plugin is used to perform fit
     """
     def __init__(self):
+        """
+        """
         ## Plug-in name
         self.sub_menu = "Fitting"
 …
     def populate_menu(self, id, 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
+        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
 …
     def on_add_sim_page(self, event):
         """
             Create a page to access simultaneous fit option
+        Create a page to access simultaneous fit option
         """
         Plugin.on_perspective(self,event=event)
 …
     def help(self, evt):
         """
+            Show a general help dialog.
+            TODO: replace the text with a nice image
+        Show a general help dialog.
         """
 …
         frame.Show(True)
     def get_context_menu(self, graph=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
+        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.graph = graph
 …
     def get_panels(self, parent):
         """
             Create and return a list of panel objects
+        Create and return a list of panel objects
         """
         self.parent = parent
 …
     def get_perspective(self):
         """
             Get the list of panel names for this perspective
+        Get the list of panel names for this perspective
         """
         return self.perspective
     def on_perspective(self, event):
         """
             Call back function for the perspective menu item.
             We notify the parent window that the perspective
             has changed.
+        Call back function for the perspective menu item.
+        We notify the parent window that the perspective
+        has changed.
         """
         self.parent.set_perspective(self.perspective)
 …
     def set_default_perspective(self):
         """
            Call back method that True to notify the parent that the current plug-in
            can be set as default  perspective.
            when returning False, the plug-in is not candidate for an automatic
            default perspective setting
+        Call back method that True to notify the parent that the current plug-in
+        can be set as default  perspective.
+        when returning False, the plug-in is not candidate for an automatic
+        default perspective setting
         """
         return True
 …
     def post_init(self):
         """
             Post initialization call back to close the loose ends
+        Post initialization call back to close the loose ends
         """
         pass
 …
     def set_state(self, state, datainfo=None):
         """
+            Call-back method for the fit page state reader.
+            This method is called when a .fitv file is loaded.
+            @param state: PageState object
+        Call-back method for the fit page state reader.
+        This method is called when a .fitv file is loaded.
+        :param state: PageState object
         """
         #working on reading state
 …
     def save_fit_state(self, filepath, fitstate):
         """
             save fit page state into file
+        save fit page state into file
         """
         self.state_reader.write(filename=filepath, fitstate=fitstate)
 …
     def copy_data(self, item, dy=None):
         """
             receive a data 1D and the list of errors on dy
             and create a new data1D data
             @param return
+        receive a data 1D and the list of errors on dy
+        and create a new data1D data
         """
         id = None
 …
     def set_fit_range(self, page, qmin, qmax):
         """
             Set the fitting range of a given page
+        Set the fitting range of a given page
         """
         if page in self.page_finder.iterkeys():
 …
     def schedule_for_fit(self,value=0,page=None,fitproblem =None):
         """
+            Set the fit problem field to 0 or 1 to schedule that problem to fit.
+            Schedule the specified fitproblem or get the fit problem related to
+            the current page and set value.
+            @param value : integer 0 or 1
+            @param fitproblem: fitproblem to schedule or not to fit
+        Set the fit problem field to 0 or 1 to schedule that problem to fit.
+        Schedule the specified fitproblem or get the fit problem related to
+        the current page and set value.
+        :param value: integer 0 or 1
+        :param fitproblem: fitproblem to schedule or not to fit
         """
         if fitproblem !=None:
 …
     def get_page_finder(self):
+        """ @return self.page_finder used also by simfitpage.py"""
+        """
+        return self.page_finder used also by simfitpage.py
+        """
         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
+             @param value: can be a string in this case.
+             @param names: the paramter name
+             @note: expecting park used for fit.
+        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
+        :param value: can be a string in this case.
+        :param names: the paramter name
+        :note: expecting park used for fit.
         """
         sim_page= self.sim_page
 …
     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:
+        receive a word containing dot and split it. used to split parameterset
+        name into model name and parameter name example: ::
             paramaterset (item) = M1.A
+            @return model_name =M1 , parameter name =A
+            Will return model_name = M1 , parameter name = A
         """
         if string.find(item,".")!=-1:
 …
     def stop_fit(self):
         """
             Stop the fit engine
+        Stop the fit engine
         """
         if self.calc_fit!= None and self.calc_fit.isrunning():
 …
     def set_smearer_nodraw(self,smearer, qmin=None, qmax=None):
         """
+            Get a smear object and store it to a fit problem
+            @param smearer: smear object to allow smearing data
+        Get a smear object and store it to a fit problem
+        :param smearer: smear object to allow smearing data
         """
         self.current_pg=self.fit_panel.get_current_page()
 …
         ## if user has already selected a model to plot
         ## redraw the model with data smeared
         smear =self.page_finder[self.current_pg].get_smearer()
     def set_smearer(self,smearer, qmin=None, qmax=None):
         """
+            Get a smear object and store it to a fit problem
+            @param smearer: smear object to allow smearing data
+        Get a smear object and store it to a fit problem
+        :param smearer: smear object to allow smearing data
         """
         self.current_pg=self.fit_panel.get_current_page()
 …
                    qmin= DEFAULT_QMIN, qmax= DEFAULT_QMAX, qstep= DEFAULT_NPTS):
         """
+             Draw model.
+             @param model: the model to draw
+             @param name: the name of the model to draw
+             @param data: the data on which the model is based to be drawn
+             @param description: model's description
+             @param enable1D: if true enable drawing model 1D
+             @param enable2D: if true enable drawing model 2D
+             @param qmin:  Range's minimum value to draw model
+             @param qmax:  Range's maximum value to draw model
+             @param qstep: number of step to divide the x and y-axis
+        Draw model.
+        :param model: the model to draw
+        :param name: the name of the model to draw
+        :param data: the data on which the model is based to be drawn
+        :param description: model's description
+        :param enable1D: if true enable drawing model 1D
+        :param enable2D: if true enable drawing model 2D
+        :param qmin:  Range's minimum value to draw model
+        :param qmax:  Range's maximum value to draw model
+        :param qstep: number of step to divide the x and y-axis
         """
         if data.__class__.__name__ !="Data2D":
             ## draw model 1D with no loaded data
 …
     def onFit(self):
         """
             perform fit
+        perform fit
         """
         ##  count the number of fitproblem schedule to fit
 …
     def remove_plot(self, page, theory=False):
         """
             remove model plot when a fit page is closed
+        remove model plot when a fit page is closed
         """
         fitproblem = self.page_finder[page]
 …
     def create_fittable_data2D(self, data):
         """
+            check if the current data is a data 2d and add dy to that data
+            @return Data2D
+        check if the current data is a data 2d and add dy to that data
+        :return: Data2D
         """
         if data.__class__.__name__ != "Data2D":
 …
     def create_fittable_data1D(self, data):
         """
+            check if the current data is a theory 1d and add dy to that data
+            @return Data1D
+        check if the current data is a theory 1d and add dy to that data
+        :return: Data1D
         """
         class_name = data.__class__.__name__
 …
     def store_page(self, page, data):
         """
+            Helper to save page reference into the plug-in
+            @param page: page to store
+        Helper to save page reference into the plug-in
+        :param page: page to store
         """
         page.set_data(data)
 …
     def add_fit_page(self, data):
         """
             given a data, ask to the fitting panel to create a new fitting page,
             get this page and store it into the page_finder of this plug-in
+        given a data, ask to the fitting panel to create a new fitting page,
+        get this page and store it into the page_finder of this plug-in
         """
         try:
 …
     def _onEVT_SLICER_PANEL(self, event):
         """
+            receive and event telling to update a panel with a name starting with
+            event.panel_name. this method update slicer panel for a given interactor.
+            @param event: contains type of slicer , paramaters for updating the panel
+        receive and event telling to update a panel with a name starting with
+        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.
         """
 …
         self.parent._mgr.Update()
     def _closed_fitpage(self, event):
         """
             request fitpanel to close a given page when its unique data is removed
             from the plot. close fitpage only when the a loaded data is removed
+        request fitpanel to close a given page when its unique data is removed
+        from the plot. close fitpage only when the a loaded data is removed
         """
         if event is None or event.data is None:
 …
     def _add_page_onmenu(self, name,fitproblem=None):
         """
             Add name of a closed page of fitpanel in a menu
+        Add name of a closed page of fitpanel in a menu
         """
         list = self.menu1.GetMenuItems()
 …
             wx.EVT_MENU(self.parent,event_id,  self._open_closed_page)
     def _open_closed_page(self, event):
         """
             reopen a closed page
+        reopen a closed page
         """
         for name, value in self.closed_page_dict.iteritems():
 …
                                                   reset= True)
                     break
     def _reset_schedule_problem(self, value=0):
         """
              unschedule or schedule all fitproblem to be fit
+        unschedule or schedule all fitproblem to be fit
         """
         for page, fitproblem in self.page_finder.iteritems():
 …
     def _fit_helper(self,pars,value, id, title="Single Fit " ):
         """
             helper for fitting
+        helper for fitting
         """
         metadata = value.get_fit_data()
 …
     def _onSelect(self,event):
         """
             when Select data to fit a new page is created .Its reference is
             added to self.page_finder
+        when Select data to fit a new page is created .Its reference is
+        added to self.page_finder
         """
         self.panel = event.GetEventObject()
 …
     def _single_fit_completed(self,result,pars,cpage, elapsed=None):
         """
+            Display fit result on one page of the notebook.
+            @param result: result of fit
+            @param pars: list of names of parameters fitted
+            @param current_pg: the page where information will be displayed
+            @param qmin: the minimum value of x to replot the model
+            @param qmax: the maximum value of x to replot model
+        Display fit result on one page of the notebook.
+        :param result: result of fit
+        :param pars: list of names of parameters fitted
+        :param current_pg: the page where information will be displayed
+        :param qmin: the minimum value of x to replot the model
+        :param qmax: the maximum value of x to replot model
         """
 …
             return
     def _simul_fit_completed(self,result,pars=None,cpage=None, elapsed=None):
         """
+            Parameter estimation completed,
+            display the results to the user
+            @param alpha: estimated best alpha
+            @param elapsed: computation time
+        Parameter estimation completed,
+        display the results to the user
+        :param alpha: estimated best alpha
+        :param elapsed: computation time
         """
         ## fit more than 1 model at the same time
 …
              return
     def _on_show_panel(self, event):
+        print "_on_show_panel: fitting"
+        """
+        """
+        #print "_on_show_panel: fitting"
+        pass
     def _onset_engine_park(self,event):
         """
             set engine to park
+        set engine to park
         """
         Plugin.on_perspective(self,event=event)
         self._on_change_engine('park')
     def _onset_engine_scipy(self,event):
         """
             set engine to scipy
+        set engine to scipy
         """
         self._on_change_engine('scipy')
 …
     def _on_slicer_event(self, event):
         """
+            Receive a panel as event and send it to guiframe
+            @param event: event containing a panel
+        """
+        if event.panel!=None:
+        Receive a panel as event and send it to guiframe
+        :param event: event containing a panel
+        """
+        if event.panel is not None:
             new_panel = event.panel
             self.slicer_panels.append(event.panel)
 …
             new_panel.uid = event_id
             self.mypanels.append(new_panel)
+        return
     def _onclearslicer(self, event):
         """
             Clear the boxslicer when close the panel associate with this slicer
+        Clear the boxslicer when close the panel associate with this slicer
         """
         name =event.GetPane().caption
 …
                             break
                 break
     def _return_engine_type(self):
         """
             return the current type of engine
+        return the current type of engine
         """
         return self._fit_engine
 …
     def _on_change_engine(self, engine='park'):
         """
+            Allow to select the type of engine to perform fit
+            @param engine: the key work of the engine
+        """
+        Allow to select the type of engine to perform fit
+        :param engine: the key work of the engine
+        """
         ## saving fit engine name
         self._fit_engine = engine
 …
             wx.PostEvent(key, event)
     def _on_model_panel(self, evt):
         """
+            react to model selection on any combo box or model menu.plot the model
+            @param evt: wx.combobox event
+        react to model selection on any combo box or model menu.plot the model
+        :param evt: wx.combobox event
         """
         model = evt.model
 …
     def _on_model_menu(self, evt):
         """
+            Plot a theory from a model selected from the menu
+            @param evt: wx.menu event
+        Plot a theory from a model selected from the menu
+        :param evt: wx.menu event
         """
         model = evt.model
 …
         # the content will be updated and the plot refreshed
         self.fit_panel.add_model_page(model,topmenu=True)
     def _update1D(self,x, output):
         """
             Update the output of plotting model 1D
+        Update the output of plotting model 1D
         """
         wx.PostEvent(self.parent, StatusEvent(status="Plot \
 …
         #self.calc_thread.ready(0.01)
     def _fill_default_model2D(self, theory, qmax,qstep, qmin=None):
         """
+            fill Data2D with default value
+            @param theory: Data2D to fill
+        fill Data2D with default value
+        :param theory: Data2D to fill
         """
         from DataLoader.data_info import Detector, Source
 …
         theory.detector[0].beam_center.x= qmax
         theory.detector[0].beam_center.y= qmax
         ## create x_bins and y_bins of the model 2D
         pixel_width_x = theory.detector[0].pixel_size.x
 …
         theory.ymin= ymin
         theory.ymax= ymax
+        theory.group_id ="Model"
+        theory.id ="Model"
+        theory.group_id = "Model"
+        theory.id = "Model"
     def _get_plotting_info(self, data=None):
         """
+            get plotting info from data if data !=None
+            else use some default
+        get plotting info from data if data !=None else use some default
         """
         my_info = PlotInfo()
 …
             if hasattr(data, "group_id"):
                 my_info.group_id= data.group_id
         return my_info
     def _complete1D(self, x,y, elapsed,index,model,data=None):
         """
             Complete plotting 1D data
+        Complete plotting 1D data
         """
         try:
 …
             msg+= " %s"%sys.exc_value
             wx.PostEvent( self.parent, StatusEvent(status= msg, type="stop"))
+            return
     def _update2D(self, output,time=None):
         """
             Update the output of plotting model
+        Update the output of plotting model
         """
         wx.PostEvent(self.parent, StatusEvent(status="Plot \
 …
         self.ready_fit()
         #self.calc_thread.ready(0.01)
     def _complete2D(self, image,data, model,  elapsed,index,qmin, qmax,qstep=DEFAULT_NPTS):
         """
             Complete get the result of modelthread and create model 2D
             that can be plot.
+    def _complete2D(self, image, data, model, elapsed, index, qmin,
+                     qmax, qstep=DEFAULT_NPTS):
+        """
+        Complete get the result of modelthread and create model 2D
+        that can be plot.
         """
         err_image = numpy.zeros(numpy.shape(image))
 …
         if data ==None:
+            self._fill_default_model2D(theory= theory, qmax=qmax,qstep=qstep, qmin= qmin)
+            self._fill_default_model2D(theory=theory, qmax=qmax, qstep=qstep,
+                                        qmin= qmin)
         else:
 …
                          title="Analytical model 2D ", reset=True ))
         # Chisqr in fitpage
+        current_pg=self.fit_panel.get_current_page()
+        wx.PostEvent(current_pg,Chi2UpdateEvent(output=self._cal_chisqr(data=data,index=index)))
+        current_pg = self.fit_panel.get_current_page()
+        wx.PostEvent(current_pg,
+            Chi2UpdateEvent(output=self._cal_chisqr(data=data,index=index)))
         msg = "Plot 2D complete !"
         wx.PostEvent( self.parent, StatusEvent( status= msg , type="stop" ))
+        wx.PostEvent( self.parent, StatusEvent(status=msg, type="stop" ))
     def _on_data_error(self, event):
         """
             receives and event from plotting plu-gins to store the data name and
             their errors of y coordinates for 1Data hide and show error
+        receives and event from plotting plu-gins to store the data name and
+        their errors of y coordinates for 1Data hide and show error
         """
         self.err_dy = event.err_dy
 …
                       qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS):
         """
+            draw model in 2D
+            @param model: instance of the model to draw
+            @param description: the description of the model
+            @param enable2D: when True allows to draw model 2D
+            @param qmin: the minimum value to  draw model 2D
+            @param qmax: the maximum value to draw model 2D
+            @param qstep: the number of division of Qx and Qy of the model to draw
+        draw model in 2D
+        :param model: instance of the model to draw
+        :param description: the description of the model
+        :param enable2D: when True allows to draw model 2D
+        :param qmin: the minimum value to  draw model 2D
+        :param qmax: the maximum value to draw model 2D
+        :param qstep: the number of division of Qx and Qy of the model to draw
         """
 …
             wx.PostEvent( self.parent, StatusEvent(status= msg ))
     def _draw_model1D(self, model, data=None, smearer= None,
                 qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep= DEFAULT_NPTS,enable1D= True):
         """
+            Draw model 1D from loaded data1D
+            @param data: loaded data
+            @param model: the model to plot
+        Draw model 1D from loaded data1D
+        :param data: loaded data
+        :param model: the model to plot
         """
         x=  numpy.linspace(start= qmin,
 …
     def _cal_chisqr(self, data=None, index=None):
         """
             Get handy Chisqr using the output from draw1D and 2D,
             instead of calling expansive CalcChisqr in guithread
+        Get handy Chisqr using the output from draw1D and 2D,
+        instead of calling expansive CalcChisqr in guithread
         """
         # default chisqr
 …
 def profile(fn, *args, **kw):
     import cProfile, pstats, os
     global call_result
     def call():
         global call_result
         call_result = fn(*args, **kw)
     cProfile.runctx('call()', dict(call=call), {}, 'profile.out')
     stats = pstats.Stats('profile.out')
     #stats.sort_stats('time')
     stats.sort_stats('calls')
     stats.print_stats()
     os.unlink('profile.out')
     return call_result
+#def profile(fn, *args, **kw):
+#    import cProfile, pstats, os
+#    global call_result
+#    def call():
+#        global call_result
+#        call_result = fn(*args, **kw)
+#    cProfile.runctx('call()', dict(call=call), {}, 'profile.out')
+#    stats = pstats.Stats('profile.out')
+#    #stats.sort_stats('time')
+#    stats.sort_stats('calls')
+#    stats.print_stats()
+#    os.unlink('profile.out')
+#    return call_result
 if __name__ == "__main__":
     i = Plugin()

sansview/perspectives/fitting/help_panel.py

-                      r0df5d68
+                      r5062bbf
 #!/usr/bin/python
 import wx
 import wx.html as html
 from wx.lib.splitter import MultiSplitterWindow
 import os
-def help():
-    """
-        Provide general online help text
-        Future work: extend this function to allow topic selection
-    """
-    info_txt  = "The inversion approach is based on Moore, J. Appl. Cryst. (1980) 13, 168-175.\n\n"
-    info_txt += "P(r) is set to be equal to an expansion of base functions of the type "
-    info_txt += "phi_n(r) = 2*r*sin(pi*n*r/D_max). The coefficient of each base functions "
-    info_txt += "in the expansion is found by performing a least square fit with the "
-    info_txt += "following fit function:\n\n"
-    info_txt += "chi**2 = sum_i[ I_meas(q_i) - I_th(q_i) ]**2/error**2 + Reg_term\n\n"
-    info_txt += "where I_meas(q) is the measured scattering intensity and I_th(q) is "
-    info_txt += "the prediction from the Fourier transform of the P(r) expansion. "
-    info_txt += "The Reg_term term is a regularization term set to the second derivative "
-    info_txt += "d**2P(r)/dr**2 integrated over r. It is used to produce a smooth P(r) output.\n\n"
-    info_txt += "The following are user inputs:\n\n"
-    info_txt += "   - Number of terms: the number of base functions in the P(r) expansion.\n\n"
-    info_txt += "   - Regularization constant: a multiplicative constant to set the size of "
-    info_txt += "the regularization term.\n\n"
-    info_txt += "   - Maximum distance: the maximum distance between any two points in the system.\n"
-    return info_txt
-class HelpDialog(wx.Dialog):
-    def __init__(self, parent, id):
-        wx.Dialog.__init__(self, parent, id, size=(400, 420))
-        self.SetTitle("P(r) help")
-        vbox = wx.BoxSizer(wx.VERTICAL)
-        explanation = help()
-        label_explain = wx.StaticText(self, -1, explanation, size=(350,320))
-        vbox.Add(label_explain, 0, wx.ALL|wx.EXPAND, 15)
-        static_line = wx.StaticLine(self, -1)
-        vbox.Add(static_line, 0, wx.EXPAND, 0)
-        button_OK = wx.Button(self, wx.ID_OK, "OK")
-        sizer_button = wx.BoxSizer(wx.HORIZONTAL)
-        sizer_button.Add((20, 20), 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        sizer_button.Add(button_OK, 0, wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
-        vbox.Add(sizer_button, 0, wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
-        self.SetSizer(vbox)
-        self.SetAutoLayout(True)
-        self.Layout()
-        self.Centre()
 class HelpWindow(wx.Frame):
+    """
+    """
     def __init__(self, parent, id, title= 'HelpWindow', pageToOpen=None):
         wx.Frame.__init__(self, parent, id, title, size=(850, 500))
         """
              contains help info
+        contains help info
         """
 …
     def OnButtonClicked(self, event):
         """
             Function to diplay html page related to the hyperlinktext selected
+        Function to diplay html page related to the hyperlinktext selected
         """
-        #link= "media/modelfunction.html"
         self.rhelp.LoadPage("media/modelfunction.html")
     def OnLinkClicked(self, event):
         """
             Function to diplay html page related to the hyperlinktext selected
+        Function to diplay html page related to the hyperlinktext selected
         """
         link= event.GetLinkInfo().GetHref()
         self.rhelp.LoadPage(link)
+"""
+Example: ::
+class ViewApp(wx.App):
+    def OnInit(self):
+        frame = HelpWindow(None, -1, 'HelpWindow')
+        frame.Show(True)
+        self.SetTopWindow(frame)
+        return True
+    class ViewApp(wx.App):
+        def OnInit(self):
+            frame = HelpWindow(None, -1, 'HelpWindow')
+            frame.Show(True)
+            self.SetTopWindow(frame)
+            return True
+    if __name__ == "__main__":
+    app = ViewApp(0)
+    app.MainLoop()
+if __name__ == "__main__":
+    app = ViewApp(0)
+    app.MainLoop()
+"""

sansview/perspectives/fitting/hint_fitpage.py

-                      r533d38d
+                      r5062bbf
 import wx
 …
 class HintFitPage(wx.ScrolledWindow):
     """
         This class provide general structure of  fitpanel page
+    This class provide general structure of  fitpanel page
     """
      ## Internal name for the AUI manager
 …
     def __init__(self, parent):
+        """
+        """
         wx.ScrolledWindow.__init__(self, parent,
                  style= wx.FULL_REPAINT_ON_RESIZE )
 …
     def do_layout(self):
         """
             Draw the page
+        Draw the page
         """
         name="Hint"
 …
     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()
+        self.Show(True)
+if __name__=="__main__":
+    app = wx.App()
+    HelpWindow(None, -1, 'HelpWindow')
+    app.MainLoop()
+"""
+Example: ::
+    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()
+            self.Show(True)
+    if __name__=="__main__":
+        app = wx.App()
+        HelpWindow(None, -1, 'HelpWindow')
+        app.MainLoop()
+"""

sansview/perspectives/fitting/model_thread.py

-                      rf72333f
+                      r5062bbf
 import time
 from data_util.calcthread import CalcThread
 …
 import numpy,math
 from DataLoader.smearing_2d import Smearer2D
+import fitpage
 class Calc2D(CalcThread):
     """
+        Compute 2D model
+        This calculation assumes a 2-fold symmetry of the model
+        where points are computed for one half of the detector
+        and I(qx, qy) = I(-qx, -qy) is assumed.
+    """
+    Compute 2D model
+    This calculation assumes a 2-fold symmetry of the model
+    where points are computed for one half of the detector
+    and I(qx, qy) = I(-qx, -qy) is assumed.
+    """
     def __init__(self, x, y, data,model,smearer,qmin, qmax,qstep,
                  completefn = None,
 …
     def compute(self):
         """
             Compute the data given a model function
+        Compute the data given a model function
         """
         self.starttime = time.time()
 …
 class Calc1D(CalcThread):
+    """Compute 1D data"""
+    """
+    Compute 1D data
+    """
     def __init__(self, x, model,
                  data=None,
 …
                  worktime   = 0.01
                  ):
+        """
+        """
         CalcThread.__init__(self,completefn,
                  updatefn,
 …
     def compute(self):
         """
+            Compute model 1d value given qmin , qmax , x value
+        """
+        Compute model 1d value given qmin , qmax , x value
+        """
         self.starttime = time.time()
         output = numpy.zeros((len(self.x)))
 …
             output[index] = self.model.evalDistribution(self.x[index])
         elapsed = time.time()-self.starttime
+        elapsed = time.time() - self.starttime
         self.complete(x= self.x[index], y= output[index],
                       elapsed=elapsed,index=index, model= self.model, data=self.data)
+        self.complete(x=self.x[index], y=output[index],
+                      elapsed=elapsed,index=index, model=self.model,
+                                        data=self.data)
     def results(self):
         """
             Send resuts of the computation
+        Send resuts of the computation
         """
         return [self.out, self.index]
+class CalcCommandline:
+    def __init__(self, n=20000):
+        #print thread.get_ident()
+        from sans.models.CylinderModel import CylinderModel
+        model = CylinderModel()
+"""
+Example: ::
+    class CalcCommandline:
+        def __init__(self, n=20000):
+            #print thread.get_ident()
+            from sans.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,
+                                            completefn=self.complete,
+                                            updatefn=self.update ,
+                                            yieldtime=0.0)
+        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.queue()
+            calc_thread_2D.ready(2.5)
+            while not self.done:
+                time.sleep(1)
+        def update(self,output):
+            print "update"
+        calc_thread_2D = Calc2D(x, y, None, model.clone(),-qmax, qmax,qstep,
+                                        completefn=self.complete,
+                                        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, qstep ):
+        print "complete"
+        self.done = True
+if __name__ == "__main__":
+    CalcCommandline()
+        def complete(self, image, data, model, elapsed, qmin, qmax,index, qstep ):
+            print "complete"
+            self.done = True
+    if __name__ == "__main__":
+        CalcCommandline()
+"""

sansview/perspectives/fitting/models.py

-                      rce07fa8
+                      r5062bbf
-#TODO: add comments to document this module
-#TODO: clean-up the exception handling.
-#TODO: clean-up the FractalAbsModel and PowerLawAbsModel menu items. Those
-#      model definitions do not belong here. They belong with the rest of the
-#      models.
 import wx
 …
 def log(message):
+    """
+    """
     out = open("plugins.log", 'a')
     out.write("%10g:  %s\n" % (time.clock(), message))
 …
 def findModels():
+    """
+    """
     log("looking for models in: %s/plugins" % os.getcwd())
     if os.path.isdir('plugins'):
 …
 def _check_plugin(model, name):
     """
+        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
+    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 is the plugin is of type Model1DPlugin
 …
 def _findModels(dir):
+    """
+    """
     # List of plugin objects
     plugins = []
 …
 class ModelList(object):
     """
         Contains dictionary of model and their type
+    Contains dictionary of model and their type
     """
     def __init__(self):
+        self.mydict={}
+        """
+        """
+        self.mydict = {}
     def set_list(self, name, mylist):
         """
+            @param name: the type of the list
+            @param mylist: the list to add
+        :param name: the type of the list
+        :param mylist: the list to add
         """
         if name not in self.mydict.keys():
 …
     def get_list(self):
         """
          return all the list stored in a dictionary object
+        return all the list stored in a dictionary object
         """
         return self.mydict
 class ModelManager:
+    """
+    """
     ## external dict for models
     model_combobox = ModelList()
 …
     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
+        List of models we want to make available by default
+        for this application
+        :return: the next free event ID following the new menu events
         """
         ## form factor
 …
         from sans.models.HayterMSAStructure import HayterMSAStructure
         self.struct_list.append(HayterMSAStructure)
+        ##shape-independent models
+        ##shape-independent models
         from sans.models.PowerLawAbsModel import PowerLawAbsModel
         self.shape_indep_list.append( PowerLawAbsModel )
 …
         self.shape_indep_list.append(PorodModel )
         #FractalModel (a c-model)will be used.
         #from sans.models.FractalAbsModel import FractalAbsModel
 …
         from sans.models.LineModel import LineModel
         self.shape_indep_list.append(LineModel)
         #Looking for plugins
         self.plugins = findModels()
         return 0
 …
     def populate_menu(self, modelmenu, event_owner):
         """
+            Populate a menu with our models
+            @param id: first menu event ID to use when binding the menu events
+            @param modelmenu: wx.Menu object to populate
+            @param event_owner: wx object to bind the menu events to
+            @return: the next free event ID following the new menu events
+        Populate a menu with our models
+        :param id: first menu event ID to use when binding the menu events
+        :param modelmenu: wx.Menu object to populate
+        :param event_owner: wx object to bind the menu events to
+        :return: the next free event ID following the new menu events
         """
         ## Fill model lists
 …
         self.event_owner = event_owner
         shape_submenu = wx.Menu()
         shape_indep_submenu = wx.Menu()
 …
         multip_models = wx.Menu()
         ## create menu with shape
         self._fill_simple_menu( menuinfo = ["Shapes",shape_submenu," simple shape"],
                          list1 = self.shape_list )
         self._fill_simple_menu( menuinfo = ["Shape-Independent",shape_indep_submenu,
+        self._fill_simple_menu(menuinfo=["Shapes",shape_submenu," 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,
+                         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,
+                                list1=self.struct_list)
+        self._fill_plugin_menu(menuinfo=["Customized Models", added_models,
                                             "List of additional models"],
                                  list1= self.plugins )
+                                 list1=self.plugins)
         self._fill_menu(menuinfo=["P(Q)*S(Q)",multip_models,
                                   "mulplication of 2 models"],
+                                   list1 = self.multiplication_factor ,
+                                   list2 =  self.struct_list)
+                                   list1=self.multiplication_factor ,
+                                   list2= self.struct_list)
         return 0
     def _fill_plugin_menu(self,menuinfo, list1):
         """
             fill the plugin menu with costumized models
+    def _fill_plugin_menu(self, menuinfo, list1):
+        """
+        fill the plugin menu with costumized models
         """
         if len(list1)==0:
 …
         self._fill_simple_menu( menuinfo,list1)
+    def _fill_simple_menu(self,menuinfo, list1):
+        """
+            Fill the menu with list item
+            @param modelmenu: the menu to fill
+            @param menuinfo: submenu item for the first column of this modelmenu
+                             with info.Should be a list :
+                             [name(string) , menu(wx.menu), help(string)]
+            @param list1: contains item (form factor )to fill modelmenu second column
+    def _fill_simple_menu(self, menuinfo, list1):
+        """
+        Fill the menu with list item
+        :param modelmenu: the menu to fill
+        :param menuinfo: submenu item for the first column of this modelmenu
+                         with info.Should be a list :
+                         [name(string) , menu(wx.menu), help(string)]
+        :param list1: contains item (form factor )to fill modelmenu second column
         """
         if len(list1)>0:
 …
         self.modelmenu.AppendMenu(id, menuinfo[0],menuinfo[1],menuinfo[2])
+    def _fill_menu(self,menuinfo, list1,list2  ):
+        """
+            Fill the menu with list item
+            @param menuinfo: submenu item for the first column of this modelmenu
+                             with info.Should be a list :
+                             [name(string) , menu(wx.menu), help(string)]
+            @param list1: contains item (form factor )to fill modelmenu second column
+            @param list2: contains item (Structure factor )to fill modelmenu third column
+    def _fill_menu(self, menuinfo, list1, list2):
+        """
+        Fill the menu with list item
+        :param menuinfo: submenu item for the first column of this modelmenu
+                         with info.Should be a list :
+                         [name(string) , menu(wx.menu), help(string)]
+        :param list1: contains item (form factor )to fill modelmenu second column
+        :param list2: contains item (Structure factor )to fill modelmenu
+                third column
         """
         if len(list1)>0:
 …
         self.modelmenu.AppendMenu(id,menuinfo[0],menuinfo[1], menuinfo[2])
     def _on_model(self, evt):
         """
+            React to a model menu event
+            @param event: wx menu event
+        React to a model menu event
+        :param event: wx menu event
         """
         if int(evt.GetId()) in self.form_factor_dict.keys():
             from sans.models.MultiplicationModel import MultiplicationModel
             model1, model2 = self.form_factor_dict[int(evt.GetId())]
+            model = MultiplicationModel(model1, model2)
+            model = MultiplicationModel(model1, model2)
         else:
             model= self.struct_factor_dict[str(evt.GetId())]()
         evt = ModelEvent( model= model )
         wx.PostEvent(self.event_owner, evt)
     def get_model_list(self):
+        """ @ return dictionary of models for fitpanel use """
+        """
+        return dictionary of models for fitpanel use
+        """
         self.model_combobox.set_list("multiplication", self.multiplication_factor)
         return self.model_combobox

sansview/perspectives/fitting/pagestate.py

-                      r35b556d
+                      r5062bbf
+"""
+This software was developed by the University of Tennessee as part of the
+Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
+project funded by the US National Science Foundation.
+See the license text in license.txt
+copyright 2009, University of Tennessee
+"""
+################################################################################
+#This software was developed by the University of Tennessee as part of the
+#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
+#project funded by the US National Science Foundation.
+#
+#See the license text in license.txt
+#
+#copyright 2009, University of Tennessee
+################################################################################
 import time
 import os
 …
 class PageState(object):
     """
         Contains information to reconstruct a page of the fitpanel.
+    Contains information to reconstruct a page of the fitpanel.
     """
     def __init__(self, parent=None, model=None, data=None):
         """
+            Initialize the current state
+            @param model: a selected model within a page
+            @param data:
+        Initialize the current state
+        :param model: a selected model within a page
+        :param data:
         """
         self.file = None
 …
     def clone(self):
         """
             Create a new copy of the current object
+        Create a new copy of the current object
         """
         model = None
 …
     def _repr_helper(self, list, rep):
         """
             Helper method to print a state
+        Helper method to print a state
         """
         for item in list:
 …
     def __repr__(self):
         """
             output string for printing
+        output string for printing
         """
         rep = "\nState name: %s\n"%self.file
 …
     def _toXML_helper(self, list, element, newdoc):
         """
             Helper method to create xml file for saving state
+        Helper method to create xml file for saving state
         """
         for item in list:
 …
     def toXML(self, file="fitting_state.fitv", doc=None, entry_node=None):
         """
+            Writes the state of the InversionControl panel to file, as XML.
+            Compatible with standalone writing, or appending to an
+            already existing XML document. In that case, the XML document
+            is required. An optional entry node in the XML document may also be given.
+            @param file: file to write to
+            @param doc: XML document object [optional]
+            @param entry_node: XML node within the XML document at which we will append the data [optional]
+        Writes the state of the InversionControl panel to file, as XML.
+        Compatible with standalone writing, or appending to an
+        already existing XML document. In that case, the XML document
+        is required. An optional entry node in the XML document may also be given.
+        :param file: file to write to
+        :param doc: XML document object [optional]
+        :param entry_node: XML node within the XML document at which we will append the data [optional]
         """
         from xml.dom.minidom import getDOMImplementation
 …
     def _fromXML_helper(self, node, list):
         """
             Helper function to write state to xml
+        Helper function to write state to xml
         """
         for item in node:
 …
     def fromXML(self, file=None, node=None):
         """
+            Load fitting state from a file
+            @param file: .fitv file
+            @param node: node of a XML document to read from
+        Load fitting state from a file
+        :param file: .fitv file
+        :param node: node of a XML document to read from
         """
 …
 class Reader(CansasReader):
     """
         Class to load a .fitv fitting file
+    Class to load a .fitv fitting file
     """
     ## File type
 …
     def __init__(self, call_back=None, cansas=True):
         """
+            Initialize the call-back method to be called
+            after we load a file
+            @param call_back: call-back method
+            @param cansas:  True = files will be written/read in CanSAS format
+                            False = write CanSAS format
+        Initialize the call-back method to be called
+        after we load a file
+        :param call_back: call-back method
+        :param cansas:  True = files will be written/read in CanSAS format
+                        False = write CanSAS format
         """
 …
     def read(self, path):
         """
             Load a new P(r) inversion state from file
             @param path: file path
             @return: None
+        Load a new P(r) inversion state from file
+        :param path: file path
         """
         if self.cansas == True:
 …
     def _data2d_to_xml_doc(self, datainfo):
         """
+            Create an XML document to contain the content of a Data2D
+            @param datainfo: Data2D object
+        Create an XML document to contain the content of a Data2D
+        :param datainfo: Data2D object
         """
         if not issubclass(datainfo.__class__, Data2D):
 …
             for note in item.notes:
                 write_node(doc, node, "SASprocessnote", note)
         # Return the document, and the SASentry node associated with
         # the data we just wrote
         return doc, entry_node
     def _parse_state(self, entry):
         """
+            Read a fit result from an XML node
+            @param entry: XML node to read from
+            @return: PageState object
+        Read a fit result from an XML node
+        :param entry: XML node to read from
+        :return: PageState object
         """
         # Create an empty state
 …
     def _parse_entry_2d(self, dom):
         """
+            Parse a SASentry
+            @param node: SASentry node
+            @return: Data2D object
+        """
+        Parse a SASentry
+        :param node: SASentry node
+        :return: Data2D object
+        """
         data_info = Data2D()
 …
     def _read_cansas(self, path):
         """
+            Load data and P(r) information from a CanSAS XML file.
+            @param path: file path
+            @return: Data1D object if a single SASentry was found,
+                        or a list of Data1D objects if multiple entries were found,
+                        or None of nothing was found
+            @raise RuntimeError: when the file can't be opened
+            @raise ValueError: when the length of the data vectors are inconsistent
+        Load data and P(r) information from a CanSAS XML file.
+        :param path: file path
+        :return: Data1D object if a single SASentry was found,
+                    or a list of Data1D objects if multiple entries were found,
+                    or None of nothing was found
+        :raise RuntimeError: when the file can't be opened
+        :raise ValueError: when the length of the data vectors are inconsistent
         """
         output = []
 …
     def write(self, filename, datainfo=None, fitstate=None):
         """
+            Write the content of a Data1D as a CanSAS XML file
+            @param filename: name of the file to write
+            @param datainfo: Data1D object
+            @param fitstate: PageState object
+        Write the content of a Data1D as a CanSAS XML file
+        :param filename: name of the file to write
+        :param datainfo: Data1D object
+        :param fitstate: PageState object
         """
         # Sanity check
 …
             fitstate.toXML(file=filename)
+if __name__ == "__main__":
+    state = PageState(parent=None)
+    state.toXML()
+    print "state", state
+"""
+Example: ::
+    if __name__ == "__main__":
+        state = PageState(parent=None)
+        state.toXML()
+        print "state", state
+"""

sansview/perspectives/fitting/simfitpage.py

-                      r6e9976b
+                      r5062bbf
 def get_fittableParam( model):
     """
+        @return list of fittable parameters name of a model
+        @param model: the model used
+    return list of fittable parameters name of a model
+    :param model: the model used
     """
     fittable_param=[]
 …
 class SimultaneousFitPage(wx.ScrolledWindow):
     """
         Simultaneous fitting panel
         All that needs to be defined are the
         two data members window_name and window_caption
+    Simultaneous fitting panel
+    All that needs to be defined are the
+    two data members window_name and window_caption
     """
     ## Internal name for the AUI manager
 …
         wx.ScrolledWindow.__init__(self, parent,style= wx.FULL_REPAINT_ON_RESIZE )
         """
              Simultaneous page display
+        Simultaneous page display
         """
         ##Font size
 …
         self.set_layout()
     def define_page_structure(self):
         """
             Create empty sizer for a panel
+        Create empty sizer for a panel
         """
         self.vbox  = wx.BoxSizer(wx.VERTICAL)
 …
     def set_scroll(self):
+        """
+        """
         self.SetScrollbars(20,20,25,65)
         self.Layout()
 …
     def set_layout(self):
         """
              layout
+        layout
         """
         self.vbox.Layout()
         self.vbox.Fit(self)
         self.SetSizer(self.vbox)
         self.set_scroll()
         self.Centre()
 …
     def onRemove(self, event):
         """
             Remove constraint fields
+        Remove constraint fields
         """
         if len(self.constraints_list)==1:
 …
                 break
     def onFit(self,event):
+        """ signal for fitting"""
+        """
+        signal for fitting
+        """
         ## making sure all parameters content a constraint
         ## validity of the constraint expression is own by fit engine
 …
             wx.PostEvent(self.parent.Parent, StatusEvent(status= msg ))
     def set_manager(self, manager):
         """
+            set panel manager
+            @param manager: instance of plugin fitting
+        set panel manager
+        :param manager: instance of plugin fitting
         """
         self.manager = manager
     def check_all_model_name(self,event):
         """
             check all models names
+        check all models names
         """
         self.model_toFit=[]
 …
             self._hide_constraint()
     def check_model_name(self,event):
         """
             Save information related to checkbox and their states
+        Save information related to checkbox and their states
         """
         self.model_toFit=[]
 …
         else:
             self.cb1.SetValue(False)
     def draw_page(self):
         """
             Draw a sizer containing couples of data and model
+        Draw a sizer containing couples of data and model
         """
         self.model_list=[]
         self.model_toFit=[]
 …
                 self.manager.schedule_for_fit( value=0,fitproblem =item[1])
+        self.sizer1.Clear(True)
+        self.sizer1.Clear(True)
         box_description= wx.StaticBox(self, -1,"Fit Combinations")
         boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
         sizer_title = wx.BoxSizer(wx.HORIZONTAL)
         sizer_couples = wx.GridBagSizer(5,5)
         #------------------------------------------------------
         if len(self.page_finder)==0:
 …
             ## draw fit button
             self._fill_sizer_fit()
         #--------------------------------------------------------
         boxsizer1.Add(sizer_title, flag= wx.TOP|wx.BOTTOM,border=5)
 …
     def _store_model(self):
         """
             Store selected model
+         Store selected model
         """
         if len(self.model_toFit) < 2:
 …
             self.constraint_dict[page] = model
     def _display_constraint(self, event):
         """
             Show fields to add constraint
+        Show fields to add constraint
         """
         if len(self.model_toFit)< 2:
 …
            return
     def _show_constraint(self):
         """
             Show constraint fields
+        Show constraint fields
         """
         self.btAdd.Show(True)
 …
         btRemove.SetToolTipString("Remove constraint.")
         for page,model in self.constraint_dict.iteritems():
             ## check if all parameters have been selected for constraint
 …
         wx.EVT_COMBOBOX(model_cbox,-1, self._on_select_model)
         sizer_constraint.Add(model_cbox, flag= wx.RIGHT|wx.EXPAND,border=10)
         sizer_constraint.Add(param_cbox, flag= wx.RIGHT|wx.EXPAND,border=5)
 …
         ##[combobox1, combobox2,=,textcrtl, remove button ]
         self.constraints_list.append([model_cbox, param_cbox, egal_txt, ctl2,btRemove,sizer_constraint])
         self.nb_constraint += 1
         self.sizer_constraints.Layout()
 …
     def _hide_constraint(self):
         """
             hide buttons related constraint
+        hide buttons related constraint
         """
         for page in  self.page_finder.iterkeys():
 …
             self.btAdd.Hide()
         self._store_model()
         self.constraints_list=[]
         self.sizer_constraints.Clear(True)
 …
         self.SetScrollbars(20,20,25,65)
         self.AdjustScrollbars()
     def _on_select_model(self, event):
         """
          fill combox box with list of parameters
+        fill combox box with list of parameters
         """
         ##This way PC/MAC both work, instead of using event.GetClientData().
 …
         if length < 1:
             return
         param_cbox = self.constraints_list[length-1][1]
         param_cbox.Clear()
 …
         param_cbox.Show(True)
         self.sizer2.Layout()
         self.SetScrollbars(20,20,25,65)
     def _on_select_param(self, event):
         """
             Store the appropriate constraint in the page_finder
+        Store the appropriate constraint in the page_finder
         """
         ##This way PC/MAC both work, instead of using event.GetClientData().
 …
         ctl2 = self.constraints_list[length-1][3]
         ctl2.Show(True)
         #self.sizer2.Layout()
         self.SetScrollbars(20,20,25,65)
     def _onAdd_constraint(self, event):
         """
+            Add another line for constraint
+        """
+        Add another line for constraint
+        """
         if not self.show_constraint.GetValue():
             msg= " Select Yes to add Constraint "
             wx.PostEvent(self.parent.Parent, StatusEvent(status= msg ))
             return
         ## check that a constraint is added before allow to add another cosntraint
         for item in self.constraints_list:
             model_cbox = item[0]
 …
                 wx.PostEvent(self.parent.Parent, StatusEvent(status= msg ))
                 return
         ## some model or parameters can be constrained
         self._show_constraint()
 …
     def _fill_sizer_fit(self):
         """
             Draw fit fit button
+        Draw fit button
         """
         self.sizer3.Clear(True)
 …
     def _fill_sizer_constraint(self):
         """
             Fill sizer containing constraint info
         """
         msg= "Select at least 2 model to add constraint "
+        Fill sizer containing constraint info
+        """
+        msg = "Select at least 2 model to add constraint "
         wx.PostEvent(self.parent.Parent, StatusEvent(status= msg ))
         self.sizer2.Clear(True)
         box_description= wx.StaticBox(self, -1,"Fit Constraints")
         boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
 …
         self.hide_constraint = wx.RadioButton(self, -1, 'No', (10, 10), style=wx.RB_GROUP)
         self.show_constraint = wx.RadioButton(self, -1, 'Yes', (10, 30))
         self.Bind( wx.EVT_RADIOBUTTON, self._display_constraint,
                     id= self.hide_constraint.GetId() )
         self.Bind(  wx.EVT_RADIOBUTTON, self._display_constraint,
                          id= self.show_constraint.GetId()    )
 …
         self.btAdd.Hide()
         text_hint = wx.StaticText(self,-1,"Example: [M0][paramter] = M1.parameter")
         sizer_button.Add(text_hint, 0 , wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 10)
         sizer_button.Add(self.btAdd, 0, wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 10)
         boxsizer1.Add(sizer_title, flag= wx.TOP|wx.BOTTOM,border=10)
         boxsizer1.Add(self.sizer_constraints, flag= wx.TOP|wx.BOTTOM,border=10)
 …
         self.sizer2.Layout()
         self.SetScrollbars(20,20,25,65)
     def _set_constraint(self):
         """
             get values from the constrainst textcrtl ,parses them into model name
             parameter name and parameters values.
             store them in a list self.params .when when params is not empty set_model
             uses it to reset the appropriate model and its appropriates parameters
+        get values from the constrainst textcrtl ,parses them into model name
+        parameter name and parameters values.
+        store them in a list self.params .when when params is not empty set_model
+        uses it to reset the appropriate model and its appropriates parameters
         """
         for item in self.constraints_list:
             model = item[0].GetClientData(item[0].GetCurrentSelection())
             param = item[1].GetString(item[1].GetCurrentSelection())
 …
                     self.page_finder[page].set_model_param(param,constraint)
                     break
     def _fill_sizer_model_list(self,sizer):
         """
+            Receive a dictionary containing information to display model name
+            @param page_finder: the dictionary containing models information
+        Receive a dictionary containing information to display model name
+        :param page_finder: the dictionary containing models information
         """
         ix = 0
 …
         sizer.Add(new_name,(iy, ix),(1,1),
                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
+        ix +=2
+        ix += 2
         model_type = wx.StaticText(self, -1, '  Model Type')
         model_type.SetBackgroundColour('grey')
         sizer.Add(model_type,(iy, ix),(1,1),
                             wx.EXPAND|wx.ADJUST_MINSIZE, 0)
         ix +=1
+        ix += 1
         data_used = wx.StaticText(self, -1, '  Used Data')
         data_used.SetBackgroundColour('grey')
 …
                 wx.EVT_CHECKBOX(self, cb.GetId(), self.check_model_name)
                 ix +=2
+                ix += 2
                 type = model.__class__.__name__
                 model_type = wx.StaticText(self, -1, str(type))
                 sizer.Add(model_type,( iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
                 ix +=1
+                ix += 1
                 data = value.get_fit_data()
                 data_used= wx.StaticText(self, -1, str(data.name))
 …
             except:
                 pass
         iy +=1
+        iy += 1
         sizer.Add((20,20),( iy,ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
         sizer.Layout()
-class HelpWindow(wx.Frame):
-    def __init__(self, parent, id, title):
-        wx.Frame.__init__(self, parent, id, title, size=(570, 400))
-        page_finder ={}
-        ## create random data
-        from danse.common.plottools.plottables import Data1D
-        data= Data1D(x=[1,2], y=[3,4], dy=[0.1, 0,1])
-        data.name="mydata.txt"
-        ## create model
-        from sans.models.CylinderModel import CylinderModel
-        model = CylinderModel()
-        model.name="M0"
-        from fitproblem import FitProblem
-        page_finder["page"]= FitProblem()
-        ## fill the page_finder
-        page_finder["page"].add_fit_data(data)
-        page_finder["page"].set_model(model)
-        self.page = SimultaneousFitPage(self, page_finder=page_finder)
-        self.Centre()
-        self.Show(True)
-if __name__=="__main__":
-    app = wx.App()
-    HelpWindow(None, -1, 'HelpWindow')
-    app.MainLoop()

SasView

Changeset 5062bbf in sasview for sansview/perspectives/fitting

Legend:

sansview/perspectives/fitting/basepage.py

sansview/perspectives/fitting/console.py

sansview/perspectives/fitting/fit_thread.py

sansview/perspectives/fitting/fitpage.py

sansview/perspectives/fitting/fitpanel.py

sansview/perspectives/fitting/fitproblem.py

sansview/perspectives/fitting/fitting.py

sansview/perspectives/fitting/help_panel.py

sansview/perspectives/fitting/hint_fitpage.py

sansview/perspectives/fitting/model_thread.py

sansview/perspectives/fitting/models.py

sansview/perspectives/fitting/pagestate.py

sansview/perspectives/fitting/simfitpage.py

Download in other formats: