source: sasview/sansview/perspectives/fitting/fitpage.py @ 1b43306

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 1b43306 was 5062bbf, checked in by Gervaise Alina <gervyh@…>, 14 years ago

working on documentation
  • Property mode set to 100644
File size: 99.5 KB
Line 
1
2
3import sys
4import wx
5import wx.lib.newevent
6import numpy
7import copy
8import math
9import time
10from sans.models.dispersion_models import ArrayDispersion, GaussianDispersion
11from DataLoader.data_info import Data1D
12from sans.guicomm.events import StatusEvent   
13from sans.guiframe.utils import format_number,check_float
14#from sans.guiframe.local_perspectives.plotting.Masking import ModelPanel2D as panel2D
15
16## event to post model to fit to fitting plugins
17(ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent()
18
19## event to know the selected fit engine
20(FitterTypeEvent, EVT_FITTER_TYPE)   = wx.lib.newevent.NewEvent()
21(FitStopEvent, EVT_FIT_STOP)   = wx.lib.newevent.NewEvent()
22(Chi2UpdateEvent, EVT_CHI2_UPDATE)   = wx.lib.newevent.NewEvent()
23_BOX_WIDTH = 76
24_DATA_BOX_WIDTH = 300
25SMEAR_SIZE_L = 0.005
26SMEAR_SIZE_H = 0.006
27
28import basepage
29from basepage import BasicPage
30from basepage import PageInfoEvent
31from DataLoader.qsmearing import smear_selection
32
33class FitPage(BasicPage):
34    """
35    FitPanel class contains fields allowing to display results when
36    fitting  a model and one data
37   
38    :note: For Fit to be performed the user should check at least one parameter
39        on fit Panel window.
40    """
41   
42    def __init__(self,parent, page_info):
43        """
44        Initialization of the Panel
45        """
46        BasicPage.__init__(self, parent, page_info)
47        ## total number of point: float
48        self.npts=None
49        ## thread for compute Chisqr
50        self.calc_Chisqr=None
51        ## default fitengine type
52        self.engine_type = None
53        ## smear default
54        self.smearer = None
55        self.current_smearer = None
56        ## 2D smear accuracy default
57        self.smear2d_accuracy = 'Low'
58        ## slit smear:
59        self.dxl = None
60        self.dxw = None
61        ## pinhole smear
62        self.dx_min = None
63        self.dx_max = None
64       
65        ## model data (theory) calculated on drawing.
66        self.theory_data = None
67     
68        ## draw sizer
69        self._fill_datainfo_sizer()
70       
71        # get smear info from data
72        self._get_smear_info()
73       
74        self._fill_model_sizer( self.sizer1)
75       
76        self._get_defult_custom_smear()
77       
78        self._fill_range_sizer() 
79       
80        if self.data is None:
81            self.formfactorbox.Disable()
82            self.structurebox.Disable()
83        else:
84            self.smearer = smear_selection( self.data )
85            if self.smearer ==None:
86                self.enable_smearer.Disable()
87            #if self.data.__class__.__name__ =="Data2D":
88                #if self.model != None:
89                    #self.smear_description_2d.Show(True)
90                   
91        self.disp_cb_dict = {}
92        ## to update the panel according to the fit engine type selected
93        self.Bind(EVT_FITTER_TYPE,self._on_engine_change)
94        self.Bind(EVT_FIT_STOP,self._on_fit_complete)
95        self.Bind(EVT_CHI2_UPDATE, self.on_complete_chisqr)
96
97    def _on_fit_complete(self, event):
98        """
99        When fit is complete ,reset the fit button label.
100        """
101        #self.btFit.SetLabel("Fit")
102        #self.btFit.Unbind(event=wx.EVT_BUTTON, id=self.btFit.GetId())
103        #self.btFit.Bind(event=wx.EVT_BUTTON, handler=self._onFit,id=self.btFit.GetId())
104        pass
105       
106    def _is_2D(self):
107        """
108        Check if data_name is Data2D
109       
110        :return: True or False
111       
112        """
113       
114        if self.data.__class__.__name__ =="Data2D":
115            return True
116        return False
117           
118    def _on_engine_change(self, event):
119        """
120        get an event containing the current name of the fit engine type
121       
122        :param event: FitterTypeEvent containing  the name of the current engine
123       
124        """
125        self.engine_type = event.type
126        if len(self.parameters)==0:
127            self.Layout()
128            return
129        if event.type =="park":
130            self.btFit.SetLabel("Fit")
131
132        for item in self.parameters:
133            if event.type =="scipy" :
134                item[5].SetValue("")
135                item[5].Hide()
136                item[6].SetValue("")
137                item[6].Hide()
138                self.text2_min.Hide()
139                self.text2_max.Hide()
140
141            else:
142                item[5].Show(True)
143                item[6].Show(True)
144                self.text2_min.Show(True)
145                self.text2_max.Show(True)
146        for item in self.fittable_param:
147            if item[5]!=None and item[6]!=None and not item in self.orientation_params_disp:
148                if event.type =="scipy" and not item in self.orientation_params:
149                    item[5].SetValue("")
150                    item[5].Hide()
151                    item[6].SetValue("")
152                    item[6].Hide()
153                    self.text2_min.Hide()
154                    self.text2_max.Hide()
155                    self.text_disp_min.Hide()
156                    self.text_disp_max.Hide()
157                else:
158                    item[5].Show(True)
159                    item[6].Show(True)
160                    self.text2_min.Show(True)
161                    self.text2_max.Show(True)
162                    self.text_disp_min.Show(True)
163                    self.text_disp_max.Show(True)
164           
165        for item in self.orientation_params:
166            if item[5]!=None and item[6]!=None:
167                if event.type =="scipy" or self.data.__class__.__name__ !="Data2D":
168                    item[5].SetValue("")
169                    item[5].Hide()
170                    item[6].SetValue("")
171                    item[6].Hide()
172                else:
173                    item[5].Show(True)
174                    item[6].Show(True)
175                   
176        for item in self.orientation_params_disp:         
177            if item[5]!=None and item[6]!=None:
178                if event.type =="scipy" or self.data.__class__.__name__ !="Data2D":
179                    item[5].SetValue("")
180                    item[5].Hide()
181                    item[6].SetValue("")
182                    item[6].Hide()
183                else:
184                    item[5].Show(True)
185                    item[6].Show(True)
186        self.Layout()
187        self.Refresh()
188
189    def _fill_range_sizer(self):
190        """
191        Fill the sizer containing the plotting range
192        add  access to npts
193        """
194        is_2Ddata = False
195       
196        # Check if data is 2D
197        if self.data.__class__.__name__ == 'Data2D':
198            is_2Ddata = True
199           
200        title = "Fitting"
201        #smear messages & titles
202        smear_message_none  =  "No smearing is selected..."
203        smear_message_dqdata  =  "The dQ data is being used for smearing..."
204        smear_message_2d  =  "Higher accuracy is very time-expensive. Use it with care..."
205        smear_message_new_ssmear  =  "Please enter only the value of interest to customize smearing..."
206        smear_message_new_psmear  =  "Please enter both; the dQ will be generated by interpolation..."
207        smear_message_2d_x_title = "<dQx>[1/A]:"
208        smear_message_2d_y_title = "<dQy>[1/A]:"
209        smear_message_pinhole_min_title = "dQ_low[1/A]:"
210        smear_message_pinhole_max_title = "dQ_high[1/A]:"
211        smear_message_slit_height_title = "Slit height[1/A]:"
212        smear_message_slit_width_title = "Slit width[1/A]:"
213       
214        self._get_smear_info()
215       
216        #Sizers
217        box_description_range = wx.StaticBox(self, -1,str(title))
218        boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)     
219        self.sizer_set_smearer = wx.BoxSizer(wx.VERTICAL)
220        sizer_smearer = wx.BoxSizer(wx.HORIZONTAL)
221        self.sizer_new_smear= wx.BoxSizer(wx.HORIZONTAL)
222        self.sizer_set_masking = wx.BoxSizer(wx.HORIZONTAL)
223        sizer_chi2 = wx.BoxSizer(wx.VERTICAL)
224        smear_set_box= wx.StaticBox(self, -1,'Set Instrumental Smearing')
225        sizer_smearer_box = wx.StaticBoxSizer(smear_set_box, wx.HORIZONTAL)
226        sizer_smearer_box.SetMinSize((_DATA_BOX_WIDTH,85))
227        sizer_fit = wx.GridSizer(2, 4,2,6)
228       
229        # combobox for smear2d accuracy selection
230        self.smear_accuracy = wx.ComboBox(self, -1,size=(50,-1),style=wx.CB_READONLY)
231        self._set_accuracy_list()
232        self.smear_accuracy.SetValue(self.smear2d_accuracy)
233        self.smear_accuracy.SetSelection(0)
234        self.smear_accuracy.SetToolTipString("'Higher' uses more Gaussian points for smearing computation.")
235                   
236        wx.EVT_COMBOBOX(self.smear_accuracy,-1, self._on_select_accuracy)
237
238        #Fit button
239        self.btFit = wx.Button(self,wx.NewId(),'Fit', size=(88,25))
240        self.btFit.Bind(wx.EVT_BUTTON, self._onFit,id= self.btFit.GetId())
241        self.btFit.SetToolTipString("Start fitting.")
242       
243        #textcntrl for custom resolution
244        self.smear_pinhole_max = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER,
245                                            text_enter_callback = self.onPinholeSmear)
246        self.smear_pinhole_min = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER,
247                                            text_enter_callback = self.onPinholeSmear)
248        self.smear_slit_height= self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER,
249                                            text_enter_callback = self.onSlitSmear)
250        self.smear_slit_width = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER,
251                                            text_enter_callback = self.onSlitSmear)
252
253        ## smear
254        self.smear_data_left= BGTextCtrl(self, -1, size=(_BOX_WIDTH-25,20), style=0)
255        self.smear_data_left.SetValue(str(self.dq_l))
256        self.smear_data_right = BGTextCtrl(self, -1, size=(_BOX_WIDTH-25,20), style=0)
257        self.smear_data_right.SetValue(str(self.dq_r))
258
259        #set default values for smear
260        self.smear_pinhole_max.SetValue(str(self.dx_max))
261        self.smear_pinhole_min.SetValue(str(self.dx_min))
262        self.smear_slit_height.SetValue(str(self.dxl))
263        self.smear_slit_width.SetValue(str(self.dxw))
264
265        #Filling the sizer containing instruments smearing info.
266        self.disable_smearer = wx.RadioButton(self, -1, 'None', style=wx.RB_GROUP)
267        self.enable_smearer = wx.RadioButton(self, -1, 'Use dQ Data')
268        #self.enable_smearer.SetToolTipString("Click to use the loaded dQ data for smearing.")
269        self.pinhole_smearer = wx.RadioButton(self, -1, 'Custom Pinhole Smear')
270        #self.pinhole_smearer.SetToolTipString("Click to input custom resolution for pinhole smearing.")
271        self.slit_smearer = wx.RadioButton(self, -1, 'Custom Slit Smear')
272        #self.slit_smearer.SetToolTipString("Click to input custom resolution for slit smearing.")
273        self.Bind(wx.EVT_RADIOBUTTON, self.onSmear, id=self.disable_smearer.GetId())
274        self.Bind(wx.EVT_RADIOBUTTON, self.onSmear, id=self.enable_smearer.GetId())
275        self.Bind(wx.EVT_RADIOBUTTON, self.onPinholeSmear, id=self.pinhole_smearer.GetId())
276        self.Bind(wx.EVT_RADIOBUTTON, self.onSlitSmear, id=self.slit_smearer.GetId())
277        self.disable_smearer.SetValue(True)
278       
279        # add 4 types of smearing to the sizer
280        sizer_smearer.Add( self.disable_smearer,0, wx.LEFT, 10)
281        sizer_smearer.Add((10,10))
282        sizer_smearer.Add( self.enable_smearer)
283        sizer_smearer.Add((10,10))
284        sizer_smearer.Add( self.pinhole_smearer ) 
285        sizer_smearer.Add((10,10))
286        sizer_smearer.Add( self.slit_smearer ) 
287        sizer_smearer.Add((10,10))       
288       
289        # StaticText for chi2, N(for fitting), Npts
290        self.tcChi    =  BGTextCtrl(self, -1, "-", size=(75,20), style=0)
291        self.tcChi.SetToolTipString("Chi2/Npts")
292        self.Npts_fit    =  BGTextCtrl(self, -1, "-", size=(75,20), style=0)
293        self.Npts_fit.SetToolTipString(" Npts : number of points selected for fitting")
294        self.Npts_total  =  BGTextCtrl(self, -1, "-", size=(75,20), style=0)
295        self.Npts_total.SetToolTipString(" Total Npts : total number of data points")
296        box_description_1= wx.StaticText(self, -1,'    Chi2/Npts')
297        box_description_2= wx.StaticText(self, -1,'  Npts')
298        box_description_3= wx.StaticText(self, -1,'  Total Npts')
299        box_description_4= wx.StaticText(self, -1,' ')
300       
301       
302        sizer_fit.Add(box_description_1,0,0)
303        sizer_fit.Add(box_description_2,0,0)
304        sizer_fit.Add(box_description_3,0,0)       
305        sizer_fit.Add(box_description_4,0,0)
306        sizer_fit.Add(self.tcChi,0,0)
307        sizer_fit.Add(self.Npts_fit ,0,0)
308        sizer_fit.Add(self.Npts_total,0,0)
309        sizer_fit.Add(self.btFit,0,0) 
310
311        # StaticText for smear
312        #self.tcChi    =  wx.StaticText(self, -1, "-", style=wx.ALIGN_LEFT)
313        self.smear_description_none    =  wx.StaticText(self, -1, smear_message_none , style=wx.ALIGN_LEFT)
314        self.smear_description_dqdata    =  wx.StaticText(self, -1, smear_message_dqdata , style=wx.ALIGN_LEFT)
315        self.smear_description_type    =  wx.StaticText(self, -1, "Type:" , style=wx.ALIGN_LEFT)
316        self.smear_description_accuracy_type    =  wx.StaticText(self, -1, "Accuracy:" , style=wx.ALIGN_LEFT)
317        self.smear_description_smear_type    =  BGTextCtrl(self, -1, size=(57,20), style=0)
318        self.smear_description_smear_type.SetValue(str(self.dq_l))
319        self.SetBackgroundColour(self.GetParent().GetBackgroundColour())
320        self.smear_description_2d     =  wx.StaticText(self, -1, smear_message_2d  , style=wx.ALIGN_LEFT)
321        self.smear_message_new_s = wx.StaticText(self, -1, smear_message_new_ssmear  , style=wx.ALIGN_LEFT)
322        self.smear_message_new_p = wx.StaticText(self, -1, smear_message_new_psmear  , style=wx.ALIGN_LEFT)
323        self.smear_description_2d_x     =  wx.StaticText(self, -1, smear_message_2d_x_title  , style=wx.ALIGN_LEFT)
324        self.smear_description_2d_y     =  wx.StaticText(self, -1, smear_message_2d_y_title  , style=wx.ALIGN_LEFT)
325        self.smear_description_pin_min     =  wx.StaticText(self, -1, smear_message_pinhole_min_title  , style=wx.ALIGN_LEFT)
326        self.smear_description_pin_max     =  wx.StaticText(self, -1, smear_message_pinhole_max_title  , style=wx.ALIGN_LEFT)
327        self.smear_description_slit_height    =  wx.StaticText(self, -1, smear_message_slit_height_title   , style=wx.ALIGN_LEFT)
328        self.smear_description_slit_width    =  wx.StaticText(self, -1, smear_message_slit_width_title   , style=wx.ALIGN_LEFT)
329       
330        #arrange sizers
331        #boxsizer1.Add( self.tcChi ) 
332        self.sizer_set_smearer.Add(sizer_smearer )
333        self.sizer_set_smearer.Add((10,10))
334        self.sizer_set_smearer.Add( self.smear_description_none,0, wx.CENTER, 10 ) 
335        self.sizer_set_smearer.Add( self.smear_description_dqdata,0, wx.CENTER, 10 )
336        self.sizer_set_smearer.Add( self.smear_description_2d,0, wx.CENTER, 10 )
337        self.sizer_new_smear.Add( self.smear_description_type,0, wx.CENTER, 10 )
338        self.sizer_new_smear.Add( self.smear_description_accuracy_type,0, wx.CENTER, 10 )
339        self.sizer_new_smear.Add( self.smear_accuracy )
340        self.sizer_new_smear.Add( self.smear_description_smear_type,0, wx.CENTER, 10 )
341        self.sizer_new_smear.Add((15,-1))
342        self.sizer_new_smear.Add( self.smear_description_2d_x,0, wx.CENTER, 10 )
343        self.sizer_new_smear.Add( self.smear_description_pin_min,0, wx.CENTER, 10 )
344        self.sizer_new_smear.Add( self.smear_description_slit_height,0, wx.CENTER, 10 )
345
346        self.sizer_new_smear.Add( self.smear_pinhole_min,0, wx.CENTER, 10 )
347        self.sizer_new_smear.Add( self.smear_slit_height,0, wx.CENTER, 10 )
348        self.sizer_new_smear.Add( self.smear_data_left,0, wx.CENTER, 10 )
349        self.sizer_new_smear.Add((20,-1))
350        self.sizer_new_smear.Add( self.smear_description_2d_y,0, wx.CENTER, 10 )
351        self.sizer_new_smear.Add( self.smear_description_pin_max,0, wx.CENTER, 10 )
352        self.sizer_new_smear.Add( self.smear_description_slit_width,0, wx.CENTER, 10 )
353
354        self.sizer_new_smear.Add( self.smear_pinhole_max,0, wx.CENTER, 10 )
355        self.sizer_new_smear.Add( self.smear_slit_width,0, wx.CENTER, 10 )
356        self.sizer_new_smear.Add( self.smear_data_right,0, wx.CENTER, 10 )
357           
358        self.sizer_set_smearer.Add( self.smear_message_new_s,0, wx.CENTER, 10)
359        self.sizer_set_smearer.Add( self.smear_message_new_p,0, wx.CENTER, 10)
360        self.sizer_set_smearer.Add((5,2))
361        self.sizer_set_smearer.Add( self.sizer_new_smear,0, wx.CENTER, 10 )
362       
363        # add all to chi2 sizer
364        sizer_smearer_box.Add(self.sizer_set_smearer)       
365        sizer_chi2.Add(sizer_smearer_box)
366        sizer_chi2.Add((-1,5))
367
368        # hide all smear messages and textctrl
369        self._hide_all_smear_info()
370       
371        # get smear_selection
372        self.current_smearer= smear_selection( self.data )
373
374        # Show only the relevant smear messages, etc
375        if self.current_smearer == None:
376            if not is_2Ddata:
377                self.smear_description_none.Show(True)
378                self.enable_smearer.Disable() 
379            else:
380                self.smear_description_none.Show(True)
381                #self.smear_description_2d.Show(True)
382                #self.pinhole_smearer.Disable()
383                self.slit_smearer.Disable()   
384                #self.enable_smearer.Disable()
385        else: self._show_smear_sizer()
386        boxsizer_range.Add(self.sizer_set_masking)
387           
388        #Set sizer for Fitting section
389        self._set_range_sizer( title=title,box_sizer=boxsizer_range, object1=sizer_chi2, object= sizer_fit)
390       
391    def _fill_datainfo_sizer(self):
392        """
393        fill sizer 0 with data info
394        """
395        ## no loaded data , don't fill the sizer
396        if self.data is None:
397            data_min = ""
398            data_max = ""
399            data_name = ""
400        else:
401            data_name = self.data.name
402            #set maximum range for x in linear scale
403            if not hasattr(self.data,"data"): #Display only for 1D data fit
404                # Minimum value of data   
405                data_min = min(self.data.x)
406                # Maximum value of data 
407                data_max = max(self.data.x)
408            else:
409                ## Minimum value of data
410                data_min = 0
411                x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax)) 
412                y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
413                ## Maximum value of data 
414                data_max = math.sqrt(x*x + y*y)
415       
416        box_description= wx.StaticBox(self, -1, 'Data')
417        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
418        #----------------------------------------------------------
419        sizer_data = wx.BoxSizer(wx.HORIZONTAL)
420        #Filling the sizer containing data related fields
421        #self.dataSource = wx.StaticText(self, -1,str(self.data.name))
422        self.dataSource = BGTextCtrl(self, -1)
423        self.dataSource.SetValue(str(data_name))
424        #self.dataSource.SetEditable(False)
425        self.dataSource.SetMinSize((_DATA_BOX_WIDTH, -1))
426        sizer_data.Add(wx.StaticText(self, -1, 'Source Name : '))
427        sizer_data.Add(self.dataSource )
428        sizer_data.Add( (0,5) )
429       
430        #---------sizer 2 draw--------------------------------
431        text4_3 = wx.StaticText(self, -1, 'Total Q Range (1/A)',
432                                 style=wx.ALIGN_LEFT)
433        sizer_range = wx.BoxSizer(wx.HORIZONTAL)
434        sizer_range.Add( text4_3 ,0, wx.RIGHT, 10)
435        self.minimum_q = BGTextCtrl(self, -1, size=(_BOX_WIDTH,20))
436        self.minimum_q.SetValue(str(data_min))
437        #self.minimum_q.SetEditable(False)
438        self.maximum_q = BGTextCtrl(self, -1,size=(_BOX_WIDTH,20))
439        self.maximum_q.SetValue(str(data_max))
440        #self.maximum_q.SetEditable(False)
441        sizer_range.Add(wx.StaticText(self, -1, "Min: "),0, wx.LEFT, 10)
442        sizer_range.Add(self.minimum_q,0, wx.LEFT, 10)
443        sizer_range.Add(wx.StaticText(self, -1, "Max: "),0, wx.LEFT, 10)
444        sizer_range.Add(self.maximum_q,0, wx.LEFT, 10)
445
446        ## set q range to plot
447        self.qmin_x = data_min
448        self.qmax_x = data_max
449
450        boxsizer1.Add(sizer_data,0, wx.ALL, 10)
451        boxsizer1.Add(sizer_range, 0 , wx.LEFT, 10)
452        #------------------------------------------------------------
453        self.sizer0.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10)
454        self.sizer0.Layout()
455       
456    def _fill_model_sizer(self, sizer):
457        """
458        fill sizer containing model info
459        """
460        ##Add model function Details button in fitpanel.
461        ##The following 3 lines are for Mac. Let JHC know before modifying...
462        title = "Model"
463        box_description= wx.StaticBox(self, -1,str(title))
464        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
465         
466        id = wx.NewId()
467        self.model_help =wx.Button(self,id,'Details', size=(80,23))
468        self.model_help.Bind(wx.EVT_BUTTON, self.on_model_help_clicked,id=id)
469        self.model_help.SetToolTipString("Model Function Help")
470       
471        ## class base method  to add view 2d button   
472        self._set_model_sizer(sizer=sizer, box_sizer=boxsizer1, title="Model",object=self.model_help )   
473       
474    def _set_sizer_dispersion(self, dispersity):
475        """
476        draw sizer with gaussian dispersity parameters
477        """
478        self.fittable_param=[]
479        self.fixed_param=[]
480        self.orientation_params_disp=[]
481
482        self.sizer4_4.Clear(True)
483        if self.model==None:
484            ##no model is selected
485            return
486        if not self.enable_disp.GetValue():
487            ## the user didn't select dispersity display
488            return 
489           
490        self._reset_dispersity()
491       
492        # Create the dispersion objects
493        for item in self.model.dispersion.keys():
494            #disp_model =  GaussianDispersion()
495            disp_model = dispersity()
496            self._disp_obj_dict[item] = disp_model
497            self.model.set_dispersion(item, disp_model)
498            self.state._disp_obj_dict[item]= disp_model
499
500
501        ix=0
502        iy=1
503        disp = wx.StaticText(self, -1, ' ')
504        self.sizer4_4.Add(disp,( iy, ix),(1,1), 
505                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
506        ix += 1 
507        values = wx.StaticText(self, -1, 'Sigma (STD)')
508        values.SetToolTipString("Polydispersity multiplied by the value of the original parameter.")
509        self.sizer4_4.Add(values,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
510        ix +=2 
511        self.text_disp_1 = wx.StaticText(self, -1, '')
512        self.sizer4_4.Add( self.text_disp_1,(iy, ix),(1,1),\
513                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
514        self.text_disp_1.Hide()
515       
516       
517        ix +=1 
518        self.text_disp_min = wx.StaticText(self, -1, 'Min')
519        self.sizer4_4.Add(self.text_disp_min,(iy, ix),(1,1),\
520                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
521        self.text_disp_min.Hide()
522        ix +=1 
523        self.text_disp_max = wx.StaticText(self, -1, 'Max')
524        self.sizer4_4.Add(self.text_disp_max,(iy, ix),(1,1),\
525                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
526        self.text_disp_max.Hide()
527                       
528       
529        ix += 1 
530        npts = wx.StaticText(self, -1, 'Npts')
531        npts.SetToolTipString("Number of points for weighting.")
532        self.sizer4_4.Add(npts,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
533        ix += 1 
534        nsigmas = wx.StaticText(self, -1, 'Nsigmas')
535        nsigmas.SetToolTipString("Number of sigmas between which the range of the distribution function will be used for weighting. The value '3' covers 99.5% for Gaussian distribution function.")
536        self.sizer4_4.Add(nsigmas,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
537       
538        if self.engine_type=="park":
539            self.text_disp_max.Show(True)
540            self.text_disp_min.Show(True)
541
542        for item in self.model.dispersion.keys():
543            if not item in self.model.orientation_params:
544                if not self.disp_cb_dict.has_key(item):
545                    self.disp_cb_dict[item]= None
546                name1=item+".width"
547                name2=item+".npts"
548                name3=item+".nsigmas"
549                if not self.model.details.has_key(name1):
550                    self.model.details [name1] = ["",None,None] 
551
552                iy += 1
553                for p in self.model.dispersion[item].keys(): 
554       
555                    if p=="width":
556                        ix = 0
557                        cb = wx.CheckBox(self, -1, name1, (10, 10))
558                        cb.SetToolTipString("Check for fitting")
559                        wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
560                        self.sizer4_4.Add( cb,( iy, ix),(1,1), 
561                                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
562                        ix = 1
563                        value= self.model.getParam(name1)
564                        ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH,20),
565                                            style=wx.TE_PROCESS_ENTER)
566                        ctl1.SetToolTipString("Polydispersity multiplied by the value of '%s'."%item)
567                        ctl1.SetValue(str (format_number(value)))
568                        self.sizer4_4.Add(ctl1, (iy,ix),(1,1),wx.EXPAND)
569                        ## text to show error sign
570                        ix = 2
571                        text2=wx.StaticText(self, -1, '+/-')
572                        self.sizer4_4.Add(text2,(iy, ix),(1,1),
573                                          wx.EXPAND|wx.ADJUST_MINSIZE, 0)
574                        text2.Hide() 
575
576                        ix = 3
577                        ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=0)
578                 
579                        self.sizer4_4.Add(ctl2, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
580                     
581                        ctl2.Hide()
582
583                        ix = 4
584                        ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
585                                                       text_enter_callback = self._onparamRangeEnter)
586                       
587                        self.sizer4_4.Add(ctl3, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
588                        ctl3.Hide()
589               
590                        ix = 5
591                        ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
592                                                       text_enter_callback = self._onparamRangeEnter)
593                       
594                        self.sizer4_4.Add(ctl4, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
595
596                        ctl4.Hide()
597                       
598                        if self.engine_type=="park":
599                            ctl3.Show(True)
600                            ctl4.Show(True)
601                                         
602                        self.fittable_param.append([cb,name1,ctl1,text2,
603                                                    ctl2, ctl3, ctl4,None])                   
604                   
605                    elif p=="npts":
606                            ix = 6
607                            value= self.model.getParam(name2)
608                            Tctl = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20),
609                                                style=wx.TE_PROCESS_ENTER)
610                           
611                            Tctl.SetValue(str (format_number(value)))
612                            self.sizer4_4.Add(Tctl, (iy,ix),(1,1),
613                                               wx.EXPAND|wx.ADJUST_MINSIZE, 0)
614                            self.fixed_param.append([None,name2, Tctl,None,None,
615                                                      None, None,None])
616                    elif p=="nsigmas":
617                            ix = 7
618                            value= self.model.getParam(name3)
619                            Tct2 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20),
620                                                style=wx.TE_PROCESS_ENTER)
621                           
622                            Tct2.SetValue(str (format_number(value)))
623                            self.sizer4_4.Add(Tct2, (iy,ix),(1,1),
624                                               wx.EXPAND|wx.ADJUST_MINSIZE, 0)
625                            ix +=1
626                            self.sizer4_4.Add((20,20), (iy,ix),(1,1),
627                                               wx.EXPAND|wx.ADJUST_MINSIZE, 0)
628                           
629                            self.fixed_param.append([None,name3, Tct2
630                                                     ,None,None,None, None,None])
631                           
632        ix =0
633        iy +=1 
634        self.sizer4_4.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
635        for item in self.model.dispersion.keys():
636            if  item in self.model.orientation_params:
637                if not self.disp_cb_dict.has_key(item):
638                    self.disp_cb_dict[item]= None
639                name1=item+".width"
640                name2=item+".npts"
641                name3=item+".nsigmas"
642                if not self.model.details.has_key(name1):
643                    self.model.details [name1] = ["",None,None]                 
644 
645
646                iy += 1
647                for p in self.model.dispersion[item].keys(): 
648       
649                    if p=="width":
650                        ix = 0
651                        cb = wx.CheckBox(self, -1, name1, (10, 10))
652                        cb.SetToolTipString("Check for fitting")
653                        wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
654                        self.sizer4_4.Add( cb,( iy, ix),(1,1), 
655                                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
656                        if self.data.__class__.__name__ =="Data2D":
657                            cb.Show(True)
658                        elif cb.IsShown():
659                            cb.Hide()
660                        ix = 1
661                        value= self.model.getParam(name1)
662                        ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH,20),
663                                            style=wx.TE_PROCESS_ENTER)
664                        ctl1.SetToolTipString("Polydispersity multiplied by the value of '%s'."%item)
665                        ctl1.SetValue(str (format_number(value)))
666                        if self.data.__class__.__name__ =="Data2D":
667                            ctl1.Show(True)
668                        elif ctl1.IsShown():
669                            ctl1.Hide()
670                        self.sizer4_4.Add(ctl1, (iy,ix),(1,1),wx.EXPAND)
671                        ## text to show error sign
672                        ix = 2
673                        text2=wx.StaticText(self, -1, '+/-')
674                        self.sizer4_4.Add(text2,(iy, ix),(1,1),
675                                          wx.EXPAND|wx.ADJUST_MINSIZE, 0)
676                        text2.Hide() 
677
678                        ix = 3
679                        ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=0)
680                   
681                        self.sizer4_4.Add(ctl2, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
682                        ctl2.Hide()
683                           
684                        ix = 4
685                        ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
686                                                       text_enter_callback = self._onparamRangeEnter)
687
688                        self.sizer4_4.Add(ctl3, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
689
690                        ctl3.Hide()
691               
692                        ix = 5
693                        ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
694                                                       text_enter_callback = self._onparamRangeEnter)
695                        self.sizer4_4.Add(ctl4, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
696                        ctl4.Hide()
697                        #if self.data.__class__.__name__ =="Data2D":
698                            #ctl4.Enable(True)
699                        #elif ctl4.Shown():
700                            #ctl4.Hide()
701                       
702                        if self.engine_type=="park" and self.data.__class__.__name__ =="Data2D":
703                            ctl3.Show(True)
704                            ctl4.Show(True) 
705                           
706                           
707                           
708                           
709                        self.fittable_param.append([cb,name1,ctl1,text2,
710                                                    ctl2, ctl3, ctl4,None])
711                        self.orientation_params_disp.append([cb,name1,ctl1,text2,
712                                                    ctl2, ctl3, ctl4,None])
713                    elif p=="npts":
714                            ix = 6
715                            value= self.model.getParam(name2)
716                            Tctl = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20),
717                                                style=wx.TE_PROCESS_ENTER)
718                           
719                            Tctl.SetValue(str (format_number(value)))
720                            if self.data.__class__.__name__ =="Data2D":
721                                Tctl.Show(True)
722                            else:
723                                Tctl.Hide()
724                            self.sizer4_4.Add(Tctl, (iy,ix),(1,1),
725                                               wx.EXPAND|wx.ADJUST_MINSIZE, 0)
726                            self.fixed_param.append([None,name2, Tctl,None,None,
727                                                      None, None,None])
728                            self.orientation_params_disp.append([None,name2, Tctl,None,None,
729                                                      None, None,None])
730                    elif p=="nsigmas":
731                            ix = 7
732                            value= self.model.getParam(name3)
733                            Tct2 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20),
734                                                style=wx.TE_PROCESS_ENTER)
735                           
736                            Tct2.SetValue(str (format_number(value)))
737                            if self.data.__class__.__name__ =="Data2D":
738                                Tct2.Show(True)
739                            else:
740                                Tct2.Hide()
741                            self.sizer4_4.Add(Tct2, (iy,ix),(1,1),
742                                               wx.EXPAND|wx.ADJUST_MINSIZE, 0)
743                            ix +=1
744
745                            self.fixed_param.append([None,name3, Tct2
746                                                     ,None,None, None, None,None])   
747                                                       
748                            self.orientation_params_disp.append([None,name3, Tct2
749                                                     ,None,None, None, None,None])
750       
751        self.state.disp_cb_dict = copy.deepcopy(self.disp_cb_dict) 
752         
753        self.state.model = self.model.clone() 
754         ## save state into
755        self.state.cb1 = self.cb1.GetValue()
756        self._copy_parameters_state(self.parameters, self.state.parameters)
757        self._copy_parameters_state(self.orientation_params_disp,
758                                     self.state.orientation_params_disp)
759        self._copy_parameters_state(self.fittable_param, self.state.fittable_param)
760        self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
761
762
763        wx.PostEvent(self.parent, StatusEvent(status=\
764                        " Selected Distribution: Gaussian"))   
765        #Fill the list of fittable parameters
766        self.select_all_param(event=None)
767       
768        self.Layout()
769
770    def _onFit(self, event):     
771        """
772        Allow to fit
773        """
774        #make sure all parameter values are updated.
775        if self.check_invalid_panel():
776            return
777        if self.model ==None:
778            msg="Please select a Model first..."
779            wx.MessageBox(msg, 'Info')
780            wx.PostEvent(self.manager.parent, StatusEvent(status=\
781                            "Fit: %s"%msg))
782            return
783
784        flag = self._update_paramv_on_fit() 
785               
786        if not flag:
787            msg= "Fitting range or parameters are invalid"
788            wx.PostEvent(self.parent.parent, StatusEvent(status= msg ))
789            return 
790       
791        if len(self.param_toFit) <= 0:
792            msg= "Select at least one parameter to fit"
793            wx.PostEvent(self.parent.parent, StatusEvent(status= msg ))
794            return 
795     
796        self.select_param(event =None)
797       
798        #Clear errors if exist from previous fitting
799        #self._clear_Err_on_Fit()
800
801        # Remove or do not allow fitting on the Q=0 point, especially when y(q=0)=None at x[0].         
802        self.qmin_x = float(self.qmin.GetValue())
803        self.qmax_x = float( self.qmax.GetValue())
804        self.manager._reset_schedule_problem( value=0)
805        self.manager.schedule_for_fit( value=1,page=self,fitproblem =None) 
806        self.manager.set_fit_range(page= self,qmin= self.qmin_x, qmax= self.qmax_x)
807       
808        #single fit
809        self.manager.onFit()
810        ## allow stopping the fit
811        #if self.engine_type=="scipy":
812        #    self.btFit.SetLabel("Stop")
813        #    self.btFit.Unbind(event=wx.EVT_BUTTON, id= self.btFit.GetId())
814        #    self.btFit.Bind(event= wx.EVT_BUTTON, handler=self._StopFit, id=self.btFit.GetId())
815        #else:
816        #    self.btFit.SetLabel("Fit")
817        #    self.btFit.Bind(event= wx.EVT_BUTTON, handler=self._onFit, id=self.btFit.GetId())
818           
819    def _StopFit(self, event):
820        """
821        Stop fit
822        """
823        self.btFit.SetLabel("Fit")
824        if self.engine_type=="scipy":
825            self.manager.stop_fit()
826        self.btFit.Unbind(event=wx.EVT_BUTTON, id=self.btFit.GetId())
827        self.btFit.Bind(event=wx.EVT_BUTTON, handler=self._onFit,id=self.btFit.GetId())
828       
829           
830    def _on_select_model(self, event): 
831        """
832        call back for model selection
833        """ 
834        self._on_select_model_helper() 
835        self.set_model_param_sizer(self.model)                   
836       
837        self.enable_disp.SetValue(False)
838        self.disable_disp.SetValue(True)
839        try:
840            self.set_dispers_sizer()
841        except:
842            pass
843        self.btFit.SetFocus() 
844        self.state.enable_disp = self.enable_disp.GetValue()
845        self.state.disable_disp = self.disable_disp.GetValue()
846        self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
847        self.state.slit_smearer = self.slit_smearer.GetValue()
848   
849        self.state.structurecombobox = self.structurebox.GetCurrentSelection()
850        self.state.formfactorcombobox = self.formfactorbox.GetCurrentSelection()
851     
852        if self.model != None:
853            try:
854                temp_smear= None
855                if self.enable_smearer.GetValue():
856                    temp_smear= self.smearer
857                #self.compute_chisqr(temp_smear)
858            except:
859                ## error occured on chisqr computation
860                pass
861            if self.data is not None and self.data.__class__.__name__ !="Data2D":
862                ## set smearing value whether or not the data contain the smearing info
863                evt = ModelEventbox(model=self.model, 
864                                        smearer=temp_smear, 
865                                        qmin= float(self.qmin_x),
866                                     qmax= float(self.qmax_x)) 
867            else:   
868                 evt = ModelEventbox(model=self.model)
869            wx.PostEvent(self.event_owner, evt) 
870           
871        if event !=None:
872            #self._undo.Enable(True)
873            ## post state to fit panel
874            event = PageInfoEvent(page = self)
875            wx.PostEvent(self.parent, event) 
876     
877    def _onparamEnter(self,event):
878        """
879        when enter value on panel redraw model according to changed
880        """
881        if self.model ==None:
882            msg="Please select a Model first..."
883            wx.MessageBox(msg, 'Info')
884            #wx.PostEvent(self.manager.parent, StatusEvent(status=\
885            #                "Parameters: %s"%msg))
886            return
887
888        #default flag
889        flag = False
890        self.fitrange = True
891        #get event object
892        tcrtl= event.GetEventObject()
893        wx.PostEvent(self.manager.parent, StatusEvent(status=" \
894                                updating ... ",type="update"))
895        #Clear msg if previously shown.
896        msg= ""
897        wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
898
899        if check_float(tcrtl):
900            flag = self._onparamEnter_helper() 
901            self.set_npts2fit() 
902            if self.fitrange:             
903                temp_smearer = None
904                if not self.disable_smearer.GetValue():
905                    temp_smearer= self.current_smearer
906                    ## set smearing value whether or not the data contain the smearing info
907                    if self.slit_smearer.GetValue():
908                        flag1 = self.update_slit_smear()
909                        flag = flag or flag1
910                    elif self.pinhole_smearer.GetValue():
911                        flag1 = self.update_pinhole_smear()
912                        flag = flag or flag1
913                elif self.data.__class__.__name__ !="Data2D":
914                    self.manager.set_smearer(smearer=temp_smearer, qmin= float(self.qmin_x),
915                                                             qmax= float(self.qmax_x)) 
916                if flag:   
917                    #self.compute_chisqr(smearer= temp_smearer)
918       
919                    ## new state posted
920                    if self.state_change:
921                        #self._undo.Enable(True)
922                        event = PageInfoEvent(page = self)
923                        wx.PostEvent(self.parent, event)
924                    self.state_change= False 
925            else: 
926                return    # invalid fit range: do nothing here: msg already displayed in validate   
927        else:
928            self.save_current_state()
929            msg= "Cannot Plot :Must enter a number!!!  "
930            wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
931             
932        self.save_current_state() 
933        return 
934   
935    def _onparamRangeEnter(self, event):
936        """
937        Check validity of value enter in the parameters range field
938        """
939        if self.check_invalid_panel():
940            return
941        tcrtl= event.GetEventObject()
942        #Clear msg if previously shown.
943        msg= ""
944        wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
945        # Flag to register when a parameter has changed.
946        is_modified = False
947        if tcrtl.GetValue().lstrip().rstrip()!="":
948            try:
949                value = float(tcrtl.GetValue())
950                tcrtl.SetBackgroundColour(wx.WHITE)
951                self._check_value_enter(self.fittable_param ,is_modified)
952                self._check_value_enter(self.parameters ,is_modified) 
953            except:
954                tcrtl.SetBackgroundColour("pink")
955                msg= "Model Error:wrong value entered : %s"% sys.exc_value
956                wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
957                return 
958        else:
959           tcrtl.SetBackgroundColour(wx.WHITE)
960           
961        #self._undo.Enable(True)
962        self.save_current_state()
963        event = PageInfoEvent(page = self)
964        wx.PostEvent(self.parent, event)
965        self.state_change= False
966
967                   
968    def _onQrangeEnter(self, event):
969        """
970        Check validity of value enter in the Q range field
971        """
972        if self.check_invalid_panel():
973            return
974        tcrtl= event.GetEventObject()
975        #Clear msg if previously shown.
976        msg= ""
977        wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
978        # Flag to register when a parameter has changed.
979        is_modified = False
980        if tcrtl.GetValue().lstrip().rstrip()!="":
981            try:
982                value = float(tcrtl.GetValue())
983                tcrtl.SetBackgroundColour(wx.WHITE)
984
985                # If qmin and qmax have been modified, update qmin and qmax
986                if self._validate_qrange( self.qmin, self.qmax):
987                    tempmin = float(self.qmin.GetValue())
988                    if tempmin != self.qmin_x:
989                        self.qmin_x = tempmin
990                    tempmax = float(self.qmax.GetValue())
991                    if tempmax != self.qmax_x:
992                        self.qmax_x = tempmax
993                else:
994                    tcrtl.SetBackgroundColour("pink")
995                    msg= "Model Error:wrong value entered : %s"% sys.exc_value
996                    wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
997                    return 
998               
999            except:
1000                tcrtl.SetBackgroundColour("pink")
1001                msg= "Model Error:wrong value entered : %s"% sys.exc_value
1002                wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1003                return 
1004            #Check if # of points for theory model are valid(>0).
1005            # check for 2d
1006            if self.data.__class__.__name__ =="Data2D":
1007                # set mask   
1008                radius= numpy.sqrt( self.data.qx_data*self.data.qx_data + self.data.qy_data*self.data.qy_data )
1009                index_data = ((self.qmin <= radius)&(radius<= self.qmax))
1010                index_data = (index_data)&(self.data.mask)
1011                index_data = (index_data)&(numpy.isfinite(self.data.data))
1012                if len(index_data[index_data]) < 10:
1013                    msg= "Cannot Plot :No or too little npts in that data range!!!  "
1014                    wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1015                    return
1016                else:
1017                    self.data.mask = index_data
1018                    self.Npts_fit.Setvalue(str(len(self.data.mask)))
1019            else:
1020                index_data = ((self.qmin <= self.data.x)&(self.data.x <= self.qmax))
1021                self.Npts_fit.SetValue(str(len(self.data.x[index_data])))
1022           
1023        else:
1024           tcrtl.SetBackgroundColour("pink")
1025           msg= "Model Error:wrong value entered!!!"
1026           wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1027       
1028        self._draw_model()
1029        ##update chi2
1030        #self.compute_chisqr(smearer= temp_smearer)
1031        #self._undo.Enable(True)
1032        self.save_current_state()
1033        event = PageInfoEvent(page = self)
1034        wx.PostEvent(self.parent, event)
1035        self.state_change= False
1036        return
1037   
1038    def _clear_Err_on_Fit(self):
1039        """
1040        hide the error text control shown
1041        after fitting
1042        """
1043       
1044        if hasattr(self,"text2_3"):
1045            self.text2_3.Hide()
1046
1047        if len(self.parameters)>0:
1048            for item in self.parameters:
1049                #Skip t ifhe angle parameters if 1D data
1050                if self.data.__class__.__name__ !="Data2D":
1051                    if item in self.orientation_params:
1052                        continue
1053                if item in self.param_toFit:
1054                    continue
1055                ## hide statictext +/-   
1056                if item[3]!=None and item[3].IsShown():
1057                    item[3].Hide()
1058                ## hide textcrtl  for error after fit
1059                if item[4]!=None and item[4].IsShown():                   
1060                    item[4].Hide()
1061 
1062        if len(self.fittable_param)>0:
1063            for item in self.fittable_param:
1064                #Skip t ifhe angle parameters if 1D data
1065                if self.data.__class__.__name__ !="Data2D":
1066                    if item in self.orientation_params:
1067                        continue
1068                if item in self.param_toFit:
1069                    continue
1070                ## hide statictext +/-   
1071                if item[3]!=None and item[3].IsShown():
1072                    item[3].Hide()
1073                ## hide textcrtl  for error after fit
1074                if item[4]!=None and item[4].IsShown():
1075                    item[4].Hide()
1076        return       
1077               
1078    def _get_defult_custom_smear(self):
1079        """
1080        Get the defult values for custum smearing.
1081        """
1082        # get the default values
1083        if self.dxl == None: self.dxl = 0.0
1084        if self.dxw == None: self.dxw = ""
1085        if self.dx_min == None: self.dx_min = SMEAR_SIZE_L
1086        if self.dx_max == None: self.dx_max = SMEAR_SIZE_H
1087       
1088    def _get_smear_info(self):
1089        """
1090        Get the smear info from data.
1091       
1092        :return: self.smear_type, self.dq_l and self.dq_r,
1093            respectively the type of the smear, dq_min and dq_max for pinhole smear data
1094            while dxl and dxw for slit smear
1095           
1096        """
1097
1098        # default
1099        self.smear_type = None
1100        self.dq_l = None
1101        self.dq_r = None
1102        data = self.data
1103        if self.data is None:
1104            return
1105        elif self.data.__class__.__name__ == 'Data2D': 
1106            if data.dqx_data == None or  data.dqy_data ==None: 
1107                return
1108            elif self.smearer != None and (data.dqx_data.any()!=0) and (data.dqx_data.any()!=0): 
1109                self.smear_type = "Pinhole2d"
1110                self.dq_l = format_number(numpy.average(data.dqx_data)) 
1111                self.dq_r = format_number(numpy.average(data.dqy_data)) 
1112                return 
1113            else: 
1114                return
1115        # check if it is pinhole smear and get min max if it is.
1116        if data.dx != None and all(data.dx !=0): 
1117            self.smear_type = "Pinhole" 
1118            self.dq_l = data.dx[0]
1119            self.dq_r = data.dx[-1]
1120           
1121        # check if it is slit smear and get min max if it is.
1122        elif data.dxl != None or data.dxw != None: 
1123            self.smear_type = "Slit" 
1124            if data.dxl != None and all(data.dxl !=0):
1125                self.dq_l = data.dxl[0]
1126            if data.dxw != None and all(data.dxw !=0): 
1127                self.dq_r = data.dxw[0]   
1128        #return self.smear_type,self.dq_l,self.dq_r       
1129   
1130    def _show_smear_sizer(self):   
1131        """
1132        Show only the sizers depending on smear selection
1133        """
1134        # smear disabled
1135        if self.disable_smearer.GetValue():
1136            self.smear_description_none.Show(True)
1137        # 2Dsmear
1138        elif self._is_2D():
1139            self.smear_description_accuracy_type.Show(True)
1140            self.smear_accuracy.Show(True)
1141            self.smear_description_accuracy_type.Show(True)
1142            self.smear_description_2d.Show(True)
1143            self.smear_description_2d_x.Show(True)
1144            self.smear_description_2d_y.Show(True)
1145            if self.pinhole_smearer.GetValue():
1146                self.smear_pinhole_min.Show(True)
1147                self.smear_pinhole_max.Show(True)
1148        # smear from data
1149        elif self.enable_smearer.GetValue():
1150
1151            self.smear_description_dqdata.Show(True)
1152            if self.smear_type != None:
1153                self.smear_description_smear_type.Show(True)
1154                if self.smear_type == 'Slit':
1155                    self.smear_description_slit_height.Show(True)
1156                    self.smear_description_slit_width.Show(True)               
1157                elif self.smear_type == 'Pinhole':
1158                    self.smear_description_pin_min.Show(True)
1159                    self.smear_description_pin_max.Show(True)
1160                self.smear_description_smear_type.Show(True)
1161                self.smear_description_type.Show(True)
1162                self.smear_data_left.Show(True)
1163                self.smear_data_right.Show(True)
1164        # custom pinhole smear
1165        elif self.pinhole_smearer.GetValue():
1166            if self.smear_type == 'Pinhole':
1167                self.smear_message_new_p.Show(True)
1168                self.smear_description_pin_min.Show(True)
1169                self.smear_description_pin_max.Show(True)
1170
1171            self.smear_pinhole_min.Show(True)
1172            self.smear_pinhole_max.Show(True)
1173        # custom slit smear
1174        elif self.slit_smearer.GetValue():
1175            self.smear_message_new_s.Show(True)
1176            self.smear_description_slit_height.Show(True)
1177            self.smear_slit_height.Show(True)
1178            self.smear_description_slit_width.Show(True)
1179            self.smear_slit_width.Show(True)
1180
1181    def _hide_all_smear_info(self):
1182        """
1183        Hide all smearing messages in the set_smearer sizer
1184        """
1185        self.smear_description_none.Hide()
1186        self.smear_description_dqdata.Hide()
1187        self.smear_description_type.Hide()
1188        self.smear_description_smear_type.Hide()
1189        self.smear_description_accuracy_type.Hide()
1190        self.smear_description_2d_x.Hide()
1191        self.smear_description_2d_y.Hide()
1192        self.smear_description_2d.Hide()
1193       
1194        self.smear_accuracy.Hide()
1195        self.smear_data_left.Hide()
1196        self.smear_data_right.Hide()
1197        self.smear_description_pin_min.Hide()
1198        self.smear_pinhole_min.Hide()
1199        self.smear_description_pin_max.Hide()
1200        self.smear_pinhole_max.Hide()
1201        self.smear_description_slit_height.Hide()
1202        self.smear_slit_height.Hide()
1203        self.smear_description_slit_width.Hide()
1204        self.smear_slit_width.Hide()
1205        self.smear_message_new_p.Hide()
1206        self.smear_message_new_s.Hide()
1207   
1208    def _set_accuracy_list(self):
1209        """
1210        Set the list of an accuracy in 2D custum smear: Xhigh, High, Med, or Low
1211        """
1212        # list of accuracy choices
1213        list = ['Low','Med','High','Xhigh']
1214        for idx in range(len(list)):
1215            self.smear_accuracy.Append(list[idx],idx)
1216           
1217    def _on_select_accuracy(self,event):
1218        """
1219        Select an accuracy in 2D custom smear: Xhigh, High, Med, or Low
1220        """
1221        #event.Skip()
1222        # Check if the accuracy is same as before
1223        #self.smear2d_accuracy = event.GetEventObject().GetValue()
1224        self.smear2d_accuracy = self.smear_accuracy.GetValue()
1225        if self.pinhole_smearer.GetValue():
1226            self.onPinholeSmear(event=None)
1227        else:   
1228            self.onSmear(event=None)
1229            if self.current_smearer != None:
1230                self.current_smearer.set_accuracy(accuracy = self.smear2d_accuracy) 
1231        event.Skip()
1232       
1233    def _onMask(self, event):     
1234        """
1235        Build a panel to allow to edit Mask
1236        """
1237       
1238        from sans.guiframe.local_perspectives.plotting.masking import MaskPanel as MaskDialog
1239       
1240        self.panel = MaskDialog(self, data=self.data,id =-1 )
1241        self.panel.Bind(wx.EVT_CLOSE, self._draw_masked_model)
1242        self.panel.ShowModal()
1243        #wx.PostEvent(self.parent, event)
1244       
1245    def _draw_masked_model(self,event):
1246        """
1247        Draw model image w/mask
1248        """
1249        event.Skip()
1250
1251        is_valid_qrange = self._update_paramv_on_fit()
1252
1253        if is_valid_qrange:
1254            # try re draw the model plot if it exists
1255            self._draw_model()
1256            self.panel.Destroy() # frame
1257            self.set_npts2fit()
1258        elif self.model == None:
1259            self.panel.Destroy()
1260            self.set_npts2fit()
1261            msg= "No model is found on updating MASK in the model plot... "
1262            wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))
1263        else:
1264            msg = ' Please consider your Q range, too.'
1265            self.panel.ShowMessage(msg)
1266       
1267    def set_data(self, data):
1268        """
1269        reset the current data
1270        """
1271        self.data = data
1272        if self.data is None:
1273            data_min = ""
1274            data_max = ""
1275            data_name = ""
1276            self.formfactorbox.Disable()
1277            self.structurebox.Disable()
1278        else:
1279            self.smearer = smear_selection( self.data )
1280            self.disable_smearer.SetValue(True)
1281            if self.smearer == None:
1282                self.enable_smearer.Disable()
1283            else:
1284                self.enable_smearer.Enable()
1285           
1286            # more disables for 2D
1287            if self.data.__class__.__name__ =="Data2D":
1288                self.slit_smearer.Disable()
1289                self.default_mask = copy.deepcopy(self.data.mask)
1290               
1291            self.formfactorbox.Enable()
1292            self.structurebox.Enable()
1293            data_name = self.data.name
1294            #set maximum range for x in linear scale
1295            if not hasattr(self.data,"data"): #Display only for 1D data fit
1296                # Minimum value of data   
1297                data_min = min(self.data.x)
1298                # Maximum value of data 
1299                data_max = max(self.data.x)
1300                #number of total data points
1301                self.Npts_total.SetValue(str(len(self.data.x)))
1302                #default:number of data points selected to fit
1303                self.Npts_fit.SetValue(str(len(self.data.x)))
1304                self.btEditMask.Disable() 
1305                self.EditMask_title.Disable()
1306            else:
1307                ## Minimum value of data
1308                data_min = 0
1309                x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax)) 
1310                y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
1311                ## Maximum value of data 
1312                data_max = math.sqrt(x*x + y*y)
1313                #number of total data points
1314                self.Npts_total.SetValue(str(len(self.data.data)))
1315                #default:number of data points selected to fit
1316                self.Npts_fit.SetValue(str(len(self.data.data)))
1317                self.btEditMask.Enable() 
1318                self.EditMask_title.Enable() 
1319        self.dataSource.SetValue(data_name)
1320        self.qmin_x = data_min
1321        self.qmax_x = data_max
1322        self.minimum_q.SetValue(str(data_min))
1323        self.maximum_q.SetValue(str(data_max))
1324        self.qmin.SetValue(str(data_min))
1325        self.qmax.SetValue(str(data_max))
1326        self.qmin.SetBackgroundColour("white")
1327        self.qmax.SetBackgroundColour("white")
1328        self.state.data = data
1329        self.state.qmin = self.qmin_x
1330        self.state.qmax = self.qmax_x
1331       
1332    def reset_page(self, state,first=False):
1333        """
1334        reset the state
1335        """
1336        self.reset_page_helper(state)
1337        import sans.guiframe.gui_manager
1338        evt = ModelEventbox(model=state.model)
1339        wx.PostEvent(self.event_owner, evt) 
1340   
1341        if self.engine_type != None:
1342            self.manager._on_change_engine(engine=self.engine_type)
1343
1344        self.select_param(event = None) 
1345        #Save state_fit
1346        self.save_current_state_fit()
1347        self._lay_out()
1348        self.Refresh()
1349       
1350    def get_range(self):
1351        """
1352        return the fitting range
1353        """
1354        return float(self.qmin_x) , float(self.qmax_x)
1355   
1356    def get_npts2fit(self):
1357        """
1358        return numbers of data points within qrange
1359       
1360        :Note: This is for Park where chi2 is not normalized by Npts of fit
1361       
1362        """
1363        npts2fit = 0
1364        qmin,qmax = self.get_range()
1365        if self.data.__class__.__name__ =="Data2D": 
1366            radius= numpy.sqrt( self.data.qx_data*self.data.qx_data + self.data.qy_data*self.data.qy_data )
1367            index_data = (self.qmin_x <= radius)&(radius<= self.qmax_x)
1368            index_data= (index_data)&(self.data.mask)
1369            index_data = (index_data)&(numpy.isfinite(self.data.data))
1370            npts2fit = len(self.data.data[index_data])
1371        else:
1372            for qx in self.data.x:
1373                   if qx >= qmin and qx <= qmax:
1374                       npts2fit += 1
1375        return npts2fit
1376
1377    def set_npts2fit(self):
1378        """
1379        setValue Npts for fitting
1380        """
1381        self.Npts_fit.SetValue(str(self.get_npts2fit()))
1382       
1383    def get_chi2(self):
1384        """
1385        return the current chi2
1386        """
1387        return self.tcChi.GetValue()
1388       
1389    def get_param_list(self):
1390        """
1391        :return self.param_toFit: list containing  references to TextCtrl
1392            checked.Theses TextCtrl will allow reference to parameters to fit.
1393       
1394        :raise: if return an empty list of parameter fit will nnote work
1395            properly so raise ValueError,"missing parameter to fit"
1396        """
1397        if self.param_toFit !=[]:
1398            return self.param_toFit
1399        else:
1400            raise ValueError,"missing parameter to fit"   
1401     
1402    def onsetValues(self,chisqr,p_name, out,cov):
1403        """
1404        Build the panel from the fit result
1405       
1406        :param chisqr: Value of the goodness of fit metric
1407        :param p_name: the name of parameters
1408        :param out: list of parameter with the best value found during fitting
1409        :param cov: Covariance matrix
1410   
1411        """
1412        if out == None or not numpy.isfinite(chisqr):
1413            raise ValueError,"Fit error occured..." 
1414       
1415        is_modified = False
1416        has_error = False   
1417       
1418        #Hide textctrl boxes of errors.
1419        self._clear_Err_on_Fit()   
1420       
1421        #Check if chi2 is finite
1422        if chisqr != None or numpy.isfinite(chisqr):
1423        #format chi2 
1424            if self.engine_type == "park": 
1425                npt_fit = float(self.get_npts2fit()) 
1426                if npt_fit > 0:
1427                    chisqr =chisqr/npt_fit   
1428            chi2 = format_number(chisqr)   
1429            self.tcChi.SetValue(chi2)   
1430            self.tcChi.Refresh()   
1431        else:
1432            self.tcChi.SetValue("-")
1433       
1434        #Hide error title
1435        if self.text2_3.IsShown():
1436            self.text2_3.Hide()
1437     
1438        try:
1439            n = self.disp_box.GetCurrentSelection()
1440            dispersity= self.disp_box.GetClientData(n)
1441            if dispersity !=None and self.enable_disp.GetValue():
1442                name= dispersity.__name__
1443                if name == "GaussianDispersion":
1444                    if hasattr(self,"text_disp_1" ):
1445                        if self.text_disp_1 !=None:
1446                            self.text_disp_1.Hide()
1447        except:
1448            dispersty = None
1449            pass
1450        #set the panel when fit result are float not list
1451        if out.__class__== numpy.float64:
1452            self.param_toFit[0][2].SetValue(format_number(out))
1453           
1454            if self.param_toFit[0][4].IsShown:
1455                self.param_toFit[0][4].Hide()
1456            if cov !=None :
1457                self.text2_3.Show(True)
1458                try:
1459                    if dispersity !=None:
1460                        name= dispersity.__name__
1461                        if name == "GaussianDispersion" and self.enable_disp.GetValue():
1462                            if hasattr(self,"text_disp_1" ):
1463                                if self.text_disp_1 !=None:
1464                                    self.text_disp_1.Show(True)
1465                except:
1466                    pass
1467
1468                if cov[0]==None or  not numpy.isfinite(cov[0]): 
1469                    if self.param_toFit[0][3].IsShown:
1470                        self.param_toFit[0][3].Hide()
1471                else:                   
1472                    self.param_toFit[0][3].Show(True)               
1473                    self.param_toFit[0][4].Show(True)
1474                    self.param_toFit[0][4].SetValue(format_number(cov[0]))
1475                    has_error = True
1476        else:
1477
1478            i = 0
1479            #Set the panel when fit result are list
1480            for item in self.param_toFit:     
1481                if len(item)>5 and item != None:     
1482                    ## reset error value to initial state
1483                    item[3].Hide()
1484                    item[4].Hide()
1485                   
1486                    for ind in range(len(out)):
1487                       
1488                        if item[1] == p_name[ind]:
1489                            break       
1490                    if len(out)<=len(self.param_toFit) and out[ind] !=None:   
1491                        val_out = format_number(out[ind])                 
1492                        item[2].SetValue(val_out)
1493
1494                    if(cov !=None):
1495                       
1496                        try:
1497                            if dispersity !=None:
1498                                name= dispersity.__name__
1499                                if name == "GaussianDispersion" and self.enable_disp.GetValue():
1500                                    if hasattr(self,"text_disp_1" ):
1501                                        if self.text_disp_1!=None:
1502                                            if not self.text_disp_1.IsShown():
1503                                                self.text_disp_1.Show(True)
1504                        except:
1505                            pass   
1506                   
1507                        if cov[ind]!=None :
1508                            if numpy.isfinite(float(cov[ind])):
1509                                val_err = format_number(cov[ind])
1510                                item[3].Show(True)
1511                                item[4].Show(True)
1512                                item[4].SetValue(val_err)
1513
1514                                has_error = True
1515                    i += 1         
1516        #Show error title when any errors displayed
1517        if has_error: 
1518            if not self.text2_3.IsShown():
1519                self.text2_3.Show(True) 
1520               
1521        ## save current state 
1522        self.save_current_state()         
1523        #plot model
1524        self._draw_model()   
1525        self._lay_out()     
1526        #PostStatusEvent     
1527        msg = "Fit completed! "
1528        wx.PostEvent(self.manager.parent, StatusEvent(status=msg))
1529
1530    def onPinholeSmear(self, event):
1531        """
1532        Create a custom pinhole smear object that will change the way residuals
1533        are compute when fitting
1534       
1535        :Note: accuracy is given by strings'High','Med', 'Low' FOR 2d,
1536                     None for 1D
1537                     
1538        """
1539
1540        if self.check_invalid_panel():
1541            return
1542        if self.model ==None:
1543            self.disable_smearer.SetValue(True)
1544            msg="Please select a Model first..."
1545            wx.MessageBox(msg, 'Info')
1546            wx.PostEvent(self.manager.parent, StatusEvent(status=\
1547                            "Smear: %s"%msg))
1548            return
1549
1550        # Need update param values
1551        self._update_paramv_on_fit()     
1552
1553        # msg default
1554        msg = None
1555        if event != None:
1556            tcrtl= event.GetEventObject()
1557            # event case of radio button
1558            if tcrtl.GetValue()== True:
1559                self.dx_min = 0.0
1560                self.dx_max = 0.0
1561                is_new_pinhole = True
1562            else:
1563                is_new_pinhole = self._is_changed_pinhole()
1564        else:
1565            is_new_pinhole = True 
1566        # if any value is changed
1567        if is_new_pinhole:
1568            msg = self._set_pinhole_smear()
1569        # hide all silt sizer   
1570        self._hide_all_smear_info()
1571       
1572        ##Calculate chi2
1573        temp_smearer = self.current_smearer
1574        #self.compute_chisqr(smearer= temp_smearer)
1575           
1576        # show relevant slit sizers
1577        self._show_smear_sizer()
1578
1579        self.sizer_set_smearer.Layout()
1580        self.Layout()   
1581       
1582        if event != None: 
1583            event.Skip()                 
1584        #self._undo.Enable(True)
1585        self.save_current_state()
1586        event = PageInfoEvent(page = self)
1587        wx.PostEvent(self.parent, event)
1588       
1589    def _is_changed_pinhole(self): 
1590        """
1591        check if any of pinhole smear is changed
1592       
1593        :return: True or False
1594       
1595        """
1596        # get the values
1597        pin_min = self.smear_pinhole_min.GetValue()
1598        pin_max = self.smear_pinhole_max.GetValue()
1599                   
1600        # Check changes in slit width   
1601        try:
1602            dx_min = float(pin_min)
1603        except:
1604            return True
1605        if self.dx_min != dx_min:
1606            return True
1607       
1608        # Check changes in slit heigth
1609        try:
1610            dx_max = float(pin_max)
1611        except:
1612            return True
1613        if self.dx_max != dx_max:
1614            return True
1615        return False
1616   
1617    def _set_pinhole_smear(self):
1618        """
1619        Set custom pinhole smear
1620       
1621        :return: msg
1622       
1623        """
1624        # copy data
1625        data = copy.deepcopy(self.data)
1626        if self._is_2D():
1627            self.smear_type = 'Pinhole2d'
1628            len_data = len(data.data)
1629            data.dqx_data = numpy.zeros(len_data)
1630            data.dqy_data = numpy.zeros(len_data)
1631        else:
1632            self.smear_type = 'Pinhole'
1633            len_data = len(data.x)
1634            data.dx = numpy.zeros(len_data)
1635            data.dxl = None
1636            data.dxw = None
1637        msg = None
1638   
1639        get_pin_min = self.smear_pinhole_min
1640        get_pin_max = self.smear_pinhole_max       
1641
1642        if not check_float(get_pin_min):
1643            get_pin_min.SetBackgroundColour("pink")
1644            msg= "Model Error:wrong value entered!!!"
1645        elif not check_float(get_pin_max ):
1646            get_pin_max.SetBackgroundColour("pink")
1647            msg= "Model Error:wrong value entered!!!"
1648        else:
1649            if len_data < 2: len_data = 2     
1650            self.dx_min = float(get_pin_min.GetValue())
1651            self.dx_max = float(get_pin_max.GetValue())
1652            if self.dx_min < 0:
1653                get_pin_min.SetBackgroundColour("pink")
1654                msg= "Model Error:This value can not be negative!!!"
1655            elif self.dx_max <0:
1656                get_pin_max.SetBackgroundColour("pink")
1657                msg= "Model Error:This value can not be negative!!!"
1658            elif self.dx_min != None and self.dx_max != None:   
1659                if self._is_2D():
1660                    data.dqx_data[data.dqx_data==0] = self.dx_min
1661                    data.dqy_data[data.dqy_data==0] = self.dx_max         
1662                elif self.dx_min == self.dx_max:
1663                    data.dx[data.dx==0] = self.dx_min
1664                else:
1665                    step = (self.dx_max - self.dx_min)/(len_data-1)   
1666                    data.dx = numpy.arange(self.dx_min,self.dx_max+step/1.1,step)           
1667            elif self.dx_min != None: 
1668                if self._is_2D(): data.dqx_data[data.dqx_data==0] = self.dx_min
1669                else: data.dx[data.dx==0] = self.dx_min
1670            elif self.dx_max != None:
1671                if self._is_2D(): data.dqy_data[data.dqy_data==0] = self.dx_max
1672                else: data.dx[data.dx==0] = self.dx_max         
1673            self.current_smearer = smear_selection(data)
1674            # 2D need to set accuracy
1675            if self._is_2D(): 
1676                self.current_smearer.set_accuracy(accuracy = self.smear2d_accuracy)
1677
1678        if msg != None:
1679            wx.PostEvent(self.manager.parent, StatusEvent(status = msg ))
1680        else:
1681            get_pin_min.SetBackgroundColour("white")
1682            get_pin_max.SetBackgroundColour("white")
1683        ## set smearing value whether or not the data contain the smearing info
1684        self.manager.set_smearer(smearer=self.current_smearer, qmin= float(self.qmin_x),qmax= float(self.qmax_x))
1685        return msg
1686       
1687    def update_pinhole_smear(self):
1688        """
1689        called by kill_focus on pinhole TextCntrl
1690        to update the changes
1691       
1692        :return: False when wrong value was entered
1693       
1694        """
1695        # msg default
1696        msg = None
1697        # check if any value is changed
1698        if self._is_changed_pinhole():
1699            msg = self._set_pinhole_smear()           
1700        #self._undo.Enable(True)
1701        self.save_current_state()
1702
1703        if msg != None:
1704            return False   
1705        else:
1706            return True
1707                     
1708    def onSlitSmear(self, event):
1709        """
1710        Create a custom slit smear object that will change the way residuals
1711        are compute when fitting
1712        """
1713 
1714        if self.check_invalid_panel():
1715            return
1716
1717        if self.model ==None:
1718            self.disable_smearer.SetValue(True)
1719           
1720            msg="Please select a Model first..."
1721            wx.MessageBox(msg, 'Info')
1722            wx.PostEvent(self.manager.parent, StatusEvent(status=\
1723                            "Smear: %s"%msg))
1724            return
1725
1726        # Need update param values
1727        self._update_paramv_on_fit()
1728
1729        # msg default
1730        msg = None
1731        # for event given
1732        if event != None:
1733            tcrtl= event.GetEventObject()
1734            # event case of radio button
1735            if tcrtl.GetValue():
1736                self.dxl = 0.0
1737                self.dxw = 0.0
1738                is_new_slit = True
1739            else:
1740                is_new_slit = self._is_changed_slit()
1741        else:
1742            is_new_slit = True 
1743       
1744        # if any value is changed
1745        if is_new_slit:
1746            msg = self._set_slit_smear()
1747           
1748        # hide all silt sizer
1749        self._hide_all_smear_info()       
1750        ##Calculate chi2
1751        #self.compute_chisqr(smearer= self.current_smearer) 
1752        # show relevant slit sizers       
1753        self._show_smear_sizer()
1754        self.sizer_set_smearer.Layout()
1755        self.Layout()
1756
1757        if event != None:
1758            event.Skip()     
1759        #self._undo.Enable(True)
1760        self.save_current_state()
1761        event = PageInfoEvent(page = self)
1762        wx.PostEvent(self.parent, event)
1763        if msg != None:
1764            wx.PostEvent(self.manager.parent, StatusEvent(status = msg))
1765
1766    def _is_changed_slit(self): 
1767        """
1768        check if any of slit lengths is changed
1769       
1770        :return: True or False
1771       
1772        """
1773        # get the values
1774        width = self.smear_slit_width.GetValue()
1775        height = self.smear_slit_height.GetValue()
1776       
1777        # check and change the box bg color if it was pink but it should be white now
1778        # because this is the case that _set_slit_smear() will not handle
1779        if height.lstrip().rstrip()=="":
1780            self.smear_slit_height.SetBackgroundColour(wx.WHITE)
1781        if width.lstrip().rstrip()=="":
1782            self.smear_slit_width.SetBackgroundColour(wx.WHITE)
1783           
1784        # Check changes in slit width   
1785        if width == "": 
1786            dxw = 0.0
1787        else:
1788            try:
1789                dxw = float(width)
1790            except:
1791                return True
1792        if self.dxw != dxw:
1793            return True
1794       
1795        # Check changes in slit heigth
1796        if height == "": 
1797            dxl = 0.0
1798        else:
1799            try:
1800                dxl = float(height)
1801            except:
1802                return True
1803        if self.dxl != dxl:
1804            return True
1805
1806        return False
1807   
1808    def _set_slit_smear(self):
1809        """
1810        Set custom slit smear
1811       
1812        :return: message to inform the user about the validity
1813            of the values entered for slit smear
1814        """
1815        temp_smearer = None
1816        # make sure once more if it is smearer
1817        data = copy.deepcopy(self.data)
1818        data_len = len(data.x)
1819        data.dx = None
1820        data.dxl = None
1821        data.dxw = None
1822        msg = None
1823   
1824        try:
1825            self.dxl = float(self.smear_slit_height.GetValue())
1826            data.dxl = self.dxl* numpy.ones(data_len)
1827            self.smear_slit_height.SetBackgroundColour(wx.WHITE)
1828        except: 
1829            data.dxl = numpy.zeros(data_len)
1830            if self.smear_slit_height.GetValue().lstrip().rstrip()!="":
1831                self.smear_slit_height.SetBackgroundColour("pink")
1832                msg = "Wrong value entered... " 
1833            else:
1834                self.smear_slit_height.SetBackgroundColour(wx.WHITE)
1835        try:
1836            self.dxw = float(self.smear_slit_width.GetValue())
1837            self.smear_slit_width.SetBackgroundColour(wx.WHITE)
1838            data.dxw = self.dxw* numpy.ones(data_len)
1839        except: 
1840            data.dxw = numpy.zeros(data_len)
1841            if self.smear_slit_width.GetValue().lstrip().rstrip()!="":
1842                self.smear_slit_width.SetBackgroundColour("pink")
1843                msg = "Wrong Fit value entered... "
1844            else:
1845                self.smear_slit_width.SetBackgroundColour(wx.WHITE)
1846             
1847        self.current_smearer = smear_selection(data)
1848        #temp_smearer = self.current_smearer
1849        ## set smearing value whether or not the data contain the smearing info
1850        self.manager.set_smearer(smearer=self.current_smearer, qmin= float(self.qmin_x), qmax= float(self.qmax_x)) 
1851        return msg
1852   
1853    def update_slit_smear(self):
1854        """
1855        called by kill_focus on pinhole TextCntrl
1856        to update the changes
1857       
1858        :return: False when wrong value was entered
1859       
1860        """             
1861        # msg default
1862        msg = None
1863        # check if any value is changed
1864        if self._is_changed_slit():
1865            msg = self._set_slit_smear()           
1866        #self._undo.Enable(True)
1867        self.save_current_state()
1868
1869        if msg != None:
1870            return False   
1871        else:
1872            return True
1873                           
1874    def onSmear(self, event):
1875        """
1876        Create a smear object that will change the way residuals
1877        are compute when fitting
1878        """
1879        if event != None: 
1880            event.Skip()   
1881        if self.check_invalid_panel():
1882            return
1883        if self.model ==None:
1884            self.disable_smearer.SetValue(True)
1885            msg="Please select a Model first..."
1886            wx.MessageBox(msg, 'Info')
1887            wx.PostEvent(self.manager.parent, StatusEvent(status=\
1888                            "Smear: %s"%msg))
1889            return
1890       
1891        # Need update param values
1892        self._update_paramv_on_fit()
1893             
1894        temp_smearer = None
1895        self._get_smear_info()
1896       
1897        #renew smear sizer
1898        if self.smear_type != None:
1899            self.smear_description_smear_type.SetValue(str(self.smear_type))
1900            self.smear_data_left.SetValue(str(self.dq_l))   
1901            self.smear_data_right.SetValue(str(self.dq_r))       
1902
1903        self._hide_all_smear_info()
1904       
1905        data = copy.deepcopy(self.data)
1906        # make sure once more if it is smearer
1907        self.current_smearer = smear_selection(data)
1908       
1909        if self.enable_smearer.GetValue():
1910            if hasattr(self.data,"dxl"):
1911               
1912                msg= ": Resolution smearing parameters"
1913            if hasattr(self.data,"dxw"):
1914                msg= ": Slit smearing parameters"
1915            if self.smearer ==None:
1916                wx.PostEvent(self.manager.parent, StatusEvent(status=\
1917                            "Data contains no smearing information"))
1918            else:
1919                wx.PostEvent(self.manager.parent, StatusEvent(status=\
1920                            "Data contains smearing information"))
1921
1922            #self.smear_description_dqdata.Show(True)
1923            self.smear_data_left.Show(True)
1924            self.smear_data_right.Show(True)
1925            temp_smearer= self.current_smearer
1926        elif self.disable_smearer.GetValue():
1927            self.smear_description_none.Show(True)
1928           
1929        self._show_smear_sizer()
1930       
1931        self.sizer_set_smearer.Layout()
1932        self.Layout()
1933        ## set smearing value whether or not the data contain the smearing info
1934        self.manager.set_smearer(smearer=temp_smearer, qmin= float(self.qmin_x),
1935                                     qmax= float(self.qmax_x)) 
1936
1937        ##Calculate chi2
1938        #self.compute_chisqr(smearer= temp_smearer)
1939       
1940        self.state.enable_smearer=  self.enable_smearer.GetValue()
1941        self.state.disable_smearer=self.disable_smearer.GetValue()
1942        self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
1943        self.state.slit_smearer = self.slit_smearer.GetValue()
1944     
1945    def on_complete_chisqr(self, event): 
1946        """
1947        print result chisqr
1948       
1949        :event: activated by fitting/ complete after draw
1950       
1951        """
1952        try:
1953            if event ==None:
1954                output= "-"
1955            else:
1956                output = event.output
1957            self.tcChi.SetValue(str(format_number(output)))
1958
1959            self.state.tcChi =self.tcChi
1960        except:
1961            pass 
1962           
1963
1964    def select_all_param(self,event): 
1965        """
1966        set to true or false all checkBox given the main checkbox value cb1
1967        """           
1968        self.param_toFit=[]
1969        if  self.parameters !=[]:
1970            if  self.cb1.GetValue():
1971                for item in self.parameters:
1972                    ## for data2D select all to fit
1973                    if self.data.__class__.__name__=="Data2D":
1974                        item[0].SetValue(True)
1975                        self.param_toFit.append(item )
1976                    else:
1977                        ## for 1D all parameters except orientation
1978                        if not item in self.orientation_params:
1979                            item[0].SetValue(True)
1980                            self.param_toFit.append(item )
1981                #if len(self.fittable_param)>0:
1982                for item in self.fittable_param:
1983                    if self.data.__class__.__name__=="Data2D":
1984                        item[0].SetValue(True)
1985                        self.param_toFit.append(item )
1986                    else:
1987                        ## for 1D all parameters except orientation
1988                        if not item in self.orientation_params_disp:
1989                            item[0].SetValue(True)
1990                            self.param_toFit.append(item )
1991            else:
1992                for item in self.parameters:
1993                    item[0].SetValue(False)
1994                for item in self.fittable_param:
1995                    item[0].SetValue(False)
1996                self.param_toFit=[]
1997           
1998        self.save_current_state_fit() 
1999       
2000        if event !=None:
2001            #self._undo.Enable(True)
2002            ## post state to fit panel
2003            event = PageInfoEvent(page = self)
2004            wx.PostEvent(self.parent, event) 
2005     
2006    def select_param(self,event):
2007        """
2008        Select TextCtrl  checked for fitting purpose and stores them
2009        in  self.param_toFit=[] list
2010        """
2011        self.param_toFit=[]
2012        for item in self.parameters:
2013            #Skip t ifhe angle parameters if 1D data
2014            if self.data.__class__.__name__ !="Data2D":
2015                if item in self.orientation_params:
2016                    continue
2017            #Select parameters to fit for list of primary parameters
2018            if item[0].GetValue():
2019                if not (item in self.param_toFit):
2020                    self.param_toFit.append(item ) 
2021            else:
2022                #remove parameters from the fitting list
2023                if item in self.param_toFit:
2024                    self.param_toFit.remove(item)
2025
2026        #Select parameters to fit for list of fittable parameters with dispersion         
2027        for item in self.fittable_param:
2028            #Skip t ifhe angle parameters if 1D data
2029            if self.data.__class__.__name__ !="Data2D":
2030                if item in self.orientation_params:
2031                    continue
2032            if item[0].GetValue():
2033                if not (item in self.param_toFit):
2034                    self.param_toFit.append(item) 
2035            else:
2036                #remove parameters from the fitting list
2037                if item in self.param_toFit:
2038                    self.param_toFit.remove(item)
2039
2040        #Calculate num. of angle parameters
2041        if self.data.__class__.__name__ =="Data2D": 
2042            len_orient_para = 0
2043        else:
2044            len_orient_para = len(self.orientation_params)  #assume even len
2045        #Total num. of angle parameters
2046        if len(self.fittable_param) > 0:
2047            len_orient_para *= 2
2048        #Set the value of checkbox that selected every checkbox or not           
2049        if len(self.parameters)+len(self.fittable_param)-len_orient_para ==len(self.param_toFit):
2050            self.cb1.SetValue(True)
2051        else:
2052            self.cb1.SetValue(False)
2053        self.save_current_state_fit()
2054        if event !=None:
2055            #self._undo.Enable(True)
2056            ## post state to fit panel
2057            event = PageInfoEvent(page = self)
2058            wx.PostEvent(self.parent, event) 
2059   
2060    def set_model_param_sizer(self, model):
2061        """
2062        Build the panel from the model content
2063       
2064        :param model: the model selected in combo box for fitting purpose
2065       
2066        """
2067        self.sizer3.Clear(True)
2068        self.parameters = []
2069        self.param_toFit=[]
2070        self.fittable_param=[]
2071        self.fixed_param=[]
2072        self.orientation_params=[]
2073        self.orientation_params_disp=[]
2074       
2075        if model ==None:
2076            self.sizer3.Layout()
2077            self.SetScrollbars(20,20,25,65)
2078            return
2079        ## the panel is drawn using the current value of the fit engine
2080        if self.engine_type==None and self.manager !=None:
2081            self.engine_type= self.manager._return_engine_type()
2082
2083        box_description= wx.StaticBox(self, -1,str("Model Parameters"))
2084        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
2085        sizer = wx.GridBagSizer(5,5)
2086        ## save the current model
2087        self.model = model
2088           
2089        keys = self.model.getParamList()
2090        #list of dispersion paramaters
2091        self.disp_list=self.model.getDispParamList()
2092
2093        keys.sort()
2094   
2095        iy = 0
2096        ix = 0
2097        select_text = "Select All"
2098        self.cb1 = wx.CheckBox(self, -1,str(select_text), (10, 10))
2099        wx.EVT_CHECKBOX(self, self.cb1.GetId(), self.select_all_param)
2100        self.cb1.SetToolTipString("To check/uncheck all the boxes below.")
2101        #self.cb1.SetValue(True)
2102       
2103        sizer.Add(self.cb1,(iy, ix),(1,1),\
2104                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 5)
2105        ix +=1
2106        self.text2_2 = wx.StaticText(self, -1, 'Values')
2107        sizer.Add(self.text2_2,(iy, ix),(1,1),\
2108                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2109        ix +=2 
2110        self.text2_3 = wx.StaticText(self, -1, 'Errors')
2111        sizer.Add(self.text2_3,(iy, ix),(1,1),\
2112                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
2113        self.text2_3.Hide()
2114        ix +=1 
2115        self.text2_min = wx.StaticText(self, -1, 'Min')
2116        sizer.Add(self.text2_min,(iy, ix),(1,1),\
2117                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
2118        self.text2_min.Hide()
2119        ix +=1 
2120        self.text2_max = wx.StaticText(self, -1, 'Max')
2121        sizer.Add(self.text2_max,(iy, ix),(1,1),\
2122                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
2123        self.text2_max.Hide()
2124        ix += 1
2125        self.text2_4 = wx.StaticText(self, -1, '[Units]')
2126        sizer.Add(self.text2_4,(iy, ix),(1,1),\
2127                            wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
2128        self.text2_4.Hide()
2129        if self.engine_type=="park":
2130            self.text2_max.Show(True)
2131            self.text2_min.Show(True)
2132       
2133        for item in keys:
2134            if not item in self.disp_list and not item in self.model.orientation_params:
2135               
2136                ##prepare a spot to store errors
2137                if not self.model.details.has_key(item):
2138                    self.model.details [item] = ["",None,None] 
2139         
2140                iy += 1
2141                ix = 0
2142                ## add parameters name with checkbox for selecting to fit
2143                cb = wx.CheckBox(self, -1, item )             
2144                cb.SetToolTipString(" Check for fitting.")
2145                #cb.SetValue(True)
2146                wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
2147               
2148                sizer.Add( cb,( iy, ix),(1,1),
2149                             wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 5)
2150               
2151                ## add parameter value
2152                ix += 1
2153                value= self.model.getParam(item)
2154                ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH,20),
2155                                    style=wx.TE_PROCESS_ENTER)
2156                ctl1.SetToolTipString("Hit 'Enter' after typing.")
2157                ctl1.SetValue(format_number(value))
2158                sizer.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
2159                ## text to show error sign
2160                ix += 1
2161                text2=wx.StaticText(self, -1, '+/-')
2162                sizer.Add(text2,(iy, ix),(1,1),\
2163                                wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
2164                text2.Hide() 
2165                ix += 1
2166                ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=0)
2167                sizer.Add(ctl2, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2168                ctl2.Hide()
2169               
2170                ix += 1
2171                ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
2172                                               text_enter_callback = self._onparamRangeEnter)
2173     
2174                sizer.Add(ctl3, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2175                ctl3.Hide()
2176       
2177                ix += 1
2178                ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
2179                                               text_enter_callback = self._onparamRangeEnter)
2180                sizer.Add(ctl4, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2181     
2182                ctl4.Hide()
2183
2184                if self.engine_type=="park":
2185                    ctl3.Show(True)
2186                    ctl4.Show(True)
2187                ix +=1
2188                # Units
2189                if self.model.details.has_key(item):
2190                    units = wx.StaticText(self, -1, self.model.details[item][0], style=wx.ALIGN_LEFT)
2191                else:
2192                    units = wx.StaticText(self, -1, "", style=wx.ALIGN_LEFT)
2193                sizer.Add(units, (iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2194                   
2195                ##[cb state, name, value, "+/-", error of fit, min, max , units]
2196                self.parameters.append([cb,item, ctl1,
2197                                        text2,ctl2, ctl3, ctl4,units])
2198             
2199        iy+=1
2200        sizer.Add((10,10),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
2201       
2202        # type can be either Guassian or Array
2203        if len(self.model.dispersion.values())>0:
2204            type= self.model.dispersion.values()[0]["type"]
2205        else:
2206            type = "Gaussian"
2207           
2208        iy += 1
2209        ix = 0
2210        #Add tile for orientational angle
2211        for item in keys:
2212            if item in self.model.orientation_params:       
2213                orient_angle = wx.StaticText(self, -1, '[For 2D only]:')
2214                sizer.Add(orient_angle,(iy, ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
2215                if not self.data.__class__.__name__ =="Data2D":
2216                    orient_angle.Hide()
2217                else:
2218                    orient_angle.Show(True)
2219                break
2220     
2221        #For Gaussian only
2222        if type.lower() != "array":
2223            for item in self.model.orientation_params:
2224                if not item in self.disp_list:
2225                    ##prepare a spot to store min max
2226                    if not self.model.details.has_key(item):
2227                        self.model.details [item] = ["",None,None] 
2228                         
2229                    iy += 1
2230                    ix = 0
2231                    ## add parameters name with checkbox for selecting to fit
2232                    cb = wx.CheckBox(self, -1, item )
2233                    cb.SetValue(False)
2234                    cb.SetToolTipString("Check for fitting")
2235                    wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
2236                    if self.data.__class__.__name__ =="Data2D":
2237                        cb.Show(True)
2238                    else:
2239                        cb.Hide()
2240                    sizer.Add( cb,( iy, ix),(1,1),
2241                                 wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 5)
2242   
2243                    ## add parameter value
2244                    ix += 1
2245                    value= self.model.getParam(item)
2246                    ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH,20),
2247                                        style=wx.TE_PROCESS_ENTER)
2248                    ctl1.SetToolTipString("Hit 'Enter' after typing.")
2249                    ctl1.SetValue(format_number(value))
2250                    if self.data.__class__.__name__ =="Data2D":
2251                        ctl1.Show(True)
2252                    else:
2253                        ctl1.Hide()
2254                    sizer.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
2255                    ## text to show error sign
2256                    ix += 1
2257                    text2=wx.StaticText(self, -1, '+/-')
2258                    sizer.Add(text2,(iy, ix),(1,1),\
2259                                    wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
2260                    text2.Hide() 
2261                    ix += 1
2262                    ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=0)
2263                    sizer.Add(ctl2, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2264                    ctl2.Hide()
2265                   
2266                   
2267                    ix += 1
2268                    ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
2269                                                   text_enter_callback = self._onparamRangeEnter)
2270                   
2271                    sizer.Add(ctl3, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2272                    ctl3.Hide()
2273                 
2274                    ix += 1
2275                    ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
2276                                                   text_enter_callback = self._onparamRangeEnter)
2277                    sizer.Add(ctl4, (iy,ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2278                   
2279                    ctl4.Hide()
2280                   
2281                    if self.engine_type =="park" and self.data.__class__.__name__ =="Data2D":                     
2282                        ctl3.Show(True)
2283                        ctl4.Show(True)
2284                   
2285                    ix +=1
2286                    # Units
2287                    if self.model.details.has_key(item):
2288                        units = wx.StaticText(self, -1, self.model.details[item][0], style=wx.ALIGN_LEFT)
2289                    else:
2290                        units = wx.StaticText(self, -1, "", style=wx.ALIGN_LEFT)
2291                    if self.data.__class__.__name__ =="Data2D":
2292                        units.Show(True)
2293                   
2294                    else:
2295                        units.Hide()
2296                   
2297                    sizer.Add(units, (iy,ix),(1,1),  wx.EXPAND|wx.ADJUST_MINSIZE, 0)
2298                                         
2299                    ##[cb state, name, value, "+/-", error of fit, min, max , units]
2300                    self.parameters.append([cb,item, ctl1,
2301                                            text2,ctl2, ctl3, ctl4,units])
2302                    self.orientation_params.append([cb,item, ctl1,
2303                                            text2,ctl2, ctl3, ctl4,units])
2304             
2305        iy+=1
2306       
2307        #Display units text on panel
2308        for item in keys:   
2309            if self.model.details.has_key(item):
2310                self.text2_4.Show()
2311        #Fill the list of fittable parameters
2312        self.select_all_param(event=None)
2313
2314        self.save_current_state_fit()
2315        boxsizer1.Add(sizer)
2316        self.sizer3.Add(boxsizer1,0, wx.EXPAND | wx.ALL, 10)
2317        self.sizer3.Layout()
2318        self.Layout()
2319        self.Refresh()
2320        self.SetScrollbars(20,20,25,65)
2321       
2322
2323class BGTextCtrl(wx.TextCtrl):
2324    """
2325    Text control used to display outputs.
2326    No editing allowed. The background is
2327    grayed out. User can't select text.
2328    """
2329    def __init__(self, *args, **kwds):
2330        wx.TextCtrl.__init__(self, *args, **kwds)
2331        self.SetEditable(False)
2332        self.SetBackgroundColour(self.GetParent().GetBackgroundColour())
2333       
2334        # Bind to mouse event to avoid text highlighting
2335        # The event will be skipped once the call-back
2336        # is called.
2337        self.Bind(wx.EVT_MOUSE_EVENTS, self._click)
2338       
2339    def _click(self, event):
2340        """
2341        Prevent further handling of the mouse event
2342        by not calling Skip().
2343        """ 
2344        pass
2345 
2346"""
2347Example: ::   
2348   
2349    class HelpWindow(wx.Frame):
2350        def __init__(self, parent, id, title):
2351            wx.Frame.__init__(self, parent, id, title, size=(570, 400))
2352           
2353            from sans.models.CylinderModel import CylinderModel
2354            model = CylinderModel()
2355           
2356            from danse.common.plottools.plottables import Data1D
2357            data= Data1D(x=[1,2], y=[3,4], dy=[0.1, 0,1])
2358       
2359            from fitpanel import PageInfo
2360            myinfo = PageInfo(self,  model, data=data )
2361           
2362            ## add data
2363           
2364            from models import ModelList
2365            mylist= ModelList()
2366   
2367            from sans.models.SphereModel import SphereModel
2368            from sans.models.SquareWellStructure import SquareWellStructure
2369            from sans.models.DebyeModel import DebyeModel
2370            from sans.models.LineModel import LineModel
2371            name= "shapes"
2372            list1= [SphereModel]
2373            mylist.set_list( name, list1)
2374           
2375            name= "Shape-independent"
2376            list1= [DebyeModel]
2377            mylist.set_list( name, list1)
2378           
2379            name= "Structure Factors"
2380            list1= [SquareWellStructure]
2381            mylist.set_list( name, list1)
2382           
2383            name= "Added models"
2384            list1= [LineModel]
2385            mylist.set_list( name, list1)
2386           
2387            myinfo.model_list_box = mylist.get_list()
2388           
2389            self.page = FitPage(self, myinfo)
2390           
2391            self.Centre()
2392            self.Show(True)
2393     
2394    if __name__=="__main__":
2395        app = wx.App()
2396        HelpWindow(None, -1, 'HelpWindow')
2397        app.MainLoop()
2398"""
2399           
Note: See TracBrowser for help on using the repository browser.