fitpage.py @ 7bd6860a

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

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

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

SasView

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

Download in other formats: