fitpage.py @ 4225aed

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 4225aed was 4225aed, checked in by Gervaise Alina <gervyh@…>, 13 years ago
working on batch
Property mode set to `100644`
File size: 123.0 KB

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

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

SasView

source: sasview/sansview/perspectives/fitting/fitpage.py @ 4225aed

Download in other formats: