Index: nsview/perspectives/fitting/Copy of fitting.py
===================================================================
--- sansview/perspectives/fitting/Copy of fitting.py	(revision 2140e68d04b8406b34c5c4a54bdf7cc8706f5f70)
+++ 	(revision )
@@ -1,1080 +1,0 @@
-import  re
-import sys, wx, logging
-import string, numpy, math
-
-from copy import deepcopy 
-from danse.common.plottools.plottables import Data1D, Theory1D,Data2D
-from danse.common.plottools.PlotPanel import PlotPanel
-from sans.guicomm.events import NewPlotEvent, StatusEvent  
-from sans.guicomm.events import EVT_SLICER_PANEL,ERR_DATA
-
-from sans.fit.AbstractFitEngine import Model,FitData1D,FitData2D#,Data,
-from fitproblem import FitProblem
-from fitpanel import FitPanel
-from fit_thread import FitThread
-import models
-import fitpage
-
-DEFAULT_BEAM = 0.005
-DEFAULT_QMIN = 0.0
-DEFAULT_QMAX = 0.1
-DEFAULT_NPTS = 50
-import time
-import thread
-class PlotInfo:
-    """
-        store some plotting field
-    """
-    _xunit = 'A^{-1}'
-    _xaxis= "\\rm{Q}"
-    _yunit = "cm^{-1}"
-    _yaxis= "\\rm{Intensity} "
-    id = "Model"
-    group_id = "Model"
-    title= None
-    info= None
-    
-    
-class Plugin:
-    """
-        Fitting plugin is used to perform fit 
-    """
-    def __init__(self):
-        ## Plug-in name
-        self.sub_menu = "Fitting"
-        
-        ## Reference to the parent window
-        self.parent = None
-        #Provide list of models existing in the application
-        self.menu_mng = models.ModelManager()
-        ## List of panels for the simulation perspective (names)
-        self.perspective = []
-        #list of panel to send to guiframe
-        self.mypanels=[]
-        # reference to the current running thread
-        self.calc_2D= None
-        self.calc_1D= None
-        self.calc_fit= None
-        
-        # Start with a good default
-        self.elapsed = 0.022
-        # the type of optimizer selected, park or scipy
-        self.fitter  = None
-        #Flag to let the plug-in know that it is running stand alone
-        self.standalone=True
-        ## Fit engine
-        self._fit_engine = 'scipy'
-        #List of selected data
-        self.selected_data_list=[]
-        # Log startup
-        logging.info("Fitting plug-in started")   
-        # model 2D view
-        self.model2D_id=None
-        #keep reference of the simultaneous fit page
-        self.sim_page=None
-        #dictionary containing data name and error on dy of that data 
-        self.err_dy={}
-        
-   
-        
-    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
-        """
-        #Menu for fitting
-        self.menu1 = wx.Menu()
-        id1 = wx.NewId()
-        self.menu1.Append(id1, '&Simultaneous')
-        wx.EVT_MENU(owner, id1, self.on_add_sim_page)
-        self.menu1.AppendSeparator()
-        #Set park engine
-        id3 = wx.NewId()
-        scipy_help= "Scipy Engine: Perform Simple fit. More in Help window...."
-        self.menu1.Append(id3, "Scipy",scipy_help) 
-        wx.EVT_MENU(owner, id3,  self._onset_engine_scipy)
-        self.menu1.AppendSeparator()
-        id3 = wx.NewId()
-        park_help = "Park Engine: Perform Complex fit. More in Help window...."
-        self.menu1.Append(id3, "park",park_help) 
-        wx.EVT_MENU(owner, id3,  self._onset_engine_park)
-        
-        #menu for model
-        menu2 = wx.Menu()
-    
-        self.menu_mng.populate_menu(menu2, owner)
-        id2 = wx.NewId()
-        owner.Bind(models.EVT_MODEL,self._on_model_menu)
-      
-        self.fit_panel.set_owner(owner)
-        self.fit_panel.set_model_list(self.menu_mng.get_model_list())
-        owner.Bind(fitpage.EVT_MODEL_BOX,self._on_model_panel)
-        
-        #create  menubar items
-        return [(id, self.menu1, "Fitting"),(id2, menu2, "Model")]
-    
-    def on_add_sim_page(self, event):
-        """
-            Create a page to access simultaneous fit option
-        """
-        self.sim_page= self.fit_panel.add_sim_page()
-        self.sim_page.draw_page(self.page_finder)
-        
-        
-    def help(self, evt):
-        """
-            Show a general help dialog. 
-            TODO: replace the text with a nice image
-        """
-        from helpPanel import  HelpWindow
-        frame = HelpWindow(None, -1, 'HelpWindow')    
-        frame.Show(True)
-        
-        
-    def get_context_menu(self, graph=None):
-        """
-            Get the context menu items available for P(r)
-            @param graph: the Graph object to which we attach the context menu
-            @return: a list of menu items with call-back function
-        """
-        self.graph=graph
-        for item in graph.plottables:
-            if item.__class__.__name__ is "Data2D":
-                return [["Select data  for Fitting",\
-                          "Dialog with fitting parameters ", self._onSelect]] 
-            else:
-               
-                if item.name==graph.selected_plottable :
-                    if not hasattr(item, "group_id"):
-                        return []
-                    return [["Select data  for Fitting", \
-                             "Dialog with fitting parameters ", self._onSelect]] 
-        return []   
-
-
-    def get_panels(self, parent):
-        """
-            Create and return a list of panel objects
-        """
-        self.parent = parent
-        # Creation of the fit panel
-        self.fit_panel = FitPanel(self.parent, -1)
-        #Set the manager for the main panel
-        self.fit_panel.set_manager(self)
-        # List of windows used for the perspective
-        self.perspective = []
-        self.perspective.append(self.fit_panel.window_name)
-        # take care of saving  data, model and page associated with each other
-        self.page_finder = {}
-        #index number to create random model name
-        self.index_model = 0
-        self.index_theory= 0
-        self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event)
-        self.parent.Bind( ERR_DATA, self._on_data_error)
-        
-        #Send the fitting panel to guiframe
-        self.mypanels.append(self.fit_panel)
-        return self.mypanels
-
-        
-      
-    def get_perspective(self):
-        """
-            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.
-        """
-        self.parent.set_perspective(self.perspective)
-    
-    
-    def post_init(self):
-        """
-            Post initialization call back to close the loose ends
-            [Somehow openGL needs this call]
-        """
-        self.parent.set_perspective(self.perspective)
-
-
-    def copy_data(self, item, dy):
-        """
-            receive a data 1D and the list of errors on dy
-            and create a new data1D data
-            @param return 
-        """
-        detector=None
-        source=None
-        dxl=None
-        dxw=None
-        if hasattr(item, "dxl"):
-            dxl = item.dxl
-        if hasattr(item, "dxw"):
-            dxw = item.dxw
-        if hasattr(item, "detector"):
-            detector =item.detector
-        if hasattr(item, "source"):
-            source =item.source
-        from sans.guiframe import dataFitting 
-        data= dataFitting.Data1D(x=item.x, y=item.y, dy=dy, dxl=dxl, dxw=dxw)
-        data.name=item.name
-        data.detector=detector
-        data.source= source
-        return data
-
-
-   
-                    
-    def schedule_for_fit(self,value=0,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
-        """   
-        if fitproblem !=None:
-            fitproblem.schedule_tofit(value)
-        else:
-            current_pg=self.fit_panel.get_current_page() 
-            for page, val in self.page_finder.iteritems():
-                if page ==current_pg :
-                    val.schedule_tofit(value)
-                    break
-                      
-                    
-    def get_page_finder(self):
-        """ @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.
-        """  
-        sim_page= self.sim_page
-        for page, value in self.page_finder.iteritems():
-            if page != sim_page:
-                list=value.get_model()
-                model = list[0]
-                if model.name== modelname:
-                    value.set_model_param(names,values)
-                    break
-
-   
-                            
-    def split_string(self,item): 
-        """
-            receive a word containing dot and split it. used to split parameterset
-            name into model name and parameter name example:
-            paramaterset (item) = M1.A
-            @return model_name =M1 , parameter name =A
-        """
-        if string.find(item,".")!=-1:
-            param_names= re.split("\.",item)
-            model_name=param_names[0]
-            param_name=param_names[1]  
-            return model_name,param_name
-        
-   
-    def stop_fit(self):
-        """
-            Stop the fit engine
-        """
-        if self.calc_fit!= None and self.calc_thread.isrunning():
-            self.calc_thread.stop()
-            wx.PostEvent(self.parent, StatusEvent(status="Fitting  \
-                is cancelled" , type="stop"))
-            
-      
-    def on_single_fit(self,id=None,qmin=None, qmax=None):
-        """ 
-            perform fit for the  current page  and return chisqr,out and cov
-            @param engineName: type of fit to be performed
-            @param id: unique id corresponding to a fit problem(model, set of data)
-            @param model: model to fit
-            
-        """
-        #set an engine to perform fit
-        from sans.fit.Fitting import Fit
-        self.fitter = Fit(self._fit_engine)
-        #Setting an id to store model and data in fit engine
-        self.fit_id = 0
-        if id!=None:
-            self.fit_id = id
-        
-        page_fitted = None
-        fit_problem = None
-        #Get information (model , data) related to the page on 
-        #with the fit will be perform
-        current_pg= self.fit_panel.get_current_page() 
-        simul_pg= self.sim_page
-        pars=[]   
-        ## Check that the current page is different from self.sim_page
-        if current_pg != simul_pg:
-            value = self.page_finder[current_pg]
-            metadata =  value.get_fit_data()
-            list = value.get_model()
-            model = list[0]
-            smearer = value.get_smearer()
-           
-            #Create list of parameters for fitting used
-            templist=[]
-            try:
-                ## get the list of parameter names to fit
-                templist = current_pg.get_param_list()
-            
-                for element in templist:
-                    pars.append(str(element[1]))
-    
-                pars.sort()
-                #Do the single fit
-                self.fitter.set_model(Model(model), self.fit_id, pars)
-                dy=[]
-                x=[]
-                y=[]
-                ## checking the validity of error
-                if metadata.__class__ in  ["Data1D","Theory1D"]:
-                    for i in range(len(metadata.dy)):
-                        if metadata.dy[i] !=0:
-                            dy.append(metadata.dy[i])
-                            x.append(metadata.x[i])
-                            y.append(metadata.y[i])
-                    if len(dy)>0:        
-                        metadata.dy=numpy.zeros(len(dy))
-                        metadata.dy=dy
-                        metadata.y=numpy.zeros(len(y))
-                        metadata.y=y
-                        metadata.x=numpy.zeros(len(x))
-                        metadata.x=x
-               
-                self.fitter.set_data(data=metadata,Uid=self.fit_id,
-                                     smearer=smearer,qmin= qmin,qmax=qmax )
-                
-                self.fitter.select_problem_for_fit(Uid= self.fit_id,
-                                                   value= value.get_scheduled())
-                page_fitted=current_pg
-               
-            except:
-                msg= "Single Fit error: %s" % sys.exc_value
-                wx.PostEvent(self.parent, StatusEvent(status= msg ))
-                return
-            # make sure to keep an alphabetic order 
-            #of parameter names in the list      
-            try:
-                ## If a thread is already started, stop it
-                if self.calc_fit!= None and self.calc_fit.isrunning():
-                    self.calc_fit.stop()
-                        
-                self.calc_fit=FitThread(parent =self.parent,
-                                            fn= self.fitter,
-                                            pars= pars,
-                                            cpage= page_fitted,
-                                           qmin=qmin,
-                                           qmax=qmax,
-                                          
-                                           completefn=self._single_fit_completed,
-                                           updatefn=None)
-                self.calc_fit.queue()
-                self.calc_fit.ready(2.5)
-             
-            except:
-                wx.PostEvent(self.parent, StatusEvent(status="Single Fit error: %s" % sys.exc_value))
-                return
-         
-    def on_simul_fit(self, id=None,qmin=None,qmax=None):
-        """ 
-            perform fit for all the pages selected on simpage and return chisqr,out and cov
-            @param engineName: type of fit to be performed
-            @param id: unique id corresponding to a fit problem(model, set of data)
-             in park_integration
-            @param model: model to fit
-            
-        """
-        ##Setting an id to store model and data
-        self.fit_id= 0
-        #Setting an id to store model and data
-        if id!=None:
-             self.fit_id= id
-        ##  count the number of fitproblem schedule to fit 
-        fitproblem_count= 0
-        for value in self.page_finder.itervalues():
-            if value.get_scheduled()==1:
-                fitproblem_count += 1
-        ## if simultaneous fit change automatically the engine to park
-        if fitproblem_count >1:
-            self._on_change_engine(engine='park')
-        from sans.fit.Fitting import Fit
-        self.fitter= Fit(self._fit_engine)
-        
-        
-        for page, value in self.page_finder.iteritems():
-            try:
-                if value.get_scheduled()==1:
-                    metadata = value.get_fit_data()
-                    list = value.get_model()
-                    model= list[0]
-                    ## store page
-                    cpage= page
-                    #Get list of parameters name to fit
-                    pars = []
-                    templist = []
-                    templist = page.get_param_list()
-                    for element in templist:
-                        try:
-                            name = str(element[0].GetLabelText())
-                            pars.append(name)
-                        except:
-                            wx.PostEvent(self.parent, StatusEvent(status="Simultaneous Fit error: %s" % sys.exc_value))
-                            return
-                    ## create a park model and reset parameter value if constraint
-                    ## is given
-                    new_model=Model(model)
-                    param=value.get_model_param()
-                    
-                    if len(param)>0:
-                        for item in param:
-                            param_value = item[1]
-                            param_name = item[0]
-    
-                            new_model.parameterset[ param_name].set( param_value )
-                        
-                    self.fitter.set_model(new_model, self.fit_id, pars) 
-                    ## check that non -zero value are send as dy in the fit engine
-                    dy=[]
-                    x=[]
-                    y=[]
-                    if metadata.__class__ in  ["Data1D","Theory1D"]:
-                        for i in range(len(metadata.dy)):
-                            if metadata.dy[i] !=0:
-                                dy.append(metadata.dy[i])
-                                x.append(metadata.x[i])
-                                y.append(metadata.y[i])
-                            if len(dy)>0:        
-                                metadata.dy=numpy.zeros(len(dy))
-                                metadata.dy=dy
-                                metadata.y=numpy.zeros(len(y))
-                                metadata.y=y
-                                metadata.x=numpy.zeros(len(x))
-                                metadata.x=x
-                                
-                    self.fitter.set_data(metadata,self.fit_id,qmin,qmax)
-                    self.fitter.select_problem_for_fit(Uid= self.fit_id,
-                                                       value= value.get_scheduled())
-                    self.fit_id += 1 
-                    value.clear_model_param()
-                   
-            except:
-                msg= "Simultaneous Fit error: %s" % sys.exc_value
-                wx.PostEvent(self.parent, StatusEvent(status= msg ))
-                return 
-            
-        #Do the simultaneous fit
-        try:
-            ## If a thread is already started, stop it
-            if self.calc_fit!= None and self.calc_fit.isrunning():
-                self.calc_fit.stop()
-			## perform single fit
-            if  fitproblem_count==1:
-                self.calc_fit=FitThread(parent =self.parent,
-                                        fn= self.fitter,
-                                       qmin=qmin,
-                                       qmax=qmax,
-                                       ymin= ymin,
-                                       ymax= ymax,
-                                       cpage=cpage,
-                                       pars= pars,
-                                       completefn= self._simul_fit_completed,
-                                       updatefn=None)
-                      
-            else:
-                ## Perform more than 1 fit at the time
-                self.calc_fit=FitThread(parent =self.parent,
-                                        fn= self.fitter,
-                                       qmin=qmin,
-                                       qmax=qmax,
-                                       ymin= ymin,
-                                       ymax= ymax,
-                                       completefn= self._simul_fit_completed,
-                                       updatefn=None)
-            self.calc_fit.queue()
-            self.calc_fit.ready(2.5)
-            
-        except:
-            msg= "Simultaneous Fit error: %s" % sys.exc_value
-            wx.PostEvent(self.parent, StatusEvent(status= msg ))
-            return
-      
-    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
-        """   
-        current_pg=self.fit_panel.get_current_page()
-        self.page_finder[current_pg].set_smearer(smearer)
-        ## draw model 1D with smeared data
-        data =  self.page_finder[current_pg].get_plotted_data()
-        list = self.page_finder[current_pg].get_model()
-        ## if user has already selected a model to plot
-        ## redraw the model with data smeared
-        if len(list)>0:
-            model = list[0]
-            smearer =self.page_finder[current_pg].get_smearer()
-            if smearer != None:
-                self.draw_model( model=model, data= data, smearer= smearer,
-                    qmin= qmin, qmax= qmax)
-    
-    
-    
-    def draw_model(self, model, data= None,smearer= None,
-                   enable1D= True, enable2D= False,
-                   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 1D with no loaded data
-        self._draw_model1D( model= model, data= data,enable1D=enable1D, smearer= smearer,
-                           qmin= qmin, qmax= qmax, qstep= qstep )
-        ## draw model 2D with no initial data
-        self._draw_model2D(model=model,
-                           data = data,
-                           enable2D= enable2D,
-                           qmin=qmin,
-                           qmax=qmax,
-                           qstep=qstep)
-          
-  
-  
-    def _onSelect(self,event):
-        """ 
-            when Select data to fit a new page is created .Its reference is 
-            added to self.page_finder
-        """
-        self.panel = event.GetEventObject()
-        for item in self.panel.graph.plottables:
-            if item.name == self.panel.graph.selected_plottable:
-                ## put the errors values back to the model if the errors were hiden
-                ## before sending them to the fit engine
-                if len(self.err_dy)>0:
-                    if item.name in  self.err_dy.iterkeys():
-                        dy= self.err_dy[item.name]
-                        data= self.copy_data(item, dy)
-                    else:
-                        data= item
-                else:
-                    if item.dy==None:
-                        dy= numpy.zeros(len(item.y))
-                        dy[dy==0]=1
-                        data= self.copy_data(item, dy)
-                    else:
-                        data= item
-            else:
-                data= item
-            ## create anew page                   
-            if item.name == self.panel.graph.selected_plottable or\
-                 item.__class__.__name__ is "Data2D":
-                try:
-                    page = self.fit_panel.add_fit_page(data)
-                    # add data associated to the page created
-                    if page !=None:   
-                        #create a fitproblem storing all link to data,model,page creation
-                        self.page_finder[page]= FitProblem()
-                        ## item is almost the same as data but contains
-                        ## axis info for plotting 
-                        self.page_finder[page].add_plotted_data(item)
-                        self.page_finder[page].add_fit_data(data)
-                        
-                        wx.PostEvent(self.parent, StatusEvent(status="Page Created"))
-                    else:
-                        wx.PostEvent(self.parent, StatusEvent(status="Page was already Created"))
-                except:
-                    wx.PostEvent(self.parent, StatusEvent(status="Creating Fit page: %s"\
-                    %sys.exc_value))
-                    return
-    
-    def _single_fit_completed(self,result,pars,cpage,qmin,qmax,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
-          
-        """
-        wx.PostEvent(self.parent, StatusEvent(status="Single fit \
-        complete! " , type="stop"))
-        try:
-            for page, value in self.page_finder.iteritems():
-                if page==cpage :
-                    list = value.get_model()
-                    model= list[0]
-                    break
-            i = 0
-            for name in pars:
-                if result.pvec.__class__==numpy.float64:
-                    model.setParam(name,result.pvec)
-                else:
-                    model.setParam(name,result.pvec[i])
-                    i += 1
-            ## Reset values of the current page to fit result
-            cpage.onsetValues(result.fitness, result.pvec,result.stderr)
-            ## plot the current model with new param
-            metadata =  self.page_finder[cpage].get_fit_data()
-            list = self.page_finder[cpage].get_model()
-            model = list[0]
-            self.draw_model( model=model, data= metadata,qmin= qmin, qmax= qmax)
-            
-        except:
-            msg= "Single Fit completed but Following error occurred:"
-            wx.PostEvent(self.parent, StatusEvent(status="%s %s" % (msg, sys.exc_value)))
-            return
-       
-       
-    def _simul_fit_completed(self,result,qmin,qmax, elapsed,pars=None,cpage=None,
-                             xmin=None, xmax=None, ymin=None, ymax=None):
-        """
-            Parameter estimation completed, 
-            display the results to the user
-            @param alpha: estimated best alpha
-            @param elapsed: computation time
-        """
-        if cpage!=None:
-            self._single_fit_completed(result=result,pars=pars,cpage=cpage,
-                                       qmin=qmin,qmax=qmax,
-                              ymin=ymin, ymax=ymax, xmin=xmin, xmax=xmax)
-            return
-        else:
-            wx.PostEvent(self.parent, StatusEvent(status="Simultaneous fit \
-            complete ", type="stop"))
-            ## fit more than 1 model at the same time 
-            try:
-                for page, value in self.page_finder.iteritems():
-                    if value.get_scheduled()==1:
-                        list = value.get_model()
-                        model= list[0]
-                       
-                        small_out = []
-                        small_cov = []
-                        i = 0
-                        #Separate result in to data corresponding to each page
-                        for p in result.parameters:
-                            model_name,param_name = self.split_string(p.name)  
-                            if model.name == model_name:
-                                small_out.append(p.value )
-                                if p.stderr==None:
-                                    p.stderr=numpy.nan
-                                small_cov.append(p.stderr)
-                                model.setParam(param_name,p.value)  
-                                
-                        # Display result on each page 
-                        page.onsetValues(result.fitness, small_out,small_cov)
-                        #Replot models
-                        msg= "Single Fit completed plotting %s:"%model.name
-                        wx.PostEvent(self.parent, StatusEvent(status="%s " % msg))
-                        self.plot_helper(currpage= page,qmin= qmin,qmax= qmax,
-                                         xmin=xmin, xmax=xmax,
-                                         ymin=ymin, ymax=ymax) 
-            except:
-                 msg= "Simultaneous Fit completed but Following error occurred: "
-                 wx.PostEvent(self.parent, StatusEvent(status="%s%s" %(msg,sys.exc_value)))
-                 return 
-             
-                           
-        
-    def _on_show_panel(self, event):
-        print "_on_show_panel: fitting"
-      
-      
-    def _onset_engine_park(self,event):
-        """ 
-            set engine to park
-        """
-        self._on_change_engine('park')
-       
-       
-    def _onset_engine_scipy(self,event):
-        """ 
-            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:
-            new_panel = event.panel
-            # Set group ID if available
-            event_id = self.parent.popup_panel(new_panel)
-            self.menu1.Append(event_id, new_panel.window_caption, 
-                             "Show %s plot panel" % new_panel.window_caption)
-            # Set UID to allow us to reference the panel later
-            new_panel.uid = event_id
-            new_panel
-            self.mypanels.append(new_panel) 
-        return    
-    
-    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
-        """
-        self._fit_engine = engine
-        wx.PostEvent(self.parent, StatusEvent(status="Engine set to: %s" % self._fit_engine))
-   
-   
-    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
-        """
-        model = evt.model
-        if model ==None:
-            return
-       
-        sim_page=self.sim_page
-        current_pg = self.fit_panel.get_current_page() 
-        ## make sure nothing is done on self.sim_page
-        ## example trying to call set_panel on self.sim_page
-        if current_pg != sim_page:
-           
-            if self.page_finder[current_pg].get_model()== None :
-                
-                model.name="M"+str(self.index_model)
-                self.index_model += 1  
-            else:
-                
-                model.name= self.page_finder[current_pg].get_model().name
-                
-           
-            metadata = self.page_finder[current_pg].get_plotted_data()
-            
-            # save the name containing the data name with the appropriate model
-            self.page_finder[current_pg].set_model(model)
-            print "wwent hete",model.name
-            # save model name
-            self.draw_model( model=model, data= metadata)
-            
-            if self.sim_page!=None:
-                self.sim_page.draw_page(self.page_finder)
-        
-        
-  
-    def _on_model_menu(self, evt):
-        """
-            Plot a theory from a model selected from the menu
-            @param evt: wx.menu event
-        """
-        name = evt.model.__class__.__name__
-        if hasattr(evt.model, "name"):
-            name = evt.model.name
-        model=evt.model
-        description=model.description
-        
-        # Create a model page. If a new page is created, the model
-        # will be plotted automatically. If a page already exists,
-        # the content will be updated and the plot refreshed
-        self.fit_panel.add_model_page(model,description,name,topmenu=True)
-    
-   
-    
-    
-    def _update1D(self,x, output):
-        """
-            Update the output of plotting model 1D
-        """
-        self.calc_thread.ready(1)
-    
-    def _fill_default_model2D(self, theory, qmax,qstep, qmin=None):
-        """
-            fill Data2D with default value 
-            @param theory: Data2D to fill
-        """
-        from DataLoader.data_info import Detector, Source
-        
-        detector = Detector()
-        theory.detector.append(detector) 
-            
-        theory.detector[0].distance=1e+32
-        theory.source= Source()
-        theory.source.wavelength=2*math.pi/1e+32
-      
-        ## Create detector for Model 2D
-        xmax=2*theory.detector[0].distance*math.atan(\
-                            qmax/(4*math.pi/theory.source.wavelength))
-        
-        theory.detector[0].pixel_size.x= xmax/(qstep/2-0.5)
-        theory.detector[0].pixel_size.y= xmax/(qstep/2-0.5)
-        theory.detector[0].beam_center.x= qmax
-        theory.detector[0].beam_center.y= qmax
-        ## create x_bins and y_bins of the model 2D
-        distance   = theory.detector[0].distance
-        pixel      = qstep/2-1
-        theta      = pixel / distance / qstep#100.0
-        wavelength = theory.source.wavelength
-        pixel_width_x = theory.detector[0].pixel_size.x
-        pixel_width_y = theory.detector[0].pixel_size.y
-        center_x      = theory.detector[0].beam_center.x/pixel_width_x
-        center_y      = theory.detector[0].beam_center.y/pixel_width_y
-        
-        
-        size_x, size_y= numpy.shape(theory.data)
-        for i_x in range(size_x):
-            theta = (i_x-center_x)*pixel_width_x / distance 
-            qx = 4.0*math.pi/wavelength * math.tan(theta/2.0)
-            theory.x_bins.append(qx)    
-        for i_y in range(size_y):
-            theta = (i_y-center_y)*pixel_width_y / distance 
-            qy =4.0*math.pi/wavelength * math.tan(theta/2.0)
-            theory.y_bins.append(qy)
-           
-        theory.group_id ="Model"
-        theory.id ="Model"
-        ## determine plot boundaries
-        theory.xmin= -qmax
-        theory.xmax= qmax
-        theory.ymin= -qmax
-        theory.ymax= qmax
-        
-        
-    def _get_plotting_info(self, data=None):
-        """
-            get plotting info from data if data !=None
-            else use some default
-        """
-        my_info = PlotInfo()
-        if data !=None:
-            if hasattr(data,"info"):
-                x_name, x_units = data.get_xaxis() 
-                y_name, y_units = data.get_yaxis() 
-                
-                my_info._xunit = x_units
-                my_info._xaxis = x_name
-                my_info._yunit = y_units
-                my_info._yaxis = y_name
-                
-            my_info.title= data.name
-            if hasattr(data, "info"):
-                my_info.info= data.info
-            if hasattr(data, "group_id"):
-                my_info.group_id= data.group_id
-            
-        return my_info
-                
-    def _complete1D(self, x,y, elapsed,model,data=None):
-        """
-            Complete plotting 1D data
-        """ 
-        try:
-            new_plot = Theory1D(x=x, y=y)
-            my_info = self._get_plotting_info( data)
-            new_plot.name = model.name
-            new_plot.id = my_info.id
-            new_plot.group_id = my_info.group_id
-            
-            new_plot.xaxis( my_info._xaxis,  my_info._xunit)
-            new_plot.yaxis( my_info._yaxis, my_info._yunit)
-            
-            # Pass the reset flag to let the plotting event handler
-            # know that we are replacing the whole plot
-            title= my_info.title
-            if title== None:
-                title="Analytical model 1D "
-                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
-                             title= str(title), reset=True ))
-            else:
-                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
-                             title= str(title)))
-            
-        except:
-            msg= " Error occurred when drawing %s Model 1D: "%new_plot.name
-            msg+= " %s"%sys.exc_value
-            wx.PostEvent( self.parent, StatusEvent(status= msg ))
-            return  
-        
-                 
-    
-        
-    def _update2D(self, output,time=None):
-        """
-            Update the output of plotting model
-        """
-        wx.PostEvent(self.parent, StatusEvent(status="Plot \
-        #updating ... ",type="update"))
-        self.calc_thread.ready(0.01)
-        
-        
-    def _complete2D(self, image,data, model,  elapsed,qmin, qmax,qstep=DEFAULT_NPTS):
-        """
-            Complete get the result of modelthread and create model 2D
-            that can be plot.
-        """
-        msg = "Calc complete !"
-        wx.PostEvent( self.parent, StatusEvent( status= msg , type="stop" ))
-    
-        err_image = numpy.zeros(numpy.shape(image))
-        err_image[err_image==0]= 1
-        theory= Data2D(image= image , err_image= err_image)
-        theory.name= model.name
-        
-        if data ==None:
-            self._fill_default_model2D(theory= theory, qmax=qmax,qstep=qstep, qmin= qmin)
-        
-        else:
-            theory.id= "Model"
-            theory.group_id= "Model"+data.name
-            theory.x_bins= data.x_bins
-            theory.y_bins= data.y_bins
-            theory.detector= data.detector
-            theory.source= data.source
-            
-            ## plot boundaries
-            theory.ymin= data.ymin
-            theory.ymax= data.ymax
-            theory.xmin= data.xmin
-            theory.xmax= data.xmax
-        
-        ## plot
-        wx.PostEvent(self.parent, NewPlotEvent(plot=theory,
-                         title="Analytical model 2D ", reset=True ))
-         
-    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
-        """
-        self.err_dy= event.err_dy
-         
-    def _draw_model2D(self,model,data=None,description=None, enable2D=False,
-                      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
-            
-        """
-        
-        x=  numpy.linspace(start= -1*qmax,
-                               stop= qmax,
-                               num= qstep,
-                               endpoint=True )  
-        y = numpy.linspace(start= -1*qmax,
-                               stop= qmax,
-                               num= qstep,
-                               endpoint=True )
-        ## use data info instead
-        if data !=None:
-            ## check if data2D to plot
-            if hasattr(data, "x_bins"):
-                enable2D = True
-                x= data.x_bins
-                y= data.y_bins
-            
-        if not enable2D:
-            return
-        try:
-            from model_thread import Calc2D
-            ## If a thread is already started, stop it
-            if self.calc_2D != None and self.calc_2D.isrunning():
-                self.calc_2D.stop()
-            self.calc_2D = Calc2D(  x= x,
-                                    y= y,
-                                    model= model, 
-                                    data = data,
-                                    qmin= qmin,
-                                    qmax= qmax,
-                                    qstep= qstep,
-                                    completefn= self._complete2D,
-                                    updatefn= self._update2D )
-            self.calc_2D.queue()
-            
-        except:
-            msg= " Error occurred when drawing %s Model 2D: "%model.name
-            msg+= " %s"%sys.exc_value
-            wx.PostEvent( self.parent, StatusEvent(status= msg ))
-            return  
-   
-    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
-        """
-         
-        x=  numpy.linspace(start= qmin,
-                           stop= qmax,
-                           num= qstep,
-                           endpoint=True
-                           )
-        if data!=None:
-            ## check for data2D
-            if hasattr(data,"x_bins"):
-                return
-            x = data.x
-            if qmin == DEFAULT_QMIN :
-                qmin = min(data.x)
-            if qmax == DEFAULT_QMAX:
-                qmax = max(data.x)
-        
-        if not enable1D:
-            return
-    
-        try:
-            from model_thread import Calc1D
-            ## If a thread is already started, stop it
-            if self.calc_1D!= None and self.calc_1D.isrunning():
-                self.calc_1D.stop()
-            self.calc_1D= Calc1D( x= x,
-                                  data = data,
-                                  model= model, 
-                                  qmin = qmin,
-                                  qmax = qmax,
-                                  smearer = smearer,
-                                  completefn = self._complete1D,
-                                  updatefn = self._update1D  )
-            self.calc_1D.queue()
-            
-        except:
-            msg= " Error occurred when drawing %s Model 1D: "%model.name
-            msg+= " %s"%sys.exc_value
-            wx.PostEvent( self.parent, StatusEvent(status= msg ))
-            return  
-            
-   
-
-
-   
-if __name__ == "__main__":
-    i = Plugin()
-    
-    
-    
-    
Index: sansview/perspectives/fitting/basepage.py
===================================================================
--- sansview/perspectives/fitting/basepage.py	(revision 59a7f2d96a740711698407c792a5438a82d5809b)
+++ sansview/perspectives/fitting/basepage.py	(revision 1328e03fb2dbb5ff0404eac3502aef46dc24fe5d)
@@ -354,5 +354,11 @@
             out.close()
 
-    
+     
+    def onSetFocus(self, evt):
+        # Get a handle to the TextCtrl
+        widget = evt.GetEventObject()
+        # Select the whole control, after this event resolves
+        wx.CallAfter(widget.SetSelection, -1, -1)
+        return
     
     def read_file(self, path):
@@ -754,13 +760,12 @@
                 value= float(item[2].GetValue())
                 # If the value of the parameter has changed,
-                # update the model and set the is_modified flag
+                # +update the model and set the is_modified flag
                 if value != self.model.getParam(name):
                     self.model.setParam(name,value)
                     is_modified = True    
             except:
-                raise
-                #msg= "Model Drawing  Error:wrong value entered : %s"% sys.exc_value
-                #wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
-                #return 
+                msg= "Model Drawing  Error:wrong value entered : %s"% sys.exc_value
+                wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
+                return 
         
         return is_modified 
@@ -797,5 +802,5 @@
             self.SetScrollbars(20,20,200,100)
             
-        
+   
         
     def _layout_sizer_noDipers(self):
@@ -916,5 +921,5 @@
         self.qmin.SetValue(format_number(self.qmin_x))
         self.qmin.SetToolTipString("Minimun value of Q in linear scale.")
-        self.qmin.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+        self.qmin.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
         self.qmin.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
      
@@ -922,5 +927,5 @@
         self.qmax.SetValue(format_number(self.qmax_x))
         self.qmax.SetToolTipString("Maximum value of Q in linear scale.")
-        self.qmax.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+        self.qmax.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
         self.qmax.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
      
Index: sansview/perspectives/fitting/fitpage.py
===================================================================
--- sansview/perspectives/fitting/fitpage.py	(revision 59a7f2d96a740711698407c792a5438a82d5809b)
+++ sansview/perspectives/fitting/fitpage.py	(revision 1328e03fb2dbb5ff0404eac3502aef46dc24fe5d)
@@ -252,5 +252,5 @@
                     
                     ctl1.SetValue(str (format_number(value)))
-                    ctl1.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                    ctl1.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
                     ctl1.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
                     self.sizer4_4.Add(ctl1, (iy,ix),(1,1),wx.EXPAND)
@@ -277,5 +277,5 @@
                         
                         Tctl.SetValue(str (format_number(value)))
-                        Tctl.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                        Tctl.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
                         Tctl.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
                         self.sizer4_4.Add(Tctl, (iy,ix),(1,1),
@@ -291,5 +291,5 @@
                                             style=wx.TE_PROCESS_ENTER)
                         Tctl.SetValue(str (format_number(value)))
-                        Tctl.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                        Tctl.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
                         Tctl.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
                         self.sizer4_4.Add(Tctl, (iy,ix),(1,1),
Index: sansview/perspectives/fitting/fitpanel.py
===================================================================
--- sansview/perspectives/fitting/fitpanel.py	(revision 9853ad069a86f1e21bce16d80f5733f56cfedd79)
+++ sansview/perspectives/fitting/fitpanel.py	(revision 1328e03fb2dbb5ff0404eac3502aef46dc24fe5d)
@@ -33,5 +33,5 @@
         #Creating the default page --welcomed page
         self.about_page=None
-        from sans.guiframe.welcome_panel import PanelAbout
+        from welcome_panel import PanelAbout
         self.about_page = PanelAbout(self, -1)
         self.AddPage(self.about_page,"welcome!")
Index: sansview/perspectives/fitting/modelpage.py
===================================================================
--- sansview/perspectives/fitting/modelpage.py	(revision 59a7f2d96a740711698407c792a5438a82d5809b)
+++ sansview/perspectives/fitting/modelpage.py	(revision 1328e03fb2dbb5ff0404eac3502aef46dc24fe5d)
@@ -86,5 +86,5 @@
         self.npts.SetValue(format_number(self.num_points))
         self.npts.SetToolTipString("Number of point to plot.")
-        self.npts.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+        self.npts.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
         self.npts.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
         
@@ -169,5 +169,5 @@
                     
                     ctl1.SetValue(str (format_number(value)))
-                    ctl1.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                    ctl1.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
                     ctl1.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
                     self.sizer4_4.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
@@ -183,5 +183,5 @@
                         
                         Tctl1.SetValue(str (format_number(value)))
-                        Tctl1.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                        Tctl1.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
                         Tctl1.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
                         self.sizer4_4.Add(Tctl1, (iy,ix),(1,1),
@@ -198,5 +198,5 @@
                                             style=wx.TE_PROCESS_ENTER)
                         Tctl2.SetValue(str (format_number(value)))
-                        Tctl2.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                        Tctl2.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
                         Tctl2.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
                         self.sizer4_4.Add(Tctl2, (iy,ix),(1,1),
@@ -383,6 +383,7 @@
                 
                 ctl1.SetValue(str (format_number(value)))
-                ctl1.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                ctl1.Bind(wx.EVT_SET_FOCUS, self.onSetFocus)
                 ctl1.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
+                
                 sizer.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
         
Index: nsview/perspectives/fitting/old_fit_thread.py
===================================================================
--- sansview/perspectives/fitting/old_fit_thread.py	(revision c77d8592395f6684cf45ee976c1cac9db9c00110)
+++ 	(revision )
@@ -1,179 +1,0 @@
-
-import sys, wx, logging
-import string, numpy, math
-from sans.guicomm.events import NewPlotEvent, StatusEvent  
-from sans.guiframe.calcthread import CalcThread
-import park
-from park.fitresult import FitHandler
-DEFAULT_BEAM = 0.005
-import time
-import thread
- 
-class ConsoleUpdate(FitHandler):
-    """
-    Print progress to the console.
-    """
-    isbetter = False
-    """Record whether results improved since last update"""
-    progress_delta =  60
-    """Number of seconds between progress updates"""
-    improvement_delta = 5
-    """Number of seconds between improvement updates"""
-    def __init__(self,parent, quiet=False,progress_delta=60,improvement_delta=5):
-        """
-        If quiet is true, only print out final summary, not progress and
-        improvements.
-        """
-        self.parent= parent
-        self.progress_time = time.time()
-        self.progress_percent = 0
-        self.improvement_time = self.progress_time
-        self.isbetter = False
-        self.quiet = quiet
-        self.progress_delta = progress_delta
-        self.improvement_delta = improvement_delta
-
-    def progress(self, k, n):
-        """
-        Report on progress.
-        """
-        if self.quiet: return
-        t = time.time()
-        p = int((100*k)//n)
-        
-        # Show improvements if there are any
-        dt = t - self.improvement_time
-        if self.isbetter and dt > self.improvement_delta:
-            self.result.print_summary()
-            self.isbetter = False
-            self.improvement_time = t
-            
-            wx.PostEvent(self.parent, StatusEvent(status=\
-             "%d%% complete ..."%(p),type="update"))
-       
-        # Update percent complete
-        dp = p-self.progress_percent
-        if dp < 1: return
-        dt = t - self.progress_time
-        if dt > self.progress_delta:
-            if 1 <= dp <= 2:
-                self.progress_percent = p
-                self.progress_time = t
-                wx.PostEvent(self.parent, StatusEvent(status=\
-                                                      "%d%% complete ..."%(p),type="update"))
-       
-            elif 2 < dp <= 5:
-                if p//5 != self.progress_percent//5:
-                    wx.PostEvent(self.parent, StatusEvent(status=\
-                       "%d%% complete ..."%(5*(p//5)),type="update"))
-                    self.progress_percent = p
-                    self.progress_time = t
-            else:
-                if p//10 != self.progress_percent//10:
-                    self.progress_percent = p
-                    self.progress_time = t
-                    wx.PostEvent(self.parent, StatusEvent(status=\
-                   "%d%% complete ..."%(10*(p//10)),type="update"))
-        
-    def improvement(self):
-        """
-        Called when a result is observed which is better than previous
-        results from the fit.
-        """
-        self.isbetter = True
-    
-    def error(self, msg):
-        """
-        Model had an error; print traceback
-        """
-        if self.isbetter:
-            self.result.print_summary()
-        print msg
-
-    def finalize(self):
-        if self.isbetter:
-            self.result.print_summary()
-
-    def abort(self):
-        if self.isbetter:
-            self.result.print_summary()
-
-class FitThread(CalcThread):
-    """Thread performing the fit """
-    
-    def __init__(self,parent, fn,pars=None,cpage=None, qmin=None,qmax=None,ymin=None, ymax=None,
-                 xmin=None,xmax=None,
-                 completefn = None,
-                 updatefn   = None,
-                 yieldtime  = 0.01,
-                 worktime   = 0.01
-                 ):
-        CalcThread.__init__(self,completefn,
-                 updatefn,
-                 yieldtime,
-                 worktime)
-        self.parent = parent
-        self.fitter= fn
-        self.cpage= cpage
-        self.pars = pars
-        self.starttime = 0
-        self.qmin = qmin
-        self.qmax = qmax
-        self.xmin = xmin
-        self.xmax = xmax
-        self.ymin = ymin
-        self.ymax = ymax
-        self.done= False
-        wx.PostEvent(self.parent, StatusEvent(status=\
-                       "Start the computation  ",curr_thread=self,type="start"))
-    def isquit(self):
-        """
-             @raise KeyboardInterrupt: when the thread is interrupted
-        """
-        try:
-            CalcThread.isquit(self)
-        except KeyboardInterrupt:
-            wx.PostEvent(self.parent, StatusEvent(status=\
-                       "Calc %g interrupted"))
-            raise KeyboardInterrupt
-        
-    def update(self):
-        """
-            Is called when values of result are available
-        """
-        wx.PostEvent(self.parent, StatusEvent(status="Computing \
-        ... " ,curr_thread=self,type="update"))
-            
-    def compute(self):
-        """
-            Perform a fit 
-        """
-        try: 
-            self.starttime = time.time()
-            #Sending a progess message to the status bar
-            wx.PostEvent(self.parent, StatusEvent(status=\
-                       "Computing . ...",curr_thread=self,type="progress"))
-            #Handler used for park engine displayed message
-            handler= ConsoleUpdate(parent= self.parent,improvement_delta=0.1)
-            #Result from the fit
-            result = self.fitter.fit(handler= handler)
-        
-            elapsed = time.time()-self.starttime
-            self.complete(result= result,
-                          pars = self.pars,
-                          cpage= self.cpage,
-                          qmin = self.qmin,
-                          qmax = self.qmax,
-                          xmin= self.xmin,
-                          xmax= self.xmax,
-                          ymin = self.ymin,
-                          ymax = self.ymax, 
-                          elapsed=elapsed )
-        except KeyboardInterrupt:
-            # Thread was interrupted, just proceed and re-raise.
-            # Real code should not print, but this is an example...
-            raise
-        except:
-            wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value))
-            return 
-    
Index: nsview/perspectives/fitting/old_fitpage1D.py
===================================================================
--- sansview/perspectives/fitting/old_fitpage1D.py	(revision c77d8592395f6684cf45ee976c1cac9db9c00110)
+++ 	(revision )
@@ -1,613 +1,0 @@
-import sys
-import wx
-import wx.lib
-import numpy,math
-import copy
-
-from sans.guicomm.events import StatusEvent 
-from sans.guiframe.utils import format_number
-from modelpage import ModelPage  
-from modelpage import format_number
-(ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent()
-_BOX_WIDTH = 80
-
-
-#TODO: FitPage1D inherits from ModelPage but doesn't call its __init__ method!
-#TODO: refactor this class to have an __init__ that deals with data only, then calls a UI builder method.
-
-class FitPage1D(ModelPage):
-    """
-        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.
-    """
-    ## Internal name for the AUI manager
-    window_name = "Fit page"
-    ## Title to appear on top of the window
-    window_caption = "Fit Page"
-    
-    name=None
-    
-    def __init__(self, parent,data, *args, **kwargs):
-        wx.ScrolledWindow.__init__(self, parent, *args, **kwargs)
-        
-        """ 
-            Initialization of the Panel
-        """
-        #TODO: remove this once the inheritence is cleaned up
-        ## Data member to store the dispersion object created
-        self._disp_obj_dict = {}
-
-        #Data used for fitting 
-        self.data = data
-        # flag to allow data2D plot
-        self.enable2D=False
-        #fit page manager 
-        self.manager = None
-        #Store the parent of this panel parent
-        # For this application fitpanel is the parent
-        self.parent  = parent
-        # Event_owner is the owner of model event
-        self.event_owner = None
-        #panel interface
-        self.vbox  = wx.BoxSizer(wx.VERTICAL)
-    
-        self.sizer9 = wx.GridBagSizer(5,5)
-        self.sizer8 = wx.GridBagSizer(5,5)
-        self.sizer7 = wx.GridBagSizer(5,5)
-        self.sizer6 = wx.GridBagSizer(5,5)
-        self.sizer5 = wx.GridBagSizer(5,5)
-        self.sizer4 = wx.GridBagSizer(5,5)
-        self.sizer3 = wx.GridBagSizer(5,5)
-        self.sizer2 = wx.GridBagSizer(5,5)
-        self.sizer1 = wx.GridBagSizer(5,5)
-        # Add layer
-        #data info layer
-        self.vbox.Add(self.sizer1)
-        #data range 
-        self.vbox.Add(self.sizer2)
-        #instrument smearing selection layer
-        self.vbox.Add(self.sizer3)
-        #model selection
-        self.vbox.Add(wx.StaticLine(self, -1), 0, wx.EXPAND, 0)
-        self.vbox.Add(self.sizer4)
-        #model paramaters layer
-        self.vbox.Add(self.sizer5)
-        #polydispersion selected
-        self.vbox.Add(wx.StaticLine(self, -1), 0, wx.EXPAND, 0)
-        self.vbox.Add(self.sizer6)
-        #combox box for type of dispersion
-        self.vbox.Add(self.sizer7)
-        #dispersion parameters layer
-        self.vbox.Add(self.sizer8)
-        #fit info layer
-        self.vbox.Add(wx.StaticLine(self, -1), 0, wx.EXPAND, 0)
-        self.vbox.Add(self.sizer9)
-        #---------sizer 1 draw--------------------------------
-        #Filling the sizer containing data related fields
-        self.DataSource  =wx.StaticText(self, -1,str(data.name))
-        ix = 0
-        iy = 1
-        self.sizer1.Add(wx.StaticText(self, -1, 'Data Source Name : '),(iy,ix),\
-                 (1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1
-        self.sizer1.Add(self.DataSource,(iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        
-        #---------sizer 2 draw--------------------------------
-        #set maximum range for x in linear scale
-        if not hasattr(self.data,"data"): #Display only for 1D data fit
-            ix = 0
-            iy = 1
-            # Minimum value of data   
-            self.data_min    = wx.StaticText(self, -1,str(format_number(numpy.min(data.x))))
-            # Maximum value of data  
-            self.data_max    =  wx.StaticText(self, -1,str(format_number(numpy.max(data.x))))   
-            self.text4_3 = wx.StaticText(self, -1, 'Maximum Data Range(Linear)', style=wx.ALIGN_LEFT)
-            self.sizer2.Add(self.text4_3,(iy,ix),(1,1),\
-                   wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-            ix += 2
-            self.sizer2.Add(wx.StaticText(self, -1, 'Min :'),(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            ix += 1
-            self.sizer2.Add(self.data_min,(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            ix += 1
-            self.sizer2.Add(wx.StaticText(self, -1, 'Max : '),(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            ix += 1
-            self.sizer2.Add(self.data_max,(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        
-        #----sizer 3 draw--------------------------------
-        #Filling the sizer containing instruments smearing info.
-        self.disable_smearer = wx.RadioButton(self, -1, 'No', (10, 10), style=wx.RB_GROUP)
-        self.enable_smearer = wx.RadioButton(self, -1, 'Yes', (10, 30))
-        self.Bind(wx.EVT_RADIOBUTTON, self.onSmear, id=self.disable_smearer.GetId())
-        self.Bind(wx.EVT_RADIOBUTTON, self.onSmear, id=self.enable_smearer.GetId())
-        ix = 0
-        iy = 1
-        self.sizer3.Add(wx.StaticText(self,-1,'Instrument Smearing'),(iy,ix),(1,1)\
-                  , wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1
-        self.sizer3.Add(self.enable_smearer,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer3.Add(self.disable_smearer,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix =0
-        iy+=1
-        self.sizer3.Add((20,20),(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
-            
-        #------------------ sizer 4  draw------------------------   
-        # This sizer contains model list and chisqr value 
-        #filling sizer4
-        ## structure combox box
-        self.structbox = wx.ComboBox(self, -1)
-        # define combox box
-        self.modelbox = wx.ComboBox(self, -1)
-        
-        self.tcChi    =  wx.StaticText(self, -1, str(0), style=wx.ALIGN_LEFT)
-        self.tcChi.Hide()
-        self.text1_1 = wx.StaticText(self, -1, 'Chi2/dof', style=wx.ALIGN_LEFT)
-        self.text1_1.Hide()
-        ix = 0
-        iy = 1
-        self.sizer4.Add(wx.StaticText(self,-1,'Model'),(iy,ix),(1,1)\
-                  , wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        
-        ix += 1
-        self.sizer4.Add(self.modelbox,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix +=1
-        self.text_mult= wx.StaticText(self,-1,' x ')
-        self.sizer4.Add(self.text_mult,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer4.Add(self.structbox,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        
-        
-        
-        ix += 1
-        self.sizer4.Add(self.text1_1,(iy,ix),(1,1),\
-                   wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1
-        self.sizer4.Add(self.tcChi,(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        #----------sizer6-------------------------------------------------
-        #Sizer containing info on polydispersity
-        self.disable_disp = wx.RadioButton(self, -1, 'No', (10, 10), style=wx.RB_GROUP)
-        self.enable_disp = wx.RadioButton(self, -1, 'Yes', (10, 30))
-        self.Bind(wx.EVT_RADIOBUTTON, self.Set_DipersParam, id=self.disable_disp.GetId())
-        self.Bind(wx.EVT_RADIOBUTTON, self.Set_DipersParam, id=self.enable_disp.GetId())
-        ix= 0
-        iy=1
-        self.sizer6.Add(wx.StaticText(self,-1,'Polydispersity: '),(iy,ix),(1,1)\
-                  , wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1
-        self.sizer6.Add(self.enable_disp ,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer6.Add(self.disable_disp ,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix =0
-        iy+=1
-        self.sizer6.Add((20,20),(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
-        #---------sizer 9 draw----------------------------------------
-        
-        
-        id = wx.NewId()
-        self.btFit =wx.Button(self,id,'Fit')
-        self.btFit.Bind(wx.EVT_BUTTON, self.onFit,id=id)
-        self.btFit.SetToolTipString("Perform fit.")
-        ## Q range
-        # Reversed to the codes; Need to think  carefully about consistency in q between 2D plot and fitting
-        if not hasattr(self.data,"data"):
-            self.qmin_x= numpy.min(self.data.x)
-            self.qmax_x= numpy.max(self.data.x)
-            self.num_points= len(self.data.x)
-        else:
-            # Reversed to the codes; Need to think  carefully about consistency in q between 2D plot and fitting
-            radius1= math.sqrt(math.pow(self.data.xmin, 2)+ math.pow(self.data.ymin, 2))
-            radius2= math.sqrt(math.pow(self.data.xmax, 2)+ math.pow(self.data.ymin, 2))
-            radius3= math.sqrt(math.pow(self.data.xmin, 2)+ math.pow(self.data.ymax, 2))
-            radius4= math.sqrt(math.pow(self.data.xmax, 2)+ math.pow(self.data.ymax, 2))
-            
-            self.qmin_x= 0
-            self.qmax_x= math.sqrt(math.pow(max(math.fabs(self.data.xmax),math.fabs(self.data.xmin)),2)
-                            +math.pow(max(math.fabs(self.data.ymax),math.fabs(self.data.ymin)),2))#self.data.xmax           
-        
-        self.num_points= 100
-        # The minimum fitting range
-        self.qmin    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
-        self.qmin.SetValue(str(format_number(self.qmin_x)))
-        self.qmin.SetToolTipString("Minimun value of x in linear scale.")
-        self.qmin.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-        self.qmin.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
-        self.qmin.Enable()
-        #The maximum fitting range
-        self.qmax    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
-        self.qmax.SetValue(str(format_number(self.qmax_x)))
-        self.qmax.SetToolTipString("Maximum value of x in linear scale.")
-        self.qmax.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-        self.qmax.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
-        self.qmax.Enable()
-        #The number of points to plots
-        self.npts    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
-        self.npts.SetValue(format_number(self.num_points))
-        self.npts.SetToolTipString("Number of point to plot.")
-        self.npts.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-        self.npts.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
-        self.npts.Disable()
-        self.npts.Hide()
-        ix = 0
-        iy = 1 
-        self.sizer9.Add(wx.StaticText(self, -1, 'Fitting Range'),(iy, ix),(1,1),\
-                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1 
-        self.sizer9.Add(wx.StaticText(self, -1, 'Min'),(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer9.Add(wx.StaticText(self, -1, 'Max'),(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix = 0
-        iy += 1
-        self.sizer9.Add(wx.StaticText(self, -1, 'Q range'),(iy, ix),(1,1),\
-                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1
-        self.sizer9.Add(self.qmin,(iy, ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer9.Add(self.qmax,(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer9.Add(self.npts,(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        
-        ix += 1
-        self.sizer9.Add(self.btFit,(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-       
-        ix =0
-        iy+=1 
-        self.sizer9.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        
-        # Contains link between  model ,all its parameters, and panel organization
-        self.parameters=[]
-        # Contains list of parameters that cannot be fitted and reference to 
-        #panel objects 
-        self.fixed_param=[]
-        # Contains list of parameters with dispersity and reference to 
-        #panel objects 
-        self.fittable_param=[]
-        #list of dispersion paramaters
-        self.disp_list=[]
-        #contains link between a model and selected parameters to fit 
-        self.param_toFit=[]
-        # model on which the fit would be performed
-        self.model=None
-       
-        self.back_up_model= None
-        #dictionary of model name and model class
-        self.model_list_box={}    
-                     
-        if self.model == None:
-            self.qmin.Disable()
-            self.qmax.Disable() 
-        else:
-            self.qmin.Enable()
-            self.qmax.Enable() 
-
-    
-        self.vbox.Layout()
-        self.vbox.Fit(self) 
-        self.SetSizer(self.vbox)
-        self.SetScrollbars(20,20,55,40)
-        
-        self.Centre()
-        self.Layout()
-        
-        self.parent.GetSizer().Layout()
-   
-    def compute_chisqr2D(self):
-        """ 
-            compute chi square given a model and data 2D and set the value
-            to the tcChi txtcrl
-        """
-        from sans.guiframe.utils import check_value
-        flag = check_value( self.qmin, self.qmax)
-        #flag=self.checkFitRange()
-        res=[]
-        if flag== True:
-            try:
-                self.qmin_x = float(self.qmin.GetValue())
-                self.qmax_x = float(self.qmax.GetValue())
-                for i in range(len(self.data.x_bins)):
-                    for j in range(len(self.data.y_bins)):
-                        #Check the range containing data between self.qmin_x and self.qmax_x
-                        if math.pow(self.data.x_bins[i],2)+math.pow(self.data.y_bins[j],2)>=math.pow(self.qmin_x,2):
-                            if math.pow(self.data.x_bins[i],2)+math.pow(self.data.y_bins[j],2)<=math.pow(self.qmax_x,2):
-                                chisqrji=(self.data.data[j][i]- self.model.runXY(\
-                                                                                    [self.data.y_bins[j],self.data.x_bins[i]]))\
-                                                                                    /self.data.err_data[j][i]
-                                #Vector containing residuals
-                                res.append( math.pow(chisqrji,2) )
-                # compute sum of residual
-                sum=0
-                for item in res:
-                    if numpy.isfinite(item):
-                        sum +=item
-                self.tcChi.SetLabel(format_number(math.fabs(sum/ len(res))))
-            except:
-                wx.PostEvent(self.parent.GrandParent, StatusEvent(status=\
-                            "Chisqr cannot be compute: %s"% sys.exc_value))
-                return
-    
-        
-    def compute_chisqr(self):
-        """ 
-            compute chi square given a model and data 1D and set the value
-            to the tcChi txtcrl
-        """
-        from sans.guiframe.utils import check_value
-        flag = check_value( self.qmin, self.qmax)
-        #flag=self.checkFitRange()
-        if flag== True:
-            try:
-                if hasattr(self.data,"data"):
-                    self.compute_chisqr2D()
-                    return
-                else:
-                    self.qmin_x = float(self.qmin.GetValue())
-                    self.qmax_x = float(self.qmax.GetValue())
-                    # return residuals within self.qmin_x and self.qmax_x
-                    x,y,dy = [numpy.asarray(v) for v in (self.data.x,self.data.y,self.data.dy)]
-                    if self.qmin_x==None and self.qmax_x==None: 
-                        fx =numpy.asarray([self.model.run(v) for v in x])
-                        temp=(y - fx)/dy
-                        res= temp*temp
-                    else:
-                        idx = (x>= self.qmin_x) & (x <=self.qmax_x)
-                        fx = numpy.asarray([self.model.run(item)for item in x[idx ]])
-                        temp=(y[idx] - fx)/dy[idx]
-                        res= temp*temp
-                    #sum of residuals
-                    sum=0
-                    for item in res:
-                        if numpy.isfinite(item):
-                            sum +=item
-                    self.tcChi.SetLabel(format_number(math.fabs(sum/ len(res))))
-            except:
-                wx.PostEvent(self.parent.GrandParent, StatusEvent(status=\
-                            "Chisqr cannot be compute: %s"% sys.exc_value))
-                return 
-            
-    def _on_select_model(self,event):
-        """
-            react when a model is selected from page's combo box
-            post an event to its owner to draw an appropriate theory
-        """
-        self.btFit.SetFocus()
-        self.disable_disp.SetValue(True)
-        self.sizer8.Clear(True)
-        self.sizer7.Clear(True)       
-        self.vbox.Layout()
-        self.SetScrollbars(20,20,55,40)
-        self.Layout()
-        self.parent.GetSizer().Layout()
-
-       
-        name= self.modelbox.GetString(self.modelbox.GetCurrentSelection())
-        form_factor =self.modelbox.GetClientData(self.modelbox.GetCurrentSelection())
-        struct_factor =self.structbox.GetClientData(self.structbox.GetCurrentSelection())
-       
-      
-        if form_factor!="separator":
-            if struct_factor != None and struct_factor.__name__ != "NoStructure":
-                from sans.models.MultiplicationModel import MultiplicationModel
-                self.model= MultiplicationModel(form_factor(),struct_factor())
-            else:
-                 self.model= form_factor() 
-            self.back_up_model= self.model.clone()
-            name= self.model.name
-            if name == None:
-                self.qmin.Disable()
-                self.qmax.Disable() 
-            else:
-                self.qmin.Enable()
-                self.qmax.Enable() 
-            evt = ModelEventbox(model=self.model,name=name)
-            wx.PostEvent(self.event_owner, evt)   
-            self.text1_1.Show()
-            self.tcChi.Show()
-            self.compute_chisqr()
-        
-            
-        else:
-            self.model=None 
-            msg= " Select non - model value:%s ! Previous Model reloaded "%name 
-            wx.PostEvent(self.parent.parent, StatusEvent(status= msg))
-            
-        self.set_panel(self.model)
-            
-                 
-    def onFit(self,event):
-        """ 
-            signal for fitting .Perform single fit only
-        """
-        from sans.guiframe.utils import check_value
-        flag = check_value( self.qmin, self.qmax) 
-        
-        if not flag:
-            msg= "Fitting range invalid"
-            wx.PostEvent(self.parent.parent, StatusEvent(status= msg ))
-            return 
-        
-        if len(self.param_toFit) <= 0:
-            msg= "Select at least one parameter to fit"
-            wx.PostEvent(self.parent.parent, StatusEvent(status= msg ))
-            return 
-        
-        self.qmin_x=float(self.qmin.GetValue())
-        self.qmax_x =float( self.qmax.GetValue())
-        
-        self.manager.schedule_for_fit( value=1,fitproblem =None) 
-        if hasattr(self.data, "data"):
-            #single fit for Data2D
-            self.manager._on_single_fit(qmin=self.qmin_x,qmax=self.qmax_x,
-                                        ymin=self.data.ymin, ymax=self.data.ymax,
-                                        xmin=self.data.xmin,xmax=self.data.xmax)
-        else:
-            #single fit for Data1D
-            self.manager._on_single_fit(qmin=self.qmin_x,qmax=self.qmax_x)
-                
-            self.vbox.Layout()
-            self.SetScrollbars(20,20,55,40)
-            self.Layout()
-            self.parent.GetSizer().Layout()
-        
-            
-  
-   
-    
-    def get_param_list(self):
-        """
-            @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 
-            properly so raise ValueError,"missing parameter to fit"
-        """
-        if self.param_toFit !=[]:
-            return self.param_toFit
-        else:
-            raise ValueError,"missing parameter to fit"
-        
-    
-    def _onparamEnter(self,event):
-        """ 
-            when enter value on panel redraw model according to changed
-        """
-        self.set_model()
-        try:
-            self.compute_chisqr()
-        except:
-            pass
-        
-    def set_model(self): 
-        """
-            Hide panel object related to the previous fit and set
-            values entered by the used inside the model
-        """
-        if len(self.parameters) !=0 and self.model !=None:
-            # Flag to register when a parameter has changed.
-            for item in self.parameters:
-                try:
-                    self.text2_3.Hide()
-                    item[2].Hide()
-                    item[3].Clear()
-                    item[3].Hide()
-                except:
-                    pass
-        self.set_model_parameter()
-        
-    
-    def select_all_param(self,event): 
-        """
-             set to true or false all checkBox given the main checkbox value cb1
-        """
-        self.select_all_param_helper()
-                
-                
-    def select_param(self,event):
-        """ 
-            Select TextCtrl  checked for fitting purpose and stores them
-            in  self.param_toFit=[] list
-        """
-        self.param_toFit=[]
-        for item in self.parameters:
-            #Select parameters to fit for list of primary parameters
-            if item[0].GetValue()==True:
-                list= [item[0],item[1],item[2],item[3]]
-                if not (list  in self.param_toFit):
-                    self.param_toFit.append(list )  
-            else:
-                #remove parameters from the fitting list
-                if item in self.param_toFit:
-                    self.param_toFit.remove(item)
-        #Select parameters to fit for list of fittable parameters with dispersion          
-        for item in self.fittable_param:
-            if item[0].GetValue()==True:
-                list= [item[0],item[1],item[2],item[3]]
-                if not (list  in self.param_toFit):
-                    self.param_toFit.append(list )  
-            else:
-                #remove parameters from the fitting list
-                if item in self.param_toFit:
-                    self.param_toFit.remove(item)           
-        #Set the value of checkbox that selected every checkbox or not            
-        if len(self.parameters)+len(self.fittable_param) ==len(self.param_toFit):
-            self.cb1.SetValue(True)
-        else:
-            self.cb1.SetValue(False)
-       
-       
-    def onsetValues(self,chisqr, out,cov):
-        """
-            Build the panel from the fit result
-            @param chisqr:Value of the goodness of fit metric
-            @param out:list of parameter with the best value found during fitting
-            @param cov:Covariance matrix
-       
-        """
-        self.tcChi.SetLabel(format_number(chisqr))
-        params = {}
-        is_modified = False
-        has_error = False
-        #set the panel when fit result are float not list
-        if out.__class__==numpy.float64:
-            self.param_toFit[0][1].SetValue(format_number(out))
-            self.param_toFit[0][1].Refresh()
-            if cov !=None :
-                self.text2_3.Show()
-                self.param_toFit[0][2].Show()
-                self.param_toFit[0][3].Clear()
-                self.param_toFit[0][3].SetValue(format_number(cov[0]))
-                self.param_toFit[0][3].Show()
-        else:
-            i=0
-            j=0
-            #Set the panel when fit result are list
-            for item in self.param_toFit:
-                if( out != None ) and len(out)<=len(self.param_toFit)and i < len(out):
-                    item[1].SetValue(format_number(self.model.getParam(item[0].GetLabelText())))
-                    item[1].Refresh()
-                if(cov !=None)and len(cov)<=len(self.param_toFit)and i < len(cov):
-                    self.text2_3.Show() 
-                    item[2].Show()
-                    item[3].Clear()
-                    for j in range(len(out)):
-                        if out[j]==self.model.getParam(item[0].GetLabelText()):
-                            break
-                    item[3].SetValue(format_number(cov[j]))
-                    item[3].Show()   
-                i+=1
-        
-        self.vbox.Layout()
-        self.SetScrollbars(20,20,55,40)
-        self.Layout()
-        self.GrandParent.GetSizer().Layout()
-        
-        
-    def onSmear(self, event):
-        """
-            Create a smear object that will change the way residuals
-            are compute when fitting
-        """
-        smear =None
-        msg=""
-        if self.enable_smearer.GetValue():
-            from DataLoader.qsmearing import smear_selection
-            smear =smear_selection( self.data )
-            if hasattr(self.data,"dxl"):
-                msg= ": Resolution smearing parameters"
-            if hasattr(self.data,"dxw"):
-                msg= ": Slit smearing parameters"
-            if smear ==None:
-                wx.PostEvent(self.manager.parent, StatusEvent(status=\
-                            "Data contains no smearing information"))
-            else:
-                wx.PostEvent(self.manager.parent, StatusEvent(status=\
-                            "Data contains smearing information %s"%msg))
-        self.manager.set_smearer(smear)   
-            
-              
-        
-       
Index: nsview/perspectives/fitting/old_fitpanel.py
===================================================================
--- sansview/perspectives/fitting/old_fitpanel.py	(revision c77d8592395f6684cf45ee976c1cac9db9c00110)
+++ 	(revision )
@@ -1,244 +1,0 @@
-import wx
-import wx.aui
-import wx.lib
-import numpy
-import string ,re
-#import models
-_BOX_WIDTH = 80
-
-(FitPageEvent, EVT_FIT_PAGE)   = wx.lib.newevent.NewEvent()
-class FitPanel(wx.aui.AuiNotebook):    
-
-    """
-        FitPanel class contains fields allowing to fit  models and  data
-        @note: For Fit to be performed the user should check at least one parameter
-        on fit Panel window.
-       
-    """
-    ## Internal name for the AUI manager
-    window_name = "Fit panel"
-    ## Title to appear on top of the window
-    window_caption = "Fit Panel "
-    CENTER_PANE = True
-    def __init__(self, parent, *args, **kwargs):
-        wx.aui.AuiNotebook.__init__(self,parent,-1, style=wx.aui.AUI_NB_DEFAULT_STYLE  )
-        
-        
-        self.manager=None
-        self.parent=parent
-        self.event_owner=None
-        
-        pageClosedEvent = wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE
-        self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.onClosePage)
-        #Creating the default page --welcomed page
-        self.about_page=None
-        from sans.guiframe.welcome_panel import PanelAbout
-        self.about_page = PanelAbout(self, -1)
-        self.AddPage(self.about_page,"welcome!")
-      
-       
-        #dictionary of miodel {model class name, model class}
-        self.model_list_box={}
-        ## list of structure factor
-        self.struct_list_box=[]
-        # save the title of the last page tab added
-        self.fit_page_name=[]
-        self.draw_model_name=None
-        #model page info
-        self.model_page_number=None
-       
-        self.model_page=None
-        self.sim_page=None
-        # increment number for model name
-        self.count=0
-        #updating the panel
-        self.Update()
-        self.Center()
-        
-        
-    def onClosePage(self, event):
-        """
-             close page and remove all references to the closed page
-        """
-        selected_page = self.GetPage(self.GetSelection())
-        page_number = self.GetSelection()
-        if self.sim_page != selected_page and selected_page!=self.about_page:
-            # remove the check box link to the model name of this page (selected_page)
-            if self.sim_page !=None :
-                self.sim_page.remove_model(selected_page)
-            #remove that page from page_finder of fitting module
-            page_finder=self.manager.get_page_finder() 
-            for page, value in page_finder.iteritems():
-                if page==selected_page:
-                    del page_finder[page]
-                    break
-            #Delete the page from notebook
-            if selected_page.name in self.fit_page_name:
-                self.fit_page_name.remove(selected_page.name)
-                
-            if selected_page.name== self.draw_model_name:
-                self.draw_model_name=None
-                self.model_page=None
-            if  page_number == 1:
-                self.model_page=None
-                self.draw_model_name=None
-            
-        elif selected_page==self.about_page:
-            self.about_page=None
-        else:
-            self.manager.sim_page=None  
-        
-        
-    def set_manager(self, manager):
-        """
-             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
-        """
-        self.event_owner=owner
-        
-    def add_sim_page(self):
-        """
-            Add the simultaneous fit page
-        """
-        from simfitpage import SimultaneousFitPage
-        self.sim_page = SimultaneousFitPage(self, id=-1)
-        self.AddPage(self.sim_page,caption="Simultaneous Fit",select=True)
-        self.sim_page.set_manager(self.manager)
-        return self.sim_page
-        
-    def add_fit_page( self,data ):
-        """ 
-            Add a fitting page on the notebook contained by fitpanel
-            @param data: data to fit
-            @return panel : page just added for futher used. is used by fitting module
-        """     
-        try:
-            name = data.name 
-        except:
-            name = 'Fit'
-        
-        if not name in self.fit_page_name :
-            from fitpage1D import FitPage1D
-            panel = FitPage1D(self,data, -1)
-            panel.name=name
-            
-            panel.set_manager(self.manager)
-            panel.set_owner(self.event_owner)
-            
-            self.AddPage(page=panel,caption=name,select=True)
-            panel.populate_box( self.model_list_box)
-            self.fit_page_name.append(name)
-    
-            return panel 
-        else:
-            return None 
-        
-    def _help_add_model_page(self,model,description,page_title, qmin=0, qmax=0.1, npts=50):
-        """
-            #TODO: fill in description
-            
-            @param qmin: mimimum Q
-            @param qmax: maximum Q
-            @param npts: number of Q points
-        """
-        from modelpage import ModelPage
-        #print "fitpanel model", model
-        panel = ModelPage(self,model,page_title, -1)
-        panel.set_manager(self.manager)
-        panel.set_owner(self.event_owner)
-        self.AddPage(page=panel,caption="Model",select=True)
-        panel.populate_box( self.model_list_box)
-        panel.name = page_title
-        self.draw_model_name=page_title
-        self.model_page_number=self.GetSelection()
-        self.model_page=self.GetPage(self.GetSelection())
-        
-        
-        # Set the range used to plot models
-        self.model_page.set_range(qmin, qmax, npts)
-        
-        # We just created a model page, we are ready to plot the model
-        #self.manager.draw_model(model, model.name)
-        #FOR PLUGIN  for somereason model.name is = BASEcomponent
-        self.manager.draw_model(model, page_title)
-        
-    def new_help_add_model_page(self,model,description,page_title, qmin=0, qmax=0.1, npts=50):
-        """
-            #TODO: fill in description
-            
-            @param qmin: mimimum Q
-            @param qmax: maximum Q
-            @param npts: number of Q points
-        """
-        ## storing page info
-        from pageInfo import  PageInfo
-        myinfo = PageInfo( self, model )
-        myinfo.model_list_box = self.model_list_box
-        from modelpage import ModelPage
-        
-        panel = ModelPage(self,myinfo,page_title)
-        panel.set_manager(self.manager)
-        panel.set_owner(self.event_owner)
-        
-        
-        self.AddPage(page=panel,caption="Model",select=True)
-        panel.populate_box( self.model_list_box)
-        panel.name = page_title
-        self.draw_model_name=page_title
-        self.model_page_number=self.GetSelection()
-        self.model_page=self.GetPage(self.GetSelection())
-        
-        
-        # Set the range used to plot models
-        self.model_page.set_range(qmin, qmax, npts)
-        
-        # We just created a model page, we are ready to plot the model
-        #self.manager.draw_model(model, model.name)
-        #FOR PLUGIN  for some reason model.name is = BASEcomponent
-        self.manager.draw_model(model, page_title)
-     
-        
-    def add_model_page(self,model,description,page_title, qmin=0, qmax=0.1, npts=50, topmenu=False):
-        """
-            Add a model page only one  to display any model selected from the menu or the page combo box.
-            when this page is closed than the user will be able to open a new one
-            
-            @param model: the model for which paramters will be changed
-            @param page_title: the name of the page
-            @param description: [Coder: fill your description!]
-            @param page_title: [Coder: fill your description!]
-            @param qmin: mimimum Q
-            @param qmax: maximum Q
-            @param npts: number of Q points
-        """
-        if topmenu==True:
-            if  self.draw_model_name ==None:
-                self._help_add_model_page(model,description,page_title, qmin=qmin, qmax=qmax, npts=npts)
-            else:
-                self.model_page.select_model(model, page_title)
-          
-    def get_current_page(self):
-        """
-            @return the current page selected
-        """
-        #return self.nb.GetCurrentPage()
-        return self.GetPage(self.GetSelection() )
-  
-    
-     
-    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
-             as value
-         """
-         self.model_list_box = dict
-  
Index: nsview/perspectives/fitting/old_fitting.py
===================================================================
--- sansview/perspectives/fitting/old_fitting.py	(revision c77d8592395f6684cf45ee976c1cac9db9c00110)
+++ 	(revision )
@@ -1,1053 +1,0 @@
-import  re
-import sys, wx, logging
-import string, numpy, math
-
-from copy import deepcopy 
-from danse.common.plottools.plottables import Data1D, Theory1D,Data2D
-from danse.common.plottools.PlotPanel import PlotPanel
-from sans.guicomm.events import NewPlotEvent, StatusEvent  
-from sans.guicomm.events import EVT_SLICER_PANEL,ERR_DATA
-
-from sans.fit.AbstractFitEngine import Model,FitData1D,FitData2D#,Data,
-from fitproblem import FitProblem
-from fitpanel import FitPanel
-from fit_thread import FitThread
-import models
-import fitpage1D
-
-DEFAULT_BEAM = 0.005
-DEFAULT_QMIN = 0.0
-DEFAULT_QMAX = 0.1
-DEFAULT_NPTS = 50
-import time
-import thread
-
-class Plugin:
-    """
-        Fitting plugin is used to perform fit 
-    """
-    def __init__(self):
-        ## Plug-in name
-        self.sub_menu = "Fitting"
-        
-        ## Reference to the parent window
-        self.parent = None
-        #Provide list of models existing in the application
-        self.menu_mng = models.ModelManager()
-        ## List of panels for the simulation perspective (names)
-        self.perspective = []
-        #list of panel to send to guiframe
-        self.mypanels=[]
-        # reference to the current running thread
-        self.calc_thread = None
-        # Start with a good default
-        self.elapsed = 0.022
-        # the type of optimizer selected, park or scipy
-        self.fitter  = None
-        #Flag to let the plug-in know that it is running stand alone
-        self.standalone=True
-        ## Fit engine
-        self._fit_engine = 'scipy'
-        #List of selected data
-        self.selected_data_list=[]
-        # Log startup
-        logging.info("Fitting plug-in started")   
-        # model 2D view
-        self.model2D_id=None
-        #keep reference of the simultaneous fit page
-        self.sim_page=None
-        #dictionary containing data name and error on dy of that data 
-        self.err_dy={}
-        
-    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
-        """
-        self.err_dy= event.err_dy
-        
-    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
-        """
-        #Menu for fitting
-        self.menu1 = wx.Menu()
-        id1 = wx.NewId()
-        self.menu1.Append(id1, '&Simultaneous')
-        wx.EVT_MENU(owner, id1, self.on_add_sim_page)
-        #Set park engine
-        id3 = wx.NewId()
-        self.menu1.AppendCheckItem(id3, "park") 
-        wx.EVT_MENU(owner, id3, self._onset_engine)
-        
-        #menu for model
-        menu2 = wx.Menu()
-    
-        self.menu_mng.populate_menu(menu2, owner)
-        id2 = wx.NewId()
-        owner.Bind(models.EVT_MODEL,self._on_model_menu)
-      
-        self.fit_panel.set_owner(owner)
-        self.fit_panel.set_model_list(self.menu_mng.get_model_list())
-        owner.Bind(fitpage1D.EVT_MODEL_BOX,self._on_model_panel)
-        
-        #create  menubar items
-        return [(id, self.menu1, "Fitting"),(id2, menu2, "Model")]
-    
-    def on_add_sim_page(self, event):
-        """
-        """
-        self.sim_page= self.fit_panel.add_sim_page()
-        self.sim_page.add_model(self.page_finder)
-        
-        
-    def help(self, evt):
-        """
-            Show a general help dialog. 
-            TODO: replace the text with a nice image
-        """
-        #from helpDialog import  HelpWindow
-        #dialog = HelpWindow(None, -1, 'HelpWindow')
-        #if dialog.ShowModal() == wx.ID_OK:
-        #    pass
-        #dialog.Destroy()
-        from helpPanel import  HelpWindow
-        frame = HelpWindow(None, -1, 'HelpWindow')    
-        frame.Show(True)
-        
-        
-    def get_context_menu(self, graph=None):
-        """
-            Get the context menu items available for P(r)
-            @param graph: the Graph object to which we attach the context menu
-            @return: a list of menu items with call-back function
-        """
-        self.graph=graph
-        for item in graph.plottables:
-            if item.__class__.__name__ is "Data2D":
-                return [["Select data  for Fitting",\
-                          "Dialog with fitting parameters ", self._onSelect]] 
-            else:
-                #if item.name==graph.selected_plottable and\
-                # item.__class__.__name__ is  "Data1D":
-                if item.name==graph.selected_plottable :
-                    return [["Select data  for Fitting", \
-                             "Dialog with fitting parameters ", self._onSelect]] 
-        return []   
-
-
-    def get_panels(self, parent):
-        """
-            Create and return a list of panel objects
-        """
-        self.parent = parent
-        # Creation of the fit panel
-        self.fit_panel = FitPanel(self.parent, -1)
-        #Set the manager forthe main panel
-        self.fit_panel.set_manager(self)
-        # List of windows used for the perspective
-        self.perspective = []
-        self.perspective.append(self.fit_panel.window_name)
-        # take care of saving  data, model and page associated with each other
-        self.page_finder = {}
-        #index number to create random model name
-        self.index_model = 0
-        self.index_theory= 0
-        self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event)
-        self.parent.Bind( ERR_DATA, self._on_data_error)
-        
-        #create the fitting panel
-        #return [self.fit_panel]
-        
-        self.mypanels.append(self.fit_panel)
-        return self.mypanels
-
-        
-    def _on_slicer_event(self, event):
-        """
-        """
-        #print "fitting:slicer event ", event.panel
-        if event.panel!=None:
-            new_panel = event.panel
-            # Set group ID if available
-            event_id = self.parent.popup_panel(new_panel)
-            self.menu1.Append(event_id, new_panel.window_caption, 
-                             "Show %s plot panel" % new_panel.window_caption)
-            # Set UID to allow us to reference the panel later
-            new_panel.uid = event_id
-            new_panel
-            self.mypanels.append(new_panel) 
-        return    
-    
-        
-    def _on_show_panel(self, event):
-        print "_on_show_panel: fitting"
-      
-      
-    def get_perspective(self):
-        """
-            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.
-        """
-        self.parent.set_perspective(self.perspective)
-    
-    
-    def post_init(self):
-        """
-            Post initialization call back to close the loose ends
-            [Somehow openGL needs this call]
-        """
-        self.parent.set_perspective(self.perspective)
-
-
-    def copy_data(self, item, dy):
-        """
-        """
-        detector=None
-        source=None
-        dxl=None
-        dxw=None
-        if hasattr(item, "dxl"):
-            dxl = item.dxl
-        if hasattr(item, "dxw"):
-            dxw = item.dxw
-        if hasattr(item, "detector"):
-            detector =item.detector
-        if hasattr(item, "source"):
-            source =item.source
-        from sans.guiframe import dataFitting 
-        data= dataFitting.Data1D(x=item.x, y=item.y, dy=dy, dxl=dxl, dxw=dxw)
-        data.name=item.name
-        data.detector=detector
-        data.source= source
-        return data
-
-
-    def _onSelect(self,event):
-        """ 
-            when Select data to fit a new page is created .Its reference is 
-            added to self.page_finder
-        """
-        self.panel = event.GetEventObject()
-        for item in self.panel.graph.plottables:
-            if item.name == self.panel.graph.selected_plottable:
-                if len(self.err_dy)>0:
-                    if item.name in  self.err_dy.iterkeys():
-                        dy= self.err_dy[item.name]
-                        data= self.copy_data(item, dy)
-                    else:
-                        data= item
-                else:
-                    if item.dy==None:
-                        dy= numpy.zeros(len(item.y))
-                        dy[dy==0]=1
-                        data= self.copy_data(item, dy)
-                    else:
-                        data= item
-            else:
-                data= item
-                        
-                        
-            if item.name == self.panel.graph.selected_plottable or\
-                 item.__class__.__name__ is "Data2D":
-                #find a name for the page created for notebook
-                #print "fitting", self.panel
-                try:
-                   
-                    #page = self.fit_panel.add_fit_page(item)
-                    page = self.fit_panel.add_fit_page(data)
-                    #page, model_name = self.fit_panel.add_fit_page(item)
-                    # add data associated to the page created
-                   
-                    if page !=None:   
-                        #create a fitproblem storing all link to data,model,page creation
-                        self.page_finder[page]= FitProblem()
-                        #self.page_finder[page].save_model_name(model_name)  
-                        self.page_finder[page].add_plotted_data(item)
-                        self.page_finder[page].add_fit_data(data)
-                       
-                            
-                        wx.PostEvent(self.parent, StatusEvent(status="Page Created"))
-                    else:
-                        wx.PostEvent(self.parent, StatusEvent(status="Page was already Created"))
-                except:
-                    #raise
-                    wx.PostEvent(self.parent, StatusEvent(status="Creating Fit page: %s"\
-                    %sys.exc_value))
-                    return
-                    
-                    
-    def schedule_for_fit(self,value=0,fitproblem =None):  
-        """
-        
-        """   
-        if fitproblem !=None:
-            fitproblem.schedule_tofit(value)
-        else:
-            current_pg=self.fit_panel.get_current_page() 
-            for page, val in self.page_finder.iteritems():
-                if page ==current_pg :
-                    val.schedule_tofit(value)
-                    break
-                      
-                    
-    def get_page_finder(self):
-        """ @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.
-        """  
-        #sim_page=self.fit_panel.GetPage(1) 
-        sim_page= self.sim_page
-        for page, value in self.page_finder.iteritems():
-            if page != sim_page:
-                list=value.get_model()
-                model=list[0]
-                #print "fitting",model.name,modelname, values
-                if model.name== modelname:
-                    value.set_model_param(names,values)
-                    break
-
-   
-                            
-    def split_string(self,item): 
-        """
-            receive a word containing dot and split it. used to split parameterset
-            name into model name and parameter name example:
-            paramaterset (item) = M1.A
-            @return model_name =M1 , parameter name =A
-        """
-        if string.find(item,".")!=-1:
-            param_names= re.split("\.",item)
-            model_name=param_names[0]
-            param_name=param_names[1]  
-            return model_name,param_name
-        
-   
-    def _single_fit_completed(self,result,pars,cpage,qmin,qmax,elapsed=None,
-                              ymin=None, ymax=None, xmin=None, xmax=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
-          
-        """
-        
-        #print "single fit ", pars,result.pvec,result.stderr,result.fitness
-        wx.PostEvent(self.parent, StatusEvent(status="Single fit \
-        complete " , type="stop"))
-        try:
-            for page, value in self.page_finder.iteritems():
-                if page==cpage :
-                    #fitdata = value.get_data()
-                    list = value.get_model()
-                    model= list[0]
-                    break
-            i = 0
-          
-            for name in pars:
-                if result.pvec.__class__==numpy.float64:
-                    model.setParam(name,result.pvec)
-                else:
-                    #print "fitting result : chisqr",result.fitness
-                    #print "fitting result : pvec",result.pvec
-                    #print "fitting result : stderr",result.stderr
-                    model.setParam(name,result.pvec[i])
-                    #print "fitting: single fit", name, result.pvec[i]
-                    i += 1
-           
-           
-            cpage.onsetValues(result.fitness, result.pvec,result.stderr)
-            #title="Fitted model 2D "
-            self.plot_helper(currpage=cpage,qmin=qmin,qmax=qmax,
-                             ymin=ymin, ymax=ymax,
-                             xmin=xmin, xmax=xmax,title=None)
-        except:
-            #raise
-            wx.PostEvent(self.parent, StatusEvent(status="Fitting error: %s" % sys.exc_value))
-            return
-       
-       
-    def _simul_fit_completed(self,result,qmin,qmax, elapsed,pars=None,cpage=None,
-                             xmin=None, xmax=None, ymin=None, ymax=None):
-        """
-            Parameter estimation completed, 
-            display the results to the user
-            @param alpha: estimated best alpha
-            @param elapsed: computation time
-        """
-        if cpage!=None:
-            self._single_fit_completed(result=result,pars=pars,cpage=cpage,
-                                       qmin=qmin,qmax=qmax,
-                              ymin=ymin, ymax=ymax, xmin=xmin, xmax=xmax)
-            return
-        else:
-            wx.PostEvent(self.parent, StatusEvent(status="Simultaneous fit \
-            complete ", type="stop"))
-            #print "result",cpage,str(result),result.parameters,result.fitness,result.stderr
-            
-            try:
-                for page, value in self.page_finder.iteritems():
-                    if value.get_scheduled()==1:
-                        #fitdata = value.get_data()
-                        list = value.get_model()
-                        model= list[0]
-                       
-                        small_out = []
-                        small_cov = []
-                        i = 0
-                        #Separate result in to data corresponding to each page
-                        for p in result.parameters:
-                            model_name,param_name = self.split_string(p.name)  
-                            if model.name == model_name:
-                                small_out.append(p.value )
-                                if p.stderr==None:
-                                    p.stderr=numpy.nan
-                                small_cov.append(p.stderr)
-                                model.setParam(param_name,p.value)  
-                        # Display result on each page 
-                        #print "mmmm",p.value,p.stderr
-                        page.onsetValues(result.fitness, small_out,small_cov)
-                        #print "out,err",small_out,small_cov
-                        #Replot model
-                        self.plot_helper(currpage= page,qmin= qmin,qmax= qmax,
-                                         xmin=xmin, xmax=xmax,
-                                         ymin=ymin, ymax=ymax) 
-            except:
-                wx.PostEvent(self.parent, StatusEvent(status="Simultaneous Fitting error: %s" % sys.exc_value))
-                return
-            
-            
-    def stop_fit(self):
-        """
-        """
-        if self.calc_thread != None and self.calc_thread.isrunning():
-            #self.calc_thread.interrupt()
-            self.calc_thread.stop()
-            wx.PostEvent(self.parent, StatusEvent(status="Fitting  \
-                is cancelled" , type="stop"))
-            
-            
-    def _on_single_fit(self,id=None,qmin=None, qmax=None,ymin=None, ymax=None,xmin=None,xmax=None):
-        """ 
-            perform fit for the  current page  and return chisqr,out and cov
-            @param engineName: type of fit to be performed
-            @param id: unique id corresponding to a fit problem(model, set of data)
-            @param model: model to fit
-            
-        """
-        #print "in single fitting"
-        #set an engine to perform fit
-        from sans.fit.Fitting import Fit
-        self.fitter= Fit(self._fit_engine)
-        #Setting an id to store model and data in fit engine
-        self.fit_id= 0
-        if id!=None:
-            self.fit_id= id
-        
-        page_fitted=None
-        fit_problem=None
-        #Get information (model , data) related to the page on 
-        #with the fit will be perform
-        current_pg=self.fit_panel.get_current_page() 
-        #simul_pg=self.fit_panel.GetPage(1 )
-        simul_pg=self.sim_page
-        pars=[]   
-        #for page, value in self.page_finder.iteritems():
-        if current_pg!= simul_pg:
-        #    if  value.get_scheduled() ==1 :
-            value = self.page_finder[current_pg]
-            metadata =  value.get_fit_data()
-            list = value.get_model()
-            model = list[0]
-            smearer= value.get_smearer()
-           
-    
-            #Create list of parameters for fitting used
-            
-            templist=[]
-            try:
-                #templist=current_pg.get_param_list()
-                templist=current_pg.get_param_list()
-                for element in templist:
-                    pars.append(str(element[0].GetLabelText()))
-                pars.sort()
-                #Do the single fit
-                self.fitter.set_model(Model(model), self.fit_id, pars) 
-                if self._fit_engine=="scipy":
-                    wx.PostEvent(self.parent, StatusEvent(status="Parameters range will\
-                     be ignored for %s fitting engine"%str(self._fit_engine)))
-                #print "args...:",metadata,self.fit_id,smearer,qmin,qmax,ymin,ymax
-                dy=[]
-                x=[]
-                y=[]
-                if metadata.__class__ in  ["Data1D","Theory1D"]:
-                    for i in range(len(metadata.dy)):
-                        if metadata.dy[i] !=0:
-                            dy.append(metadata.dy[i])
-                            x.append(metadata.x[i])
-                            y.append(metadata.y[i])
-                    if len(dy)>0:        
-                        metadata.dy=numpy.zeros(len(dy))
-                        metadata.dy=dy
-                        metadata.y=numpy.zeros(len(y))
-                        metadata.y=y
-                        metadata.x=numpy.zeros(len(x))
-                        metadata.x=x
-                self.fitter.set_data(data=metadata,Uid=self.fit_id,
-                                     smearer=smearer,qmin= qmin,qmax=qmax,
-                                     ymin=ymin,ymax=ymax)
-                self.fitter.select_problem_for_fit(Uid=self.fit_id,value=value.get_scheduled())
-                page_fitted=current_pg
-                #self.fit_id+=1
-                #self.schedule_for_fit( 0,value) 
-            except:
-                wx.PostEvent(self.parent, StatusEvent(status="Single Fit error: %s" % sys.exc_value))
-                return
-            # make sure to keep an alphabetic order 
-            #of parameter names in the list      
-            try:
-                # If a thread is already started, stop it
-                if self.calc_thread != None and self.calc_thread.isrunning():
-                    self.calc_thread.stop()
-                        
-                self.calc_thread =FitThread(parent =self.parent,
-                                            fn= self.fitter,
-                                            pars= pars,
-                                            cpage= page_fitted,
-                                           qmin=qmin,
-                                           qmax=qmax,
-                                          
-                                           completefn=self._single_fit_completed,
-                                           updatefn=None)
-                self.calc_thread.queue()
-                self.calc_thread.ready(2.5)
-             
-            except:
-                wx.PostEvent(self.parent, StatusEvent(status="Single Fit error: %s" % sys.exc_value))
-                return
-         
-    def _on_simul_fit(self, id=None,qmin=None,qmax=None, ymin=None, ymax=None):
-        """ 
-            perform fit for all the pages selected on simpage and return chisqr,out and cov
-            @param engineName: type of fit to be performed
-            @param id: unique id corresponding to a fit problem(model, set of data)
-             in park_integration
-            @param model: model to fit
-            
-        """
-        #set an engine to perform fit
-        from sans.fit.Fitting import Fit
-        self.fitter= Fit(self._fit_engine)
-        self.fit_id= 0
-        #Setting an id to store model and data
-        if id!=None:
-             self.fit_id= id
-       
-        
-        for page, value in self.page_finder.iteritems():
-            try:
-                if value.get_scheduled()==1:
-                    metadata = value.get_fit_data()
-                    list = value.get_model()
-                    model= list[0]
-                    #Create dictionary of parameters for fitting used
-                    cpage= page
-                    print ""
-                    pars = []
-                    templist = []
-                    templist = page.get_param_list()
-                    for element in templist:
-                        try:
-                            name = str(element[0].GetLabelText())
-                            pars.append(name)
-                        except:
-                            wx.PostEvent(self.parent, StatusEvent(status="Simultaneous Fit error: %s" % sys.exc_value))
-                            return
-                    # need to check this print "new model "
-                    
-                    new_model=Model(model)
-                    param=value.get_model_param()
-                    
-                    if len(param)>0:
-                        for item in param:
-                            param_value = item[1]
-                            param_name = item[0]
-    
-                            new_model.parameterset[ param_name].set( param_value )
-                        
-                    self.fitter.set_model(new_model, self.fit_id, pars) 
-                    #print "sim-->model",metadata,model,self.fit_id, pars
-                    dy=[]
-                    x=[]
-                    y=[]
-                    if metadata.__class__ in  ["Data1D","Theory1D"]:
-                        for i in range(len(metadata.dy)):
-                            if metadata.dy[i] !=0:
-                                dy.append(metadata.dy[i])
-                                x.append(metadata.x[i])
-                                y.append(metadata.y[i])
-                            if len(dy)>0:        
-                                metadata.dy=numpy.zeros(len(dy))
-                                metadata.dy=dy
-                                metadata.y=numpy.zeros(len(y))
-                                metadata.y=y
-                                metadata.x=numpy.zeros(len(x))
-                                metadata.x=x
-                    self.fitter.set_data(metadata,self.fit_id,qmin,qmax,ymin,ymax)
-                    #print "sim---->value of problem",value.get_scheduled()
-                    self.fitter.select_problem_for_fit(Uid=self.fit_id,value=value.get_scheduled())
-                    self.fit_id += 1 
-                    value.clear_model_param()
-                    #self.schedule_for_fit( 0,value) 
-            except:
-                wx.PostEvent(self.parent, StatusEvent(status="Simultaneous Fit error: %s" % sys.exc_value))
-                return 
-        #Do the simultaneous fit
-        try:
-            # If a thread is already started, stop it
-            if self.calc_thread != None and self.calc_thread.isrunning():
-                self.calc_thread.stop()
-            if  self.fit_id==1:
-                self.calc_thread =FitThread(parent =self.parent,
-                                        fn= self.fitter,
-                                       qmin=qmin,
-                                       qmax=qmax,
-                                       ymin= ymin,
-                                       ymax= ymax,
-                                       cpage=cpage,
-                                       pars= pars,
-                                       completefn= self._simul_fit_completed,
-                                       updatefn=None)
-                      
-            else:
-                self.calc_thread =FitThread(parent =self.parent,
-                                        fn= self.fitter,
-                                       qmin=qmin,
-                                       qmax=qmax,
-                                       ymin= ymin,
-                                       ymax= ymax,
-                                       completefn= self._simul_fit_completed,
-                                       updatefn=None)
-            self.calc_thread.queue()
-            self.calc_thread.ready(2.5)
-            
-        except:
-            wx.PostEvent(self.parent, StatusEvent(status="Simultaneous Fit error: %s" % sys.exc_value))
-            return
-        
-        
-    def _onset_engine(self,event):
-        """ 
-            set engine to scipy
-        """
-        if self._fit_engine== 'park':
-            self._on_change_engine('scipy')
-        else:
-            self._on_change_engine('park')
-        wx.PostEvent(self.parent, StatusEvent(status="Engine set to: %s" % 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
-        """
-        self._fit_engine = engine
-   
-   
-    def _on_model_panel(self, evt):
-        """
-            react to model selection on any combo box or model menu.plot the model  
-        """
-       
-        model = evt.model
-        name = evt.name
-        
-        #print "name fitting", name
-        #sim_page=self.fit_panel.GetPage(1)
-        sim_page=self.sim_page
-        current_pg = self.fit_panel.get_current_page() 
-        if current_pg != sim_page:
-            current_pg.set_panel(model)
-            #model.name = self.page_finder[current_pg].get_name()
-            #print "model name", model.name
-            model.name="M"+str(self.index_model)
-            try:
-                metadata=self.page_finder[current_pg].get_data()
-                M_name=model.name+"= "+name+"("+metadata.group_id+")"
-            except:
-                M_name=model.name+"= "+name
-            self.index_model += 1  
-            
-            
-            # save model name
-            
-            # save the name containing the data name with the appropriate model
-            self.page_finder[current_pg].set_model(model,M_name)
-            self.plot_helper(currpage= current_pg,qmin= None,qmax= None)
-            if self.sim_page!=None:
-                self.sim_page.add_model(self.page_finder)
-        
-    def  set_smearer(self,smearer):
-        """
-        
-        """   
-        current_pg=self.fit_panel.get_current_page()
-        self.page_finder[current_pg].set_smearer(smearer)
-         
-    def redraw_model(self,qmin= None,qmax= None):
-        """
-            Draw a theory according to model changes or data range.
-            @param qmin: the minimum value plotted for theory
-            @param qmax: the maximum value plotted for theory
-        """
-        current_pg=self.fit_panel.get_current_page()
-        for page, value in self.page_finder.iteritems():
-            if page ==current_pg :
-                break 
-        self.plot_helper(currpage=page,qmin= qmin,qmax= qmax)
-        
-    def plot_helper(self,currpage, fitModel=None, qmin=None,qmax=None,
-                    ymin=None,ymax=None, xmin=None, xmax=None,title=None ):
-        """
-            Plot a theory given a model and data
-            @param model: the model from where the theory is derived
-            @param currpage: page in a dictionary referring to some data
-        """
-        if self.fit_panel.GetPageCount() >1:
-            for page in self.page_finder.iterkeys():
-                if  page==currpage :  
-                    data=self.page_finder[page].get_plotted_data()
-                    list=self.page_finder[page].get_model()
-                    model=list[0]
-                    break 
-            #print "model in fitting",model
-            if data!=None and data.__class__.__name__ != 'Data2D':
-                theory = Theory1D(x=[], y=[])
-                theory.name = model.name
-                theory.group_id = data.group_id
-                theory.id = "Model"
-                   
-                x_name, x_units = data.get_xaxis() 
-                y_name, y_units = data.get_yaxis() 
-                theory.xaxis(x_name, x_units)
-                theory.yaxis(y_name, y_units)
-                if qmin == None :
-                   qmin = min(data.x)
-                if qmax == None :
-                   qmax = max(data.x)
-                try:
-                    tempx = qmin
-                    tempy = model.run(qmin)
-                    theory.x.append(tempx)
-                    theory.y.append(tempy)
-                except :
-                        wx.PostEvent(self.parent, StatusEvent(status="fitting \
-                        skipping point x %g %s" %(qmin, sys.exc_value)))
-                           
-                for i in range(len(data.x)):
-                    try:
-                        if data.x[i]> qmin and data.x[i]< qmax: 
-                            tempx = data.x[i]
-                            tempy = model.run(tempx)
-                            theory.x.append(tempx) 
-                            theory.y.append(tempy)
-                           
-                    except:
-                        wx.PostEvent(self.parent, StatusEvent(status="fitting \
-                        skipping point x %g %s" %(data.x[i], sys.exc_value)))   
-                try:
-                    tempx = qmax
-                    tempy = model.run(qmax)
-                    theory.x.append(tempx)
-                    theory.y.append(tempy)
-                except:
-                    wx.PostEvent(self.parent, StatusEvent(status="fitting \
-                        skipping point x %g %s" %(qmin, sys.exc_value)) )
-                    
-                wx.PostEvent(self.parent, NewPlotEvent(plot=theory,
-                                                title=str(data.name)))
-            else:
-               
-                theory=Data2D(data.data, data.err_data)
-                theory.name= model.name
-                if title !=None:
-                    self.title = title
-                    theory.id= self.title
-                    theory.group_id= self.title+data.name
-                else:
-                    self.title= "Analytical model 2D "
-                    theory.id= "Model"
-                    theory.group_id= "Model"+data.name
-                theory.x_bins= data.x_bins
-                theory.y_bins= data.y_bins
-                tempy=[]
-                #print "max x,y",max(data.xmax,data.xmin),max(data.ymax,data.ymin)
-                if qmin==None:
-                    qmin=0#min(math.fabs(data.xmax),math.fabs(data.ymin))
-                if qmax==None:
-                    qmax=math.sqrt(math.pow(max(math.fabs(data.xmax),math.fabs(data.xmin)),2)/
-                                   +math.pow(max(math.fabs(data.ymax),math.fabs(data.ymin)),2))
-                if ymin==None:
-                    ymin=data.ymin
-                if ymax==None:
-                    ymax=data.ymax
-                if xmin ==None:
-                    xmin=data.xmin
-                if xmax==None:
-                    xmax=data.xmax      
-                                  
-                theory.data = numpy.zeros((len(data.y_bins),len(data.x_bins)))
-                for j in range(len(data.y_bins)):
-                    for i in range(len(data.x_bins)):
-                        tempqij=math.sqrt((math.pow(data.y_bins[j],2)+math.pow(data.x_bins[i],2)))
-                        if tempqij>= qmin and tempqij<= qmax: 
-                            theory.data[j][i]=model.runXY([data.y_bins[j],data.x_bins[i]])
-                        else:
-                            theory.data[j][i]=0 #None # Later, We need to decide which of  0 and None is better.
-                #print "len(data.x_bins),len(data.y_bins);",len(data.x_bins),len(data.y_bins),qmax
-                #print "fitting : plot_helper:", theory.image
-                #print "fitting : plot_helper:",theory.image
-                theory.detector= data.detector
-                theory.source= data.source
-                
-                theory.qmin= qmin
-                theory.qmax= qmax
-                theory.ymin= ymin
-                theory.ymax= ymax
-                theory.xmin= xmin
-                theory.xmax= xmax
-        
-                wx.PostEvent(self.parent, NewPlotEvent(plot=theory,
-                                                title=self.title +str(data.name)))
-        
-        
-    def _on_model_menu(self, evt):
-        """
-            Plot a theory from a model selected from the menu
-        """
-        name = evt.model.__name__
-        if hasattr(evt.model, "name"):
-            name = evt.model.name
-        #print "on model menu", name
-        model=evt.model()
-        description=model.description
-        
-        # Create a model page. If a new page is created, the model
-        # will be plotted automatically. If a page already exists,
-        # the content will be updated and the plot refreshed
-        self.fit_panel.add_model_page(model,description,name,topmenu=True)
-        
-    def draw_model(self,model,name ,data=None,description=None,enable1D=True, enable2D=False,
-                   qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS):
-        """
-             draw model with default data value
-        """
-        if data !=None:
-            self.redraw_model(qmin,qmax)
-            return 
-        self._draw_model1D(model,name,model.description, enable1D,qmin,qmax, qstep)
-        self._draw_model2D(model=model,
-                           description=model.description,
-                           enable2D= enable2D,
-                           qmin=qmin,
-                           qmax=qmax,
-                           qstep=qstep)
-        
-              
-    def _draw_model1D(self,model,name,description=None, enable1D=True,
-                      qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS):
-        """
-        
-        """
-        
-        if enable1D:
-            x=  numpy.linspace(start= qmin,
-                               stop= qmax,
-                               num= qstep,
-                               endpoint=True
-                               )      
-            xlen= len(x)
-            y = numpy.zeros(xlen)
-            if not enable1D:
-                for i in range(xlen):
-                    y[i] = model.run(x[i])
-                
-                try:
-                    new_plot = Theory1D(x, y)
-                    
-                    new_plot.name = name
-                    new_plot.xaxis("\\rm{Q}", 'A^{-1}')
-                    new_plot.yaxis("\\rm{Intensity} ","cm^{-1}")
-                    new_plot.id = "Model"
-                    new_plot.group_id ="Model"
-                    wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title="Analytical model 1D"))
-                except:
-                    wx.PostEvent(self.parent, StatusEvent(status="Draw model 1D error: %s" % sys.exc_value))
-                    #raise
-                    return
-            else:
-                for i in range(xlen):
-                    y[i] = model.run(x[i]) 
-                try:
-                    new_plot = Theory1D(x, y)
-                    #print "draw model 1D", name
-                    new_plot.name = name
-                    new_plot.xaxis("\\rm{Q}", 'A^{-1}')
-                    new_plot.yaxis("\\rm{Intensity} ","cm^{-1}")
-                    new_plot.id ="Model"
-                    new_plot.group_id ="Model"
-                    
-                    # Pass the reset flag to let the plotting event handler
-                    # know that we are replacing the whole plot
-                    wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
-                                     title="Analytical model 1D ", reset=True ))
-                    
-                except:
-                    #raise
-                    wx.PostEvent(self.parent, StatusEvent(status="Draw model 1D error: %s" % sys.exc_value))
-                    return
-    
-    
-    
-    def update(self, output,time):
-        """
-        """
-        pass
-    
-    def complete(self, output, elapsed, model, qmin, qmax,qstep=DEFAULT_NPTS):
-        """
-        """
-        wx.PostEvent(self.parent, StatusEvent(status="Calc \
-        complete !" , type="stop"))
-        #print "complete",output, model,qmin, qmax
-        data = output
-        temp= numpy.zeros(numpy.shape(data))
-        temp[temp==0]=1
-        theory= Data2D(image=data, err_image=temp)
-    
-        from DataLoader.data_info import Detector, Source
-        
-        detector = Detector()
-        theory.detector=[]
-        theory.detector.append(detector) 
-            
-        theory.detector[0].distance=1e+32#13705.0
-        theory.source= Source()
-        theory.source.wavelength=2*math.pi/1e+32#8.4
-        theory.x_bins =[]
-        theory.y_bins =[]
-        #Now qmax is xmax.
-        xmax=2*theory.detector[0].distance*math.atan(qmax/(4*math.pi/theory.source.wavelength))
-        theory.detector[0].pixel_size.x= xmax/(qstep/2-0.5)#5.0
-        theory.detector[0].pixel_size.y= xmax/(qstep/2-0.5)#5.0
-        theory.detector[0].beam_center.x= qmax
-        theory.detector[0].beam_center.y= qmax
-        #print "xmax,qmax",xmax,qmax
-        # compute x_bins and y_bins
-        # Qx and Qy vectors
-    
-        distance   = theory.detector[0].distance
-        pixel      = qstep/2-1
-        theta      = pixel / distance / qstep#100.0
-        wavelength = theory.source.wavelength
-        pixel_width_x = theory.detector[0].pixel_size.x
-        pixel_width_y = theory.detector[0].pixel_size.y
-        center_x      = theory.detector[0].beam_center.x/pixel_width_x
-        center_y      = theory.detector[0].beam_center.y/pixel_width_y
-        
-        
-        size_x, size_y= numpy.shape(theory.data)
-        #print "size_x,size_y",size_x, size_y
-        #This case, q and x are equivalent to each other.
-        for i_x in range(size_x):
-            theta = (i_x-center_x)*pixel_width_x / distance #/ size_x#100.0
-            qx = 4.0*math.pi/wavelength * math.tan(theta/2.0)
-            theory.x_bins.append(qx)    
-        for i_y in range(size_y):
-            theta = (i_y-center_y)*pixel_width_y / distance #/ size_y#100.0
-            qy =4.0*math.pi/wavelength * math.tan(theta/2.0)
-            theory.y_bins.append(qy)
-           
-        #theory.err_data= numpy.    
-        theory.name= model.name
-        theory.group_id ="Model"
-        theory.id ="Model"
-        
-       
-        
-        theory.xmin= -qmax#/math.sqrt(2)#You can not do sqrt(2), that changes axis scale not data itself
-        theory.xmax= qmax#/math.sqrt(2)
-        theory.ymin= -qmax#/math.sqrt(2)
-        theory.ymax= qmax#/math.sqrt(2)
-        
-        #print "model draw comptele xmax",theory.xmax,model.name
-        wx.PostEvent(self.parent, NewPlotEvent(plot=theory,
-                         title="Analytical model 2D ", reset=True ))
-         
-        
-         
-    def _draw_model2D(self,model,description=None, enable2D=False,
-                      qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS):
-        
-        x=  numpy.linspace(start= -1*qmax,
-                               stop= qmax,
-                               num= qstep,
-                               endpoint=True )  
-        y = numpy.linspace(start= -1*qmax,
-                               stop= qmax,
-                               num= qstep,
-                               endpoint=True )
-       
-        lx = len(x)
-        #print x
-        #data=numpy.zeros([len(x),len(y)])
-        self.model= model
-        if enable2D:
-            try:
-                from sans.guiframe.model_thread import Calc2D
-               # print "in draw model 2d ",self.model
-                self.calc_thread = Calc2D(parent =self.parent,x=x,
-                                           y=y,model= self.model, 
-                                           qmin=qmin,
-                                           qmax=qmax,
-                                           qstep=qstep,
-                                completefn=self.complete,
-                                updatefn=None)
-                self.calc_thread.queue()
-                self.calc_thread.ready(2.5)
-            except:
-                raise
-            
-    def show_panel2D(self, id=None ):
-        self.parent.show_panel(self.model2D_id)
-           
-   
-if __name__ == "__main__":
-    i = Plugin()
-    
-    
-    
-    
Index: nsview/perspectives/fitting/old_modelpage.py
===================================================================
--- sansview/perspectives/fitting/old_modelpage.py	(revision c77d8592395f6684cf45ee976c1cac9db9c00110)
+++ 	(revision )
@@ -1,1061 +1,0 @@
-import sys
-import wx
-import wx.lib.newevent
-import numpy
-import copy
-import math
-from sans.models.dispersion_models import ArrayDispersion, GaussianDispersion
-
-from sans.guicomm.events import StatusEvent   
-from sans.guiframe.utils import format_number
-(ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent()
-_BOX_WIDTH = 80
-
-
-
-
-class ModelPage(wx.ScrolledWindow):
-    """
-        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.
-  
-    """
-    ## Internal name for the AUI manager
-    window_name = "Fit page"
-    ## Title to appear on top of the window
-    window_caption = "Fit Page"
-    name=""
-    def __init__(self, parent,model,name, *args, **kwargs):
-        wx.ScrolledWindow.__init__(self, parent, *args, **kwargs)
-        """ 
-            Initialization of the Panel
-        """
-        # model on which the fit would be performed
-        self.model=model
-        # Data member to store the dispersion object created
-        self._disp_obj_dict = {}
-        self.back_up_model= model.clone()
-        #list of dispersion paramaters
-        self.disp_list=[]
-        try:
-            self.disp_list=self.model.getDispParamList()
-        except:
-            pass 
-        self.manager = None
-        self.parent  = parent
-        self.event_owner = None
-        # this panel does contain data .existing data allow a different drawing
-        #on set_model parameters
-        self.data=None
-        #panel interface
-        self.vbox  = wx.BoxSizer(wx.VERTICAL)
-        self.sizer11 = wx.BoxSizer(wx.HORIZONTAL)
-        #self.sizer10 = wx.GridBagSizer(5,5)
-        self.sizer9 = wx.GridBagSizer(5,5)
-        self.sizer8 = wx.GridBagSizer(5,5)
-        self.sizer7 = wx.GridBagSizer(5,5)
-        self.sizer6 = wx.GridBagSizer(5,5)
-        self.sizer5 = wx.GridBagSizer(5,5)
-        self.sizer4 = wx.GridBagSizer(5,5)
-       
-        #model selection
-        self.vbox.Add(wx.StaticLine(self, -1), 0, wx.EXPAND, 0)
-        self.vbox.Add(self.sizer4)
-        #model description
-        self.vbox.Add(self.sizer11)
-        #model paramaters layer
-        self.vbox.Add(self.sizer5)
-        #polydispersion selected
-        self.vbox.Add(wx.StaticLine(self, -1), 0, wx.EXPAND, 0)
-        self.vbox.Add(self.sizer6)
-        #combox box for type of dispersion
-        self.vbox.Add(self.sizer7)
-        #dispersion parameters layer
-        self.vbox.Add(self.sizer8)
-        # plotting range
-        self.vbox.Add(self.sizer9)
-        #close layer
-        #self.vbox.Add(wx.StaticLine(self, -1), 0, wx.EXPAND, 0)
-        #self.vbox.Add(self.sizer10)
-        
-      
-        #------------------ sizer 4  draw------------------------  
-       
-        ## structure combox box
-        self.structbox = wx.ComboBox(self, -1)
-        # define combox box
-        self.modelbox = wx.ComboBox(self, -1)
-        
-        #enable model 2D draw
-        self.enable2D= False
-        self.fitrange= True
-        #filling sizer2
-        ix = 0
-        iy = 1
-        self.sizer4.Add(wx.StaticText(self,-1,'Model'),(iy,ix),(1,1)\
-                  , wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1
-        self.sizer4.Add(self.modelbox,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix +=1
-        self.text_mult= wx.StaticText(self,-1,' x ')
-        self.sizer4.Add(self.text_mult,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer4.Add(self.structbox,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        
-        if hasattr(model ,"model2"):
-            name= model.model2.name
-
-            self.structbox.SetValue(name)          
-        if hasattr(model ,"model1"):
-            name= model.model1.name
-            items = self.modelbox.GetItems()
-            self.modelbox.SetValue(name)
-        else:
-            #print "model view prev_model",name
-            self.modelbox.SetValue( name )
-        ix += 1
-        id = wx.NewId()
-        self.model_view =wx.Button(self,id,'View 2D')
-        self.model_view.Bind(wx.EVT_BUTTON, self.onModel2D,id=id)
-        self.model_view.SetToolTipString("View model in 2D")
-        
-        self.sizer4.Add(self.model_view,(iy,ix),(1,1),\
-                   wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        
-        self.model_view.Enable()
-        self.model_view.SetFocus()
-        
-        ix = 0
-        iy += 1
-        self.sizer4.Add((20,20),(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-
-        #----------sizer6-------------------------------------------------
-        self.disable_disp = wx.RadioButton(self, -1, 'No', (10, 10), style=wx.RB_GROUP)
-        self.enable_disp = wx.RadioButton(self, -1, 'Yes', (10, 30))
-        self.Bind(wx.EVT_RADIOBUTTON, self.Set_DipersParam, id=self.disable_disp.GetId())
-        self.Bind(wx.EVT_RADIOBUTTON, self.Set_DipersParam, id=self.enable_disp.GetId())
-        ix= 0
-        iy=1
-        self.sizer6.Add(wx.StaticText(self,-1,'Polydispersity: '),(iy,ix),(1,1)\
-                  , wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1
-        self.sizer6.Add(self.enable_disp ,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer6.Add(self.disable_disp ,(iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix =0
-        iy+=1
-        self.sizer6.Add((20,20),(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
-
-        
-        #---------sizer 9 draw----------------------------------------
-       
-         ## Q range
-        self.qmin_x= 0.001
-        self.qmax_x= 0.1
-        self.num_points= 100
-        
-        
-        self.qmin    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
-        self.qmin.SetValue(format_number(self.qmin_x))
-        self.qmin.SetToolTipString("Minimun value of Q in linear scale.")
-        self.qmin.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-        self.qmin.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
-     
-        self.qmax    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
-        self.qmax.SetValue(format_number(self.qmax_x))
-        self.qmax.SetToolTipString("Maximum value of Q in linear scale.")
-        self.qmax.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-        self.qmax.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
-     
-
-        self.npts    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
-        self.npts.SetValue(format_number(self.num_points))
-        self.npts.SetToolTipString("Number of point to plot.")
-        self.npts.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-        self.npts.Bind(wx.EVT_TEXT_ENTER, self._onparamEnter)
-       
-        ix = 0
-        iy = 1 
-        self.sizer9.Add(wx.StaticText(self, -1, 'Plotting Range'),(iy, ix),(1,1),\
-                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1 
-        self.sizer9.Add(wx.StaticText(self, -1, 'Min'),(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer9.Add(wx.StaticText(self, -1, 'Max'),(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer9.Add(wx.StaticText(self, -1, 'Npts'),(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix = 0
-        iy += 1
-        self.sizer9.Add(wx.StaticText(self, -1, 'Q range'),(iy, ix),(1,1),\
-                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix += 1
-        self.sizer9.Add(self.qmin,(iy, ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer9.Add(self.qmax,(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix += 1
-        self.sizer9.Add(self.npts,(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        
-        ix =0
-        iy+=1 
-        self.sizer9.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        
-        # contains link between  model ,all its parameters, and panel organization
-        self.parameters=[]
-        self.fixed_param=[]
-        self.fittable_param=[]
-        self.polydisp= {}
-        #contains link between a model and selected parameters to fit 
-        self.param_toFit=[]
-        
-        #dictionary of model name and model class
-        self.model_list_box={}
-        #Draw initial panel
-         #-----sizer 11--------------------model description------
-        if self.model!=None:
-            self.set_panel(self.model)
-        self.theta_cb=None
-        
-       
-        self.vbox.Layout()
-        self.vbox.Fit(self) 
-        self.SetSizer(self.vbox)
-        self.SetScrollbars(20,20,55,40)
-        
-        self.Centre()
-        self.Layout()
-        self.parent.GetSizer().Layout()
-    def set_model_description(self, model=None):
-        
-        if model !=None:
-            description="description"
-        else:
-            description=""
-            if hasattr(model,description.lower())and self.data==None:
-                self.sizer11.Clear(True)
-                self.box_description= wx.StaticBox(self, -1, 'Model Description')
-                boxsizer1 = wx.StaticBoxSizer(self.box_description, wx.VERTICAL)
-                boxsizer1.SetMinSize((320,20))
-                self.description = wx.StaticText(self,-1,str(model.description))
-                boxsizer1.Add(self.description, 0, wx.EXPAND)  
-                self.sizer11.Add(boxsizer1,1, wx.EXPAND | wx.ALL, 2)
-      
-        
-    def set_owner(self,owner):
-        """ 
-            set owner of fitpage
-            @param owner: the class responsible of plotting
-        """
-        self.event_owner=owner    
-   
-  
-    def set_manager(self, manager):
-        """
-             set panel manager
-             @param manager: instance of plugin fitting
-        """
-        self.manager = manager  
-        
-    def populate_box(self, dict):
-        """
-            Populate each combox box of each page
-            @param page: the page to populate
-        """
-        
-        self.model_list_box = dict.get_list()
-       
-        for item , mylist in self.model_list_box.iteritems():
-            separator= "---%s---"%item
-            self.modelbox.Append(separator,"separator")
-            
-            for models in mylist:
-                model= models()
-                name = model.__class__.__name__
-                if hasattr(model, "name"):
-                    name = model.name
-                self.modelbox.Append(name,models)
-            wx.EVT_COMBOBOX(self.modelbox,-1, self._on_select_model)
-            if item == "Structure Factors" :
-                for structs in mylist:
-                    struct= structs()
-                    name = struct.__class__.__name__
-                    if hasattr(struct, "name"):
-                        name = struct.name
-                    self.structbox.Append(name,structs)
-                wx.EVT_COMBOBOX(self.structbox,-1, self._on_select_model)
-        
-        return 0
-    
-
-    def Set_DipersParam(self, event):
-        if self.model ==None:
-            msg= " Select non - model value:%s !"%self.model
-            wx.PostEvent(self.parent.parent, StatusEvent(status= msg))
-            return 
-        if self.enable_disp.GetValue():
-            if len(self.disp_list)==0:
-                ix=0
-                iy=1
-                self.fittable_param=[]
-                self.fixed_param=[]
-                self.sizer8.Clear(True)
-                model_disp = wx.StaticText(self, -1, 'No PolyDispersity for this model')
-                self.sizer7.Add(model_disp,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-                self.vbox.Layout()
-                self.SetScrollbars(20,20,55,40)
-                self.Layout()
-                self.parent.GetSizer().Layout()
-                return 
-            else:
-                if self.data !=None and self.model !=None: # allow to recognize data panel from model panel
-                    
-                
-                    self.cb1.SetValue(False)
-                    self.select_all_param_helper()
-                
-                self.populate_disp_box()
-                self.set_panel_dispers(self.disp_list)
-                
-        else:
-            if self.data !=None and self.model!=None:
-                if self.cb1.GetValue():
-                    self.select_all_param_helper()
-            
-            if self.back_up_model!=None:
-                keys = self.back_up_model.getDispParamList()
-                keys.sort()
-                #disperse param into the initial state
-                for item in keys:
-                    value= self.back_up_model.getParam(item)
-                    self.model.setParam(item, value)
-                self._draw_model() 
-            
-                
-            self.fittable_param=[]        
-            self.fixed_param=[]
-            self.sizer7.Clear(True)
-            self.sizer8.Clear(True)
-            self.vbox.Layout()
-            self.SetScrollbars(20,20,55,40)
-            self.Layout()
-            self.parent.GetSizer().Layout()
-            
-    def populate_disp_box(self):
-        self.sizer7.Clear(True)
-        if len(self.disp_list)>0:
-            ix=0
-            iy=1
-            model_disp = wx.StaticText(self, -1, 'Model Disp')
-            self.sizer7.Add(model_disp,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-            ix += 1 
-            # set up the combox box
-            id = 0
-            import sans.models.dispersion_models 
-            self.polydisp= sans.models.dispersion_models.models
-            self.disp_box = wx.ComboBox(self, -1)
-            self.disp_box.SetValue("GaussianModel")
-            for k,v in self.polydisp.iteritems():
-                if str(v)=="MyModel":
-    				# Remove the option until the rest of the code is ready for it
-                    #self.disp_box.Insert("Select customized Model",id)
-                    pass  
-                else:
-                    self.disp_box.Insert(str(v),id)         
-                id+=1
-            
-            wx.EVT_COMBOBOX(self.disp_box,-1, self._on_select_Disp) 
-            self.sizer7.Add(self.disp_box,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            self.vbox.Layout()
-            self.SetScrollbars(20,20,55,40)
-            self.Layout()
-            self.parent.GetSizer().Layout()  
-            
-            
-    def set_range(self, qmin_x, qmax_x, npts):
-        """
-            Set the range for the plotted models
-            @param qmin: minimum Q
-            @param qmax: maximum Q
-            @param npts: number of Q bins
-        """
-        # Set the data members
-        self.qmin_x = qmin_x
-        self.qmax_x = qmax_x
-        self.num_points = npts
-        
-        # Set the controls
-        self.qmin.SetValue(format_number(self.qmin_x))
-        self.qmax.SetValue(format_number(self.qmax_x))
-        self.npts.SetValue(format_number(self.num_points))
-    def checkFitRange(self):
-        """
-            Check the validity of fitting range
-            @note: qmin should always be less than qmax or else each control box
-            background is colored in pink.
-        """
-       
-        flag = True
-        valueMin = self.qmin.GetValue()
-        valueMax = self.qmax.GetValue()
-        # Check for possible values entered
-        #print "fitpage: checkfitrange:",valueMin,valueMax
-        try:
-            if (float(valueMax)> float(valueMin)):
-                self.qmax.SetBackgroundColour(wx.WHITE)
-                self.qmin.SetBackgroundColour(wx.WHITE)
-            else:
-                flag = False
-                self.qmin.SetBackgroundColour("pink")
-                self.qmax.SetBackgroundColour("pink")      
-        except:
-            flag = False
-            self.qmin.SetBackgroundColour("pink")
-            self.qmax.SetBackgroundColour("pink")
-            
-        self.qmin.Refresh()
-        self.qmax.Refresh()
-        return flag
-    
-
-        
-    def onClose(self,event):
-        """ close the page associated with this panel"""
-        self.parent.onClose()
-        
-  
-        
-    def onModel2D(self, event):
-        """
-         call manager to plot model in 2D
-        """
-        # If the 2D display is not currently enabled, plot the model in 2D 
-        # and set the enable2D flag.
-        if self.fitrange:
-            self.enable2D = True
-            
-        if self.enable2D:
-            self._draw_model()
-            self.model_view.Disable()
-       
-            
-    
-    def select_model(self, model, name):
-        """
-            Select a new model
-            @param model: model object 
-        """
-        self.model = model
-        self.parent.model_page.name = name
-        self.parent.draw_model_name = name
-        
-        self.set_panel(model)
-        self._draw_model()
-       
-        if hasattr(model ,"model2"):
-            name= model.model2.name
-            items = self.structbox.GetItems()
-            for i in range(len(items)):
-                if items[i]==name:
-                    self.structbox.SetSelection(i)
-                    
-        if hasattr(model ,"model1"):
-            name= model.model1.name
-            items = self.modelbox.GetItems()
-            for i in range(len(items)):
-                if items[i]==name:
-                    self.modelbox.SetSelection(i)
-        else:
-            # Select the model from the combo box
-            items = self.modelbox.GetItems()
-            for i in range(len(items)):
-                if items[i]==name:
-                    self.modelbox.SetSelection(i)
-            self.structbox.SetValue("No Structure")
-                    
-        self.model_view.SetFocus()
-                
-    def _on_select_Disp(self,event):
-        """
-             allow selecting different dispersion
-             self.disp_list should change type later .now only gaussian
-        """
-        type =event.GetString()
-        self.set_panel_dispers( self.disp_list,type )
-                
-    def _on_select_model(self,event):
-        """
-            react when a model is selected from page's combo box
-            post an event to its owner to draw an appropriate theory
-        """
-        self.disable_disp.SetValue(True)
-        self.sizer8.Clear(True)
-        self.sizer7.Clear(True)       
-        self.vbox.Layout()
-        self.SetScrollbars(20,20,55,40)
-        self.Layout()
-        self.parent.GetSizer().Layout()
-        form_factor =self.modelbox.GetClientData(self.modelbox.GetCurrentSelection())
-        struct_factor =self.structbox.GetClientData(self.structbox.GetCurrentSelection())
-       
-        if form_factor!="separator":
-            if struct_factor != None and struct_factor.__name__ != "NoStructure":
-                from sans.models.MultiplicationModel import MultiplicationModel
-                self.model= MultiplicationModel(form_factor(),struct_factor())
-            else:
-                 self.model= form_factor()
-        else:
-            self.model=None 
-            msg= " Select non - model value:%s !Please select another model"%name 
-            wx.PostEvent(self.parent.parent, StatusEvent(status= msg))
-               
-        self.set_model_description(self.model)
-        self.set_panel(self.model)
-        self.name= self.model.name
-        self.model_view.SetFocus()
-        self.parent.model_page.name= self.name
-        self.parent.draw_model_name= self.name
-        self._draw_model()
-            
-    def get_model_box(self): 
-        """ return reference to combox box self.model"""
-        return self.modelbox
-
-    
-    def get_param_list(self):
-        """
-            @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 
-            properly so raise ValueError,"missing parameter to fit"
-        """
-        if self.param_toFit !=[]:
-            return self.param_toFit
-        else:
-            raise ValueError,"missing parameter to fit"
-        
-        
-    def set_panel(self,model):
-        """
-            Build the panel from the model content
-            @param model: the model selected in combo box for fitting purpose
-        """
-       
-        self.sizer5.Clear(True)
-        self.parameters = []
-        self.param_toFit=[]
-        self.fixed_param=[]
-        if model !=None:
-            self.model = model
-            
-            self.set_model_description( self.model) 
-            
-            keys = self.model.getParamList()
-            #list of dispersion paramaters
-            self.disp_list=self.model.getDispParamList()
-           
-            keys.sort()
-            ik=0
-            im=1
-            
-            iy = 1
-            ix = 0
-            self.cb1 = wx.CheckBox(self, -1,"Select all", (10, 10))
-            if self.data!=None:
-                wx.EVT_CHECKBOX(self, self.cb1.GetId(), self.select_all_param)
-                self.cb1.SetValue(False)
-            else:
-                self.cb1.Disable()
-                self.cb1.Hide()
-           
-            self.sizer5.Add(self.cb1,(iy, ix),(1,1),\
-                              wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-            ix +=1
-            self.text2_2 = wx.StaticText(self, -1, 'Values')
-            self.sizer5.Add(self.text2_2,(iy, ix),(1,1),\
-                                wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
-            ix +=2
-            self.text2_3 = wx.StaticText(self, -1, 'Errors')
-            self.sizer5.Add(self.text2_3,(iy, ix),(1,1),\
-                                wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            self.text2_3.Hide() 
-            
-           
-            ix +=1
-            self.text2_4 = wx.StaticText(self, -1, 'Units')
-            self.sizer5.Add(self.text2_4,(iy, ix),(1,1),\
-                                wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
-            self.text2_4.Hide()
-            disp_list=self.model.getDispParamList()
-            for item in keys:
-                if not item in disp_list:
-                    iy += 1
-                    ix = 0
-        
-                    cb = wx.CheckBox(self, -1, item, (10, 10))
-                    if self.data!=None:
-                        cb.SetValue(False)
-                        wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
-                    else:
-                        cb.Disable()
-                    self.sizer5.Add( cb,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-                   
-                    ix += 1
-                    value= self.model.getParam(item)
-                    ctl1 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=wx.TE_PROCESS_ENTER)
-                    ctl1.SetValue(str (format_number(value)))
-                    ctl1.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-                    ctl1.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
-                    self.sizer5.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
-                    
-                    ix += 1
-                    text2=wx.StaticText(self, -1, '+/-')
-                    self.sizer5.Add(text2,(iy, ix),(1,1),\
-                                    wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
-                    text2.Hide()  
-                    ix += 1
-                    ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=wx.TE_PROCESS_ENTER)
-                    self.sizer5.Add(ctl2, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-                    ctl2.Hide()
-                   
-                    ix +=1
-                    # Units
-                    try:
-                        units = wx.StaticText(self, -1, self.model.details[item][0], style=wx.ALIGN_LEFT)
-                    except:
-                        units = wx.StaticText(self, -1, "", style=wx.ALIGN_LEFT)
-                    self.sizer5.Add(units, (iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-               
-                    self.parameters.append([cb,ctl1,text2,ctl2])
-                    
-            iy+=1
-            self.sizer5.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-            
-            #Display units text on panel
-            for item in keys:   
-                if self.model.details[item][0]!='':
-                    self.text2_4.Show()
-                    break
-                else:
-                    self.text2_4.Hide()
-            
-        self.vbox.Layout()
-        self.SetScrollbars(20,20,55,40)
-        self.Layout()
-        self.parent.GetSizer().Layout()
-        
-        
-        
-    def _selectDlg(self):
-        import os
-        dlg = wx.FileDialog(self, "Choose a weight file", os.getcwd(), "", "*.*", wx.OPEN)
-        path = None
-        if dlg.ShowModal() == wx.ID_OK:
-            path = dlg.GetPath()
-        dlg.Destroy()
-        return path
-    def read_file(self, path):
-        try:
-            if path==None:
-                wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                            " Selected Distribution was not loaded: %s"%path))
-                return None, None
-            input_f = open(path, 'r')
-            buff = input_f.read()
-            lines = buff.split('\n')
-            
-            angles = []
-            weights=[]
-            for line in lines:
-                toks = line.split()
-                if len(toks)==2:
-                    try:
-                        angle = float(toks[0])
-                        weight = float(toks[1])
-                    except:
-                        # Skip non-data lines
-                        pass
-                    angles.append(angle)
-                    weights.append(weight)
-            return numpy.array(angles), numpy.array(weights)
-        except:
-            raise 
-        
-          
-    def select_disp_angle(self, event): 
-        """
-            Event for when a user select a parameter to average over.
-            @param event: check box event
-        """
-        
-        
-        # Go through the list of dispersion check boxes to identify which one has changed 
-        for p in self.disp_cb_dict:
-            # Catch which one of the box was just checked or unchecked.
-            if event.GetEventObject() == self.disp_cb_dict[p]:              
-
-                
-                if self.disp_cb_dict[p].GetValue() == True:
-                    # The user wants this parameter to be averaged. 
-                    # Pop up the file selection dialog.
-                    path = self._selectDlg()
-                    
-                    # If nothing was selected, just return
-                    if path is None:
-                        self.disp_cb_dict[p].SetValue(False)
-                        return
-                    
-                    try:
-                        values,weights = self.read_file(path)
-                    except:
-                        wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                            "Could not read input file"))
-                        return
-                    
-                    # If any of the two arrays is empty, notify the user that we won't
-                    # proceed 
-                    if values is None or weights is None:
-                        wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                            "The loaded %s distrubtion is corrupted or empty" % p))
-                        return
-                        
-                    # Tell the user that we are about to apply the distribution
-                    wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                            "Applying loaded %s distribution: %s" % (p, path)))  
-                    
-                    # Create the dispersion objects
-                    disp_model = ArrayDispersion()
-                    disp_model.set_weights(values, weights)
-                    # Store the object to make it persist outside the scope of this method
-                    #TODO: refactor model to clean this up?
-                    self._disp_obj_dict[p] = disp_model
-                    
-                    # Set the new model as the dispersion object for the selected parameter
-                    self.model.set_dispersion(p, disp_model)
-                    
-                    
-                    # Redraw the model
-                    self._draw_model()
-                         
-                else:
-                    # The parameter was un-selected. Go back to Gaussian model (with 0 pts)
-                    disp_model = GaussianDispersion()
-                    # Store the object to make it persist outside the scope of this method
-                    #TODO: refactor model to clean this up?
-                    self._disp_obj_dict[p] = disp_model
-                    
-                    # Set the new model as the dispersion object for the selected parameter
-                    self.model.set_dispersion(p, disp_model)
-                    
-                    # Redraw the model
-                    self._draw_model()
-        return
-
-                      
-                      
-                      
-    def set_panel_dispers(self, disp_list, type="GaussianModel" ):
-        """
-        """
-        
-        self.fittable_param=[]
-        self.fixed_param=[]
-        
-        ix=0
-        iy=1
-                ### this will become a separate method
-        if type== "Select customized Model":
-            ix=0
-            iy=1
-            self.sizer8.Clear(True)        
-            disp1 = wx.StaticText(self, -1, 'Array Dispersion')
-            self.sizer8.Add(disp1,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-            
-            # Look for model parameters to which we can apply an ArrayDispersion model
-            # Add a check box for each parameter.
-            self.disp_cb_dict = {}
-            for p in self.model.dispersion.keys():
-                ix+=1 
-                self.disp_cb_dict[p] = wx.CheckBox(self, -1, p, (10, 10))
-                
-                wx.EVT_CHECKBOX(self, self.disp_cb_dict[p].GetId(), self.select_disp_angle)
-                self.sizer8.Add(self.disp_cb_dict[p], (iy, ix), (1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            
-            ix =0
-            iy +=1 
-            self.sizer8.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)        
-            self.vbox.Layout()
-            self.SetScrollbars(20,20,55,40)
-            self.Layout()
-            self.parent.GetSizer().Layout()  
-           
-        if type== "GaussianModel" :
-
-            self.sizer8.Clear(True)
-            disp = wx.StaticText(self, -1, 'Dispersion')
-            self.sizer8.Add(disp,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-            ix += 1 
-            values = wx.StaticText(self, -1, 'Values')
-            self.sizer8.Add(values,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            ix +=2
-            self.text2_3 = wx.StaticText(self, -1, 'Errors')
-            self.sizer8.Add(self.text2_3,(iy, ix),(1,1),\
-                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            self.text2_3.Hide() 
-           
-            ix += 1 
-            npts = wx.StaticText(self, -1, 'Npts')
-            self.sizer8.Add(npts,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            ix += 1 
-            nsigmas = wx.StaticText(self, -1, 'Nsigmas')
-            self.sizer8.Add(nsigmas,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-            
-            disp_list.sort()
-            #print disp_list,self.model.dispersion
-            for item in self.model.dispersion.keys():
-                name1=item+".width"
-                name2=item+".npts"
-                name3=item+".nsigmas"
-                iy += 1
-                for p in self.model.dispersion[item].keys():
-                    #print "name 1 2 3", name1, name2, name3
-                    if p=="width":
-                        ix = 0
-                        cb = wx.CheckBox(self, -1, name1, (10, 10))
-                        if self.data !=None:
-                            cb.SetValue(False)
-                            wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
-                        else:
-                            cb.Disable()
-                        self.sizer8.Add( cb,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-                        ix = 1
-                        value= self.model.getParam(name1)
-                        ctl1 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=wx.TE_PROCESS_ENTER)
-                        ctl1.SetValue(str (format_number(value)))
-                        ctl1.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-                        ctl1.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
-                        self.sizer8.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
-                        
-                        ix = 2
-                        text2=wx.StaticText(self, -1, '+/-')
-                        self.sizer8.Add(text2,(iy, ix),(1,1),\
-                                        wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
-                        text2.Hide()  
-                        ix = 3
-                        ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=wx.TE_PROCESS_ENTER)
-                        self.sizer8.Add(ctl2, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-                        ctl2.Hide()
-                        self.fittable_param.append([cb,ctl1,text2,ctl2])
-                       
-                        
-                    elif p=="npts":
-                            ix =4 
-                            value= self.model.getParam(name2)
-                            Tctl = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER)
-                            Tctl.SetValue(str (format_number(value)))
-                            Tctl.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-                            Tctl.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
-                            self.sizer8.Add(Tctl, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-                            self.fixed_param.append([name2, Tctl])
-                    elif p=="nsigmas":
-                            ix =5 
-                            value= self.model.getParam(name3)
-                            Tctl = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER)
-                            Tctl.SetValue(str (format_number(value)))
-                            Tctl.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
-                            Tctl.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
-                            self.sizer8.Add(Tctl, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-                            self.fixed_param.append([name3, Tctl])
-                wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                            " Selected Distribution: Gaussian"))   
-            ix =0
-            iy +=1 
-            self.sizer8.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)        
-            self.vbox.Layout()
-            self.SetScrollbars(20,20,55,40)
-            self.Layout()
-            self.parent.GetSizer().Layout()  
-          
-    def checkFitValues(self,val_min, val_max):
-        """
-            Check the validity of input values
-        """
-        flag = True
-        min_value = val_min.GetValue()
-        max_value = val_max.GetValue()
-        # Check for possible values entered
-        if min_value.lstrip().rstrip() =="-inf":
-            min_value= -numpy.inf
-        if max_value.lstrip().rstrip() =="+inf":
-            max_value= numpy.inf
-        if  min_value==-numpy.inf and max_value== numpy.inf:
-            val_min.SetBackgroundColour(wx.WHITE)
-            val_min.Refresh()
-            val_max.SetBackgroundColour(wx.WHITE)
-            val_max.Refresh()
-            return flag
-        elif max_value== numpy.inf:
-            try:
-                float(min_value)
-                val_min.SetBackgroundColour(wx.WHITE)
-                val_min.Refresh()
-            except:
-                flag = False
-                val_min.SetBackgroundColour("pink")
-                val_min.Refresh()
-            return flag
-        elif min_value==-numpy.inf:
-            try:
-                float(max_value)
-                val_max.SetBackgroundColour(wx.WHITE)
-                val_max.Refresh()
-            except:
-                flag = False
-                val_max.SetBackgroundColour("pink")
-                val_max.Refresh()
-            return flag
-        else:    
-            if (float(min_value)< float(max_value)):
-                val_min.SetBackgroundColour(wx.WHITE)
-                val_min.Refresh()
-            else:
-                flag = False
-                val_min.SetBackgroundColour("pink")
-                val_min.Refresh()
-            return flag   
-           
-        
-    def _onparamEnter(self,event):
-        """ 
-            when enter value on panel redraw model according to changed
-        """
-        self.set_model_parameter()
-        
-    def set_model_parameter(self):
-        """
-        """
-        if len(self.parameters) !=0 and self.model !=None:
-            # Flag to register when a parameter has changed.
-            is_modified = False
-            for item in self.fittable_param:
-                try:
-                     name=str(item[0].GetLabelText())
-                     value= float(item[1].GetValue())
-                     # If the value of the parameter has changed,
-                     # update the model and set the is_modified flag
-                     if value != self.model.getParam(name):
-                         self.model.setParam(name,value)
-                         is_modified = True
-                         
-                except:
-                    #raise
-                    wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                            "Model Drawing  Error:wrong value entered : %s"% sys.exc_value))
-                    return 
-                
-                
-            for item in self.fixed_param:
-                try:
-                     name=str(item[0])
-                     value= float(item[1].GetValue())
-                     # If the value of the parameter has changed,
-                     # update the model and set the is_modified flag
-                     if value != self.model.getParam(name):
-                         self.model.setParam(name,value)
-                         is_modified = True
-                         
-                except:
-                    raise
-                    wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                            "Model Drawing  Error:wrong value entered : %s"% sys.exc_value))
-                
-            for item in self.parameters:
-                try:
-                     name=str(item[0].GetLabelText())
-                     value= float(item[1].GetValue())
-                     # If the value of the parameter has changed,
-                     # update the model and set the is_modified flag
-                     if value != self.model.getParam(name):
-                         self.model.setParam(name,value)
-                         is_modified = True
-                   
-                except:
-                    #raise 
-                    wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                           "Model Drawing  Error:wrong value entered : %s"% sys.exc_value))
-                    return
-                
-                
-            # Here we should check whether the boundaries have been modified.
-            # If qmin and qmax have been modified, update qmin and qmax and 
-            # set the is_modified flag to True
-            from sans.guiframe.utils import check_value
-            if check_value( self.qmin, self.qmax):
-                if float(self.qmin.GetValue()) != self.qmin_x:
-                    self.qmin_x = float(self.qmin.GetValue())
-                    is_modified = True
-                if float(self.qmax.GetValue()) != self.qmax_x:
-                    self.qmax_x = float(self.qmax.GetValue())
-                    is_modified = True
-                self.fitrange = True
-            else:
-                self.fitrange = False
-            if float(self.npts.GetValue()) !=  self.num_points:
-                self.num_points = float(self.npts.GetValue())
-                is_modified = True
-          
-            if is_modified:
-                self._draw_model()            
-            
-    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.] 
-        """
-        if self.model !=None:
-            self.manager.draw_model(self.model, self.model.name, data=self.data,
-                                    qmin=self.qmin_x, qmax=self.qmax_x,
-                                    qstep= self.num_points,
-                                    enable2D=self.enable2D)
-       
-    def select_param(self,event):
-        """
-        
-        """
-        pass
-    def select_all_param(self,event): 
-        """
-        
-        """
-        pass
-    def select_all_param_helper(self):
-        """
-             Allows selecting or delecting button
-        """
-        self.param_toFit=[]
-        if  self.parameters !=[]:
-            if  self.cb1.GetValue()==True:
-                for item in self.parameters:
-                    item[0].SetValue(True)
-                    list= [item[0],item[1],item[2],item[3]]
-                    self.param_toFit.append(list )
-                if len(self.fittable_param)>0:
-                    for item in self.fittable_param:
-                        item[0].SetValue(True)
-                        list= [item[0],item[1],item[2],item[3]]
-                        self.param_toFit.append(list )
-            else:
-                for item in self.parameters:
-                    item[0].SetValue(False)
-                for item in self.fittable_param:
-                    item[0].SetValue(False)
-                self.param_toFit=[]
-               
-                
-       
Index: nsview/perspectives/fitting/old_simfitpage.py
===================================================================
--- sansview/perspectives/fitting/old_simfitpage.py	(revision c77d8592395f6684cf45ee976c1cac9db9c00110)
+++ 	(revision )
@@ -1,261 +1,0 @@
-
-import sys,re,string, wx   
-from sans.guicomm.events import StatusEvent    
-
-class SimultaneousFitPage(wx.ScrolledWindow):
-    """
-        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
-    window_name = "simultaneous Fit page"
-    ## Title to appear on top of the window
-    window_caption = "Simultaneous Fit Page"
-    
-    
-    def __init__(self, parent, *args, **kwargs):
-        wx.ScrolledWindow.__init__(self, parent, *args, **kwargs)
-        """
-             Simultaneous page display
-        """
-        self.parent = parent
-        self.page_finder={}
-        self.sizer3 = wx.GridBagSizer(5,5)
-        self.sizer1 = wx.GridBagSizer(5,5)
-        self.sizer2  = wx.BoxSizer(wx.HORIZONTAL)
-        self.vbox  = wx.BoxSizer(wx.VERTICAL)
-        self.vbox.Add(self.sizer3)
-        self.vbox.Add(self.sizer1)
-        self.vbox.Add(self.sizer2)
-        id = wx.NewId()
-        self.btFit =wx.Button(self,id,'Constraint Fit')
-        self.btFit.Bind(wx.EVT_BUTTON, self.onFit,id=id)
-        self.btFit.SetToolTipString("Perform fit.")
-        ix = 0
-        iy = 1 
-        self.cb1 = wx.CheckBox(self, -1,'Models', (10, 10))
-        self.sizer3.Add(self.cb1,(iy, ix),(1,1),\
-                        wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        wx.EVT_CHECKBOX(self, self.cb1.GetId(), self.select_all_model_name)
-      
-        text=wx.StaticText(self, -1, 'Constraint')
-        self.sizer2.Add(text,0, wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
-
-        self.ctl2 = wx.TextCtrl(self, -1, style=wx.TE_MULTILINE)
-       
-        self.sizer2.Add(self.ctl2, 0, wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
-       
-        self.sizer2.Add(self.btFit, 0, wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
-        self.params=[]
-        self.model_list=[]
-        self.model_toFit=[]
-        
-        self.vbox.Layout()
-        self.vbox.Fit(self) 
-        self.SetSizer(self.vbox)
-        self.SetScrollbars(20,20,55,40)
-        self.Centre()
-        
-        
-    def onFit(self,event):
-        """ signal for fitting"""
-        for page in self.page_finder.iterkeys():
-            page.set_model_parameter()
-        if len(self.model_toFit) >= 1 :
-            self._onTextEnter()
-            self.set_model()
-            self.manager._on_simul_fit()
-        else:
-            wx.PostEvent(self.parent.Parent, StatusEvent(status=\
-                            "Select at least one model to fit "))
-           
-            
-            
-    def set_manager(self, manager):
-        """
-            set panel manager
-            @param manager: instance of plugin fitting
-        """
-        self.manager = manager
-        self.add_model( self.manager.page_finder)
-        
-        
-    def select_all_model_name(self,event):
-        """
-            check all models names
-        """
-        self.model_toFit=[] 
-        if self.cb1.GetValue()==True:
-            for item in self.model_list:
-                item[0].SetValue(True)
-                self.manager.schedule_for_fit( value=1,fitproblem =item[1]) 
-                self.model_toFit.append(item)
-        else:
-            for item in self.model_list:
-                item[0].SetValue(False) 
-                self.manager.schedule_for_fit( value=0,fitproblem =item[1]) 
-                
-            self.model_toFit=[]
-       
-            
-    def add_model(self,page_finder):
-        """
-            Receive a dictionary containing information to display model name
-            @param page_finder: the dictionary containing models information
-        """
-        if len(self.model_list)>0:
-            for item in self.model_list:
-                item[0].SetValue(False) 
-                self.manager.schedule_for_fit( value=0,fitproblem =item[1])
-        self.model_list=[]
-        self.model_toFit=[]
-        self.sizer1.Clear(True)
-        self.page_finder=page_finder
-        self.cb1.SetValue(False)
-        ix = 0
-        iy = 1 
-        list=[]
-        for page, value in page_finder.iteritems():
-            try:
-                list = value.get_model()
-                model = list[0]
-                modelname = list[1]
-                cb = wx.CheckBox(self, -1, modelname, (10, 10))
-                cb.SetValue(False)
-                self.sizer1.Add( cb,( iy,ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-                ix = 0
-                iy += 1 
-                wx.EVT_CHECKBOX(self, cb.GetId(), self.select_model_name)
-                self.model_list.append([cb,value,page,modelname])
-            except:
-                pass
-        iy +=1
-        self.sizer1.Add((20,20),( iy,ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        self.sizer1.Layout()        
-        self.vbox.Layout()
-        
-        
-    def remove_model(self,delpage):
-        """
-             Remove  a checkbox and the name related to a model selected on page delpage
-             @param delpage: the page removed
-        """
-        self.model_list=[]
-        self.model_toFit=[]
-        self.sizer1.Clear(True)
-       
-        self.cb1.SetValue(False)
-        ix = 0
-        iy = 1 
-        list=[]
-        for page, value in self.page_finder.iteritems():
-            try:
-                if page!= delpage:
-                    list = value.get_model()
-                    model = list[0]
-                    modelname = list[1]
-                    cb = wx.CheckBox(self, -1, modelname, (10, 10))
-                    cb.SetValue(False)
-                    self.sizer1.Add( cb,( iy,ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-                    ix = 0
-                    iy += 1 
-                    wx.EVT_CHECKBOX(self, cb.GetId(), self.select_model_name)
-                    self.model_list.append([cb,value,page,modelname])
-            except:
-                pass
-        iy +=1
-        self.sizer1.Add((20,20),( iy,ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        self.sizer1.Layout()        
-        self.vbox.Layout()
-        
-        
-    def select_model_name(self,event):
-        """
-            Save interformation related to checkbox and their states
-        """
-        self.model_toFit=[]
-        for item in self.model_list:
-            if item[0].GetValue()==True:
-                self.model_toFit.append(item)
-                self.manager.schedule_for_fit( value=1,fitproblem =item[1]) 
-            else:
-                self.manager.schedule_for_fit( value=0,fitproblem =item[1]) 
-                if item in self.model_toFit:
-                    self.model_toFit.remove(item)
-                    self.cb1.SetValue(False)
-                    
-        if len(self.model_list)==len(self.model_toFit):
-            self.cb1.SetValue(True)
-        else:
-            self.cb1.SetValue(False)
-     
-        
-   
-    def set_model(self):
-        """
-            set_model take values in self.params which are the values
-            entered by the user and try to assign them into the model 
-            concerned in self.manager. page.finder
-        """
-        if len(self.params) >0:
-            for item in self.model_toFit:
-                list=item[1].get_model()
-                model=list[0]
-                param_list=model.getParamList()
-                if self.params !=[]:
-                    for element in self.params:
-                        if model.name == str(element[0]):
-                            for item in param_list:
-                                if item==str(element[1]):
-                                    self.manager.set_page_finder(model.name,element[1],
-                                                                 str(element[2]))
-                           
-    
-    def _onTextEnter(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
-        """
-        value= self.ctl2.GetValue()
-        if value:
-            self.params=[]
-            try:
-                expression='[\s,;]'
-                if re.search(expression,value) !=None:
-                    word=re.split(expression,value)
-                    for item in word:
-                        self.params.append(self.parser_helper(item))
-                else:
-                    self.params.append(self.parser_helper(value))  
-            except:
-                wx.PostEvent(self.parent.Parent, StatusEvent(status="Constraint Error: %s" % sys.exc_value))
-      
-        
-    def parser_helper(self,value):
-        """
-             @return  param:a list containing the name of a model ,its parameters 
-             value and name extracted from the constrainst controlbox
-        """
-        if string.find(value, "=") !=-1:
-            model_param= re.split("=",value)
-            param_name=model_param[0]
-            param_value=model_param[1]
-            
-            if string.find(param_name,".")!=-1:
-                param_names= re.split("\.",param_name)
-                model_name=param_names[0]
-                param_name=param_names[1]
-                param=[str(model_name),param_name,str(param_value)]
-                return param
-            else:
-                wx.PostEvent(self.parent.Parent,
-                              StatusEvent(status="cannot evaluate this expression"))
-                return
-        else:
-            wx.PostEvent(self.parent.Parent, StatusEvent(status="Missing '=' in expression"))
-            
-   
-    
Index: sansview/perspectives/fitting/welcome_panel.py
===================================================================
--- sansview/perspectives/fitting/welcome_panel.py	(revision 823905f175db5e214fb0aff024e343ebf3299aaa)
+++ sansview/perspectives/fitting/welcome_panel.py	(revision 1328e03fb2dbb5ff0404eac3502aef46dc24fe5d)
@@ -81,10 +81,10 @@
         self.static_line_1 = wx.StaticLine(self, -1)
         self.label_acknowledgement = wx.StaticText(self, -1, config._acknowledgement)
-      
-
-       
-
+        
+        self.hyperlink_license = wx.StaticText(self, -1, "Comments? Bugs? Requests?")
+        self.hyperlink_paper = wx.lib.hyperlink.HyperLinkCtrl(self, -1,
+                                         "Send us a ticket",URL=config._license)
         # end wxGlade
-    
+        
 #      
         # randomly shuffle authors' names
@@ -114,22 +114,18 @@
         sizer_main = wx.BoxSizer(wx.VERTICAL)
         sizer_header = wx.BoxSizer(wx.HORIZONTAL)
-        sizer_build = wx.GridBagSizer(0,0)
+        sizer_build = wx.BoxSizer(wx.VERTICAL)
        
        
         sizer_header.Add(self.bitmap_logo, 0, wx.EXPAND|wx.LEFT, 5)
         
-        ix = 0
-        iy = 0
-        sizer_build.Add((20,20),(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
-        iy +=1
-        sizer_build.Add(self.label_acknowledgement,(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
-        iy +=1
-        sizer_build.Add(self.label_title ,(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
-        ix = 0
-        iy +=1
-        sizer_build.Add(self.label_build,(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
-        ix = 0
-        iy +=1
-        sizer_build.Add( self.label_copyright,(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
+        
+        sizer_build.Add(self.label_acknowledgement,0,wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
+        sizer_build.Add((5,5))
+        sizer_build.Add(self.label_title ,0,wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
+        sizer_build.Add(self.label_build,0,wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)  
+        sizer_build.Add( self.label_copyright,0,wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
+        sizer_build.Add((5,5))
+        sizer_build.Add( self.hyperlink_license,0,wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
+        sizer_build.Add( self.hyperlink_paper,0,wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
         
         sizer_main.Add(sizer_header, 0, wx.TOP|wx.EXPAND, 3)
@@ -147,3 +143,19 @@
 
 # end of class DialogAbout
+class HelpWindow(wx.Frame):
+    def __init__(self, parent, id, title):
+        wx.Frame.__init__(self, parent, id, title, size=(570, 400))
+       
+        
+        self.page = PanelAbout(self)
+        
+        self.Centre()
+        self.Show(True)
 
+
+   
+if __name__=="__main__":
+    app = wx.App()
+    HelpWindow(None, -1, 'HelpWindow')
+    app.MainLoop()
+        
