fitpage.py @ 69363c7

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalcmagnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

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

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

SasView

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

Download in other formats: