fitpage.py @ 7ad194fa

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

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

SasView

source: sasview/fittingview/src/sans/perspectives/fitting/fitpage.py @ 7ad194fa

Download in other formats: