fitpage.py @ fbfed45

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

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

SasView

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

Download in other formats: