fitpage.py @ 199b515e

Last change on this file since 199b515e was 8662a58, checked in by ajj, 8 years ago

Updating basepage and fitpage to pass is_modified flag out of helper functions so that _onDraw can correctly determine that there is a change and recalculate/redraw

Fixes #753 compute button no longer seems to work

Property mode set to 100644

File size: 128.2 KB

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

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

SasView

source: sasview/src/sas/sasgui/perspectives/fitting/fitpage.py @ 199b515e

Download in other formats: