fitpage.py @ 968d67e

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

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

SasView

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

Download in other formats: