Changeset c77d859 in sasview for sansview/perspectives/fitting

Timestamp:

Mar 20, 2009 8:26:01 PM (16 years ago)

Author:

Gervaise Alina <gervyh@…>

Branches:

master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

20d30e9

Parents:

f2776f6

Message:

new interface design —→ proposition

Location:

sansview/perspectives/fitting

Files:

• basepage.py (added)
• fit_thread.py (modified) (3 diffs)
• fitpage.py (added)
• fitpage1D.py (deleted)
• fitpanel.py (modified) (7 diffs)
• fitting.py (modified) (22 diffs)
• model_thread.py (modified) (7 diffs)
• modelpage.py (modified) (6 diffs)
• models.py (modified) (2 diffs)
• old_fit_thread.py (added)
• old_fitpage1D.py (modified) (9 diffs)
• old_fitpanel.py (added)
• old_fitting.py (added)
• old_modelpage.py (modified) (14 diffs)
• old_simfitpage.py (added)
• pageInfo.py (added)

sansview/perspectives/fitting/fit_thread.py

@@ -102 +102 @@
     """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,
+    def __init__(self,parent, fn,pars=None,cpage=None, qmin=None,qmax=None,
                  completefn = None,
                  updatefn   = None,
@@ -118 +117 @@
         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=\
@@ -165 +162 @@
                           qmin = self.qmin,
                           qmax = self.qmax,
-                          xmin= self.xmin,
-                          xmax= self.xmax,
-                          ymin = self.ymin,
-                          ymax = self.ymax, 
+                          
                           elapsed=elapsed )
         except KeyboardInterrupt:

sansview/perspectives/fitting/fitpanel.py

@@ -40 +40 @@
         #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=[]
@@ -103 +102 @@
             @param owner: the class responsible of plotting
         """
-        self.event_owner=owner
-        
+        self.event_owner = owner
+    
+    def set_model_list(self,dict):
+         """ 
+             copy a dictionary of model into its own dictionary
+             @param dict: dictionnary made of model name as key and model class
+             as value
+         """
+         self.model_list_box = dict
+        
+  
+    def get_current_page(self):
+        """
+            @return the current page selected
+        """
+        return self.GetPage(self.GetSelection() )
+    
     def add_sim_page(self):
         """
@@ -125 +139 @@
         except:
             name = 'Fit'
+        from pageInfo import  PageInfo
+        myinfo = PageInfo( self, data=data )
+        myinfo.model_list_box = self.model_list_box.get_list()
+        myinfo.event_owner =self.event_owner 
         
         if not name in self.fit_page_name :
-            from fitpage1D import FitPage1D
-            panel = FitPage1D(self,data, -1)
+            from fitpage import FitPage
+            panel = FitPage(parent= self, page_info=myinfo, name=name )
             panel.name=name
             
@@ -135 +153 @@
             
             self.AddPage(page=panel,caption=name,select=True)
-            panel.populate_box( self.model_list_box)
+            #panel.populate_box( self.model_list_box)
             self.fit_page_name.append(name)
     
@@ -150 +168 @@
             @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.get_list()
+        myinfo.event_owner =self.event_owner
+        
         from modelpage import ModelPage
-        #print "fitpanel model", model
-        panel = ModelPage(self,model,page_title, -1)
+        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.populate_box( self.model_list_box)
         panel.name = page_title
         self.draw_model_name=page_title
@@ -168 +193 @@
         # 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)
+        self.manager.draw_model(model)
      
         
@@ -226 +216 @@
                 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
-  
+   
+ 

sansview/perspectives/fitting/fitting.py

@@ -14 +14 @@
 from fit_thread import FitThread
 import models
-import fitpage1D
+import fitpage
 
 DEFAULT_BEAM = 0.005
@@ -22 +22 @@
 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:
     """
@@ -40 +53 @@
         self.mypanels=[]
         # reference to the current running thread
-        self.calc_thread = None
+        self.calc_2D= None
+        self.calc_1D= None
+        self.calc_fit= None
+        
         # Start with a good default
         self.elapsed = 0.022
@@ -60 +76 @@
         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):
@@ -79 +90 @@
         self.menu1.Append(id1, '&Simultaneous')
         wx.EVT_MENU(owner, id1, self.on_add_sim_page)
+        self.menu1.AppendSeparator()
         #Set park engine
         id3 = wx.NewId()
@@ -84 +96 @@
         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...."
@@ -99 +111 @@
         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)
+        owner.Bind(fitpage.EVT_MODEL_BOX,self._on_model_panel)
         
         #create  menubar items
@@ -168 +180 @@
 
         
-    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_show_panel(self, event):
-        print "_on_show_panel: fitting"
-      
       
     def get_perspective(self):
@@ -240 +231 @@
 
 
+   
+                    
+    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()
+        model = list[0]
+        smearer = value.get_smearer()
+        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):
         """ 
@@ -284 +607 @@
                     %sys.exc_value))
                     return
-                    
-                    
-    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 _single_fit_completed(self,result,pars,cpage,qmin,qmax,elapsed=None,
-                              ymin=None, ymax=None, xmin=None, xmax=None):
+    
+    def _single_fit_completed(self,result,pars,cpage,qmin,qmax,elapsed=None):
         """
             Display fit result on one page of the notebook.
@@ -371 +636 @@
             cpage.onsetValues(result.fitness, result.pvec,result.stderr)
             ## plot the current model with new param
-            self.plot_helper(currpage=cpage,qmin=qmin,qmax=qmax,
-                             ymin=ymin, ymax=ymax,
-                             xmin=xmin, xmax=xmax,title=None)
+            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:"
@@ -429 +696 @@
                  return 
              
-             
-    def stop_fit(self):
-        """
-            Stop the fit engine
-        """
-        if self.calc_thread != 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,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
-            
-        """
-        #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[0].GetLabelText()))
-                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,
-                                     ymin=ymin,ymax=ymax)
-                
-                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_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
-            
-        """
-        ##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,ymin,ymax)
-                    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_thread != None and self.calc_thread.isrunning():
-                self.calc_thread.stop()
-                        ## perform single fit
-            if  fitproblem_count==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:
-                ## Perform more than 1 fit at the time
-                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:
-            msg= "Simultaneous Fit error: %s" % sys.exc_value
-            wx.PostEvent(self.parent, StatusEvent(status= msg ))
-            return
-        
+                           
+        
+    def _on_show_panel(self, event):
+        print "_on_show_panel: fitting"
+      
+      
     def _onset_engine_park(self,event):
         """ 
@@ -671 +715 @@
         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'):
@@ -686 +746 @@
             @param evt: wx.combobox event
         """
-       
         model = evt.model
-        name = evt.name
-       
+        if model ==None:
+            return
+        name = model.name
         sim_page=self.sim_page
         current_pg = self.fit_panel.get_current_page() 
@@ -711 +771 @@
             self.page_finder[current_pg].set_model(model,M_name)
             
-                
             # save model name
-            self.plot_helper(currpage= current_pg,qmin= None,qmax= None)
+            self.draw_model( model=model, data= metadata)
+            
             if self.sim_page!=None:
                 self.sim_page.add_model(self.page_finder)
         
         
-        
-    def  set_smearer(self,smearer):
-        """
-            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)
-         
-         
-    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, 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()
-                    smearer = self.page_finder[page].get_smearer()
-                    model = list[0]
-                    break 
-            ## create Model 1D
-            if data != None and data.__class__.__name__ != 'Data2D':
-                x= numpy.zeros(len(data.x))  
-                y= numpy.zeros(len(data.y)) 
-                
-                theory = Theory1D(x=x, y=y)
-                theory.name = model.name
-                if hasattr(data ,"group_id"):
-                    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)
-                
-                j=0
-                try:
-                    tempx = qmin
-                    tempy = model.run(qmin)
-                    theory.x[j]=tempx
-                    theory.y[j]=tempy
-                    j+=1
-                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)
-                            
-                            if j< i:
-                                theory.x[j]=tempx 
-                                theory.y[j]=tempy
-                                j+=1
-                           
-                    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[j]=tempx 
-                    theory.y[j]=tempy
-                    j+=1
-                except:
-                    wx.PostEvent(self.parent, StatusEvent(status="fitting \
-                        skipping point x %g %s" %(qmin, sys.exc_value)) )
-                
-                if smearer!=None:
-                    theory.y= smearer(theory.y)   
-                wx.PostEvent(self.parent, NewPlotEvent(plot=theory,
-                                                title=str(data.name)))
-            else:
-                ## create Model 2D
-                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=[]
-                
-                if qmin==None:
-                    qmin=0
-                if qmax==None:
-                    x= math.pow(max(math.fabs(data.xmax),math.fabs(data.xmin)),2)
-                    y= math.pow(max(math.fabs(data.ymax),math.fabs(data.ymin)),2)
-                    qmax=math.sqrt( x+y )
-                    
-                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:
-                            ## Later, We need to decide which of  0 and None is better.
-                            theory.data[j][i]=0 
-             
-                theory.detector= data.detector
-                theory.source= data.source
-                ## qmin, qmax will used later to define q range.
-                theory.qmin= qmin
-                theory.qmax= qmax
-                ## plot boundaries
-                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):
         """
@@ -893 +795 @@
         self.fit_panel.add_model_page(model,description,name,topmenu=True)
     
-    def complete1D_from_data(self, output,model, data, x, elapsed, name):
-        """
-             plot model 1D with data info 
-        """
-        y= output
-        x= data.x
-        theory = Theory1D(x=x, y=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)
-        wx.PostEvent(self.parent, NewPlotEvent(plot=theory,
-                                                title=str(data.name)))
-        
-    def draw_model1D_from_Data(self, data, model,name=None,
-                                qmin=None, qmax=None, smearer= None):
-        """
-            Draw model 1D from loaded data1D
-            @param data: loaded data
-            @param model: the model to plot
-        """
-        x = data.x
-        self.model= model
-        if qmin == None :
-           qmin = min(data.x)
-        if qmax == None :
-           qmax = max(data.x)
-        if name ==None:
-            name=model.name
-        try:
-            from model_thread import Calc1D
-            ## 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 = Calc1D( x= x,
-                                      model= self.model, 
-                                       qmin= qmin,
-                                       qmax= qmax,
-                                       name= name,
-                                       smearer= smearer,
-                            completefn= self.complete1D_from_data,
-                            updatefn= self.update1D)
-            self.calc_thread.queue()
-            
-        except:
-            msg= " Error occurred when drawing %s Model 1D: "%self.model.name
-            msg+= " %s"%sys.exc_value
-            wx.PostEvent( self.parent, StatusEvent(status= msg ))
-            return  
-            
-    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.
-             @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 based on loaded data
-        if data !=None:
-            self.redraw_model(qmin,qmax)
-            return 
-        ## draw model 1D with no loaded data
-        self._draw_model1D(model,name,model.description, enable1D,qmin,qmax, qstep)
-        ## draw model 2D with no initial data
-        self._draw_model2D(model=model,
-                           description=model.description,
-                           enable2D= enable2D,
-                           qmin=qmin,
-                           qmax=qmax,
-                           qstep=qstep)
-        
-    
-    def update1D(self,x, output):
+   
+    
+    
+    def _update1D(self,x, output):
         """
             Update the output of plotting model 1D
@@ -984 +804 @@
         self.calc_thread.ready(1)
     
-    def complete1D(self, x,output, elapsed, name,data=None):
-        """
-            Complete plotting 1D data
-        """ 
-        try:
-            y = output
-            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"
-            # 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:
-            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 _draw_model1D(self, model, name, description= None, enable1D= True,
-                      qmin= DEFAULT_QMIN, qmax= DEFAULT_QMAX, qstep= DEFAULT_NPTS):
-        """
-            Draw model 1D between qmin and qmax value
-            @param model: the model to draw
-            @param name: the name of the model
-            @param description: descripion of the model as string
-            @param enable1D:  allow to draw model 1D if True  else False
-            @param qmin: the minimum value of the range to draw the model
-            @param qmax: the maximum value of the range to draw the model
-            @param qstep: the number of points to draw  
-        """
-        x=  numpy.linspace(start= qmin,
-                           stop= qmax,
-                           num= qstep,
-                           endpoint=True
-                           )      
-        self.model= model
-        if enable1D:
-            try:
-                from model_thread import Calc1D
-                ## 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 = Calc1D( x= x,
-                                          model= self.model, 
-                                           qmin= qmin,
-                                           qmax= qmax,
-                                           name= name,
-                                           data=None,
-                                        smearer=None,
-                                completefn= self.complete1D,
-                                updatefn= self.update1D)
-                self.calc_thread.queue()
-                
-            except:
-                msg= " Error occurred when drawing %s Model 1D: "%self.model.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, output, elapsed, model, 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" ))
-    
-        data = output
-        temp= numpy.zeros(numpy.shape(data))
-        temp[temp==0]=1
-        theory= Data2D(image=data, err_image=temp)
-    
+    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=[]
         theory.detector.append(detector) 
             
@@ -1083 +817 @@
         theory.source= Source()
         theory.source.wavelength=2*math.pi/1e+32
-        theory.x_bins =[]
-        theory.y_bins =[]
+      
         ## Create detector for Model 2D
         xmax=2*theory.detector[0].distance*math.atan(\
@@ -1114 +847 @@
             theory.y_bins.append(qy)
            
-        theory.name= model.name
         theory.group_id ="Model"
         theory.id ="Model"
@@ -1122 +854 @@
         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)
+        
+        if data ==None:
+            self._fill_default_model2D(theory= theory, qmax=qmax,qstep=qstep, qmin= qmin)
+            theory.name= model.name
+        else:
+            theory.name= data.name
+            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,description=None, enable2D=False,
+    def _draw_model2D(self,model,data=None,description=None, enable2D=False,
                       qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS):
         """
@@ -1140 +976 @@
             
         """
+        
         x=  numpy.linspace(start= -1*qmax,
                                stop= qmax,
@@ -1148 +985 @@
                                num= qstep,
                                endpoint=True )
-       
-        self.model= model
-        if enable2D:
-            try:
-                from model_thread import Calc2D
-                ## 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 = Calc2D( x= x,
-                                           y= y, model= self.model, 
-                                           qmin= qmin,
-                                           qmax= qmax,
-                                           qstep= qstep,
-                                completefn= self.complete2D,
-                                updatefn= self.update2D )
-                self.calc_thread.queue()
-                
-            except:
-                raise
-    
+        ## 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__":

sansview/perspectives/fitting/model_thread.py

@@ -90 +90 @@
     """
     
-    def __init__(self, x, y, model,qmin, qmax,qstep,
+    def __init__(self, x, y, data,model,qmin, qmax,qstep,
                  completefn = None,
                  updatefn   = None,
@@ -101 +101 @@
                  worktime)
         self.qmin= qmin
-        self.qmax=qmax
+        self.qmax= qmax
         self.qstep= qstep
         self.x = x
         self.y = y
+        self.data= data
         ## the model on to calculate
         self.model = model
@@ -128 +129 @@
         y = self.y
         output = numpy.zeros((len(x),len(y)))
-      
-        center_x=0
-        center_y=0
+        
+        if self.qmin==None:
+            self.qmin = 0
+        if self.qmax== None:
+            if data ==None:
+                return
+            newx= math.pow(max(math.fabs(data.xmax),math.fabs(data.xmin)),2)
+            newy= math.pow(max(math.fabs(data.ymax),math.fabs(data.ymin)),2)
+            self.qmax=math.sqrt( newx + newy )
         
         self.starttime = time.time()
         
-        
         lx = len(self.x)
-       
         for i_x in range(len(self.x)):
             # Check whether we need to bail out
@@ -143 +148 @@
        
             for i_y in range(int(len(self.y))):
-           
-                if (self.x[i_x]*self.x[i_x]+self.y[i_y]*self.y[i_y]) \
-                    < self.qmin * self.qmin:
-                    
-                    output[i_x] [i_y]=0   
+                radius = self.x[i_x]*self.x[i_x]+self.y[i_y]*self.y[i_y]
+                
+                if  self.qmin <= radius or radius<= self.qmax:
+                    value = self.model.runXY( [self.x[i_x], self.y[i_y]] )
+                    output[i_x] [i_y]=value   
                 else:
-                    value = self.model.runXY([self.x[i_x]-center_x, self.y[i_y]-center_y])
-                    output[i_x] [i_y]=value   
+                     output[i_x] [i_y]=0   
             
         elapsed = time.time()-self.starttime
-        self.complete(
-                      output=output, elapsed=elapsed,model= self.model,
-                      qmin= self.qmin,
-                      qmax=self.qmax,
-                      qstep=self.qstep)
+        self.complete( image = output,
+                       data = self.data , 
+                       model = self.model,
+                       elapsed = elapsed,
+                       qmin = self.qmin,
+                       qmax =self.qmax,
+                       qstep = self.qstep )
 
 
@@ -256 +262 @@
                  qmin=None,
                  qmax=None,
-                 name=None,
                  smearer=None,
                  completefn = None,
@@ -272 +277 @@
         self.qmax= qmax
         self.model = model
-        self.name= name
         self.smearer= smearer
         self.starttime = 0
         
     def compute(self):
+        """
+            Compute model 1d value given qmin , qmax , x value 
+        """
         import numpy
         
         output = numpy.zeros(len(self.x))
-        if self.qmin==None:
-            self.qmin= min(self.x)
-        if self.qmax==None:
-            self.qmax= max(self.x) 
-               
+       
         self.starttime = time.time()
         
@@ -294 +297 @@
                 value = self.model.run(self.x[i_x])
                 output[i_x] = value
+                
         if self.smearer!=None:
             output = self.smearer(output)
-                    
+            
+                      
         elapsed = time.time()-self.starttime
-        self.complete(x= self.x, output=output, 
-                      elapsed=elapsed, name=self.name, data=self.data)
+        self.complete(x= self.x, y= output, 
+                      elapsed=elapsed, model= self.model, data=self.data)
         
         

sansview/perspectives/fitting/modelpage.py

@@ -1 @@
-import sys
+
 import wx
 import wx.lib.newevent
@@ -12 +12 @@
 _BOX_WIDTH = 80
 
-
-
-
-class ModelPage(wx.ScrolledWindow):
+import basepage
+from basepage import BasicPage
+
+
+class ModelPage(BasicPage):
     """
         FitPanel class contains fields allowing to display results when
@@ -23 +24 @@
   
     """
-    ## 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)
+    def __init__(self,parent, page_info, name=""):
+        BasicPage.__init__(self, parent, page_info,name)
         """ 
             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)
+        
+        self._fill_model_sizer( self.sizer1)  
+        self._fill_range_sizer() 
+        if hasattr(self.page_info,"model"):
+            model=self.page_info.model
+            description=""
+            if model!=None:
+                description = self.page_info.model.description
+            self.set_model_param_sizer(self.model)
+            self.set_model_description(description,self.sizer2)
+        
+    
+
+        
+    def _on_display_description(self, event):
+        """
+            Show or Hide description
+            @param event: wx.EVT_RADIOBUTTON
+        """
+        self._on_display_description_helper()
+        
+        
+        
+    def _on_display_description_helper(self):
+        """
+            Show or Hide description
+            @param event: wx.EVT_RADIOBUTTON
+        """
+        ## save state of radiobox
+        self.page_info. save_radiobox_state( self.description_hide )
+        self.page_info. save_radiobox_state( self.description_show )
+        ## Show description
+        if not self.description_show.GetValue():
+            self.sizer_description.Clear(True)
+            
         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)
-     
-
+            model=self.page_info.model
+            description=""
+            if model!=None:
+                description = self.page_info.model.description
+            self.description = wx.StaticText( self,-1,str(description) )
+            self.sizer_description.Add( self.description, 1, wx.EXPAND | wx.ALL, 10 )
+           
+        self.Layout()
+    
+    
+    def _fill_range_sizer(self):
+        """
+            Fill the sizer containing the plotting range
+            add  access to npts
+        """
+        sizer_npts= wx.GridSizer(1, 1,5, 5)
+    
         self.npts    = wx.TextCtrl(self, -1,size=(_BOX_WIDTH,20))
         self.npts.SetValue(format_number(self.num_points))
@@ -176 +87 @@
         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)
+        
+        sizer_npts.Add(wx.StaticText(self, -1, 'Npts'),1, wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 5)        
+        sizer_npts.Add(self.npts,1, wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 5) 
+        self._set_range_sizer( title="Plotted Q Range", object= sizer_npts)
+       
+    def _on_select_model(self, event): 
+        """
+             call back for model selection
+        """    
+        self._on_select_model_helper(event) 
+        self.set_model_param_sizer(self.model)
+        self._set_sizer_gaussian()
+        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 _fill_model_sizer(self, sizer):
+        """
+            fill sizer containing model info
+        """
+        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")
+        
+        ## class base method  to add view 2d button    
+        self._set_model_sizer(sizer=sizer, title="Model",object= self.model_view )    
+    
+  
+    def _set_sizer_gaussian(self):
+        """
+            draw sizer with gaussian dispersity parameters
+        """
+        self.fittable_param=[]
+        self.fixed_param=[]
+        ##reset model dispersity to gaussian
+        self._reset_gaussian_dispers()
+        
+        self.sizer4_4.Clear(True)
+        if self.model==None:
+            ##no model is selected
+            return
+        if not self.enable_disp.GetValue():
+            ## the user didn't select dispersity display
+            return 
+        ix=0
+        iy=1
+        disp = wx.StaticText(self, -1, 'Names')
+        self.sizer4_4.Add(disp,( 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)
-        
+        values = wx.StaticText(self, -1, 'Values')
+        self.sizer4_4.Add(values,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+       
+        ix += 1 
+        npts = wx.StaticText(self, -1, 'Npts')
+        self.sizer4_4.Add(npts,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+        ix += 1 
+        nsigmas = wx.StaticText(self, -1, 'Nsigmas')
+        self.sizer4_4.Add(nsigmas,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+       
+        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():
+                if p=="width":
+                    ix = 0
+                    name = wx.StaticText(self, -1,  name1)
+                    self.sizer4_4.Add( name,( 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.sizer4_4.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
+                    
+                    self.fittable_param.append([None,name1,ctl1,None,
+                                                None, None, None,None])
+                    
+                elif p=="npts":
+                        ix =2
+                        value= self.model.getParam(name2)
+                        Tctl1 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/2,20),
+                                            style=wx.TE_PROCESS_ENTER)
+                        
+                        Tctl1.SetValue(str (format_number(value)))
+                        Tctl1.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                        Tctl1.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
+                        self.sizer4_4.Add(Tctl1, (iy,ix),(1,1),
+                                           wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+                        
+                        self.fixed_param.append([None,name2, Tctl1,None,None,
+                                                  None, None,None])
+                
+                elif p=="nsigmas":
+                        ix =3 
+                        value= self.model.getParam(name3)
+                        Tctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/2,20),
+                                            style=wx.TE_PROCESS_ENTER)
+                        Tctl2.SetValue(str (format_number(value)))
+                        Tctl2.Bind(wx.EVT_KILL_FOCUS, self._onparamEnter)
+                        Tctl2.Bind(wx.EVT_TEXT_ENTER,self._onparamEnter)
+                        self.sizer4_4.Add(Tctl2, (iy,ix),(1,1),
+                                           wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+                        ix +=1
+                        self.sizer4_4.Add((20,20), (iy,ix),(1,1),
+                                           wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+                        
+                        self.fixed_param.append([None,name3, Tctl2,
+                                                 None,None, None, None,None])
+        
+        msg = " Selected Distribution: Gaussian"        
+        wx.PostEvent(self.parent.parent, StatusEvent( status= msg ))   
         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):
+        iy +=1 
+        self.sizer4_4.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)   
+        self.sizer4_4.Layout()
+        self.sizer4.Layout()
+        self.SetScrollbars(20,20,200,100)
+             
+    def _onModel2D(self, event):
         """
          call manager to plot model in 2D
@@ -442 +227 @@
             self._draw_model()
             self.model_view.Disable()
-       
-            
-    
+   
     def select_model(self, model, name):
         """
@@ -454 +237 @@
         self.parent.draw_model_name = name
         
-        self.set_panel(model)
+        self.set_model_param_sizer(self.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")
-                    
+        ## keep the sizer view consistent with the model menu selecting
+        ##
+        self.structurebox.Hide()
+        self.text2.Hide()
+        self.multip_cb.SetValue(False)
+        
+        if hasattr( model,"model1"):
+            self._set_model_sizer_selection( model )
+        
         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 set_model_description(self,description,sizer):
+        """
+            fill a sizer with description
+            @param description: of type string
+            @param sizer: wx.BoxSizer()
+        """
+    
+        sizer.Clear(True)
+        box_description= wx.StaticBox(self, -1, 'Model Description')
+        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
             
-    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):
+        sizer_selection=wx.BoxSizer(wx.HORIZONTAL)
+      
+        self.description_show = wx.RadioButton(self, -1, 'Show', style=wx.RB_GROUP)
+        self.description_hide = wx.RadioButton(self, -1, 'Hide')
+        
+        if description=="":
+            self.description_hide.SetValue(True)
+            description=" Description unavailable. Click for details"
+            
+        self.description = wx.StaticText( self,-1,str(description) )
+        
+        self.Bind( wx.EVT_RADIOBUTTON, self._on_display_description,
+                   id=self.description_hide.GetId() )
+        
+        self.Bind( wx.EVT_RADIOBUTTON, self._on_display_description,
+                   id=self.description_show.GetId() )
+        
+        self.model_description = wx.Button(self, -1, "More Details")
+        self.model_description.SetToolTipString("See more description in help menu.")
+        
+        self.page_info.save_radiobox_state( self.description_hide )
+        self.page_info.save_radiobox_state( self.description_show )
+        
+        sizer_selection.Add( self.description_show )
+        sizer_selection.Add( (20,20)) 
+        sizer_selection.Add( self.description_hide )
+        sizer_selection.Add( (20,20)) 
+        sizer_selection.Add( self.model_description )
+        
+         
+        self.sizer_description=wx.BoxSizer(wx.HORIZONTAL)
+        self.sizer_description.Add( self.description, 1, wx.EXPAND | wx.ALL, 10 )
+       
+        boxsizer1.Add( sizer_selection) 
+        boxsizer1.Add( (20,20)) 
+        boxsizer1.Add( self.sizer_description) 
+    
+
+        sizer.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10)
+        sizer.Layout()
+   
+   
+   
+    def set_range(self, qmin, qmax, 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 set_model_param_sizer(self, model):
         """
             Build the panel from the model content
             @param model: the model selected in combo box for fitting purpose
         """
-       
-        self.sizer5.Clear(True)
+        self.sizer3.Clear(True)
         self.parameters = []
         self.param_toFit=[]
         self.fixed_param=[]
-        if model !=None:
-            self.model = model
+        
+        if model ==None:
+            ##no model avaiable to draw sizer 
+            return
+        box_description= wx.StaticBox(self, -1,str("Model Parameters"))
+        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
+        sizer = wx.GridBagSizer(5,5)
+        
+        self.model = model
+        self.set_model_description(self.model.description,self.sizer2)
+       
+        keys = self.model.getParamList()
+        #list of dispersion paramaters
+        self.disp_list=self.model.getDispParamList()
+       
+        keys.sort()
+    
+        iy = 1
+        ix = 0
+        self.text1_2 = wx.StaticText(self, -1, 'Names')
+        sizer.Add(self.text1_2,(iy, ix),(1,1),\
+                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
+        ix +=1
+        self.text2_2 = wx.StaticText(self, -1, 'Values')
+        sizer.Add(self.text2_2,(iy, ix),(1,1),\
+                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
+        ix +=1
+        self.text2_4 = wx.StaticText(self, -1, 'Units')
+        sizer.Add(self.text2_4,(iy, ix),(1,1),\
+                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
+        self.text2_4.Hide()
+        
+
+        for item in keys:
+            if not item in self.disp_list:
+                iy += 1
+                ix = 0
+    
+                name = wx.StaticText(self, -1,item)
+                sizer.Add( name,( 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)
+                sizer.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
+        
+                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)
+                sizer.Add(units, (iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
+                
+                ##[cb state, name, value, "+/-", error of fit, min, max , units]
+                self.parameters.append([None,item, ctl1,
+                                        None,None, None, None,None])
+                
+        iy+=1
+        sizer.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()
+        
+        boxsizer1.Add(sizer)
+        
+        self.sizer3.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10)
+        self.sizer3.Layout()
+        self.SetScrollbars(20,20,200,100)
+        
+    
             
-            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]:              
-
+        
+class HelpWindow(wx.Frame):
+    def __init__(self, parent, id, title):
+        wx.Frame.__init__(self, parent, id, title, size=(570, 400))
+       
+        from sans.models.CylinderModel import CylinderModel
+        model = CylinderModel()
+        #from sans.models.LineModel import LineModel
+        #model = LineModel()
+        from pageInfo import PageInfo
+        myinfo = PageInfo(self,model)
+        from models import ModelList
+        mylist= ModelList()
+        
+        from sans.models.SphereModel import SphereModel
+        from sans.models.SquareWellStructure import SquareWellStructure
+        from sans.models.DebyeModel import DebyeModel
+        from sans.models.LineModel import LineModel
+        name= "shapes"
+        list1= [SphereModel]
+        mylist.set_list( name, list1)
+        
+        name= "Shape-independent"
+        list1= [DebyeModel]
+        mylist.set_list( name, list1)
+        
+        name= "Structure Factors"
+        list1= [SquareWellStructure]
+        mylist.set_list( name, list1)
+        
+        name= "Added models"
+        list1= [LineModel]
+        mylist.set_list( name, list1)
+        
+        myinfo.model_list_box = mylist.get_list()
+        
+        self.page = ModelPage(self, myinfo) 
+        
+        
+        
+        self.Centre()
+        self.Show(True)
+
+
+   
+if __name__=="__main__":
+    app = wx.App()
+    HelpWindow(None, -1, 'HelpWindow')
+    app.MainLoop()
                 
-                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=[]
-               
-                
-       

sansview/perspectives/fitting/models.py

@@ -226 +226 @@
                          list1 = self.shape_indep_list,
                          list2 = self.struct_list )
+        self._fill_menu( menuinfo = ["Added models", added_models,
+                                            "List of additional models"],
+                                 list1= self.plugins,
+                                 list2 = self.struct_list)
         
         self._fill_simple_menu( menuinfo= ["Structure Factors",structure_factor,
@@ -231 +235 @@
                                 list1= self.struct_list )
         
-        self._fill_simple_menu( menuinfo = ["Added models", added_models,
-                                            "List of additional models"],
-                                 list1= self.plugins)
+        
         return 0
     

sansview/perspectives/fitting/old_fitpage1D.py

@@ -140 +140 @@
         # 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()
@@ -149 +153 @@
         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),\
@@ -262 +275 @@
         # model on which the fit would be performed
         self.model=None
-        
+       
         self.back_up_model= None
         #dictionary of model name and model class
@@ -282 +295 @@
         self.Centre()
         self.Layout()
-        self.GrandParent.GetSizer().Layout()
+        
+        self.parent.GetSizer().Layout()
    
     def compute_chisqr2D(self):
@@ -289 +303 @@
             to the tcChi txtcrl
         """
-        flag=self.checkFitRange()
+        from sans.guiframe.utils import check_value
+        flag = check_value( self.qmin, self.qmax)
+        #flag=self.checkFitRange()
         res=[]
         if flag== True:
@@ -322 +338 @@
             to the tcChi txtcrl
         """
-        flag=self.checkFitRange()
+        from sans.guiframe.utils import check_value
+        flag = check_value( self.qmin, self.qmax)
+        #flag=self.checkFitRange()
         if flag== True:
             try:
@@ -367 +385 @@
         self.parent.GetSizer().Layout()
 
-        for item in self.model_list_box.itervalues():
-            name = item.__name__
-            if hasattr(item, "name"):
-                name = item.name
-            
+       
+        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()
@@ -378 +405 @@
                 self.qmin.Enable()
                 self.qmax.Enable() 
-            
-            if name ==event.GetString():
-                try:
-                    self.model=item()
-                    self.back_up_model= self.model.clone()
-                    evt = ModelEventbox(model=self.model,name=name)
-                    wx.PostEvent(self.event_owner, evt)
-                    self.text1_1.Show()
-                    self.compute_chisqr()
-                    self.tcChi.Show()
-                except:
-                    raise #ValueError,"model.name is not equal to model class name"
-                break  
+            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"""
-         
-        flag=self.checkFitRange()
-        self.set_manager(self.manager)
-     
+        """ 
+            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())
-        if len(self.param_toFit) >0 and flag==True:
-            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.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()
@@ -416 +454 @@
             self.Layout()
             self.parent.GetSizer().Layout()
-        else:
-            wx.PostEvent(self.parent.parent, StatusEvent(status=\
-                            "Select at least one parameter to fit "))
+        
+            
   
-   
-    def _onTextEnter(self,event):
-        """
-            set a flag to determine if the fitting range entered by the user is valid
-        """
-      
-        try:
-            flag=self.checkFitRange()
-            if flag==True and self.model!=None:
-                self.manager.redraw_model(float(self.xmin.GetValue())\
-                                               ,float(self.xmax.GetValue()))
-        except:
-
-            wx.PostEvent(self.parent.GrandParent, StatusEvent(status=\
-                            "Drawing  Error:wrong value entered %s"% sys.exc_value))
-        
    
     

sansview/perspectives/fitting/old_modelpage.py

@@ -1 +1 @@
 import sys
 import wx
-import wx.lib
+import wx.lib.newevent
 import numpy
 import copy
@@ -84 +84 @@
         #------------------ sizer 4  draw------------------------  
        
-       
+        ## structure combox box
+        self.structbox = wx.ComboBox(self, -1)
         # define combox box
         self.modelbox = wx.ComboBox(self, -1)
-         # preview selected model name
-        self.prevmodel_name=name
-        #print "model view prev_model",name
-        self.modelbox.SetValue(self.prevmodel_name)
+        
         #enable model 2D draw
         self.enable2D= False
+        self.fitrange= True
         #filling sizer2
         ix = 0
@@ -100 +99 @@
         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()
@@ -188 +204 @@
         iy+=1 
         self.sizer9.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        #----------sizer 10 draw------------------------------------------------------
-        """
-        id = wx.NewId()
-        self.btClose =wx.Button(self,id,'Close')
-        self.btClose.Bind(wx.EVT_BUTTON, self.onClose,id=id)
-        self.btClose.SetToolTipString("Close page.")
-        
-        ix= 3
-        iy= 1
-        self.sizer10.Add((20,20),(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        ix +=1
-        self.sizer10.Add( self.btClose,(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0)
-        ix =0
-        iy+=1
-        self.sizer10.Add((20,20),(iy,ix),(1,1),wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
-        """
+        
         # contains link between  model ,all its parameters, and panel organization
         self.parameters=[]
@@ -219 +220 @@
             self.set_panel(self.model)
         self.theta_cb=None
-       
+        
        
         self.vbox.Layout()
@@ -229 +230 @@
         self.Layout()
         self.parent.GetSizer().Layout()
-    def set_model_description(self, model):
-        
-        if model !=None and str(model.description)!=""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_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)
       
         
@@ -261 +266 @@
             @param page: the page to populate
         """
-        id=0
-        self.model_list_box=dict
-        list_name=[]
-        for item in  self.model_list_box.itervalues():
-            name = item.__name__
-            if hasattr(item, "name"):
-                name = item.name
-            list_name.append(name)
-        list_name.sort() 
-         
-        for name in list_name:
-            self.modelbox.Insert(name,int(id))
-            id+=1
-        wx.EVT_COMBOBOX(self.modelbox,-1, self._on_select_model) 
+        
+        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:
@@ -417 +435 @@
         # If the 2D display is not currently enabled, plot the model in 2D 
         # and set the enable2D flag.
-        if self.enable2D==False:
-            self.enable2D=True
+        if self.fitrange:
+            self.enable2D = True
+            
+        if self.enable2D:
             self._draw_model()
             self.model_view.Disable()
+       
             
     
@@ -433 +454 @@
         
         self.set_panel(model)
-        self._draw_model(name)
-        
-        # 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.model_view.SetFocus()
+        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):
@@ -462 +499 @@
         self.Layout()
         self.parent.GetSizer().Layout()
-        for item in self.model_list_box.itervalues():
-            name = item.__name__
-            if hasattr(item, "name"):
-                name = item.name
-            if name ==event.GetString():
-                model=item()
-                self.model= model
-                self.set_panel(model)
-                self.name= name
-                self.model_view.SetFocus()
-                self.parent.model_page.name=name
-                self.parent.draw_model_name=name
+        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._draw_model(name)
-            
+        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): 
@@ -506 +549 @@
         self.param_toFit=[]
         self.fixed_param=[]
-        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)
+        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:
-                    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.text2_4.Hide()
+            
         self.vbox.Layout()
         self.SetScrollbars(20,20,55,40)
@@ -949 +993 @@
             # If qmin and qmax have been modified, update qmin and qmax and 
             # set the is_modified flag to True
-            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
-            
+            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())
@@ -963 +1011 @@
                 self._draw_model()            
             
-    def _draw_model(self, name=None):
+    def _draw_model(self):
         """
             Method to draw or refresh a plotted model.
@@ -971 +1019 @@
             [Note to coder: This way future changes will be done in only one place.] 
         """
-        if name==None:
-            name= self.model.name
-       
-        self.manager.draw_model(self.model, name, data=self.data,
-                                qmin=self.qmin_x, qmax=self.qmax_x,
-                                qstep= self.num_points,
-                                enable2D=self.enable2D)
+        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):