Copy of fitpage.py @ 883e5f5

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 883e5f5 was a07e72f, checked in by Gervaise Alina <gervyh@…>, 14 years ago
remove other type of data into sansview
Property mode set to `100644`
File size: 107.9 KB

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

Note: See TracBrowser for help on using the repository browser.

SasView

source: sasview/sansview/perspectives/fitting/Copy of fitpage.py @ 883e5f5

Download in other formats: