fitpage.py @ d0abc8e

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 d0abc8e was 67ae937, checked in by Gervaise Alina <gervyh@…>, 13 years ago
working on batch mode
Property mode set to `100644`
File size: 123.1 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, npts = self.compute_data_range(data_list[0])
101	self.qmin_data_set, self.qmax_data_set = qmin, qmax
102	self.npts_data_set = npts
103	for data in self.data_list:
104	if data is not None:
105	self.compute_data_set_range(data)
106	self.dataSource.Append(str(data.name), clientData=data)
107
108	print "fill_data_combox", self.qmin_data_set, self.qmax_data_set
109	self.dataSource.SetSelection(0)
110	self.on_select_data(event=None)
111
112	def on_select_data(self, event=None):
113	"""
114	"""
115	if event is None and self.dataSource.GetCount() > 0:
116	data = self.dataSource.GetClientData(0)
117	self.set_data(data)
118	elif self.dataSource.GetCount() > 0:
119	pos = self.dataSource.GetSelection()
120	data = self.dataSource.GetClientData(pos)
121	self.set_data(data)
122
123
124
125	def _on_fit_complete(self):
126	"""
127	When fit is complete ,reset the fit button label.
128	"""
129	self.btFit.SetLabel("Fit")
130	self.bind_fit_button()
131
132	def _is_2D(self):
133	"""
134	Check if data_name is Data2D
135
136	:return: True or False
137
138	"""
139	if self.data.__class__.__name__ == "Data2D" or \
140	self.enable2D:
141	return True
142	return False
143
144	def _on_engine_change(self, name):
145	"""
146	get the current name of the fit engine type
147	and update the panel accordingly
148	"""
149
150	self.engine_type = str(name)
151	self.state.engine_type = self.engine_type
152	if not self.is_mac:
153	if len(self.parameters) == 0:
154	self.Layout()
155	return
156	self.Layout()
157	self.Refresh()
158
159
160
161	def _fill_range_sizer(self):
162	"""
163	Fill the sizer containing the plotting range
164	add access to npts
165	"""
166	is_2Ddata = False
167
168	# Check if data is 2D
169	if self.data.__class__.__name__ == "Data2D" or \
170	self.enable2D:
171	is_2Ddata = True
172
173	title = "Fitting"
174	#smear messages & titles
175	smear_message_none = "No smearing is selected..."
176	smear_message_dqdata = "The dQ data is being used for smearing..."
177	smear_message_2d = "Higher accuracy is very time-expensive. Use it with care..."
178	smear_message_new_ssmear = "Please enter only the value of interest to customize smearing..."
179	smear_message_new_psmear = "Please enter both; the dQ will be generated by interpolation..."
180	smear_message_2d_x_title = "<dQp>[1/A]:"
181	smear_message_2d_y_title = "<dQs>[1/A]:"
182	smear_message_pinhole_min_title = "dQ_low[1/A]:"
183	smear_message_pinhole_max_title = "dQ_high[1/A]:"
184	smear_message_slit_height_title = "Slit height[1/A]:"
185	smear_message_slit_width_title = "Slit width[1/A]:"
186
187	self._get_smear_info()
188
189	#Sizers
190	box_description_range = wx.StaticBox(self, -1,str(title))
191	boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)
192	self.sizer_set_smearer = wx.BoxSizer(wx.VERTICAL)
193	sizer_smearer = wx.BoxSizer(wx.HORIZONTAL)
194	self.sizer_new_smear= wx.BoxSizer(wx.HORIZONTAL)
195	self.sizer_set_masking = wx.BoxSizer(wx.HORIZONTAL)
196	sizer_chi2 = wx.BoxSizer(wx.VERTICAL)
197	smear_set_box= wx.StaticBox(self, -1,'Set Instrumental Smearing')
198	sizer_smearer_box = wx.StaticBoxSizer(smear_set_box, wx.HORIZONTAL)
199	sizer_smearer_box.SetMinSize((_DATA_BOX_WIDTH,85))
200	sizer_fit = wx.GridSizer(2, 4, 2, 6)
201
202	# combobox for smear2d accuracy selection
203	self.smear_accuracy = wx.ComboBox(self, -1,size=(50,-1),style=wx.CB_READONLY)
204	self._set_accuracy_list()
205	self.smear_accuracy.SetValue(self.smear2d_accuracy)
206	self.smear_accuracy.SetSelection(0)
207	self.smear_accuracy.SetToolTipString("'Higher' uses more Gaussian points for smearing computation.")
208
209	wx.EVT_COMBOBOX(self.smear_accuracy,-1, self._on_select_accuracy)
210
211	#Fit button
212	self.btFit = wx.Button(self,wx.NewId(),'Fit', size=(88,25))
213	self.default_bt_colour = self.btFit.GetDefaultAttributes()
214	self.btFit.Bind(wx.EVT_BUTTON, self._onFit,id= self.btFit.GetId())
215	self.btFit.SetToolTipString("Start fitting.")
216
217	#textcntrl for custom resolution
218	self.smear_pinhole_max = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER,
219	text_enter_callback = self.onPinholeSmear)
220	self.smear_pinhole_min = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER,
221	text_enter_callback = self.onPinholeSmear)
222	self.smear_slit_height= self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER,
223	text_enter_callback = self.onSlitSmear)
224	self.smear_slit_width = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER,
225	text_enter_callback = self.onSlitSmear)
226
227	## smear
228	self.smear_data_left= BGTextCtrl(self, -1, size=(_BOX_WIDTH-25,20), style=0)
229	self.smear_data_left.SetValue(str(self.dq_l))
230	self.smear_data_right = BGTextCtrl(self, -1, size=(_BOX_WIDTH-25,20), style=0)
231	self.smear_data_right.SetValue(str(self.dq_r))
232
233	#set default values for smear
234	self.smear_pinhole_max.SetValue(str(self.dx_max))
235	self.smear_pinhole_min.SetValue(str(self.dx_min))
236	self.smear_slit_height.SetValue(str(self.dxl))
237	self.smear_slit_width.SetValue(str(self.dxw))
238
239	#Filling the sizer containing instruments smearing info.
240	self.disable_smearer = wx.RadioButton(self, -1, 'None', style=wx.RB_GROUP)
241	self.enable_smearer = wx.RadioButton(self, -1, 'Use dQ Data')
242	#self.enable_smearer.SetToolTipString("Click to use the loaded dQ data for smearing.")
243	self.pinhole_smearer = wx.RadioButton(self, -1, 'Custom Pinhole Smear')
244	#self.pinhole_smearer.SetToolTipString("Click to input custom resolution for pinhole smearing.")
245	self.slit_smearer = wx.RadioButton(self, -1, 'Custom Slit Smear')
246	#self.slit_smearer.SetToolTipString("Click to input custom resolution for slit smearing.")
247	self.Bind(wx.EVT_RADIOBUTTON, self.onSmear, id=self.disable_smearer.GetId())
248	self.Bind(wx.EVT_RADIOBUTTON, self.onSmear, id=self.enable_smearer.GetId())
249	self.Bind(wx.EVT_RADIOBUTTON, self.onPinholeSmear, id=self.pinhole_smearer.GetId())
250	self.Bind(wx.EVT_RADIOBUTTON, self.onSlitSmear, id=self.slit_smearer.GetId())
251	self.disable_smearer.SetValue(True)
252
253	# add 4 types of smearing to the sizer
254	sizer_smearer.Add( self.disable_smearer,0, wx.LEFT, 10)
255	sizer_smearer.Add((10,10))
256	sizer_smearer.Add( self.enable_smearer)
257	sizer_smearer.Add((10,10))
258	sizer_smearer.Add( self.pinhole_smearer )
259	sizer_smearer.Add((10,10))
260	sizer_smearer.Add( self.slit_smearer )
261	sizer_smearer.Add((10,10))
262
263	# StaticText for chi2, N(for fitting), Npts
264	self.tcChi = BGTextCtrl(self, -1, "-", size=(75,20), style=0)
265	self.tcChi.SetToolTipString("Chi2/Npts(Fit)")
266	self.Npts_fit = BGTextCtrl(self, -1, "-", size=(75,20), style=0)
267	self.Npts_fit.SetToolTipString(\
268	" Npts : number of points selected for fitting")
269	self.Npts_total = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
270	style=wx.TE_PROCESS_ENTER,
271	text_enter_callback=self._onQrangeEnter)
272	self.Npts_total.SetValue(format_number(self.npts_x))
273	self.Npts_total.SetToolTipString(\
274	" Total Npts : total number of data points")
275
276	# Update and Draw button
277	self.draw_button = wx.Button(self,wx.NewId(),'Compute', size=(88,24))
278	self.draw_button.Bind(wx.EVT_BUTTON, \
279	self._onDraw,id= self.draw_button.GetId())
280	self.draw_button.SetToolTipString("Compute and Draw.")
281
282	box_description_1= wx.StaticText(self, -1,' Chi2/Npts')
283	box_description_2= wx.StaticText(self, -1,'Npts(Fit)')
284	box_description_3= wx.StaticText(self, -1,'Total Npts')
285	box_description_3.SetToolTipString( \
286	" Total Npts : total number of data points")
287	#box_description_4= wx.StaticText(self, -1,' ')
288
289
290	sizer_fit.Add(box_description_1,0,0)
291	sizer_fit.Add(box_description_2,0,0)
292	sizer_fit.Add(box_description_3,0,0)
293	sizer_fit.Add(self.draw_button,0,0)
294	sizer_fit.Add(self.tcChi,0,0)
295	sizer_fit.Add(self.Npts_fit ,0,0)
296	sizer_fit.Add(self.Npts_total,0,0)
297	sizer_fit.Add(self.btFit,0,0)
298
299	# StaticText for smear
300	#self.tcChi = wx.StaticText(self, -1, "-", style=wx.ALIGN_LEFT)
301	self.smear_description_none = wx.StaticText(self, -1,
302	smear_message_none , style=wx.ALIGN_LEFT)
303	self.smear_description_dqdata = wx.StaticText(self,
304	-1, smear_message_dqdata , style=wx.ALIGN_LEFT)
305	self.smear_description_type = wx.StaticText(self,
306	-1, "Type:" , style=wx.ALIGN_LEFT)
307	self.smear_description_accuracy_type = wx.StaticText(self, -1,
308	"Accuracy:" , style=wx.ALIGN_LEFT)
309	self.smear_description_smear_type = BGTextCtrl(self, -1,
310	size=(57,20), style=0)
311	self.smear_description_smear_type.SetValue(str(self.dq_l))
312	self.SetBackgroundColour(self.GetParent().GetBackgroundColour())
313	self.smear_description_2d = wx.StaticText(self, -1,
314	smear_message_2d , style=wx.ALIGN_LEFT)
315	self.smear_message_new_s = wx.StaticText(self, -1,
316	smear_message_new_ssmear, style=wx.ALIGN_LEFT)
317	self.smear_message_new_p = wx.StaticText(self, -1,
318	smear_message_new_psmear , style=wx.ALIGN_LEFT)
319	self.smear_description_2d_x = wx.StaticText(self, -1, smear_message_2d_x_title , style=wx.ALIGN_LEFT)
320	self.smear_description_2d_x.SetToolTipString(" dQp(parallel) in q_r direction.")
321	self.smear_description_2d_y = wx.StaticText(self, -1, smear_message_2d_y_title , style=wx.ALIGN_LEFT)
322	self.smear_description_2d_y.SetToolTipString(" dQs(perpendicular) in q_phi direction.")
323	self.smear_description_pin_min = wx.StaticText(self, -1, smear_message_pinhole_min_title , style=wx.ALIGN_LEFT)
324	self.smear_description_pin_max = wx.StaticText(self, -1, smear_message_pinhole_max_title , style=wx.ALIGN_LEFT)
325	self.smear_description_slit_height = wx.StaticText(self, -1, smear_message_slit_height_title , style=wx.ALIGN_LEFT)
326	self.smear_description_slit_width = wx.StaticText(self, -1, smear_message_slit_width_title , style=wx.ALIGN_LEFT)
327
328	#arrange sizers
329	#boxsizer1.Add( self.tcChi )
330	self.sizer_set_smearer.Add(sizer_smearer )
331	self.sizer_set_smearer.Add((10,10))
332	self.sizer_set_smearer.Add( self.smear_description_none,0, wx.CENTER, 10 )
333	self.sizer_set_smearer.Add( self.smear_description_dqdata,0, wx.CENTER, 10 )
334	self.sizer_set_smearer.Add( self.smear_description_2d,0, wx.CENTER, 10 )
335	self.sizer_new_smear.Add( self.smear_description_type,0, wx.CENTER, 10 )
336	self.sizer_new_smear.Add( self.smear_description_accuracy_type,0, wx.CENTER, 10 )
337	self.sizer_new_smear.Add( self.smear_accuracy )
338	self.sizer_new_smear.Add( self.smear_description_smear_type,0, wx.CENTER, 10 )
339	self.sizer_new_smear.Add((15,-1))
340	self.sizer_new_smear.Add( self.smear_description_2d_x,0, wx.CENTER, 10 )
341	self.sizer_new_smear.Add( self.smear_description_pin_min,0, wx.CENTER, 10 )
342	self.sizer_new_smear.Add( self.smear_description_slit_height,0, wx.CENTER, 10 )
343
344	self.sizer_new_smear.Add( self.smear_pinhole_min,0, wx.CENTER, 10 )
345	self.sizer_new_smear.Add( self.smear_slit_height,0, wx.CENTER, 10 )
346	self.sizer_new_smear.Add( self.smear_data_left,0, wx.CENTER, 10 )
347	self.sizer_new_smear.Add((20,-1))
348	self.sizer_new_smear.Add( self.smear_description_2d_y,0, wx.CENTER, 10 )
349	self.sizer_new_smear.Add( self.smear_description_pin_max,0, wx.CENTER, 10 )
350	self.sizer_new_smear.Add( self.smear_description_slit_width,0, wx.CENTER, 10 )
351
352	self.sizer_new_smear.Add( self.smear_pinhole_max,0, wx.CENTER, 10 )
353	self.sizer_new_smear.Add( self.smear_slit_width,0, wx.CENTER, 10 )
354	self.sizer_new_smear.Add( self.smear_data_right,0, wx.CENTER, 10 )
355
356	self.sizer_set_smearer.Add( self.smear_message_new_s,0, wx.CENTER, 10)
357	self.sizer_set_smearer.Add( self.smear_message_new_p,0, wx.CENTER, 10)
358	self.sizer_set_smearer.Add((5,2))
359	self.sizer_set_smearer.Add( self.sizer_new_smear,0, wx.CENTER, 10 )
360
361	# add all to chi2 sizer
362	sizer_smearer_box.Add(self.sizer_set_smearer)
363	sizer_chi2.Add(sizer_smearer_box)
364	sizer_chi2.Add((-1,5))
365
366	# hide all smear messages and textctrl
367	self._hide_all_smear_info()
368
369	# get smear_selection
370	self.current_smearer= smear_selection( self.data, self.model )
371
372	# Show only the relevant smear messages, etc
373	if self.current_smearer == None:
374	if not is_2Ddata:
375	self.smear_description_none.Show(True)
376	self.enable_smearer.Disable()
377	else:
378	self.smear_description_none.Show(True)
379	#self.smear_description_2d.Show(True)
380	#self.pinhole_smearer.Disable()
381	self.slit_smearer.Disable()
382	#self.enable_smearer.Disable()
383	if self.data == None:
384	self.slit_smearer.Disable()
385	self.pinhole_smearer.Disable()
386	self.enable_smearer.Disable()
387	else: self._show_smear_sizer()
388	boxsizer_range.Add(self.sizer_set_masking)
389	#2D data? default
390	is_2Ddata = False
391
392	#check if it is 2D data
393	if self.data.__class__.__name__ == "Data2D" or \
394	self.enable2D:
395	is_2Ddata = True
396
397	self.sizer5.Clear(True)
398
399	self.qmin = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20),
400	style=wx.TE_PROCESS_ENTER,
401	text_enter_callback = self._onQrangeEnter)
402	self.qmin.SetValue(str(self.qmin_x))
403	self.qmin.SetToolTipString("Minimun value of Q in linear scale.")
404
405	self.qmax = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH,20),
406	style=wx.TE_PROCESS_ENTER,
407	text_enter_callback=self._onQrangeEnter)
408	self.qmax.SetValue(str(self.qmax_x))
409	self.qmax.SetToolTipString("Maximum value of Q in linear scale.")
410	"""
411	self.theory_npts_tcrtl = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
412	style=wx.TE_PROCESS_ENTER,
413	text_enter_callback=self._onQrangeEnter)
414	self.theory_npts_tcrtl.SetValue(format_number(self.npts_x))
415	self.theory_npts_tcrtl.SetToolTipString("Number of point to plot.")
416	"""
417	id = wx.NewId()
418	self.reset_qrange =wx.Button(self,id,'Reset',size=(77,20))
419
420	self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked,id=id)
421	self.reset_qrange.SetToolTipString("Reset Q range to the default values")
422
423	sizer_horizontal=wx.BoxSizer(wx.HORIZONTAL)
424	sizer= wx.GridSizer(2, 4, 2, 6)
425
426	self.btEditMask = wx.Button(self,wx.NewId(),'Editor', size=(88,23))
427	self.btEditMask.Bind(wx.EVT_BUTTON, self._onMask,id= self.btEditMask.GetId())
428	self.btEditMask.SetToolTipString("Edit Mask.")
429	self.EditMask_title = wx.StaticText(self, -1, ' Masking(2D)')
430
431	sizer.Add(wx.StaticText(self, -1, 'Q range'))
432	sizer.Add(wx.StaticText(self, -1, ' Min[1/A]'))
433	sizer.Add(wx.StaticText(self, -1, ' Max[1/A]'))
434	sizer.Add(self.EditMask_title)
435	#sizer.Add(wx.StaticText(self, -1, ''))
436	sizer.Add(self.reset_qrange)
437	sizer.Add(self.qmin)
438	sizer.Add(self.qmax)
439	#sizer.Add(self.theory_npts_tcrtl)
440	sizer.Add(self.btEditMask)
441	boxsizer_range.Add(sizer_chi2)
442	boxsizer_range.Add((10,10))
443	boxsizer_range.Add(sizer)
444
445	boxsizer_range.Add((10,15))
446	boxsizer_range.Add(sizer_fit)
447	if is_2Ddata:
448	self.btEditMask.Enable()
449	self.EditMask_title.Enable()
450	else:
451	self.btEditMask.Disable()
452	self.EditMask_title.Disable()
453	## save state
454	self.save_current_state()
455	self.sizer5.Add(boxsizer_range,0, wx.EXPAND \| wx.ALL, 10)
456	self.sizer5.Layout()
457
458
459	def _fill_model_sizer(self, sizer):
460	"""
461	fill sizer containing model info
462	"""
463	##Add model function Details button in fitpanel.
464	##The following 3 lines are for Mac. Let JHC know before modifying...
465	title = "Model"
466	self.formfactorbox = None
467	self.multifactorbox = None
468	self.mbox_description= wx.StaticBox(self, -1,str(title))
469	boxsizer1 = wx.StaticBoxSizer(self.mbox_description, wx.VERTICAL)
470
471	id = wx.NewId()
472	self.model_help =wx.Button(self,id,'Details', size=(80,23))
473	self.model_help.Bind(wx.EVT_BUTTON, self.on_model_help_clicked,id=id)
474	self.model_help.SetToolTipString("Model Function Help")
475	id = wx.NewId()
476	self.model_view = wx.Button(self, id,"1D Mode", size=(80, 23))
477	self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D, id=id)
478	hint = "toggle view of model from 1D to 2D or 2D to 1D"
479	self.model_view.SetToolTipString(hint)
480
481	self.shape_rbutton = wx.RadioButton(self, -1, 'Shapes',
482	style=wx.RB_GROUP)
483	self.shape_indep_rbutton = wx.RadioButton(self, -1, "Shape-Independent")
484	self.struct_rbutton = wx.RadioButton(self, -1, "Structure Factor ")
485	self.plugin_rbutton = wx.RadioButton(self, -1, "Customized Models")
486
487	self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
488	id= self.shape_rbutton.GetId())
489	self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
490	id= self.shape_indep_rbutton.GetId())
491	self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
492	id= self.struct_rbutton.GetId())
493	self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
494	id= self.plugin_rbutton.GetId())
495	#MAC needs SetValue
496	self.shape_rbutton.SetValue(True)
497
498	sizer_radiobutton = wx.GridSizer(2, 3, 5, 5)
499	sizer_radiobutton.Add(self.shape_rbutton)
500	sizer_radiobutton.Add(self.shape_indep_rbutton)
501	#sizer_radiobutton.Add((5, 5))
502	sizer_radiobutton.Add(self.model_view,1, wx.LEFT, 20)
503	sizer_radiobutton.Add(self.plugin_rbutton)
504	sizer_radiobutton.Add(self.struct_rbutton)
505	#sizer_radiobutton.Add((5, 5))
506	sizer_radiobutton.Add(self.model_help,1, wx.LEFT, 20)
507
508	sizer_selection = wx.BoxSizer(wx.HORIZONTAL)
509	mutifactor_selection = wx.BoxSizer(wx.HORIZONTAL)
510
511	self.text1 = wx.StaticText(self,-1,"" )
512	self.text2 = wx.StaticText(self,-1,"P(Q)*S(Q)" )
513	self.mutifactor_text = wx.StaticText( self,-1,"No. of Shells: ")
514	self.mutifactor_text1 = wx.StaticText( self,-1,"" )
515	self.show_sld_button = wx.Button( self,-1,"Show SLD Profile" )
516	self.show_sld_button.Bind(wx.EVT_BUTTON,self._on_show_sld)
517
518	self.formfactorbox = wx.ComboBox(self, -1,style=wx.CB_READONLY)
519	if self.model!= None:
520	self.formfactorbox.SetValue(self.model.name)
521	self.structurebox = wx.ComboBox(self, -1, style=wx.CB_READONLY)
522	self.multifactorbox = wx.ComboBox(self, -1, style=wx.CB_READONLY)
523	self.initialize_combox()
524	wx.EVT_COMBOBOX(self.formfactorbox, -1, self._on_select_model)
525
526	wx.EVT_COMBOBOX(self.structurebox, -1, self._on_select_model)
527	wx.EVT_COMBOBOX(self.multifactorbox, -1, self._on_select_model)
528	## check model type to show sizer
529	if self.model !=None:
530	self._set_model_sizer_selection(self.model)
531
532	sizer_selection.Add(self.text1)
533	sizer_selection.Add((5, 5))
534	sizer_selection.Add(self.formfactorbox)
535	sizer_selection.Add((5, 5))
536	sizer_selection.Add(self.text2)
537	sizer_selection.Add((5, 5))
538	sizer_selection.Add(self.structurebox)
539
540	mutifactor_selection.Add((10,5))
541	mutifactor_selection.Add(self.mutifactor_text)
542	mutifactor_selection.Add(self.multifactorbox)
543	mutifactor_selection.Add((5, 5))
544	mutifactor_selection.Add(self.mutifactor_text1)
545	mutifactor_selection.Add((10, 5))
546	mutifactor_selection.Add(self.show_sld_button)
547
548
549	boxsizer1.Add(sizer_radiobutton)
550	boxsizer1.Add((10, 10))
551	boxsizer1.Add(sizer_selection)
552	boxsizer1.Add((10, 10))
553	boxsizer1.Add(mutifactor_selection)
554
555	self._set_multfactor_combobox()
556	self.multifactorbox.SetSelection(1)
557	self.show_sld_button.Hide()
558	sizer.Add(boxsizer1,0, wx.EXPAND \| wx.ALL, 10)
559	sizer.Layout()
560
561	def _set_sizer_dispersion(self):
562	"""
563	draw sizer with gaussian dispersity parameters
564	"""
565	self.fittable_param=[]
566	self.fixed_param=[]
567	self.orientation_params_disp=[]
568
569	self.sizer4_4.Clear(True)
570	if self.model==None:
571	##no model is selected
572	return
573	if not self.enable_disp.GetValue():
574	## the user didn't select dispersity display
575	return
576
577	self._reset_dispersity()
578
579	## fill a sizer with the combobox to select dispersion type
580	#sizer_select_dispers = wx.BoxSizer(wx.HORIZONTAL)
581	model_disp = wx.StaticText(self, -1, 'Function')
582
583	import sans.models.dispersion_models
584	self.polydisp= sans.models.dispersion_models.models
585
586	ix = 0
587	iy = 0
588	disp = wx.StaticText(self, -1, ' ')
589	self.sizer4_4.Add(disp,( iy, ix),(1,1),
590	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
591	ix += 1
592	values = wx.StaticText(self, -1, 'PD[ratio]')
593	polytext = "Polydispersity (= STD/mean); "
594	polytext += "the standard deviation over the mean value."
595	values.SetToolTipString(polytext)
596
597	self.sizer4_4.Add(values,( iy, ix),(1,1), wx.EXPAND\|wx.ADJUST_MINSIZE,
598	0)
599	ix +=2
600	if self.is_mac:
601	err_text = 'Error'
602	else:
603	err_text = ''
604	self.text_disp_1 = wx.StaticText(self, -1, err_text)
605	self.sizer4_4.Add( self.text_disp_1,(iy, ix),(1,1),\
606	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
607
608
609	ix +=1
610	self.text_disp_min = wx.StaticText(self, -1, 'Min')
611	self.sizer4_4.Add(self.text_disp_min,(iy, ix),(1,1),\
612	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
613
614	ix +=1
615	self.text_disp_max = wx.StaticText(self, -1, 'Max')
616	self.sizer4_4.Add(self.text_disp_max,(iy, ix),(1,1),\
617	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
618
619	ix += 1
620	npts = wx.StaticText(self, -1, 'Npts')
621	npts.SetToolTipString("Number of sampling points for the numerical\n\
622	integration over the distribution function.")
623	self.sizer4_4.Add(npts,( iy, ix),(1,1), wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
624	ix += 1
625	nsigmas = wx.StaticText(self, -1, 'Nsigs')
626	nsigmas.SetToolTipString(" Number of sigmas between which the range\n\
627	of the distribution function will be used for weighting. \n\
628	The value '3' covers 99.5% for Gaussian distribution \n\
629	function. Note: Not recommended to change this value.")
630	self.sizer4_4.Add(nsigmas,( iy, ix),(1,1), wx.EXPAND\|wx.ADJUST_MINSIZE,
631	0)
632	ix +=1
633	self.sizer4_4.Add(model_disp,(iy, ix),(1,1),\
634	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
635
636	if self.engine_type=="park":
637	self.text_disp_max.Show(True)
638	self.text_disp_min.Show(True)
639
640	for item in self.model.dispersion.keys():
641	if not item in self.model.orientation_params:
642	if not self.disp_cb_dict.has_key(item):
643	self.disp_cb_dict[item]= None
644	name0="Distribution of " + item
645	name1=item+".width"
646	name2=item+".npts"
647	name3=item+".nsigmas"
648	if not self.model.details.has_key(name1):
649	self.model.details [name1] = ["",None,None]
650
651	iy += 1
652	for p in self.model.dispersion[item].keys():
653
654	if p=="width":
655	ix = 0
656	cb = wx.CheckBox(self, -1, name0, (10, 10))
657	cb.SetToolTipString("Check mark to fit")
658	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
659	self.sizer4_4.Add( cb,( iy, ix),(1,1),
660	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE,
661	5)
662	ix = 1
663	value= self.model.getParam(name1)
664	ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.3,20)
665	,style=wx.TE_PROCESS_ENTER)
666	ctl1.SetLabel('PD[ratio]')
667	poly_text = "Polydispersity (STD/mean) of %s\n" % item
668	poly_text += "STD: the standard deviation"
669	poly_text += " from the mean value."
670	ctl1.SetToolTipString(poly_text)
671	ctl1.SetValue(str (format_number(value, True)))
672	self.sizer4_4.Add(ctl1, (iy,ix),(1,1),wx.EXPAND)
673	## text to show error sign
674	ix = 2
675	text2=wx.StaticText(self, -1, '+/-')
676	self.sizer4_4.Add(text2,(iy, ix),(1,1),
677	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
678	if not self.is_mac:
679	text2.Hide()
680
681	ix = 3
682	ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/1.3,20),
683	style=0)
684
685	self.sizer4_4.Add(ctl2, (iy,ix),(1,1),
686	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
687	if not self.is_mac:
688	ctl2.Hide()
689
690	ix = 4
691	ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,
692	20), style=wx.TE_PROCESS_ENTER,
693	text_enter_callback = self._onparamRangeEnter)
694
695	self.sizer4_4.Add(ctl3, (iy,ix),(1,1),
696	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
697
698
699	ix = 5
700	ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,
701	20), style=wx.TE_PROCESS_ENTER,
702	text_enter_callback = self._onparamRangeEnter)
703
704	self.sizer4_4.Add(ctl4, (iy,ix),(1,1),
705	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
706
707
708	if self.engine_type=="park":
709	ctl3.Show(True)
710	ctl4.Show(True)
711
712	elif p=="npts":
713	ix = 6
714	value= self.model.getParam(name2)
715	Tctl = self.ModelTextCtrl(self, -1,
716	size=(_BOX_WIDTH/2.2,20),
717	style=wx.TE_PROCESS_ENTER)
718
719	Tctl.SetValue(str (format_number(value)))
720	self.sizer4_4.Add(Tctl, (iy,ix),(1,1),
721	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
722	self.fixed_param.append([None,name2, Tctl,None,None,
723	None, None,None])
724	elif p=="nsigmas":
725	ix = 7
726	value= self.model.getParam(name3)
727	Tct2 = self.ModelTextCtrl(self, -1,
728	size=(_BOX_WIDTH/2.2,20),
729	style=wx.TE_PROCESS_ENTER)
730
731	Tct2.SetValue(str (format_number(value)))
732	self.sizer4_4.Add(Tct2, (iy,ix),(1,1),
733	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
734	#ix +=1
735	#self.sizer4_4.Add((20,20), (iy,ix),(1,1),
736	# wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
737
738	self.fixed_param.append([None, name3, Tct2,
739	None, None, None,
740	None, None])
741
742
743	ix = 8
744	disp_box = wx.ComboBox(self, -1,size=(65,-1),
745	style=wx.CB_READONLY, name = '%s'% name1)
746	for key, value in self.polydisp.iteritems():
747	name_disp = str(key)
748	disp_box.Append(name_disp,value)
749	disp_box.SetStringSelection("gaussian")
750	wx.EVT_COMBOBOX(disp_box,-1, self._on_disp_func)
751	self.sizer4_4.Add(disp_box,(iy,ix),(1,1), wx.EXPAND)
752	self.fittable_param.append([cb,name1,ctl1,text2,
753	ctl2, ctl3, ctl4, disp_box])
754
755	ix =0
756	iy +=1
757	self.sizer4_4.Add((20,20),(iy,ix),(1,1),
758	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
759	first_orient = True
760	for item in self.model.dispersion.keys():
761	if item in self.model.orientation_params:
762	if not self.disp_cb_dict.has_key(item):
763	self.disp_cb_dict[item]= None
764	name0="Distribution of " + item
765	name1=item+".width"
766	name2=item+".npts"
767	name3=item+".nsigmas"
768
769	if not self.model.details.has_key(name1):
770	self.model.details [name1] = ["",None,None]
771
772
773	iy += 1
774	for p in self.model.dispersion[item].keys():
775
776	if p=="width":
777	ix = 0
778	cb = wx.CheckBox(self, -1, name0, (10, 10))
779	cb.SetToolTipString("Check mark to fit")
780	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
781	self.sizer4_4.Add( cb,( iy, ix),(1,1),
782	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE,
783	5)
784	if self.data.__class__.__name__ == "Data2D" or \
785	self.enable2D:
786	cb.Show(True)
787	elif cb.IsShown():
788	cb.Hide()
789	ix = 1
790	value= self.model.getParam(name1)
791	ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.3,
792	20),style=wx.TE_PROCESS_ENTER)
793	poly_tip = "Absolute Sigma for %s." % item
794	ctl1.SetToolTipString(poly_tip)
795	ctl1.SetValue(str (format_number(value, True)))
796	if self.data.__class__.__name__ == "Data2D" or \
797	self.enable2D:
798	if first_orient:
799	values.SetLabel('PD[ratio], Sig[deg]')
800	poly_text = "PD(polydispersity for lengths):\n"
801	poly_text += "It should be a value between"
802	poly_text += "0 and 1\n"
803	poly_text += "Sigma for angles: \n"
804	poly_text += "It is the STD (ratio*mean)"
805	poly_text += " of the distribution.\n "
806
807	values.SetToolTipString(poly_text)
808	first_orient = False
809	ctl1.Show(True)
810	elif ctl1.IsShown():
811	ctl1.Hide()
812
813	self.sizer4_4.Add(ctl1, (iy,ix),(1,1),wx.EXPAND)
814	## text to show error sign
815	ix = 2
816	text2=wx.StaticText(self, -1, '+/-')
817	self.sizer4_4.Add(text2,(iy, ix),(1,1),
818	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
819
820	text2.Hide()
821
822	ix = 3
823	ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/1.3,20),
824	style=0)
825
826	self.sizer4_4.Add(ctl2, (iy,ix),(1,1),
827	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
828
829	ctl2.Hide()
830	if self.data.__class__.__name__ == "Data2D" or \
831	self.enable2D:
832	if self.is_mac:
833	text2.Show(True)
834	ctl2.Show(True)
835
836	ix = 4
837	ctl3 = self.ModelTextCtrl(self, -1,
838	size=(_BOX_WIDTH/2,20),
839	style=wx.TE_PROCESS_ENTER,
840	text_enter_callback = self._onparamRangeEnter)
841
842	self.sizer4_4.Add(ctl3, (iy,ix),(1,1),
843	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
844
845	ctl3.Hide()
846
847	ix = 5
848	ctl4 = self.ModelTextCtrl(self, -1,
849	size=(_BOX_WIDTH/2,20), style=wx.TE_PROCESS_ENTER,
850	text_enter_callback = self._onparamRangeEnter)
851	self.sizer4_4.Add(ctl4, (iy,ix),(1,1),
852	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
853	ctl4.Hide()
854
855	if self.data.__class__.__name__ == "Data2D" or \
856	self.enable2D:
857	ctl3.Show(True)
858	ctl4.Show(True)
859
860	elif p=="npts":
861	ix = 6
862	value= self.model.getParam(name2)
863	Tctl = self.ModelTextCtrl(self, -1,
864	size=(_BOX_WIDTH/2.2, 20),
865	style=wx.TE_PROCESS_ENTER)
866
867	Tctl.SetValue(str (format_number(value)))
868	if self.data.__class__.__name__ == "Data2D" or \
869	self.enable2D:
870	Tctl.Show(True)
871	else:
872	Tctl.Hide()
873	self.sizer4_4.Add(Tctl, (iy,ix),(1,1),
874	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
875	self.fixed_param.append([None,name2, Tctl,None,None,
876	None, None,None])
877	self.orientation_params_disp.append([None,name2,
878	Tctl,None,None,
879	None, None,None])
880	elif p=="nsigmas":
881	ix = 7
882	value= self.model.getParam(name3)
883	Tct2 = self.ModelTextCtrl(self, -1,
884	size=(_BOX_WIDTH/2.2,20),
885	style=wx.TE_PROCESS_ENTER)
886
887	Tct2.SetValue(str (format_number(value)))
888	if self.data.__class__.__name__ == "Data2D" or \
889	self.enable2D:
890	Tct2.Show(True)
891	else:
892	Tct2.Hide()
893	self.sizer4_4.Add(Tct2, (iy,ix),(1,1),
894	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
895
896
897	self.fixed_param.append([None,name3, Tct2
898	,None,None, None, None,None])
899
900	self.orientation_params_disp.append([None,name3,
901	Tct2 ,None,None, None, None,None])
902
903
904	ix = 8
905	disp_box = wx.ComboBox(self, -1,size=(65,-1),
906	style=wx.CB_READONLY, name = '%s'% name1)
907	for key, value in self.polydisp.iteritems():
908	name_disp = str(key)
909	disp_box.Append(name_disp,value)
910	disp_box.SetStringSelection("gaussian")
911	wx.EVT_COMBOBOX(disp_box,-1, self._on_disp_func)
912	self.sizer4_4.Add(disp_box,(iy,ix),(1,1), wx.EXPAND)
913	self.fittable_param.append([cb,name1,ctl1,text2,
914	ctl2, ctl3, ctl4, disp_box])
915	self.orientation_params_disp.append([cb,name1,ctl1,
916	text2, ctl2, ctl3, ctl4, disp_box])
917
918	if self.data.__class__.__name__ == "Data2D" or \
919	self.enable2D:
920	disp_box.Show(True)
921	else:
922	disp_box.Hide()
923
924
925	self.state.disp_cb_dict = copy.deepcopy(self.disp_cb_dict)
926
927	self.state.model = self.model.clone()
928	## save state into
929	self.state.cb1 = self.cb1.GetValue()
930	self._copy_parameters_state(self.parameters, self.state.parameters)
931	self._copy_parameters_state(self.orientation_params_disp,
932	self.state.orientation_params_disp)
933	self._copy_parameters_state(self.fittable_param,
934	self.state.fittable_param)
935	self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
936
937
938	wx.PostEvent(self.parent, StatusEvent(status=\
939	" Selected Distribution: Gaussian"))
940	#Fill the list of fittable parameters
941	self.select_all_param(event=None)
942
943	self.Layout()
944
945
946	def _onDraw(self, event):
947	"""
948	Update and Draw the model
949	"""
950	if self.model ==None:
951	msg="Please select a Model first..."
952	wx.MessageBox(msg, 'Info')
953
954	return
955	flag = self._update_paramv_on_fit()
956	self._onparamEnter_helper()
957	if not flag:
958	msg= "The parameters are invalid"
959	wx.PostEvent(self.parent.parent, StatusEvent(status= msg ))
960	return
961
962
963	def _onFit(self, event):
964	"""
965	Allow to fit
966	"""
967	if event != None:
968	event.Skip()
969	if len(self.parent._manager.fit_thread_list)>0 and\
970	self.parent._manager._fit_engine != "park":
971	msg = "The FitEnging will be set to 'ParkMC'\n"
972	msg += " to fit with more than one data set..."
973	wx.MessageBox(msg, 'Info')
974	#wx.PostEvent(self._manager.parent, StatusEvent(status=\
975	# "Fitting: %s"%msg))
976
977	if self.data is None:
978	msg = "Please get Data first..."
979	wx.MessageBox(msg, 'Info')
980	wx.PostEvent(self._manager.parent, StatusEvent(status=\
981	"Fit: %s" % msg))
982	return
983	if self.model is None:
984	msg = "Please select a Model first..."
985	wx.MessageBox(msg, 'Info')
986	wx.PostEvent(self._manager.parent, StatusEvent(status=\
987	"Fit: %s"%msg, type="stop"))
988	return
989
990	if len(self.param_toFit) <= 0:
991	msg= "Select at least one parameter to fit"
992	wx.MessageBox(msg, 'Info')
993	wx.PostEvent(self._manager.parent, StatusEvent(status= msg,
994	type="stop" ))
995	return
996
997	flag = self._update_paramv_on_fit()
998
999	if not flag:
1000	msg= "Fitting range or parameters are invalid"
1001	wx.PostEvent(self.parent.parent, StatusEvent(status= msg,
1002	type="stop"))
1003	return
1004
1005	self.select_param(event =None)
1006
1007	#Clear errors if exist from previous fitting
1008	#self._clear_Err_on_Fit()
1009
1010	# Remove or do not allow fitting on the Q=0 point, especially
1011	# when y(q=0)=None at x[0].
1012	self.qmin_x = float(self.qmin.GetValue())
1013	self.qmax_x = float(self.qmax.GetValue())
1014	self._manager._reset_schedule_problem(value=0, uid=self.uid)
1015	self._manager.schedule_for_fit(uid=self.uid,value=1, fitproblem=None)
1016	self._manager.set_fit_range(uid=self.uid,qmin=self.qmin_x,
1017	qmax=self.qmax_x)
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, npts = 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	self.npts_data_set += npts
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	data_min, data_max = self.qmin_data_set, self.qmax_data_set
1724	npts = self.npts_data_set
1725	#set maximum range for x in linear scale
1726	if not hasattr(self.data,"data"): #Display only for 1D data fit
1727	self.btEditMask.Disable()
1728	self.EditMask_title.Disable()
1729	else:
1730
1731	self.btEditMask.Enable()
1732	self.EditMask_title.Enable()
1733	self.Npts_total.SetValue(str(npts))
1734	#default:number of data points selected to fit
1735	self.Npts_fit.SetValue(str(npts))
1736	self.Npts_total.SetEditable(False)
1737	self.Npts_total.SetBackgroundColour(\
1738	self.GetParent().GetBackgroundColour())
1739
1740	self.Npts_total.Bind(wx.EVT_MOUSE_EVENTS, self._npts_click)
1741	#self.Npts_total.Disable()
1742	self.dataSource.SetValue(data_name)
1743	self.qmin_x = data_min
1744	self.qmax_x = data_max
1745	#self.minimum_q.SetValue(str(data_min))
1746	#self.maximum_q.SetValue(str(data_max))
1747	if data_min is None:
1748	data_min = ""
1749	if data_max is None:
1750	data_max = ""
1751	self.qmin.SetValue(str(data_min))
1752	self.qmax.SetValue(str(data_max))
1753	self.qmin.SetBackgroundColour("white")
1754	self.qmax.SetBackgroundColour("white")
1755	self.state.data = data
1756	self.state.qmin = self.qmin_x
1757	self.state.qmax = self.qmax_x
1758
1759	#update model plot with new data information
1760	if flag:
1761	#set model view button
1762	if self.data.__class__.__name__ == "Data2D":
1763	self.enable2D = True
1764	self.model_view.SetLabel("2D Mode")
1765	else:
1766	self.enable2D = False
1767	self.model_view.SetLabel("1D Mode")
1768
1769	self.model_view.Disable()
1770
1771	#replace data plot on combo box selection
1772	#by removing the previous selected data
1773	wx.PostEvent(self._manager.parent, NewPlotEvent(action="remove",
1774	group_id=group_id, id=id))
1775	#plot the current selected data
1776	wx.PostEvent(self._manager.parent, NewPlotEvent(plot=self.data,
1777	title=str(self.data.title)))
1778	self._manager.store_data(uid=self.uid, data=data,
1779	data_list=self.data_list,
1780	caption=self.window_name)
1781	self._draw_model()
1782
1783	def _npts_click(self, event):
1784	"""
1785	Prevent further handling of the mouse event on Npts_total
1786	by not calling Skip().
1787	"""
1788	pass
1789
1790	def reset_page(self, state,first=False):
1791	"""
1792	reset the state
1793	"""
1794	self.reset_page_helper(state)
1795	#import sans.guiframe.gui_manager
1796	#evt = ModelEventbox(model=state.model)
1797	#wx.PostEvent(self.event_owner, evt)
1798
1799	if self.engine_type != None:
1800	self._manager._on_change_engine(engine=self.engine_type)
1801
1802	self.select_param(event = None)
1803	#Save state_fit
1804	self.save_current_state_fit()
1805	self._lay_out()
1806	self.Refresh()
1807
1808	def get_range(self):
1809	"""
1810	return the fitting range
1811	"""
1812	return float(self.qmin_x) , float(self.qmax_x)
1813
1814	def get_npts2fit(self):
1815	"""
1816	return numbers of data points within qrange
1817
1818	:Note: This is for Park where chi2 is not normalized by Npts of fit
1819
1820	"""
1821	if self.data is None:
1822	return
1823	npts2fit = 0
1824	qmin,qmax = self.get_range()
1825	if self.data.__class__.__name__ == "Data2D" or \
1826	self.enable2D:
1827	radius= numpy.sqrt( self.data.qx_data*self.data.qx_data +
1828	self.data.qy_data*self.data.qy_data )
1829	index_data = (self.qmin_x <= radius)&(radius<= self.qmax_x)
1830	index_data= (index_data)&(self.data.mask)
1831	index_data = (index_data)&(numpy.isfinite(self.data.data))
1832	npts2fit = len(self.data.data[index_data])
1833	else:
1834	for qx in self.data.x:
1835	if qx >= qmin and qx <= qmax:
1836	npts2fit += 1
1837	return npts2fit
1838
1839	def set_npts2fit(self):
1840	"""
1841	setValue Npts for fitting
1842	"""
1843	self.Npts_fit.SetValue(str(self.get_npts2fit()))
1844
1845	def get_chi2(self):
1846	"""
1847	return the current chi2
1848	"""
1849	return self.tcChi.GetValue()
1850
1851	def get_param_list(self):
1852	"""
1853	:return self.param_toFit: list containing references to TextCtrl
1854	checked.Theses TextCtrl will allow reference to parameters to fit.
1855
1856	:raise: if return an empty list of parameter fit will nnote work
1857	properly so raise ValueError,"missing parameter to fit"
1858	"""
1859	if self.param_toFit !=[]:
1860	return self.param_toFit
1861	else:
1862	msg = "missing parameters to fit"
1863	wx.MessageBox(msg, 'warning')
1864	return False
1865	#raise ValueError,"missing parameters to fit"
1866
1867	def onsetValues(self, chisqr, p_name, out, cov):
1868	"""
1869	Build the panel from the fit result
1870
1871	:param chisqr: Value of the goodness of fit metric
1872	:param p_name: the name of parameters
1873	:param out: list of parameter with the best value found during fitting
1874	:param cov: Covariance matrix
1875
1876	"""
1877	if out == None or not numpy.isfinite(chisqr):
1878	raise ValueError,"Fit error occured..."
1879
1880	is_modified = False
1881	has_error = False
1882	dispersity = ''
1883
1884	#Hide textctrl boxes of errors.
1885	self._clear_Err_on_Fit()
1886
1887	#Check if chi2 is finite
1888	if chisqr != None and numpy.isfinite(chisqr):
1889	#format chi2
1890	if self.engine_type == "park":
1891	npt_fit = float(self.get_npts2fit())
1892	if npt_fit > 0:
1893	chisqr =chisqr/npt_fit
1894	chi2 = format_number(chisqr, True)
1895	self.tcChi.SetValue(chi2)
1896	self.tcChi.Refresh()
1897	else:
1898	self.tcChi.SetValue("-")
1899
1900	#Hide error title
1901	if self.text2_3.IsShown() and not self.is_mac:
1902	self.text2_3.Hide()
1903
1904	try:
1905	if self.enable_disp.GetValue():
1906	if hasattr(self,"text_disp_1" ):
1907	if self.text_disp_1 != None and not self.is_mac:
1908	self.text_disp_1.Hide()
1909	except:
1910	dispersity = None
1911	pass
1912	#set the panel when fit result are float not list
1913	if out.__class__== numpy.float64:
1914	self.param_toFit[0][2].SetValue(format_number(out, True))
1915
1916	if self.param_toFit[0][4].IsShown and not self.is_mac:
1917	self.param_toFit[0][4].Hide()
1918	if cov !=None :
1919	self.text2_3.Show(True)
1920	try:
1921	if self.enable_disp.GetValue():
1922	if hasattr(self,"text_disp_1" ):
1923	if self.text_disp_1 !=None:
1924	self.text_disp_1.Show(True)
1925	except:
1926	pass
1927
1928	if cov[0]==None or not numpy.isfinite(cov[0]):
1929	if self.param_toFit[0][3].IsShown and not self.is_mac:
1930	self.param_toFit[0][3].Hide()
1931	else:
1932	self.param_toFit[0][3].Show(True)
1933	self.param_toFit[0][4].Show(True)
1934	self.param_toFit[0][4].SetValue(format_number(cov[0], True))
1935	has_error = True
1936	else:
1937
1938	i = 0
1939	#Set the panel when fit result are list
1940	for item in self.param_toFit:
1941	if len(item)>5 and item != None:
1942	## reset error value to initial state
1943	if not self.is_mac:
1944	item[3].Hide()
1945	item[4].Hide()
1946
1947	for ind in range(len(out)):
1948
1949	if item[1] == p_name[ind]:
1950	break
1951	if len(out)<=len(self.param_toFit) and out[ind] !=None:
1952	val_out = format_number(out[ind], True)
1953	item[2].SetValue(val_out)
1954
1955
1956	if(cov !=None):
1957
1958	try:
1959	if dispersity !=None:
1960	if self.enable_disp.GetValue():
1961	if hasattr(self,"text_disp_1" ):
1962	if self.text_disp_1!=None:
1963	if not self.text_disp_1.IsShown()\
1964	and not self.is_mac:
1965	self.text_disp_1.Show(True)
1966	except:
1967	pass
1968
1969	if cov[ind]!=None :
1970	if numpy.isfinite(float(cov[ind])):
1971	val_err = format_number(cov[ind], True)
1972	if not self.is_mac:
1973	item[3].Show(True)
1974	item[4].Show(True)
1975	item[4].SetValue(val_err)
1976
1977	has_error = True
1978	i += 1
1979	#Show error title when any errors displayed
1980	if has_error:
1981	if not self.text2_3.IsShown():
1982	self.text2_3.Show(True)
1983	## save current state
1984	self.save_current_state()
1985
1986	#self._lay_out()
1987	if not self.is_mac:
1988	self.Layout()
1989	self.Refresh()
1990	self._mac_sleep(0.1)
1991	#plot model ( when drawing, do not update chisqr value again)
1992	self._draw_model(update_chisqr=False)
1993	#PostStatusEvent
1994	#msg = "Fit completed!dddd "
1995	#wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1996
1997	def onPinholeSmear(self, event):
1998	"""
1999	Create a custom pinhole smear object that will change the way residuals
2000	are compute when fitting
2001
2002	:Note: accuracy is given by strings'High','Med', 'Low' FOR 2d,
2003	None for 1D
2004
2005	"""
2006
2007	#if self.check_invalid_panel():
2008	# return
2009	if self.model ==None:
2010	self.disable_smearer.SetValue(True)
2011	msg="Please select a Model first..."
2012	wx.MessageBox(msg, 'Info')
2013	wx.PostEvent(self._manager.parent, StatusEvent(status=\
2014	"Smear: %s"%msg))
2015	return
2016
2017	# Need update param values
2018	self._update_paramv_on_fit()
2019
2020	# msg default
2021	msg = None
2022	if event != None:
2023	tcrtl= event.GetEventObject()
2024	# event case of radio button
2025	if tcrtl.GetValue()== True:
2026	self.dx_min = 0.0
2027	self.dx_max = 0.0
2028	is_new_pinhole = True
2029	else:
2030	is_new_pinhole = self._is_changed_pinhole()
2031	else:
2032	is_new_pinhole = True
2033	# if any value is changed
2034	if is_new_pinhole:
2035	msg = self._set_pinhole_smear()
2036	# hide all silt sizer
2037	self._hide_all_smear_info()
2038
2039	##Calculate chi2
2040	temp_smearer = self.current_smearer
2041	#self.compute_chisqr(smearer= temp_smearer)
2042
2043	# show relevant slit sizers
2044	self._show_smear_sizer()
2045
2046	self.sizer_set_smearer.Layout()
2047	self.Layout()
2048
2049	if event != None:
2050	event.Skip()
2051	#self._undo.Enable(True)
2052	self.save_current_state()
2053	event = PageInfoEvent(page = self)
2054	wx.PostEvent(self.parent, event)
2055
2056	def _is_changed_pinhole(self):
2057	"""
2058	check if any of pinhole smear is changed
2059
2060	:return: True or False
2061
2062	"""
2063	# get the values
2064	pin_min = self.smear_pinhole_min.GetValue()
2065	pin_max = self.smear_pinhole_max.GetValue()
2066
2067	# Check changes in slit width
2068	try:
2069	dx_min = float(pin_min)
2070	except:
2071	return True
2072	if self.dx_min != dx_min:
2073	return True
2074
2075	# Check changes in slit heigth
2076	try:
2077	dx_max = float(pin_max)
2078	except:
2079	return True
2080	if self.dx_max != dx_max:
2081	return True
2082	return False
2083
2084	def _set_pinhole_smear(self):
2085	"""
2086	Set custom pinhole smear
2087
2088	:return: msg
2089
2090	"""
2091	# copy data
2092	data = copy.deepcopy(self.data)
2093	if self._is_2D():
2094	self.smear_type = 'Pinhole2d'
2095	len_data = len(data.data)
2096	data.dqx_data = numpy.zeros(len_data)
2097	data.dqy_data = numpy.zeros(len_data)
2098	else:
2099	self.smear_type = 'Pinhole'
2100	len_data = len(data.x)
2101	data.dx = numpy.zeros(len_data)
2102	data.dxl = None
2103	data.dxw = None
2104	msg = None
2105
2106	get_pin_min = self.smear_pinhole_min
2107	get_pin_max = self.smear_pinhole_max
2108
2109	if not check_float(get_pin_min):
2110	get_pin_min.SetBackgroundColour("pink")
2111	msg= "Model Error:wrong value entered!!!"
2112	elif not check_float(get_pin_max ):
2113	get_pin_max.SetBackgroundColour("pink")
2114	msg= "Model Error:wrong value entered!!!"
2115	else:
2116	if len_data < 2: len_data = 2
2117	self.dx_min = float(get_pin_min.GetValue())
2118	self.dx_max = float(get_pin_max.GetValue())
2119	if self.dx_min < 0:
2120	get_pin_min.SetBackgroundColour("pink")
2121	msg= "Model Error:This value can not be negative!!!"
2122	elif self.dx_max <0:
2123	get_pin_max.SetBackgroundColour("pink")
2124	msg= "Model Error:This value can not be negative!!!"
2125	elif self.dx_min != None and self.dx_max != None:
2126	if self._is_2D():
2127	data.dqx_data[data.dqx_data==0] = self.dx_min
2128	data.dqy_data[data.dqy_data==0] = self.dx_max
2129	elif self.dx_min == self.dx_max:
2130	data.dx[data.dx==0] = self.dx_min
2131	else:
2132	step = (self.dx_max - self.dx_min)/(len_data-1)
2133	data.dx = numpy.arange(self.dx_min,self.dx_max+step/1.1,
2134	step)
2135	elif self.dx_min != None:
2136	if self._is_2D(): data.dqx_data[data.dqx_data==0] = self.dx_min
2137	else: data.dx[data.dx==0] = self.dx_min
2138	elif self.dx_max != None:
2139	if self._is_2D(): data.dqy_data[data.dqy_data==0] = self.dx_max
2140	else: data.dx[data.dx==0] = self.dx_max
2141	self.current_smearer = smear_selection(data, self.model)
2142	# 2D need to set accuracy
2143	if self._is_2D():
2144	self.current_smearer.set_accuracy(accuracy = \
2145	self.smear2d_accuracy)
2146
2147	if msg != None:
2148	wx.PostEvent(self._manager.parent, StatusEvent(status = msg ))
2149	else:
2150	get_pin_min.SetBackgroundColour("white")
2151	get_pin_max.SetBackgroundColour("white")
2152	## set smearing value whether or not the data contain the smearing info
2153	self._manager.set_smearer(smearer=self.current_smearer,
2154	enable2D=self.enable2D,
2155	qmin=float(self.qmin_x),
2156	qmax= float(self.qmax_x),
2157	uid=self.uid)
2158	return msg
2159
2160	def update_pinhole_smear(self):
2161	"""
2162	called by kill_focus on pinhole TextCntrl
2163	to update the changes
2164
2165	:return: False when wrong value was entered
2166
2167	"""
2168	# msg default
2169	msg = None
2170	# check if any value is changed
2171	if self._is_changed_pinhole():
2172	msg = self._set_pinhole_smear()
2173	#self._undo.Enable(True)
2174	self.save_current_state()
2175
2176	if msg != None:
2177	return False
2178	else:
2179	return True
2180
2181	def onSlitSmear(self, event):
2182	"""
2183	Create a custom slit smear object that will change the way residuals
2184	are compute when fitting
2185	"""
2186
2187	#if self.check_invalid_panel():
2188	# return
2189
2190	if self.model ==None:
2191	self.disable_smearer.SetValue(True)
2192
2193	msg="Please select a Model first..."
2194	wx.MessageBox(msg, 'Info')
2195	wx.PostEvent(self._manager.parent, StatusEvent(status=\
2196	"Smear: %s"%msg))
2197	return
2198
2199	# Need update param values
2200	self._update_paramv_on_fit()
2201
2202	# msg default
2203	msg = None
2204	# for event given
2205	if event != None:
2206	tcrtl= event.GetEventObject()
2207	# event case of radio button
2208	if tcrtl.GetValue():
2209	self.dxl = 0.0
2210	self.dxw = 0.0
2211	is_new_slit = True
2212	else:
2213	is_new_slit = self._is_changed_slit()
2214	else:
2215	is_new_slit = True
2216
2217	# if any value is changed
2218	if is_new_slit:
2219	msg = self._set_slit_smear()
2220
2221	# hide all silt sizer
2222	self._hide_all_smear_info()
2223	##Calculate chi2
2224	#self.compute_chisqr(smearer= self.current_smearer)
2225	# show relevant slit sizers
2226	self._show_smear_sizer()
2227	self.sizer_set_smearer.Layout()
2228	self.Layout()
2229
2230	if event != None:
2231	event.Skip()
2232	#self._undo.Enable(True)
2233	self.save_current_state()
2234	event = PageInfoEvent(page = self)
2235	wx.PostEvent(self.parent, event)
2236	if msg != None:
2237	wx.PostEvent(self._manager.parent, StatusEvent(status = msg))
2238
2239	def _is_changed_slit(self):
2240	"""
2241	check if any of slit lengths is changed
2242
2243	:return: True or False
2244
2245	"""
2246	# get the values
2247	width = self.smear_slit_width.GetValue()
2248	height = self.smear_slit_height.GetValue()
2249
2250	# check and change the box bg color if it was pink
2251	# but it should be white now
2252	# because this is the case that _set_slit_smear() will not handle
2253	if height.lstrip().rstrip()=="":
2254	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2255	if width.lstrip().rstrip()=="":
2256	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2257
2258	# Check changes in slit width
2259	if width == "":
2260	dxw = 0.0
2261	else:
2262	try:
2263	dxw = float(width)
2264	except:
2265	return True
2266	if self.dxw != dxw:
2267	return True
2268
2269	# Check changes in slit heigth
2270	if height == "":
2271	dxl = 0.0
2272	else:
2273	try:
2274	dxl = float(height)
2275	except:
2276	return True
2277	if self.dxl != dxl:
2278	return True
2279
2280	return False
2281
2282	def _set_slit_smear(self):
2283	"""
2284	Set custom slit smear
2285
2286	:return: message to inform the user about the validity
2287	of the values entered for slit smear
2288	"""
2289	if self.data.__class__.__name__ == "Data2D" or \
2290	self.enable2D:
2291	return
2292	temp_smearer = None
2293	# make sure once more if it is smearer
2294	data = copy.deepcopy(self.data)
2295	data_len = len(data.x)
2296	data.dx = None
2297	data.dxl = None
2298	data.dxw = None
2299	msg = None
2300
2301	try:
2302	self.dxl = float(self.smear_slit_height.GetValue())
2303	data.dxl = self.dxl* numpy.ones(data_len)
2304	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2305	except:
2306	data.dxl = numpy.zeros(data_len)
2307	if self.smear_slit_height.GetValue().lstrip().rstrip()!="":
2308	self.smear_slit_height.SetBackgroundColour("pink")
2309	msg = "Wrong value entered... "
2310	else:
2311	self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2312	try:
2313	self.dxw = float(self.smear_slit_width.GetValue())
2314	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2315	data.dxw = self.dxw* numpy.ones(data_len)
2316	except:
2317	data.dxw = numpy.zeros(data_len)
2318	if self.smear_slit_width.GetValue().lstrip().rstrip()!="":
2319	self.smear_slit_width.SetBackgroundColour("pink")
2320	msg = "Wrong Fit value entered... "
2321	else:
2322	self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2323
2324	self.current_smearer = smear_selection(data, self.model)
2325	#temp_smearer = self.current_smearer
2326	## set smearing value whether or not the data contain the smearing info
2327	self._manager.set_smearer(smearer=self.current_smearer,
2328	enable2D=self.enable2D,
2329	qmin=float(self.qmin_x),
2330	qmax= float(self.qmax_x),
2331	uid=self.uid)
2332	return msg
2333
2334	def update_slit_smear(self):
2335	"""
2336	called by kill_focus on pinhole TextCntrl
2337	to update the changes
2338
2339	:return: False when wrong value was entered
2340
2341	"""
2342	# msg default
2343	msg = None
2344	# check if any value is changed
2345	if self._is_changed_slit():
2346	msg = self._set_slit_smear()
2347	#self._undo.Enable(True)
2348	self.save_current_state()
2349
2350	if msg != None:
2351	return False
2352	else:
2353	return True
2354
2355	def onSmear(self, event):
2356	"""
2357	Create a smear object that will change the way residuals
2358	are compute when fitting
2359	"""
2360	if event != None:
2361	event.Skip()
2362	if self.data is None:
2363	return
2364
2365	if self.model == None:
2366	self.disable_smearer.SetValue(True)
2367	msg="Please select a Model first..."
2368	wx.MessageBox(msg, 'Info')
2369	wx.PostEvent(self._manager.parent, StatusEvent(status=\
2370	"Smear: %s"%msg))
2371	return
2372
2373	# Need update param values
2374	self._update_paramv_on_fit()
2375
2376	temp_smearer = None
2377	self._get_smear_info()
2378
2379	#renew smear sizer
2380	if self.smear_type != None:
2381	self.smear_description_smear_type.SetValue(str(self.smear_type))
2382	self.smear_data_left.SetValue(str(self.dq_l))
2383	self.smear_data_right.SetValue(str(self.dq_r))
2384
2385	self._hide_all_smear_info()
2386
2387	data = copy.deepcopy(self.data)
2388	# make sure once more if it is smearer
2389	self.current_smearer = smear_selection(data, self.model)
2390
2391	if self.enable_smearer.GetValue():
2392	if hasattr(self.data,"dxl"):
2393
2394	msg= ": Resolution smearing parameters"
2395	if hasattr(self.data,"dxw"):
2396	msg= ": Slit smearing parameters"
2397	if self.smearer ==None:
2398	wx.PostEvent(self._manager.parent, StatusEvent(status=\
2399	"Data contains no smearing information"))
2400	else:
2401	wx.PostEvent(self._manager.parent, StatusEvent(status=\
2402	"Data contains smearing information"))
2403
2404	#self.smear_description_dqdata.Show(True)
2405	self.smear_data_left.Show(True)
2406	self.smear_data_right.Show(True)
2407	temp_smearer= self.current_smearer
2408	elif self.disable_smearer.GetValue():
2409	self.smear_description_none.Show(True)
2410
2411	self._show_smear_sizer()
2412
2413	self.sizer_set_smearer.Layout()
2414	self.Layout()
2415	## set smearing value whether or not the data contain the smearing info
2416	self._manager.set_smearer(uid=self.uid, smearer=temp_smearer,
2417	enable2D=self.enable2D,
2418	qmin= float(self.qmin_x),
2419	qmax= float(self.qmax_x), draw=True)
2420
2421	self.state.enable_smearer= self.enable_smearer.GetValue()
2422	self.state.disable_smearer=self.disable_smearer.GetValue()
2423	self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
2424	self.state.slit_smearer = self.slit_smearer.GetValue()
2425
2426	def on_complete_chisqr(self, event):
2427	"""
2428	print result chisqr
2429
2430	:event: activated by fitting/ complete after draw
2431
2432	"""
2433	try:
2434	if event == None:
2435	output= "-"
2436	elif not numpy.isfinite(event.output):
2437	output= "-"
2438	else:
2439	output = event.output
2440	self.tcChi.SetValue(str(format_number(output, True)))
2441
2442	self.state.tcChi = self.tcChi.GetValue()
2443	except:
2444	pass
2445
2446
2447	def select_all_param(self,event):
2448	"""
2449	set to true or false all checkBox given the main checkbox value cb1
2450	"""
2451	self.param_toFit=[]
2452	if self.parameters !=[]:
2453	if self.cb1.GetValue():
2454	for item in self.parameters:
2455	## for data2D select all to fit
2456	if self.data.__class__.__name__== "Data2D" or \
2457	self.enable2D:
2458	item[0].SetValue(True)
2459	self.param_toFit.append(item )
2460	else:
2461	## for 1D all parameters except orientation
2462	if not item in self.orientation_params:
2463	item[0].SetValue(True)
2464	self.param_toFit.append(item )
2465	#if len(self.fittable_param)>0:
2466	for item in self.fittable_param:
2467	if self.data.__class__.__name__== "Data2D" or \
2468	self.enable2D:
2469	item[0].SetValue(True)
2470	self.param_toFit.append(item )
2471	try:
2472	if len(self.values[item[1]]) > 0:
2473	item[0].SetValue(False)
2474	except:
2475	pass
2476
2477	else:
2478	## for 1D all parameters except orientation
2479	if not item in self.orientation_params_disp:
2480	item[0].SetValue(True)
2481	self.param_toFit.append(item )
2482	try:
2483	if len(self.values[item[1]]) > 0:
2484	item[0].SetValue(False)
2485	except:
2486	pass
2487
2488	else:
2489	for item in self.parameters:
2490	item[0].SetValue(False)
2491	for item in self.fittable_param:
2492	item[0].SetValue(False)
2493	self.param_toFit=[]
2494
2495	self.save_current_state_fit()
2496
2497	if event !=None:
2498	#self._undo.Enable(True)
2499	## post state to fit panel
2500	event = PageInfoEvent(page = self)
2501	wx.PostEvent(self.parent, event)
2502
2503	def select_param(self,event):
2504	"""
2505	Select TextCtrl checked for fitting purpose and stores them
2506	in self.param_toFit=[] list
2507	"""
2508	self.param_toFit=[]
2509	for item in self.parameters:
2510	#Skip t ifhe angle parameters if 1D data
2511	if self.data.__class__.__name__ != "Data2D" and\
2512	not self.enable2D:
2513	if item in self.orientation_params:
2514	continue
2515	#Select parameters to fit for list of primary parameters
2516	if item[0].GetValue():
2517	if not (item in self.param_toFit):
2518	self.param_toFit.append(item )
2519	else:
2520	#remove parameters from the fitting list
2521	if item in self.param_toFit:
2522	self.param_toFit.remove(item)
2523
2524	#Select parameters to fit for list of fittable parameters
2525	# with dispersion
2526	for item in self.fittable_param:
2527	#Skip t ifhe angle parameters if 1D data
2528	if self.data.__class__.__name__ != "Data2D" and\
2529	not self.enable2D:
2530	if item in self.orientation_params:
2531	continue
2532	if item[0].GetValue():
2533	if not (item in self.param_toFit):
2534	self.param_toFit.append(item)
2535	else:
2536	#remove parameters from the fitting list
2537	if item in self.param_toFit:
2538	self.param_toFit.remove(item)
2539
2540	#Calculate num. of angle parameters
2541	if self.data.__class__.__name__ == "Data2D" or \
2542	self.enable2D:
2543	len_orient_para = 0
2544	else:
2545	len_orient_para = len(self.orientation_params) #assume even len
2546	#Total num. of angle parameters
2547	if len(self.fittable_param) > 0:
2548	len_orient_para *= 2
2549	#Set the value of checkbox that selected every checkbox or not
2550	if len(self.parameters)+len(self.fittable_param)-len_orient_para ==\
2551	len(self.param_toFit):
2552	self.cb1.SetValue(True)
2553	else:
2554	self.cb1.SetValue(False)
2555	self.save_current_state_fit()
2556	if event !=None:
2557	#self._undo.Enable(True)
2558	## post state to fit panel
2559	event = PageInfoEvent(page = self)
2560	wx.PostEvent(self.parent, event)
2561
2562	def set_model_param_sizer(self, model):
2563	"""
2564	Build the panel from the model content
2565
2566	:param model: the model selected in combo box for fitting purpose
2567
2568	"""
2569	self.sizer3.Clear(True)
2570	self.parameters = []
2571	self.str_parameters = []
2572	self.param_toFit=[]
2573	self.fittable_param=[]
2574	self.fixed_param=[]
2575	self.orientation_params=[]
2576	self.orientation_params_disp=[]
2577
2578	if model ==None:
2579	self.sizer3.Layout()
2580	self.SetupScrolling()
2581	return
2582	## the panel is drawn using the current value of the fit engine
2583	if self.engine_type==None and self._manager !=None:
2584	self.engine_type= self._manager._return_engine_type()
2585
2586	box_description= wx.StaticBox(self, -1,str("Model Parameters"))
2587	boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
2588	sizer = wx.GridBagSizer(5,5)
2589	## save the current model
2590	self.model = model
2591
2592	keys = self.model.getParamList()
2593	#list of dispersion paramaters
2594	self.disp_list=self.model.getDispParamList()
2595
2596	def custom_compare(a,b):
2597	"""
2598	Custom compare to order, first by alphabets then second by number.
2599	"""
2600	# number at the last digit
2601	a_last = a[len(a)-1]
2602	b_last = b[len(b)-1]
2603	# default
2604	num_a = None
2605	num_b = None
2606	# split the names
2607	a2 = a.lower().split('_')
2608	b2 = b.lower().split('_')
2609	# check length of a2, b2
2610	len_a2 = len(a2)
2611	len_b2 = len(b2)
2612	# check if it contains a int number(<10)
2613	try:
2614	num_a = int(a_last)
2615	except: pass
2616	try:
2617	num_b = int(b_last)
2618	except: pass
2619	# Put 'scale' near the top; happens
2620	# when numbered param name exists
2621	if a == 'scale':
2622	return -1
2623	# both have a number
2624	if num_a != None and num_b != None:
2625	if num_a > num_b: return -1
2626	# same number
2627	elif num_a == num_b:
2628	# different last names
2629	if a2[len_a2-1] != b2[len_b2-1] and num_a != 0:
2630	return -cmp(a2[len_a2-1], b2[len_b2-1])
2631	else:
2632	return cmp(a, b)
2633	else: return 1
2634	# one of them has a number
2635	elif num_a != None: return 1
2636	elif num_b != None: return -1
2637	# no numbers
2638	else: return cmp(a.lower(), b.lower())
2639
2640
2641	keys.sort(custom_compare)
2642
2643	iy = 0
2644	ix = 0
2645	select_text = "Select All"
2646	self.cb1 = wx.CheckBox(self, -1,str(select_text), (10, 10))
2647	wx.EVT_CHECKBOX(self, self.cb1.GetId(), self.select_all_param)
2648	self.cb1.SetToolTipString("To check/uncheck all the boxes below.")
2649	self.cb1.SetValue(True)
2650
2651	sizer.Add(self.cb1,(iy, ix),(1,1),\
2652	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 5)
2653	ix +=1
2654	self.text2_2 = wx.StaticText(self, -1, 'Value')
2655	sizer.Add(self.text2_2,(iy, ix),(1,1),\
2656	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2657	ix +=2
2658	self.text2_3 = wx.StaticText(self, -1, 'Error')
2659	sizer.Add(self.text2_3,(iy, ix),(1,1),\
2660	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2661	if not self.is_mac:
2662	self.text2_3.Hide()
2663	ix +=1
2664	self.text2_min = wx.StaticText(self, -1, 'Min')
2665	sizer.Add(self.text2_min,(iy, ix),(1,1),\
2666	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2667	#self.text2_min.Hide()
2668	ix +=1
2669	self.text2_max = wx.StaticText(self, -1, 'Max')
2670	sizer.Add(self.text2_max,(iy, ix),(1,1),\
2671	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2672	#self.text2_max.Hide()
2673	ix += 1
2674	self.text2_4 = wx.StaticText(self, -1, '[Units]')
2675	sizer.Add(self.text2_4,(iy, ix),(1,1),\
2676	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2677	self.text2_4.Hide()
2678
2679	for item in keys:
2680	if not item in self.disp_list and not item in \
2681	self.model.orientation_params:
2682
2683	##prepare a spot to store errors
2684	if not self.model.details.has_key(item):
2685	self.model.details [item] = ["",None,None]
2686
2687	iy += 1
2688	ix = 0
2689	if (self.model.__class__ in \
2690	self.model_list_box["Multi-Functions"] or \
2691	self.temp_multi_functional)\
2692	and (item in self.model.non_fittable):
2693	non_fittable_name = wx.StaticText(self, -1, item )
2694	sizer.Add(non_fittable_name,(iy, ix),(1,1),\
2695	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 21)
2696	## add parameter value
2697	ix += 1
2698	value= self.model.getParam(item)
2699	if len(self.model.fun_list) > 0:
2700	num = item.split('_')[1][5:7]
2701	fun_box = wx.ComboBox(self, -1,size=(100,-1),
2702	style=wx.CB_READONLY, name = '%s'% item)
2703	self._set_fun_box_list(fun_box)
2704	fun_box.SetSelection(0)
2705	#self.fun_box.SetToolTipString("A function
2706	# describing the interface")
2707	wx.EVT_COMBOBOX(fun_box,-1, self._on_fun_box)
2708	else:
2709	fun_box = self.ModelTextCtrl(self, -1,
2710	size=(_BOX_WIDTH,20),
2711	style=wx.TE_PROCESS_ENTER, name ='%s'% item)
2712	fun_box.SetToolTipString("Hit 'Enter' after typing.")
2713	fun_box.SetValue(format_number(value, True))
2714	sizer.Add(fun_box, (iy,ix),(1,1), wx.EXPAND)
2715	self.str_parameters.append([None,item, fun_box,
2716	None, None, None,
2717	None, None])
2718
2719
2720	else:
2721	## add parameters name with checkbox for selecting to fit
2722	cb = wx.CheckBox(self, -1, item )
2723	cb.SetToolTipString(" Check mark to fit.")
2724	#cb.SetValue(True)
2725	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
2726
2727	sizer.Add( cb,( iy, ix),(1,1),
2728	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 5)
2729
2730	## add parameter value
2731	ix += 1
2732	value= self.model.getParam(item)
2733	ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH,20),
2734	style=wx.TE_PROCESS_ENTER)
2735	ctl1.SetToolTipString("Hit 'Enter' after typing.")
2736	ctl1.SetValue(format_number(value, True))
2737	sizer.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
2738	## text to show error sign
2739	ix += 1
2740	text2=wx.StaticText(self, -1, '+/-')
2741	sizer.Add(text2,(iy, ix),(1,1),\
2742	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2743	if not self.is_mac:
2744	text2.Hide()
2745	ix += 1
2746	ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/1.2,20), style=0)
2747	sizer.Add(ctl2, (iy,ix),(1,1),
2748	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2749	if not self.is_mac:
2750	ctl2.Hide()
2751
2752	ix += 1
2753	ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.9,20),
2754	style=wx.TE_PROCESS_ENTER,
2755	text_enter_callback = self._onparamRangeEnter)
2756
2757	sizer.Add(ctl3, (iy,ix),(1,1),
2758	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2759
2760	ix += 1
2761	ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.9,20),
2762	style=wx.TE_PROCESS_ENTER,
2763	text_enter_callback = self._onparamRangeEnter)
2764	sizer.Add(ctl4, (iy,ix),(1,1),
2765	wx.EXPAND\|wx.FIXED_MINSIZE, 0)
2766
2767	ix +=1
2768	# Units
2769	if self.model.details.has_key(item):
2770	units = wx.StaticText(self, -1,
2771	self.model.details[item][0], style=wx.ALIGN_LEFT)
2772	else:
2773	units = wx.StaticText(self, -1, "", style=wx.ALIGN_LEFT)
2774	sizer.Add(units, (iy,ix),(1,1),
2775	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2776
2777	##[cb state, name, value, "+/-", error of fit, min, max , units]
2778	self.parameters.append([cb,item, ctl1,
2779	text2,ctl2, ctl3, ctl4,units])
2780
2781	iy+=1
2782	sizer.Add((10,10),(iy,ix),(1,1),
2783	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
2784
2785	# type can be either Guassian or Array
2786	if len(self.model.dispersion.values())>0:
2787	type= self.model.dispersion.values()[0]["type"]
2788	else:
2789	type = "Gaussian"
2790
2791	iy += 1
2792	ix = 0
2793	#Add tile for orientational angle
2794	for item in keys:
2795	if item in self.model.orientation_params:
2796	orient_angle = wx.StaticText(self, -1, '[For 2D only]:')
2797	sizer.Add(orient_angle,(iy, ix),(1,1),
2798	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 15)
2799	if not self.data.__class__.__name__ == "Data2D" and \
2800	not self.enable2D:
2801	orient_angle.Hide()
2802	else:
2803	orient_angle.Show(True)
2804	break
2805
2806	#For Gaussian only
2807	if type.lower() != "array":
2808	for item in self.model.orientation_params:
2809	if not item in self.disp_list:
2810	##prepare a spot to store min max
2811	if not self.model.details.has_key(item):
2812	self.model.details [item] = ["",None,None]
2813
2814	iy += 1
2815	ix = 0
2816	## add parameters name with checkbox for selecting to fit
2817	cb = wx.CheckBox(self, -1, item )
2818	cb.SetValue(False)
2819	cb.SetToolTipString("Check mark to fit")
2820	wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
2821	if self.data.__class__.__name__ == "Data2D" or \
2822	self.enable2D:
2823	cb.Show(True)
2824	else:
2825	cb.Hide()
2826	sizer.Add( cb,( iy, ix),(1,1),
2827	wx.LEFT\|wx.EXPAND\|wx.ADJUST_MINSIZE, 5)
2828
2829	## add parameter value
2830	ix += 1
2831	value= self.model.getParam(item)
2832	ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH,20),
2833	style=wx.TE_PROCESS_ENTER)
2834	ctl1.SetToolTipString("Hit 'Enter' after typing.")
2835	ctl1.SetValue(format_number(value, True))
2836	if self.data.__class__.__name__ == "Data2D" or \
2837	self.enable2D:
2838	ctl1.Show(True)
2839	else:
2840	ctl1.Hide()
2841	sizer.Add(ctl1, (iy,ix),(1,1), wx.EXPAND)
2842	## text to show error sign
2843	ix += 1
2844	text2=wx.StaticText(self, -1, '+/-')
2845	sizer.Add(text2,(iy, ix),(1,1),\
2846	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2847
2848	text2.Hide()
2849	ix += 1
2850	ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/1.2,20), style=0)
2851	sizer.Add(ctl2, (iy,ix),(1,1),
2852	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2853
2854	ctl2.Hide()
2855
2856
2857	ix += 1
2858	ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.8,20),
2859	style=wx.TE_PROCESS_ENTER,
2860	text_enter_callback = self._onparamRangeEnter)
2861
2862	sizer.Add(ctl3, (iy,ix),(1,1),
2863	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2864	ctl3.Hide()
2865
2866	ix += 1
2867	ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.8,20),
2868	style=wx.TE_PROCESS_ENTER,
2869	text_enter_callback = self._onparamRangeEnter)
2870	sizer.Add(ctl4, (iy,ix),(1,1),
2871	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2872
2873	ctl4.Hide()
2874
2875	if self.data.__class__.__name__ == "Data2D" or \
2876	self.enable2D:
2877	if self.is_mac:
2878	text2.Show(True)
2879	ctl2.Show(True)
2880	ctl3.Show(True)
2881	ctl4.Show(True)
2882
2883	ix +=1
2884	# Units
2885	if self.model.details.has_key(item):
2886	units = wx.StaticText(self, -1,
2887	self.model.details[item][0],
2888	style=wx.ALIGN_LEFT)
2889	else:
2890	units = wx.StaticText(self, -1, "", style=wx.ALIGN_LEFT)
2891	if self.data.__class__.__name__ == "Data2D" or \
2892	self.enable2D:
2893	units.Show(True)
2894
2895	else:
2896	units.Hide()
2897
2898	sizer.Add(units, (iy,ix),(1,1),
2899	wx.EXPAND\|wx.ADJUST_MINSIZE, 0)
2900
2901	##[cb state, name, value, "+/-", error of fit,min,max,units]
2902	self.parameters.append([cb,item, ctl1,
2903	text2,ctl2, ctl3, ctl4,units])
2904	self.orientation_params.append([cb,item, ctl1,
2905	text2,ctl2, ctl3, ctl4,units])
2906
2907	iy+=1
2908
2909	#Display units text on panel
2910	for item in keys:
2911	if self.model.details.has_key(item):
2912	self.text2_4.Show()
2913	#Fill the list of fittable parameters
2914	self.select_all_param(event=None)
2915
2916	self.save_current_state_fit()
2917	boxsizer1.Add(sizer)
2918	self.sizer3.Add(boxsizer1,0, wx.EXPAND \| wx.ALL, 10)
2919	self.sizer3.Layout()
2920	self.Layout()
2921	#self.Refresh()
2922
2923	def on_right_down(self, event):
2924	"""
2925	Get key stroke event
2926	"""
2927	if self.data == None:
2928	return
2929	# Figuring out key combo: Cmd for copy, Alt for paste
2930	if event.AltDown() and event.ShiftDown():
2931	self._manager.show_ftol_dialog()
2932	flag = True
2933	elif event.AltDown() or event.ShiftDown():
2934	flag = False
2935	else:
2936	return
2937	# make event free
2938	event.Skip()
2939	# messages depending on the flag
2940	if not flag:
2941	msg = " Could not open ftol dialog;"
2942	msg += " Check if the Scipy fit engine is selected in the menubar."
2943	infor = 'warning'
2944	# inform msg to wx
2945	wx.PostEvent( self.parent.parent,
2946	StatusEvent(status= msg, info=infor))
2947
2948
2949	def _onModel2D(self, event):
2950	"""
2951	toggle view of model from 1D to 2D or 2D from 1D
2952	"""
2953	if self.model_view.GetLabelText() == "1D Mode":
2954	self.model_view.SetLabel("2D Mode")
2955	self.enable2D = True
2956
2957	else:
2958	self.model_view.SetLabel("1D Mode")
2959	self.enable2D = False
2960
2961	self.set_model_param_sizer(self.model)
2962	self._set_sizer_dispersion()
2963	self._draw_model()
2964
2965
2966	self.state.enable2D = copy.deepcopy(self.enable2D)
2967
2968	class BGTextCtrl(wx.TextCtrl):
2969	"""
2970	Text control used to display outputs.
2971	No editing allowed. The background is
2972	grayed out. User can't select text.
2973	"""
2974	def __init__(self, args, *kwds):
2975	wx.TextCtrl.__init__(self, args, *kwds)
2976	self.SetEditable(False)
2977	self.SetBackgroundColour(self.GetParent().parent.GetBackgroundColour())
2978
2979	# Bind to mouse event to avoid text highlighting
2980	# The event will be skipped once the call-back
2981	# is called.
2982	self.Bind(wx.EVT_MOUSE_EVENTS, self._click)
2983
2984	def _click(self, event):
2985	"""
2986	Prevent further handling of the mouse event
2987	by not calling Skip().
2988	"""
2989	pass
2990

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

SasView

source: sasview/sansview/perspectives/fitting/fitpage.py @ d0abc8e

Download in other formats: